is Google's (unit) testing and mocking framework for C++ tests.
| gmock.cc (googletest-release-1.11.0) | : | gmock.cc (googletest-release-1.12.0) |
|---|
| | |
| skipping to change at line 31 | | skipping to change at line 31 |
|---|
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| | |
| #include "gmock/gmock.h" | | #include "gmock/gmock.h" |
|
| #include "gmock/internal/gmock-port.h" | | |
| | |
|
| namespace testing { | | #include "gmock/internal/gmock-port.h" |
| | |
| GMOCK_DEFINE_bool_(catch_leaked_mocks, true, | | GMOCK_DEFINE_bool_(catch_leaked_mocks, true, |
| "true if and only if Google Mock should report leaked " | | "true if and only if Google Mock should report leaked " |
| "mock objects as failures."); | | "mock objects as failures."); |
| | |
|
| GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity, | | GMOCK_DEFINE_string_(verbose, testing::internal::kWarningVerbosity, |
| "Controls how verbose Google Mock's output is." | | "Controls how verbose Google Mock's output is." |
| " Valid values:\n" | | " Valid values:\n" |
| " info - prints all messages.\n" | | " info - prints all messages.\n" |
| " warning - prints warnings and errors.\n" | | " warning - prints warnings and errors.\n" |
| " error - prints errors only."); | | " error - prints errors only."); |
| | |
| GMOCK_DEFINE_int32_(default_mock_behavior, 1, | | GMOCK_DEFINE_int32_(default_mock_behavior, 1, |
| "Controls the default behavior of mocks." | | "Controls the default behavior of mocks." |
| " Valid values:\n" | | " Valid values:\n" |
| " 0 - by default, mocks act as NiceMocks.\n" | | " 0 - by default, mocks act as NiceMocks.\n" |
| " 1 - by default, mocks act as NaggyMocks.\n" | | " 1 - by default, mocks act as NaggyMocks.\n" |
| " 2 - by default, mocks act as StrictMocks."); | | " 2 - by default, mocks act as StrictMocks."); |
| | |
|
| | namespace testing { |
| namespace internal { | | namespace internal { |
| | |
| // Parses a string as a command line flag. The string should have the | | // Parses a string as a command line flag. The string should have the |
| // format "--gmock_flag=value". When def_optional is true, the | | // format "--gmock_flag=value". When def_optional is true, the |
| // "=value" part can be omitted. | | // "=value" part can be omitted. |
| // | | // |
| // Returns the value of the flag, or NULL if the parsing failed. | | // Returns the value of the flag, or NULL if the parsing failed. |
| static const char* ParseGoogleMockFlagValue(const char* str, | | static const char* ParseGoogleMockFlagValue(const char* str, |
|
| const char* flag, | | const char* flag_name, |
| bool def_optional) { | | bool def_optional) { |
| // str and flag must not be NULL. | | // str and flag must not be NULL. |
|
| if (str == nullptr || flag == nullptr) return nullptr; | | if (str == nullptr || flag_name == nullptr) return nullptr; |
| | |
| // The flag must start with "--gmock_". | | // The flag must start with "--gmock_". |
|
| const std::string flag_str = std::string("--gmock_") + flag; | | const std::string flag_name_str = std::string("--gmock_") + flag_name; |
| const size_t flag_len = flag_str.length(); | | const size_t flag_name_len = flag_name_str.length(); |
| if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; | | if (strncmp(str, flag_name_str.c_str(), flag_name_len) != 0) return nullptr; |
| | |
| // Skips the flag name. | | // Skips the flag name. |
|
| const char* flag_end = str + flag_len; | | const char* flag_end = str + flag_name_len; |
| | |
| // When def_optional is true, it's OK to not have a "=value" part. | | // When def_optional is true, it's OK to not have a "=value" part. |
| if (def_optional && (flag_end[0] == '\0')) { | | if (def_optional && (flag_end[0] == '\0')) { |
| return flag_end; | | return flag_end; |
| } | | } |
| | |
| // If def_optional is true and there are more characters after the | | // 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 | | // flag name, or if def_optional is false, there must be a '=' after |
| // the flag name. | | // the flag name. |
| if (flag_end[0] != '=') return nullptr; | | if (flag_end[0] != '=') return nullptr; |
| | |
| // Returns the string after "=". | | // Returns the string after "=". |
| return flag_end + 1; | | return flag_end + 1; |
| } | | } |
| | |
| // Parses a string for a Google Mock bool flag, in the form of | | // Parses a string for a Google Mock bool flag, in the form of |
| // "--gmock_flag=value". | | // "--gmock_flag=value". |
| // | | // |
| // On success, stores the value of the flag in *value, and returns | | // On success, stores the value of the flag in *value, and returns |
| // true. On failure, returns false without changing *value. | | // true. On failure, returns false without changing *value. |
|
| static bool ParseGoogleMockBoolFlag(const char* str, const char* flag, | | static bool ParseGoogleMockFlag(const char* str, const char* flag_name, |
| bool* value) { | | bool* value) { |
| // Gets the value of the flag as a string. | | // Gets the value of the flag as a string. |
|
| const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); | | const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true); |
| | |
| // Aborts if the parsing failed. | | // Aborts if the parsing failed. |
| if (value_str == nullptr) return false; | | if (value_str == nullptr) return false; |
| | |
| // Converts the string value to a bool. | | // Converts the string value to a bool. |
| *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); | | *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); |
| return true; | | return true; |
| } | | } |
| | |
| // Parses a string for a Google Mock string flag, in the form of | | // Parses a string for a Google Mock string flag, in the form of |
| // "--gmock_flag=value". | | // "--gmock_flag=value". |
| // | | // |
| // On success, stores the value of the flag in *value, and returns | | // On success, stores the value of the flag in *value, and returns |
| // true. On failure, returns false without changing *value. | | // true. On failure, returns false without changing *value. |
| template <typename String> | | template <typename String> |
|
| static bool ParseGoogleMockStringFlag(const char* str, const char* flag, | | static bool ParseGoogleMockFlag(const char* str, const char* flag_name, |
| String* value) { | | String* value) { |
| // Gets the value of the flag as a string. | | // Gets the value of the flag as a string. |
|
| const char* const value_str = ParseGoogleMockFlagValue(str, flag, false); | | const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, false); |
| | |
| // Aborts if the parsing failed. | | // Aborts if the parsing failed. |
| if (value_str == nullptr) return false; | | if (value_str == nullptr) return false; |
| | |
| // Sets *value to the value of the flag. | | // Sets *value to the value of the flag. |
| *value = value_str; | | *value = value_str; |
| return true; | | return true; |
| } | | } |
| | |
|
| static bool ParseGoogleMockIntFlag(const char* str, const char* flag, | | static bool ParseGoogleMockFlag(const char* str, const char* flag_name, |
| int32_t* value) { | | int32_t* value) { |
| // Gets the value of the flag as a string. | | // Gets the value of the flag as a string. |
|
| const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); | | const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true); |
| | |
| // Aborts if the parsing failed. | | // Aborts if the parsing failed. |
| if (value_str == nullptr) return false; | | if (value_str == nullptr) return false; |
| | |
| // Sets *value to the value of the flag. | | // Sets *value to the value of the flag. |
|
| return ParseInt32(Message() << "The value of flag --" << flag, | | return ParseInt32(Message() << "The value of flag --" << flag_name, value_str, |
| value_str, value); | | value); |
| } | | } |
| | |
| // The internal implementation of InitGoogleMock(). | | // The internal implementation of InitGoogleMock(). |
| // | | // |
| // The type parameter CharType can be instantiated to either char or | | // The type parameter CharType can be instantiated to either char or |
| // wchar_t. | | // wchar_t. |
| template <typename CharType> | | template <typename CharType> |
| void InitGoogleMockImpl(int* argc, CharType** argv) { | | void InitGoogleMockImpl(int* argc, CharType** argv) { |
| // Makes sure Google Test is initialized. InitGoogleTest() is | | // Makes sure Google Test is initialized. InitGoogleTest() is |
| // idempotent, so it's fine if the user has already called it. | | // idempotent, so it's fine if the user has already called it. |
| InitGoogleTest(argc, argv); | | InitGoogleTest(argc, argv); |
| if (*argc <= 0) return; | | if (*argc <= 0) return; |
| | |
| for (int i = 1; i != *argc; i++) { | | for (int i = 1; i != *argc; i++) { |
| const std::string arg_string = StreamableToString(argv[i]); | | const std::string arg_string = StreamableToString(argv[i]); |
| const char* const arg = arg_string.c_str(); | | const char* const arg = arg_string.c_str(); |
| | |
| // Do we see a Google Mock flag? | | // Do we see a Google Mock flag? |
|
| if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks", | | bool found_gmock_flag = false; |
| &GMOCK_FLAG(catch_leaked_mocks)) || | | |
| ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) || | | #define GMOCK_INTERNAL_PARSE_FLAG(flag_name) \ |
| ParseGoogleMockIntFlag(arg, "default_mock_behavior", | | if (!found_gmock_flag) { \ |
| &GMOCK_FLAG(default_mock_behavior))) { | | auto value = GMOCK_FLAG_GET(flag_name); \ |
| | if (ParseGoogleMockFlag(arg, #flag_name, &value)) { \ |
| | GMOCK_FLAG_SET(flag_name, value); \ |
| | found_gmock_flag = true; \ |
| | } \ |
| | } |
| | |
| | GMOCK_INTERNAL_PARSE_FLAG(catch_leaked_mocks) |
| | GMOCK_INTERNAL_PARSE_FLAG(verbose) |
| | GMOCK_INTERNAL_PARSE_FLAG(default_mock_behavior) |
| | |
| | if (found_gmock_flag) { |
| // Yes. Shift the remainder of the argv list left by one. Note | | // Yes. Shift the remainder of the argv list left by one. Note |
| // that argv has (*argc + 1) elements, the last one always being | | // that argv has (*argc + 1) elements, the last one always being |
| // NULL. The following loop moves the trailing NULL element as | | // NULL. The following loop moves the trailing NULL element as |
| // well. | | // well. |
| for (int j = i; j != *argc; j++) { | | for (int j = i; j != *argc; j++) { |
| argv[j] = argv[j + 1]; | | argv[j] = argv[j + 1]; |
| } | | } |
| | |
| // Decrements the argument count. | | // Decrements the argument count. |
| (*argc)--; | | (*argc)--; |
| | | |
| End of changes. 16 change blocks. |
|---|
| 25 lines changed or deleted | | 36 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 