| // Copyright (c) 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: Marius Eriksen |
| // |
| // For now, this unit test does not cover all features of |
| // gflags.cc |
| |
| #include "config_for_unittests.h" |
| #include <stdio.h> |
| #include <stdlib.h> // for &exit |
| #include <assert.h> |
| #include <string.h> |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> // for unlink() |
| #endif |
| #ifdef HAVE_SYS_STAT_H |
| #include <sys/stat.h> // for mkdir() |
| #endif |
| #include <math.h> // for isinf() and isnan() |
| #include <vector> |
| #include <string> |
| |
| #include <gflags/gflags.h> |
| // I don't actually use this header file, but #include it under the |
| // old location to make sure that the include-header-forwarding |
| // works. But don't bother on windows; the windows port is so new |
| // it never had the old location-names. |
| #ifndef _MSC_VER |
| #include <google/gflags_completions.h> |
| void (*unused_fn)() = &GOOGLE_NAMESPACE::HandleCommandLineCompletions; |
| #endif |
| |
| using GOOGLE_NAMESPACE::int32; |
| using GOOGLE_NAMESPACE::FlagRegisterer; |
| using GOOGLE_NAMESPACE::StringFromEnv; |
| using GOOGLE_NAMESPACE::RegisterFlagValidator; |
| using GOOGLE_NAMESPACE::CommandLineFlagInfo; |
| using GOOGLE_NAMESPACE::GetAllFlags; |
| |
| // Returns the number of elements in an array. |
| #define GET_ARRAY_SIZE(arr) (sizeof(arr)/sizeof(*(arr))) |
| |
| #if !defined(HAVE_SETENV) && defined(HAVE_PUTENV) // mingw, at least |
| void setenv(const char* name, const char* value, int) { |
| // In windows, it's impossible to set a variable to the empty string. |
| // We handle this by setting it to "0" and the NUL-ing out the \0. |
| // cf http://svn.apache.org/viewvc/stdcxx/trunk/tests/src/environ.cpp?r1=611451&r2=637508&pathrev=637508 |
| static const char* const kFakeZero = "0"; |
| if (*value == '\0') |
| value = kFakeZero; |
| // Apparently the semantics of putenv() is that the input |
| // must live forever, so we leak memory here. :-( |
| const int nameval_len = strlen(name) + 1 + strlen(value) + 1; |
| char* nameval = reinterpret_cast<char*>(malloc(nameval_len)); |
| snprintf(nameval, nameval_len, "%s=%s", name, value); |
| putenv(nameval); |
| if (value == kFakeZero) { |
| nameval[nameval_len - 2] = '\0'; // works when putenv() makes no copy |
| if (*getenv(name) != '\0') |
| *getenv(name) = '\0'; // works when putenv() copies nameval |
| } |
| } |
| #endif |
| |
| DECLARE_string(tryfromenv); // in gflags.cc |
| |
| DEFINE_string(test_tmpdir, "/tmp/gflags_unittest", "Dir we use for temp files"); |
| #ifdef _MSC_VER // in MSVC, we run from the vsprojects directory |
| DEFINE_string(srcdir, "..\\..", |
| "Source-dir root, needed to find gflags_unittest_flagfile"); |
| #else |
| DEFINE_string(srcdir, StringFromEnv("SRCDIR", "."), |
| "Source-dir root, needed to find gflags_unittest_flagfile"); |
| #endif |
| |
| DEFINE_bool(test_bool, false, "tests bool-ness"); |
| DEFINE_int32(test_int32, -1, ""); |
| DEFINE_int64(test_int64, -2, ""); |
| DEFINE_uint64(test_uint64, 2, ""); |
| DEFINE_double(test_double, -1.0, ""); |
| DEFINE_string(test_string, "initial", ""); |
| |
| // |
| // The below ugliness gets some additional code coverage in the -helpxml |
| // and -helpmatch test cases having to do with string lengths and formatting |
| // |
| DEFINE_bool(test_bool_with_quite_quite_quite_quite_quite_quite_quite_quite_quite_quite_quite_quite_quite_quite_long_name, |
| false, |
| "extremely_extremely_extremely_extremely_extremely_extremely_extremely_extremely_long_meaning"); |
| |
| DEFINE_string(test_str1, "initial", ""); |
| DEFINE_string(test_str2, "initial", ""); |
| DEFINE_string(test_str3, "initial", ""); |
| |
| // This is used to test setting tryfromenv manually |
| DEFINE_string(test_tryfromenv, "initial", ""); |
| |
| // Don't try this at home! |
| static int changeable_var = 12; |
| DEFINE_int32(changeable_var, ++changeable_var, ""); |
| |
| static int changeable_bool_var = 8008; |
| DEFINE_bool(changeable_bool_var, ++changeable_bool_var == 8009, ""); |
| |
| static int changeable_string_var = 0; |
| static std::string ChangeableString() { |
| char r[] = {static_cast<char>('0' + ++changeable_string_var), '\0'}; |
| return r; |
| } |
| DEFINE_string(changeable_string_var, ChangeableString(), ""); |
| |
| // These are never used in this unittest, but can be used by |
| // gflags_unittest.sh when it needs to specify flags |
| // that are legal for gflags_unittest but don't need to |
| // be a particular value. |
| DEFINE_bool(unused_bool, true, "unused bool-ness"); |
| DEFINE_int32(unused_int32, -1001, ""); |
| DEFINE_int64(unused_int64, -2001, ""); |
| DEFINE_uint64(unused_uint64, 2000, ""); |
| DEFINE_double(unused_double, -1000.0, ""); |
| DEFINE_string(unused_string, "unused", ""); |
| |
| // These flags are used by gflags_unittest.sh |
| DEFINE_bool(changed_bool1, false, "changed"); |
| DEFINE_bool(changed_bool2, false, "changed"); |
| |
| static bool AlwaysFail(const char* flag, bool value) { return value == false; } |
| DEFINE_bool(always_fail, false, "will fail to validate when you set it"); |
| static bool dummy = RegisterFlagValidator(&FLAGS_always_fail, AlwaysFail); |
| |
| // See the comment by GetAllFlags in commandlineflags.h |
| static bool DeadlockIfCantLockInValidators(const char* flag, bool value) { |
| if (!value) { |
| return true; |
| } |
| std::vector<CommandLineFlagInfo> dummy; |
| GetAllFlags(&dummy); |
| return true; |
| } |
| DEFINE_bool(deadlock_if_cant_lock, |
| false, |
| "will deadlock if set to true and " |
| "if locking of registry in validators fails."); |
| static bool dummy1 = RegisterFlagValidator(&FLAGS_deadlock_if_cant_lock, |
| DeadlockIfCantLockInValidators); |
| |
| // This is a pseudo-flag -- we want to register a flag with a filename |
| // at the top level, but there is no way to do this except by faking |
| // the filename. |
| namespace fLI { |
| static const int32 FLAGS_nonotldflag1 = 12; |
| int32 FLAGS_tldflag1 = FLAGS_nonotldflag1; |
| int32 FLAGS_notldflag1 = FLAGS_nonotldflag1; |
| static FlagRegisterer o_tldflag1( |
| "tldflag1", "int32", |
| "should show up in --helpshort", "gflags_unittest.cc", |
| &FLAGS_tldflag1, &FLAGS_notldflag1); |
| } |
| using fLI::FLAGS_tldflag1; |
| |
| namespace fLI { |
| static const int32 FLAGS_nonotldflag2 = 23; |
| int32 FLAGS_tldflag2 = FLAGS_nonotldflag2; |
| int32 FLAGS_notldflag2 = FLAGS_nonotldflag2; |
| static FlagRegisterer o_tldflag2( |
| "tldflag2", "int32", |
| "should show up in --helpshort", "gflags_unittest.", |
| &FLAGS_tldflag2, &FLAGS_notldflag2); |
| } |
| using fLI::FLAGS_tldflag2; |
| |
| _START_GOOGLE_NAMESPACE_ |
| |
| using std::string; |
| using std::vector; |
| |
| // The following is some bare-bones testing infrastructure |
| |
| #define EXPECT_TRUE(cond) \ |
| do { \ |
| if (!(cond)) { \ |
| fprintf(stderr, "Check failed: %s\n", #cond); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_FALSE(cond) EXPECT_TRUE(!(cond)) |
| |
| #define EXPECT_OP(op, val1, val2) \ |
| do { \ |
| if (!((val1) op (val2))) { \ |
| fprintf(stderr, "Check failed: %s %s %s\n", #val1, #op, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_EQ(val1, val2) EXPECT_OP(==, val1, val2) |
| #define EXPECT_NE(val1, val2) EXPECT_OP(!=, val1, val2) |
| #define EXPECT_GT(val1, val2) EXPECT_OP(>, val1, val2) |
| #define EXPECT_LT(val1, val2) EXPECT_OP(<, val1, val2) |
| |
| // C99 declares isnan and isinf should be macros, so the #ifdef test |
| // should be reliable everywhere. Of course, it's not, but these |
| // are testing pertty marginal functionality anyway, so it's ok to |
| // not-run them even in situations they might, with effort, be made to work. |
| #ifdef isnan // Some compilers, like sun's for Solaris 10, don't define this |
| #define EXPECT_NAN(arg) \ |
| do { \ |
| if (!isnan(arg)) { \ |
| fprintf(stderr, "Check failed: isnan(%s)\n", #arg); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| #else |
| #define EXPECT_NAN(arg) |
| #endif |
| |
| #ifdef isinf // Some compilers, like sun's for Solaris 10, don't define this |
| #define EXPECT_INF(arg) \ |
| do { \ |
| if (!isinf(arg)) { \ |
| fprintf(stderr, "Check failed: isinf(%s)\n", #arg); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| #else |
| #define EXPECT_INF(arg) |
| #endif |
| |
| #define EXPECT_DOUBLE_EQ(val1, val2) \ |
| do { \ |
| if (((val1) < (val2) - 0.001 || (val1) > (val2) + 0.001)) { \ |
| fprintf(stderr, "Check failed: %s == %s\n", #val1, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_STREQ(val1, val2) \ |
| do { \ |
| if (strcmp((val1), (val2)) != 0) { \ |
| fprintf(stderr, "Check failed: streq(%s, %s)\n", #val1, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| static bool g_called_exit; |
| static void CalledExit(int) { g_called_exit = true; } |
| extern GFLAGS_DLL_DECL void (*commandlineflags_exitfunc)(int); // in gflags.cc |
| |
| #define EXPECT_DEATH(fn, msg) \ |
| do { \ |
| g_called_exit = false; \ |
| commandlineflags_exitfunc = &CalledExit; \ |
| fn; \ |
| commandlineflags_exitfunc = &exit; /* set back to its default */ \ |
| if (!g_called_exit) { \ |
| fprintf(stderr, "Function didn't die (%s): %s\n", msg, #fn); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| |
| vector<void (*)()> g_testlist; // the tests to run |
| |
| #define TEST(a, b) \ |
| struct Test_##a##_##b { \ |
| Test_##a##_##b() { g_testlist.push_back(&Run); } \ |
| static void Run() { \ |
| FlagSaver fs; \ |
| fprintf(stderr, "Running test %s/%s\n", #a, #b); \ |
| RunTest(); \ |
| } \ |
| static void RunTest(); \ |
| }; \ |
| static Test_##a##_##b g_test_##a##_##b; \ |
| void Test_##a##_##b::RunTest() |
| |
| |
| static int RUN_ALL_TESTS() { |
| vector<void (*)()>::const_iterator it; |
| for (it = g_testlist.begin(); it != g_testlist.end(); ++it) { |
| (*it)(); |
| } |
| fprintf(stderr, "Passed %d tests\n\nPASS\n", (int)g_testlist.size()); |
| return 0; |
| } |
| |
| |
| static string TmpFile(const string& basename) { |
| #ifdef _MSC_VER |
| return FLAGS_test_tmpdir + "\\" + basename; |
| #else |
| return FLAGS_test_tmpdir + "/" + basename; |
| #endif |
| } |
| |
| // Returns the definition of the --flagfile flag to be used in the tests. |
| static const char* GetFlagFileFlag() { |
| #ifdef _MSC_VER |
| static const string flagfile = FLAGS_srcdir + "\\src\\gflags_unittest_flagfile"; |
| #else |
| static const string flagfile = FLAGS_srcdir + "/src/gflags_unittest_flagfile"; |
| #endif |
| static const string flagfile_flag = string("--flagfile=") + flagfile; |
| return flagfile_flag.c_str(); |
| } |
| |
| |
| // 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> { |
| }; |
| |
| |
| template <typename Expected, typename Actual> |
| void AssertIsType(Actual& x) { |
| CompileAssertTypesEqual<Expected, Actual>(); |
| } |
| |
| // Verify all the flags are the right type. |
| TEST(FlagTypes, FlagTypes) { |
| AssertIsType<bool>(FLAGS_test_bool); |
| AssertIsType<int32>(FLAGS_test_int32); |
| AssertIsType<int64>(FLAGS_test_int64); |
| AssertIsType<uint64>(FLAGS_test_uint64); |
| AssertIsType<double>(FLAGS_test_double); |
| AssertIsType<string>(FLAGS_test_string); |
| } |
| |
| // Death tests for "help" options. |
| // |
| // The help system automatically calls exit(1) when you specify any of |
| // the help-related flags ("-helpmatch", "-helpxml") so we can't test |
| // those mainline. |
| |
| // Tests that "-helpmatch" causes the process to die. |
| TEST(ReadFlagsFromStringDeathTest, HelpMatch) { |
| EXPECT_DEATH(ReadFlagsFromString("-helpmatch=base", GetArgv0(), true), |
| ""); |
| } |
| |
| |
| // Tests that "-helpxml" causes the process to die. |
| TEST(ReadFlagsFromStringDeathTest, HelpXml) { |
| EXPECT_DEATH(ReadFlagsFromString("-helpxml", GetArgv0(), true), |
| ""); |
| } |
| |
| |
| // A subroutine needed for testing reading flags from a string. |
| void TestFlagString(const string& flags, |
| const string& expected_string, |
| bool expected_bool, |
| int32 expected_int32, |
| double expected_double) { |
| EXPECT_TRUE(ReadFlagsFromString(flags, |
| GetArgv0(), |
| // errors are fatal |
| true)); |
| |
| EXPECT_EQ(expected_string, FLAGS_test_string); |
| EXPECT_EQ(expected_bool, FLAGS_test_bool); |
| EXPECT_EQ(expected_int32, FLAGS_test_int32); |
| EXPECT_DOUBLE_EQ(expected_double, FLAGS_test_double); |
| } |
| |
| |
| // Tests reading flags from a string. |
| TEST(FlagFileTest, ReadFlagsFromString) { |
| TestFlagString( |
| // Flag string |
| "-test_string=continued\n" |
| "# some comments are in order\n" |
| "# some\n" |
| " # comments\n" |
| "#are\n" |
| " #trickier\n" |
| "# than others\n" |
| "-test_bool=true\n" |
| " -test_int32=1\n" |
| "-test_double=0.0\n", |
| // Expected values |
| "continued", |
| true, |
| 1, |
| 0.0); |
| |
| TestFlagString( |
| // Flag string |
| "# let's make sure it can update values\n" |
| "-test_string=initial\n" |
| "-test_bool=false\n" |
| "-test_int32=123\n" |
| "-test_double=123.0\n", |
| // Expected values |
| "initial", |
| false, |
| 123, |
| 123.0); |
| } |
| |
| // Tests the filename part of the flagfile |
| TEST(FlagFileTest, FilenamesOurfileLast) { |
| FLAGS_test_string = "initial"; |
| FLAGS_test_bool = false; |
| FLAGS_test_int32 = -1; |
| FLAGS_test_double = -1.0; |
| TestFlagString( |
| // Flag string |
| "-test_string=continued\n" |
| "# some comments are in order\n" |
| "# some\n" |
| " # comments\n" |
| "#are\n" |
| " #trickier\n" |
| "# than others\n" |
| "not_our_filename\n" |
| "-test_bool=true\n" |
| " -test_int32=1\n" |
| "gflags_unittest\n" |
| "-test_double=1000.0\n", |
| // Expected values |
| "continued", |
| false, |
| -1, |
| 1000.0); |
| } |
| |
| TEST(FlagFileTest, FilenamesOurfileFirst) { |
| FLAGS_test_string = "initial"; |
| FLAGS_test_bool = false; |
| FLAGS_test_int32 = -1; |
| FLAGS_test_double = -1.0; |
| TestFlagString( |
| // Flag string |
| "-test_string=continued\n" |
| "# some comments are in order\n" |
| "# some\n" |
| " # comments\n" |
| "#are\n" |
| " #trickier\n" |
| "# than others\n" |
| "gflags_unittest\n" |
| "-test_bool=true\n" |
| " -test_int32=1\n" |
| "not_our_filename\n" |
| "-test_double=1000.0\n", |
| // Expected values |
| "continued", |
| true, |
| 1, |
| -1.0); |
| } |
| |
| #ifdef HAVE_FNMATCH_H // otherwise glob isn't supported |
| TEST(FlagFileTest, FilenamesOurfileGlob) { |
| FLAGS_test_string = "initial"; |
| FLAGS_test_bool = false; |
| FLAGS_test_int32 = -1; |
| FLAGS_test_double = -1.0; |
| TestFlagString( |
| // Flag string |
| "-test_string=continued\n" |
| "# some comments are in order\n" |
| "# some\n" |
| " # comments\n" |
| "#are\n" |
| " #trickier\n" |
| "# than others\n" |
| "*flags*\n" |
| "-test_bool=true\n" |
| " -test_int32=1\n" |
| "flags\n" |
| "-test_double=1000.0\n", |
| // Expected values |
| "continued", |
| true, |
| 1, |
| -1.0); |
| } |
| |
| TEST(FlagFileTest, FilenamesOurfileInBigList) { |
| FLAGS_test_string = "initial"; |
| FLAGS_test_bool = false; |
| FLAGS_test_int32 = -1; |
| FLAGS_test_double = -1.0; |
| TestFlagString( |
| // Flag string |
| "-test_string=continued\n" |
| "# some comments are in order\n" |
| "# some\n" |
| " # comments\n" |
| "#are\n" |
| " #trickier\n" |
| "# than others\n" |
| "*first* *flags* *third*\n" |
| "-test_bool=true\n" |
| " -test_int32=1\n" |
| "flags\n" |
| "-test_double=1000.0\n", |
| // Expected values |
| "continued", |
| true, |
| 1, |
| -1.0); |
| } |
| #endif |
| |
| // Tests that a failed flag-from-string read keeps flags at default values |
| TEST(FlagFileTest, FailReadFlagsFromString) { |
| FLAGS_test_int32 = 119; |
| string flags("# let's make sure it can update values\n" |
| "-test_string=non_initial\n" |
| "-test_bool=false\n" |
| "-test_int32=123\n" |
| "-test_double=illegal\n"); |
| |
| EXPECT_FALSE(ReadFlagsFromString(flags, |
| GetArgv0(), |
| // errors are fatal |
| false)); |
| |
| EXPECT_EQ(119, FLAGS_test_int32); |
| EXPECT_EQ("initial", FLAGS_test_string); |
| } |
| |
| // Tests that flags can be set to ordinary values. |
| TEST(SetFlagValueTest, OrdinaryValues) { |
| EXPECT_EQ("initial", FLAGS_test_str1); |
| |
| SetCommandLineOptionWithMode("test_str1", "second", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str1); // set; was default |
| |
| SetCommandLineOptionWithMode("test_str1", "third", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str1); // already set once |
| |
| FLAGS_test_str1 = "initial"; |
| SetCommandLineOptionWithMode("test_str1", "third", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("initial", FLAGS_test_str1); // still already set before |
| |
| SetCommandLineOptionWithMode("test_str1", "third", SET_FLAGS_VALUE); |
| EXPECT_EQ("third", FLAGS_test_str1); // changed value |
| |
| SetCommandLineOptionWithMode("test_str1", "fourth", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("third", FLAGS_test_str1); |
| // value not changed (already set before) |
| |
| EXPECT_EQ("initial", FLAGS_test_str2); |
| |
| SetCommandLineOptionWithMode("test_str2", "second", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str2); // changed (was default) |
| |
| FLAGS_test_str2 = "extra"; |
| EXPECT_EQ("extra", FLAGS_test_str2); |
| |
| FLAGS_test_str2 = "second"; |
| SetCommandLineOptionWithMode("test_str2", "third", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("third", FLAGS_test_str2); // still changed (was equal to default) |
| |
| SetCommandLineOptionWithMode("test_str2", "fourth", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("fourth", FLAGS_test_str2); // changed (was default) |
| |
| EXPECT_EQ("initial", FLAGS_test_str3); |
| |
| SetCommandLineOptionWithMode("test_str3", "second", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str3); // changed |
| |
| FLAGS_test_str3 = "third"; |
| SetCommandLineOptionWithMode("test_str3", "fourth", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("third", FLAGS_test_str3); // not changed (was set) |
| |
| SetCommandLineOptionWithMode("test_str3", "fourth", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("third", FLAGS_test_str3); // not changed (was set) |
| |
| SetCommandLineOptionWithMode("test_str3", "fourth", SET_FLAGS_VALUE); |
| EXPECT_EQ("fourth", FLAGS_test_str3); // changed value |
| } |
| |
| |
| // Tests that flags can be set to exceptional values. |
| // Note: apparently MINGW doesn't parse inf and nan correctly: |
| // http://www.mail-archive.com/bug-gnulib@gnu.org/msg09573.html |
| // This url says FreeBSD also has a problem, but I didn't see that. |
| TEST(SetFlagValueTest, ExceptionalValues) { |
| #if defined(isinf) && !defined(__MINGW32__) |
| EXPECT_EQ("test_double set to inf\n", |
| SetCommandLineOption("test_double", "inf")); |
| EXPECT_INF(FLAGS_test_double); |
| |
| EXPECT_EQ("test_double set to inf\n", |
| SetCommandLineOption("test_double", "INF")); |
| EXPECT_INF(FLAGS_test_double); |
| #endif |
| |
| // set some bad values |
| EXPECT_EQ("", |
| SetCommandLineOption("test_double", "0.1xxx")); |
| EXPECT_EQ("", |
| SetCommandLineOption("test_double", " ")); |
| EXPECT_EQ("", |
| SetCommandLineOption("test_double", "")); |
| #if defined(isinf) && !defined(__MINGW32__) |
| EXPECT_EQ("test_double set to -inf\n", |
| SetCommandLineOption("test_double", "-inf")); |
| EXPECT_INF(FLAGS_test_double); |
| EXPECT_GT(0, FLAGS_test_double); |
| #endif |
| |
| #if defined(isnan) && !defined(__MINGW32__) |
| EXPECT_EQ("test_double set to nan\n", |
| SetCommandLineOption("test_double", "NaN")); |
| EXPECT_NAN(FLAGS_test_double); |
| #endif |
| } |
| |
| // Tests that integer flags can be specified in many ways |
| TEST(SetFlagValueTest, DifferentRadices) { |
| EXPECT_EQ("test_int32 set to 12\n", |
| SetCommandLineOption("test_int32", "12")); |
| |
| EXPECT_EQ("test_int32 set to 16\n", |
| SetCommandLineOption("test_int32", "0x10")); |
| |
| EXPECT_EQ("test_int32 set to 34\n", |
| SetCommandLineOption("test_int32", "0X22")); |
| |
| // Leading 0 is *not* octal; it's still decimal |
| EXPECT_EQ("test_int32 set to 10\n", |
| SetCommandLineOption("test_int32", "010")); |
| } |
| |
| // Tests what happens when you try to set a flag to an illegal value |
| TEST(SetFlagValueTest, IllegalValues) { |
| FLAGS_test_bool = true; |
| FLAGS_test_int32 = 119; |
| FLAGS_test_int64 = 1191; |
| FLAGS_test_uint64 = 11911; |
| |
| EXPECT_EQ("", |
| SetCommandLineOption("test_bool", "12")); |
| |
| EXPECT_EQ("", |
| SetCommandLineOption("test_int32", "7000000000000")); |
| |
| // TODO(csilvers): uncomment this when we disallow negative numbers for uint64 |
| #if 0 |
| EXPECT_EQ("", |
| SetCommandLineOption("test_uint64", "-1")); |
| #endif |
| |
| EXPECT_EQ("", |
| SetCommandLineOption("test_int64", "not a number!")); |
| |
| // Test the empty string with each type of input |
| EXPECT_EQ("", SetCommandLineOption("test_bool", "")); |
| EXPECT_EQ("", SetCommandLineOption("test_int32", "")); |
| EXPECT_EQ("", SetCommandLineOption("test_int64", "")); |
| EXPECT_EQ("", SetCommandLineOption("test_uint64", "")); |
| EXPECT_EQ("", SetCommandLineOption("test_double", "")); |
| EXPECT_EQ("test_string set to \n", SetCommandLineOption("test_string", "")); |
| |
| EXPECT_TRUE(FLAGS_test_bool); |
| EXPECT_EQ(119, FLAGS_test_int32); |
| EXPECT_EQ(1191, FLAGS_test_int64); |
| EXPECT_EQ(11911, FLAGS_test_uint64); |
| } |
| |
| |
| // Tests that we only evaluate macro args once |
| TEST(MacroArgs, EvaluateOnce) { |
| EXPECT_EQ(13, FLAGS_changeable_var); |
| // Make sure we don't ++ the value somehow, when evaluating the flag. |
| EXPECT_EQ(13, FLAGS_changeable_var); |
| // Make sure the macro only evaluated this var once. |
| EXPECT_EQ(13, changeable_var); |
| // Make sure the actual value and default value are the same |
| SetCommandLineOptionWithMode("changeable_var", "21", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ(21, FLAGS_changeable_var); |
| } |
| |
| TEST(MacroArgs, EvaluateOnceBool) { |
| EXPECT_TRUE(FLAGS_changeable_bool_var); |
| EXPECT_TRUE(FLAGS_changeable_bool_var); |
| EXPECT_EQ(8009, changeable_bool_var); |
| SetCommandLineOptionWithMode("changeable_bool_var", "false", |
| SET_FLAG_IF_DEFAULT); |
| EXPECT_FALSE(FLAGS_changeable_bool_var); |
| } |
| |
| TEST(MacroArgs, EvaluateOnceStrings) { |
| EXPECT_EQ("1", FLAGS_changeable_string_var); |
| EXPECT_EQ("1", FLAGS_changeable_string_var); |
| EXPECT_EQ(1, changeable_string_var); |
| SetCommandLineOptionWithMode("changeable_string_var", "different", |
| SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("different", FLAGS_changeable_string_var); |
| } |
| |
| // Tests that the FooFromEnv does the right thing |
| TEST(FromEnvTest, LegalValues) { |
| setenv("BOOL_VAL1", "true", 1); |
| setenv("BOOL_VAL2", "false", 1); |
| setenv("BOOL_VAL3", "1", 1); |
| setenv("BOOL_VAL4", "F", 1); |
| EXPECT_TRUE(BoolFromEnv("BOOL_VAL1", false)); |
| EXPECT_FALSE(BoolFromEnv("BOOL_VAL2", true)); |
| EXPECT_TRUE(BoolFromEnv("BOOL_VAL3", false)); |
| EXPECT_FALSE(BoolFromEnv("BOOL_VAL4", true)); |
| EXPECT_TRUE(BoolFromEnv("BOOL_VAL_UNKNOWN", true)); |
| EXPECT_FALSE(BoolFromEnv("BOOL_VAL_UNKNOWN", false)); |
| |
| setenv("INT_VAL1", "1", 1); |
| setenv("INT_VAL2", "-1", 1); |
| EXPECT_EQ(1, Int32FromEnv("INT_VAL1", 10)); |
| EXPECT_EQ(-1, Int32FromEnv("INT_VAL2", 10)); |
| EXPECT_EQ(10, Int32FromEnv("INT_VAL_UNKNOWN", 10)); |
| |
| setenv("INT_VAL3", "1099511627776", 1); |
| EXPECT_EQ(1, Int64FromEnv("INT_VAL1", 20)); |
| EXPECT_EQ(-1, Int64FromEnv("INT_VAL2", 20)); |
| EXPECT_EQ(1099511627776LL, Int64FromEnv("INT_VAL3", 20)); |
| EXPECT_EQ(20, Int64FromEnv("INT_VAL_UNKNOWN", 20)); |
| |
| EXPECT_EQ(1, Uint64FromEnv("INT_VAL1", 30)); |
| EXPECT_EQ(1099511627776ULL, Uint64FromEnv("INT_VAL3", 30)); |
| EXPECT_EQ(30, Uint64FromEnv("INT_VAL_UNKNOWN", 30)); |
| |
| // I pick values here that can be easily represented exactly in floating-point |
| setenv("DOUBLE_VAL1", "0.0", 1); |
| setenv("DOUBLE_VAL2", "1.0", 1); |
| setenv("DOUBLE_VAL3", "-1.0", 1); |
| EXPECT_EQ(0.0, DoubleFromEnv("DOUBLE_VAL1", 40.0)); |
| EXPECT_EQ(1.0, DoubleFromEnv("DOUBLE_VAL2", 40.0)); |
| EXPECT_EQ(-1.0, DoubleFromEnv("DOUBLE_VAL3", 40.0)); |
| EXPECT_EQ(40.0, DoubleFromEnv("DOUBLE_VAL_UNKNOWN", 40.0)); |
| |
| setenv("STRING_VAL1", "", 1); |
| setenv("STRING_VAL2", "my happy string!", 1); |
| EXPECT_STREQ("", StringFromEnv("STRING_VAL1", "unknown")); |
| EXPECT_STREQ("my happy string!", StringFromEnv("STRING_VAL2", "unknown")); |
| EXPECT_STREQ("unknown", StringFromEnv("STRING_VAL_UNKNOWN", "unknown")); |
| } |
| |
| // Tests that the FooFromEnv dies on parse-error |
| TEST(FromEnvDeathTest, IllegalValues) { |
| setenv("BOOL_BAD1", "so true!", 1); |
| setenv("BOOL_BAD2", "", 1); |
| EXPECT_DEATH(BoolFromEnv("BOOL_BAD1", false), "error parsing env variable"); |
| EXPECT_DEATH(BoolFromEnv("BOOL_BAD2", true), "error parsing env variable"); |
| |
| setenv("INT_BAD1", "one", 1); |
| setenv("INT_BAD2", "100000000000000000", 1); |
| setenv("INT_BAD3", "0xx10", 1); |
| setenv("INT_BAD4", "", 1); |
| EXPECT_DEATH(Int32FromEnv("INT_BAD1", 10), "error parsing env variable"); |
| EXPECT_DEATH(Int32FromEnv("INT_BAD2", 10), "error parsing env variable"); |
| EXPECT_DEATH(Int32FromEnv("INT_BAD3", 10), "error parsing env variable"); |
| EXPECT_DEATH(Int32FromEnv("INT_BAD4", 10), "error parsing env variable"); |
| |
| setenv("BIGINT_BAD1", "18446744073709551616000", 1); |
| EXPECT_DEATH(Int64FromEnv("INT_BAD1", 20), "error parsing env variable"); |
| EXPECT_DEATH(Int64FromEnv("INT_BAD3", 20), "error parsing env variable"); |
| EXPECT_DEATH(Int64FromEnv("INT_BAD4", 20), "error parsing env variable"); |
| EXPECT_DEATH(Int64FromEnv("BIGINT_BAD1", 200), "error parsing env variable"); |
| |
| setenv("BIGINT_BAD2", "-1", 1); |
| EXPECT_DEATH(Uint64FromEnv("INT_BAD1", 30), "error parsing env variable"); |
| EXPECT_DEATH(Uint64FromEnv("INT_BAD3", 30), "error parsing env variable"); |
| EXPECT_DEATH(Uint64FromEnv("INT_BAD4", 30), "error parsing env variable"); |
| EXPECT_DEATH(Uint64FromEnv("BIGINT_BAD1", 30), "error parsing env variable"); |
| // TODO(csilvers): uncomment this when we disallow negative numbers for uint64 |
| #if 0 |
| EXPECT_DEATH(Uint64FromEnv("BIGINT_BAD2", 30), "error parsing env variable"); |
| #endif |
| |
| setenv("DOUBLE_BAD1", "0.0.0", 1); |
| setenv("DOUBLE_BAD2", "", 1); |
| EXPECT_DEATH(DoubleFromEnv("DOUBLE_BAD1", 40.0), "error parsing env variable"); |
| EXPECT_DEATH(DoubleFromEnv("DOUBLE_BAD2", 40.0), "error parsing env variable"); |
| } |
| |
| // Tests that FlagSaver can save the states of string flags. |
| TEST(FlagSaverTest, CanSaveStringFlagStates) { |
| // 1. Initializes the flags. |
| |
| // State of flag test_str1: |
| // default value - "initial" |
| // current value - "initial" |
| // not set - true |
| |
| SetCommandLineOptionWithMode("test_str2", "second", SET_FLAGS_VALUE); |
| // State of flag test_str2: |
| // default value - "initial" |
| // current value - "second" |
| // not set - false |
| |
| SetCommandLineOptionWithMode("test_str3", "second", SET_FLAGS_DEFAULT); |
| // State of flag test_str3: |
| // default value - "second" |
| // current value - "second" |
| // not set - true |
| |
| // 2. Saves the flag states. |
| |
| { |
| FlagSaver fs; |
| |
| // 3. Modifies the flag states. |
| |
| SetCommandLineOptionWithMode("test_str1", "second", SET_FLAGS_VALUE); |
| EXPECT_EQ("second", FLAGS_test_str1); |
| // State of flag test_str1: |
| // default value - "second" |
| // current value - "second" |
| // not set - true |
| |
| SetCommandLineOptionWithMode("test_str2", "third", SET_FLAGS_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str2); |
| // State of flag test_str2: |
| // default value - "third" |
| // current value - "second" |
| // not set - false |
| |
| SetCommandLineOptionWithMode("test_str3", "third", SET_FLAGS_VALUE); |
| EXPECT_EQ("third", FLAGS_test_str3); |
| // State of flag test_str1: |
| // default value - "second" |
| // current value - "third" |
| // not set - false |
| |
| // 4. Restores the flag states. |
| } |
| |
| // 5. Verifies that the states were restored. |
| |
| // Verifies that the value of test_str1 was restored. |
| EXPECT_EQ("initial", FLAGS_test_str1); |
| // Verifies that the "not set" attribute of test_str1 was restored to true. |
| SetCommandLineOptionWithMode("test_str1", "second", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str1); |
| |
| // Verifies that the value of test_str2 was restored. |
| EXPECT_EQ("second", FLAGS_test_str2); |
| // Verifies that the "not set" attribute of test_str2 was restored to false. |
| SetCommandLineOptionWithMode("test_str2", "fourth", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("second", FLAGS_test_str2); |
| |
| // Verifies that the value of test_str3 was restored. |
| EXPECT_EQ("second", FLAGS_test_str3); |
| // Verifies that the "not set" attribute of test_str3 was restored to true. |
| SetCommandLineOptionWithMode("test_str3", "fourth", SET_FLAG_IF_DEFAULT); |
| EXPECT_EQ("fourth", FLAGS_test_str3); |
| } |
| |
| |
| // Tests that FlagSaver can save the values of various-typed flags. |
| TEST(FlagSaverTest, CanSaveVariousTypedFlagValues) { |
| // Initializes the flags. |
| FLAGS_test_bool = false; |
| FLAGS_test_int32 = -1; |
| FLAGS_test_int64 = -2; |
| FLAGS_test_uint64 = 3; |
| FLAGS_test_double = 4.0; |
| FLAGS_test_string = "good"; |
| |
| // Saves the flag states. |
| { |
| FlagSaver fs; |
| |
| // Modifies the flags. |
| FLAGS_test_bool = true; |
| FLAGS_test_int32 = -5; |
| FLAGS_test_int64 = -6; |
| FLAGS_test_uint64 = 7; |
| FLAGS_test_double = 8.0; |
| FLAGS_test_string = "bad"; |
| |
| // Restores the flag states. |
| } |
| |
| // Verifies the flag values were restored. |
| EXPECT_FALSE(FLAGS_test_bool); |
| EXPECT_EQ(-1, FLAGS_test_int32); |
| EXPECT_EQ(-2, FLAGS_test_int64); |
| EXPECT_EQ(3, FLAGS_test_uint64); |
| EXPECT_DOUBLE_EQ(4.0, FLAGS_test_double); |
| EXPECT_EQ("good", FLAGS_test_string); |
| } |
| |
| TEST(GetAllFlagsTest, BaseTest) { |
| vector<CommandLineFlagInfo> flags; |
| GetAllFlags(&flags); |
| bool found_test_bool = false; |
| vector<CommandLineFlagInfo>::const_iterator i; |
| for (i = flags.begin(); i != flags.end(); ++i) { |
| if (i->name == "test_bool") { |
| found_test_bool = true; |
| EXPECT_EQ(i->type, "bool"); |
| EXPECT_EQ(i->default_value, "false"); |
| break; |
| } |
| } |
| EXPECT_TRUE(found_test_bool); |
| } |
| |
| TEST(ShowUsageWithFlagsTest, BaseTest) { |
| // TODO(csilvers): test this by allowing output other than to stdout. |
| // Not urgent since this functionality is tested via |
| // gflags_unittest.sh, though only through use of --help. |
| } |
| |
| TEST(ShowUsageWithFlagsRestrictTest, BaseTest) { |
| // TODO(csilvers): test this by allowing output other than to stdout. |
| // Not urgent since this functionality is tested via |
| // gflags_unittest.sh, though only through use of --helpmatch. |
| } |
| |
| // Note: all these argv-based tests depend on SetArgv being called |
| // before ParseCommandLineFlags() in Main(), below. |
| TEST(GetArgvsTest, BaseTest) { |
| vector<string> argvs = GetArgvs(); |
| EXPECT_EQ(4, argvs.size()); |
| EXPECT_EQ("/test/argv/for/gflags_unittest", argvs[0]); |
| EXPECT_EQ("argv 2", argvs[1]); |
| EXPECT_EQ("3rd argv", argvs[2]); |
| EXPECT_EQ("argv #4", argvs[3]); |
| } |
| |
| TEST(GetArgvTest, BaseTest) { |
| EXPECT_STREQ("/test/argv/for/gflags_unittest " |
| "argv 2 3rd argv argv #4", GetArgv()); |
| } |
| |
| TEST(GetArgv0Test, BaseTest) { |
| EXPECT_STREQ("/test/argv/for/gflags_unittest", GetArgv0()); |
| } |
| |
| TEST(GetArgvSumTest, BaseTest) { |
| // This number is just the sum of the ASCII values of all the chars |
| // in GetArgv(). |
| EXPECT_EQ(4904, GetArgvSum()); |
| } |
| |
| TEST(ProgramInvocationNameTest, BaseTest) { |
| EXPECT_STREQ("/test/argv/for/gflags_unittest", |
| ProgramInvocationName()); |
| } |
| |
| TEST(ProgramInvocationShortNameTest, BaseTest) { |
| EXPECT_STREQ("gflags_unittest", ProgramInvocationShortName()); |
| } |
| |
| TEST(ProgramUsageTest, BaseTest) { // Depends on arg to SetUsageMessage() |
| EXPECT_STREQ("/test/argv/for/gflags_unittest: " |
| "<useless flag> [...]\nDoes something useless.\n", |
| ProgramUsage()); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameExistsAndIsDefault) { |
| string value("will be changed"); |
| bool r = GetCommandLineOption("test_bool", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("false", value); |
| |
| r = GetCommandLineOption("test_int32", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("-1", value); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameExistsAndWasAssigned) { |
| FLAGS_test_int32 = 400; |
| string value("will be changed"); |
| const bool r = GetCommandLineOption("test_int32", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("400", value); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameExistsAndWasSet) { |
| SetCommandLineOption("test_int32", "700"); |
| string value("will be changed"); |
| const bool r = GetCommandLineOption("test_int32", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("700", value); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameExistsAndWasNotSet) { |
| // This doesn't set the flag's value, but rather its default value. |
| // is_default is still true, but the 'default' value returned has changed! |
| SetCommandLineOptionWithMode("test_int32", "800", SET_FLAGS_DEFAULT); |
| string value("will be changed"); |
| const bool r = GetCommandLineOption("test_int32", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("800", value); |
| EXPECT_TRUE(GetCommandLineFlagInfoOrDie("test_int32").is_default); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameExistsAndWasConditionallySet) { |
| SetCommandLineOptionWithMode("test_int32", "900", SET_FLAG_IF_DEFAULT); |
| string value("will be changed"); |
| const bool r = GetCommandLineOption("test_int32", &value); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("900", value); |
| } |
| |
| TEST(GetCommandLineOptionTest, NameDoesNotExist) { |
| string value("will not be changed"); |
| const bool r = GetCommandLineOption("test_int3210", &value); |
| EXPECT_FALSE(r); |
| EXPECT_EQ("will not be changed", value); |
| } |
| |
| TEST(GetCommandLineFlagInfoTest, FlagExists) { |
| CommandLineFlagInfo info; |
| bool r = GetCommandLineFlagInfo("test_int32", &info); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("test_int32", info.name); |
| EXPECT_EQ("int32", info.type); |
| EXPECT_EQ("", info.description); |
| EXPECT_EQ("-1", info.current_value); |
| EXPECT_EQ("-1", info.default_value); |
| EXPECT_TRUE(info.is_default); |
| EXPECT_FALSE(info.has_validator_fn); |
| |
| FLAGS_test_bool = true; |
| r = GetCommandLineFlagInfo("test_bool", &info); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("test_bool", info.name); |
| EXPECT_EQ("bool", info.type); |
| EXPECT_EQ("tests bool-ness", info.description); |
| EXPECT_EQ("true", info.current_value); |
| EXPECT_EQ("false", info.default_value); |
| EXPECT_FALSE(info.is_default); |
| EXPECT_FALSE(info.has_validator_fn); |
| |
| FLAGS_test_bool = false; |
| r = GetCommandLineFlagInfo("test_bool", &info); |
| EXPECT_TRUE(r); |
| EXPECT_EQ("test_bool", info.name); |
| EXPECT_EQ("bool", info.type); |
| EXPECT_EQ("tests bool-ness", info.description); |
| EXPECT_EQ("false", info.current_value); |
| EXPECT_EQ("false", info.default_value); |
| EXPECT_FALSE(info.is_default); // value is same, but flag *was* modified |
| EXPECT_FALSE(info.has_validator_fn); |
| } |
| |
| TEST(GetCommandLineFlagInfoTest, FlagDoesNotExist) { |
| CommandLineFlagInfo info; |
| // Set to some random values that GetCommandLineFlagInfo should not change |
| info.name = "name"; |
| info.type = "type"; |
| info.current_value = "curr"; |
| info.default_value = "def"; |
| info.filename = "/"; |
| info.is_default = false; |
| info.has_validator_fn = true; |
| bool r = GetCommandLineFlagInfo("test_int3210", &info); |
| EXPECT_FALSE(r); |
| EXPECT_EQ("name", info.name); |
| EXPECT_EQ("type", info.type); |
| EXPECT_EQ("", info.description); |
| EXPECT_EQ("curr", info.current_value); |
| EXPECT_EQ("def", info.default_value); |
| EXPECT_EQ("/", info.filename); |
| EXPECT_FALSE(info.is_default); |
| EXPECT_TRUE(info.has_validator_fn); |
| } |
| |
| TEST(GetCommandLineFlagInfoOrDieTest, FlagExistsAndIsDefault) { |
| CommandLineFlagInfo info; |
| info = GetCommandLineFlagInfoOrDie("test_int32"); |
| EXPECT_EQ("test_int32", info.name); |
| EXPECT_EQ("int32", info.type); |
| EXPECT_EQ("", info.description); |
| EXPECT_EQ("-1", info.current_value); |
| EXPECT_EQ("-1", info.default_value); |
| EXPECT_TRUE(info.is_default); |
| info = GetCommandLineFlagInfoOrDie("test_bool"); |
| EXPECT_EQ("test_bool", info.name); |
| EXPECT_EQ("bool", info.type); |
| EXPECT_EQ("tests bool-ness", info.description); |
| EXPECT_EQ("false", info.current_value); |
| EXPECT_EQ("false", info.default_value); |
| EXPECT_TRUE(info.is_default); |
| EXPECT_FALSE(info.has_validator_fn); |
| } |
| |
| TEST(GetCommandLineFlagInfoOrDieTest, FlagExistsAndWasAssigned) { |
| FLAGS_test_int32 = 400; |
| CommandLineFlagInfo info; |
| info = GetCommandLineFlagInfoOrDie("test_int32"); |
| EXPECT_EQ("test_int32", info.name); |
| EXPECT_EQ("int32", info.type); |
| EXPECT_EQ("", info.description); |
| EXPECT_EQ("400", info.current_value); |
| EXPECT_EQ("-1", info.default_value); |
| EXPECT_FALSE(info.is_default); |
| FLAGS_test_bool = true; |
| info = GetCommandLineFlagInfoOrDie("test_bool"); |
| EXPECT_EQ("test_bool", info.name); |
| EXPECT_EQ("bool", info.type); |
| EXPECT_EQ("tests bool-ness", info.description); |
| EXPECT_EQ("true", info.current_value); |
| EXPECT_EQ("false", info.default_value); |
| EXPECT_FALSE(info.is_default); |
| EXPECT_FALSE(info.has_validator_fn); |
| } |
| |
| TEST(GetCommandLineFlagInfoOrDieDeathTest, FlagDoesNotExist) { |
| EXPECT_DEATH(GetCommandLineFlagInfoOrDie("test_int3210"), |
| ".*: flag test_int3210 does not exist"); |
| } |
| |
| |
| // These are lightly tested because they're deprecated. Basically, |
| // the tests are meant to cover how existing users use these functions, |
| // but not necessarily how new users could use them. |
| TEST(DeprecatedFunctionsTest, CommandlineFlagsIntoString) { |
| string s = CommandlineFlagsIntoString(); |
| EXPECT_NE(string::npos, s.find("--test_bool=")); |
| } |
| |
| TEST(DeprecatedFunctionsTest, AppendFlagsIntoFile) { |
| FLAGS_test_int32 = 10; // just to make the test more interesting |
| string filename(TmpFile("flagfile")); |
| unlink(filename.c_str()); // just to be safe |
| const bool r = AppendFlagsIntoFile(filename, "not the real argv0"); |
| EXPECT_TRUE(r); |
| |
| FILE* fp = fopen(filename.c_str(), "r"); |
| EXPECT_TRUE(fp != NULL); |
| char line[8192]; |
| EXPECT_TRUE(fgets(line, sizeof(line)-1, fp) != NULL); // get the first line |
| // First line should be progname. |
| EXPECT_STREQ("not the real argv0\n", line); |
| |
| bool found_bool = false, found_int32 = false; |
| while (fgets(line, sizeof(line)-1, fp)) { |
| line[sizeof(line)-1] = '\0'; // just to be safe |
| if (strcmp(line, "--test_bool=false\n") == 0) |
| found_bool = true; |
| if (strcmp(line, "--test_int32=10\n") == 0) |
| found_int32 = true; |
| } |
| EXPECT_TRUE(found_int32); |
| EXPECT_TRUE(found_bool); |
| fclose(fp); |
| } |
| |
| TEST(DeprecatedFunctionsTest, ReadFromFlagsFile) { |
| FLAGS_test_int32 = -10; // just to make the test more interesting |
| string filename(TmpFile("flagfile2")); |
| unlink(filename.c_str()); // just to be safe |
| bool r = AppendFlagsIntoFile(filename, GetArgv0()); |
| EXPECT_TRUE(r); |
| |
| FLAGS_test_int32 = -11; |
| r = ReadFromFlagsFile(filename, GetArgv0(), true); |
| EXPECT_TRUE(r); |
| EXPECT_EQ(-10, FLAGS_test_int32); |
| } |
| |
| TEST(DeprecatedFunctionsTest, ReadFromFlagsFileFailure) { |
| FLAGS_test_int32 = -20; |
| string filename(TmpFile("flagfile3")); |
| FILE* fp = fopen(filename.c_str(), "w"); |
| EXPECT_TRUE(fp != NULL); |
| // Note the error in the bool assignment below... |
| fprintf(fp, "%s\n--test_int32=-21\n--test_bool=not_a_bool!\n", GetArgv0()); |
| fclose(fp); |
| |
| FLAGS_test_int32 = -22; |
| const bool r = ReadFromFlagsFile(filename, GetArgv0(), false); |
| EXPECT_FALSE(r); |
| EXPECT_EQ(-22, FLAGS_test_int32); // the -21 from the flagsfile didn't take |
| } |
| |
| TEST(FlagsSetBeforeInitTest, TryFromEnv) { |
| EXPECT_EQ("pre-set", FLAGS_test_tryfromenv); |
| } |
| |
| // The following test case verifies that ParseCommandLineFlags() and |
| // ParseCommandLineNonHelpFlags() uses the last definition of a flag |
| // in case it's defined more than once. |
| |
| DEFINE_int32(test_flag, -1, "used for testing commandlineflags.cc"); |
| |
| // Parses and returns the --test_flag flag. |
| // If with_help is true, calls ParseCommandLineFlags; otherwise calls |
| // ParseCommandLineNonHelpFlags. |
| int32 ParseTestFlag(bool with_help, int argc, const char** const_argv) { |
| FlagSaver fs; // Restores the flags before returning. |
| |
| // Makes a copy of the input array s.t. it can be reused |
| // (ParseCommandLineFlags() will alter the array). |
| char** const argv_save = new char*[argc + 1]; |
| char** argv = argv_save; |
| memcpy(argv, const_argv, sizeof(*argv)*(argc + 1)); |
| |
| if (with_help) { |
| ParseCommandLineFlags(&argc, &argv, true); |
| } else { |
| ParseCommandLineNonHelpFlags(&argc, &argv, true); |
| } |
| |
| delete[] argv_save; |
| return FLAGS_test_flag; |
| } |
| |
| TEST(ParseCommandLineFlagsUsesLastDefinitionTest, |
| WhenFlagIsDefinedTwiceOnCommandLine) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=1", |
| "--test_flag=2", |
| NULL, |
| }; |
| |
| EXPECT_EQ(2, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(2, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsUsesLastDefinitionTest, |
| WhenFlagIsDefinedTwiceInFlagFile) { |
| const char* argv[] = { |
| "my_test", |
| GetFlagFileFlag(), |
| NULL, |
| }; |
| |
| EXPECT_EQ(2, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(2, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsUsesLastDefinitionTest, |
| WhenFlagIsDefinedInCommandLineAndThenFlagFile) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=0", |
| GetFlagFileFlag(), |
| NULL, |
| }; |
| |
| EXPECT_EQ(2, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(2, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsUsesLastDefinitionTest, |
| WhenFlagIsDefinedInFlagFileAndThenCommandLine) { |
| const char* argv[] = { |
| "my_test", |
| GetFlagFileFlag(), |
| "--test_flag=3", |
| NULL, |
| }; |
| |
| EXPECT_EQ(3, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(3, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsUsesLastDefinitionTest, |
| WhenFlagIsDefinedInCommandLineAndFlagFileAndThenCommandLine) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=0", |
| GetFlagFileFlag(), |
| "--test_flag=3", |
| NULL, |
| }; |
| |
| EXPECT_EQ(3, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(3, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsAndDashArgs, TwoDashArgFirst) { |
| const char* argv[] = { |
| "my_test", |
| "--", |
| "--test_flag=0", |
| NULL, |
| }; |
| |
| EXPECT_EQ(-1, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(-1, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsAndDashArgs, TwoDashArgMiddle) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=7", |
| "--", |
| "--test_flag=0", |
| NULL, |
| }; |
| |
| EXPECT_EQ(7, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(7, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsAndDashArgs, OneDashArg) { |
| const char* argv[] = { |
| "my_test", |
| "-", |
| "--test_flag=0", |
| NULL, |
| }; |
| |
| EXPECT_EQ(0, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| EXPECT_EQ(0, ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv)); |
| } |
| |
| TEST(ParseCommandLineFlagsUnknownFlagDeathTest, |
| FlagIsCompletelyUnknown) { |
| const char* argv[] = { |
| "my_test", |
| "--this_flag_does_not_exist", |
| NULL, |
| }; |
| |
| EXPECT_DEATH(ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv), |
| "unknown command line flag.*"); |
| EXPECT_DEATH(ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv), |
| "unknown command line flag.*"); |
| } |
| |
| TEST(ParseCommandLineFlagsUnknownFlagDeathTest, |
| BoolFlagIsCompletelyUnknown) { |
| const char* argv[] = { |
| "my_test", |
| "--nothis_flag_does_not_exist", |
| NULL, |
| }; |
| |
| EXPECT_DEATH(ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv), |
| "unknown command line flag.*"); |
| EXPECT_DEATH(ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv), |
| "unknown command line flag.*"); |
| } |
| |
| TEST(ParseCommandLineFlagsUnknownFlagDeathTest, |
| FlagIsNotABool) { |
| const char* argv[] = { |
| "my_test", |
| "--notest_string", |
| NULL, |
| }; |
| |
| EXPECT_DEATH(ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv), |
| "boolean value .* specified for .* command line flag"); |
| EXPECT_DEATH(ParseTestFlag(false, GET_ARRAY_SIZE(argv) - 1, argv), |
| "boolean value .* specified for .* command line flag"); |
| } |
| |
| TEST(ParseCommandLineFlagsWrongFields, |
| DescriptionIsInvalid) { |
| // These must not be automatic variables, since command line flags |
| // aren't unregistered and gUnit uses FlagSaver to save and restore |
| // command line flags' values. If these are on the stack, then when |
| // later tests attempt to save and restore their values, the stack |
| // addresses of these variables will be overwritten... Stack smash! |
| static bool current_storage; |
| static bool defvalue_storage; |
| FlagRegisterer fr("flag_name", "bool", 0, "filename", |
| ¤t_storage, &defvalue_storage); |
| CommandLineFlagInfo fi; |
| EXPECT_TRUE(GetCommandLineFlagInfo("flag_name", &fi)); |
| EXPECT_EQ("", fi.description); |
| } |
| |
| static bool ValidateTestFlagIs5(const char* flagname, int32 flagval) { |
| if (flagval == 5) |
| return true; |
| printf("%s isn't 5!\n", flagname); |
| return false; |
| } |
| |
| static bool ValidateTestFlagIs10(const char* flagname, int32 flagval) { |
| return flagval == 10; |
| } |
| |
| |
| TEST(FlagsValidator, ValidFlagViaArgv) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=5", |
| NULL, |
| }; |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_EQ(5, ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv)); |
| // Undo the flag validator setting |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidator, ValidFlagViaSetDefault) { |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| // SetCommandLineOptionWithMode returns the empty string on error. |
| EXPECT_NE("", SetCommandLineOptionWithMode("test_flag", "5", |
| SET_FLAG_IF_DEFAULT)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidator, ValidFlagViaSetValue) { |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| FLAGS_test_flag = 100; // doesn't trigger the validator |
| // SetCommandLineOptionWithMode returns the empty string on error. |
| EXPECT_NE("", SetCommandLineOptionWithMode("test_flag", "5", |
| SET_FLAGS_VALUE)); |
| EXPECT_NE("", SetCommandLineOptionWithMode("test_flag", "5", |
| SET_FLAGS_DEFAULT)); |
| EXPECT_NE("", SetCommandLineOption("test_flag", "5")); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidatorDeathTest, InvalidFlagViaArgv) { |
| const char* argv[] = { |
| "my_test", |
| "--test_flag=50", |
| NULL, |
| }; |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_DEATH(ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv), |
| "ERROR: failed validation of new value '50' for flag 'test_flag'"); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidator, InvalidFlagViaSetDefault) { |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| // SetCommandLineOptionWithMode returns the empty string on error. |
| EXPECT_EQ("", SetCommandLineOptionWithMode("test_flag", "50", |
| SET_FLAG_IF_DEFAULT)); |
| EXPECT_EQ(-1, FLAGS_test_flag); // the setting-to-50 should have failed |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidator, InvalidFlagViaSetValue) { |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| FLAGS_test_flag = 100; // doesn't trigger the validator |
| // SetCommandLineOptionWithMode returns the empty string on error. |
| EXPECT_EQ("", SetCommandLineOptionWithMode("test_flag", "50", |
| SET_FLAGS_VALUE)); |
| EXPECT_EQ("", SetCommandLineOptionWithMode("test_flag", "50", |
| SET_FLAGS_DEFAULT)); |
| EXPECT_EQ("", SetCommandLineOption("test_flag", "50")); |
| EXPECT_EQ(100, FLAGS_test_flag); // the setting-to-50 should have failed |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidatorDeathTest, InvalidFlagNeverSet) { |
| // If a flag keeps its default value, and that default value is |
| // invalid, we should die at argv-parse time. |
| const char* argv[] = { |
| "my_test", |
| NULL, |
| }; |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_DEATH(ParseTestFlag(true, GET_ARRAY_SIZE(argv) - 1, argv), |
| "ERROR: --test_flag must be set on the commandline"); |
| } |
| |
| TEST(FlagsValidator, InvalidFlagPtr) { |
| int32 dummy; |
| EXPECT_FALSE(RegisterFlagValidator(NULL, &ValidateTestFlagIs5)); |
| EXPECT_FALSE(RegisterFlagValidator(&dummy, &ValidateTestFlagIs5)); |
| } |
| |
| TEST(FlagsValidator, RegisterValidatorTwice) { |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_FALSE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs10)); |
| EXPECT_FALSE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs10)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs10)); |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| } |
| |
| TEST(FlagsValidator, CommandLineFlagInfo) { |
| CommandLineFlagInfo info; |
| info = GetCommandLineFlagInfoOrDie("test_flag"); |
| EXPECT_FALSE(info.has_validator_fn); |
| |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| info = GetCommandLineFlagInfoOrDie("test_flag"); |
| EXPECT_TRUE(info.has_validator_fn); |
| |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| info = GetCommandLineFlagInfoOrDie("test_flag"); |
| EXPECT_FALSE(info.has_validator_fn); |
| } |
| |
| TEST(FlagsValidator, FlagSaver) { |
| { |
| FlagSaver fs; |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| EXPECT_EQ("", SetCommandLineOption("test_flag", "50")); // fails validation |
| } |
| EXPECT_NE("", SetCommandLineOption("test_flag", "50")); // validator is gone |
| |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, &ValidateTestFlagIs5)); |
| { |
| FlagSaver fs; |
| EXPECT_TRUE(RegisterFlagValidator(&FLAGS_test_flag, NULL)); |
| EXPECT_NE("", SetCommandLineOption("test_flag", "50")); // no validator |
| } |
| EXPECT_EQ("", SetCommandLineOption("test_flag", "50")); // validator is back |
| } |
| |
| |
| static int Main(int argc, char **argv) { |
| // We need to call SetArgv before SetUsage, so our "test" argv will |
| // win out over this executable's real argv. That makes running this |
| // test with a real --help flag kinda annoying, unfortunately. |
| const char* test_argv[] = { "/test/argv/for/gflags_unittest", |
| "argv 2", "3rd argv", "argv #4" }; |
| SetArgv(GET_ARRAY_SIZE(test_argv), test_argv); |
| |
| // The first arg is the usage message, also important for testing. |
| string usage_message = (string(GetArgv0()) + |
| ": <useless flag> [...]\nDoes something useless.\n"); |
| |
| // We test setting tryfromenv manually, and making sure |
| // ParseCommandLineFlags still evaluates it. |
| FLAGS_tryfromenv = "test_tryfromenv"; |
| setenv("FLAGS_test_tryfromenv", "pre-set", 1); |
| |
| // Modify flag values from declared default value in two ways. |
| // The recommended way: |
| SetCommandLineOptionWithMode("changed_bool1", "true", SET_FLAGS_DEFAULT); |
| // The non-recommended way: |
| FLAGS_changed_bool2 = true; |
| |
| SetUsageMessage(usage_message.c_str()); |
| ParseCommandLineFlags(&argc, &argv, true); |
| |
| #if defined(__MINGW32__) |
| // I had trouble creating a directory in /tmp from mingw |
| FLAGS_test_tmpdir = "./gflags_unittest_testdir"; |
| mkdir(FLAGS_test_tmpdir.c_str()); // mingw has a weird one-arg mkdir |
| #elif defined(_MSC_VER) |
| char tmppath_buffer[1024]; |
| int tmppath_len = GetTempPathA(sizeof(tmppath_buffer), tmppath_buffer); |
| assert(tmppath_len > 0 && tmppath_len < sizeof(tmppath_buffer)); |
| assert(tmppath_buffer[tmppath_len - 1] == '\\'); // API guarantees it |
| FLAGS_test_tmpdir = string(tmppath_buffer) + "gflags_unittest_testdir"; |
| _mkdir(FLAGS_test_tmpdir.c_str()); |
| #else |
| mkdir(FLAGS_test_tmpdir.c_str(), 0755); |
| #endif |
| |
| return RUN_ALL_TESTS(); |
| } |
| |
| _END_GOOGLE_NAMESPACE_ |
| |
| int main(int argc, char** argv) { |
| const int exit_status = GOOGLE_NAMESPACE::Main(argc, argv); |
| GOOGLE_NAMESPACE::ShutDownCommandLineFlags(); |
| return exit_status; |
| } |
