Fix DLL build on Windows and use PathMatchSpec instead of fnmatch.

Expose as few system variables as possible through public interface.
Perform STRIP_FLAGS_HELP test using CMake instead of Bash.
Change file path separator used by gflags_reporting.cc to backslash on Windwos.

5 files changed, 106 insertions, 173 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 67e2e0c..3f7f17e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -2,9 +2,9 @@
 
 # ----------------------------------------------------------------------------
 # output directories
-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/bin")
-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/lib")
-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/lib")
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 
 # set working directory of test commands
 set (GFLAGS_FLAGFILES_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
@@ -15,139 +15,134 @@ include_directories ("${CMAKE_CURRENT_SOURCE_DIR}")
 link_libraries (gflags_nothreads)
 
 # ----------------------------------------------------------------------------
-# STRIP_FLAG_HELP: check with "strings" that help text is not in binary
-if (UNIX AND NOT CYGWIN)
-  add_executable (strip_flags gflags_strip_flags_test.cc)
-  add_test (
-    NAME    strip_flags
-    COMMAND /bin/bash "${CMAKE_CURRENT_SOURCE_DIR}/gflags_strip_flags_test.sh"
-            "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/strip_flags"
-  )
-endif ()
+# STRIP_FLAG_HELP
+add_executable (gflags_strip_flags_test gflags_strip_flags_test.cc)
+# Make sure the --help output doesn't print the stripped text.
+add_gflags_test (strip_flags_help 1 "" "This text should be stripped out" gflags_strip_flags_test --help)
+# Make sure the stripped text isn't in the binary at all.
+add_test (
+  NAME strip_flags_binary
+  COMMAND "${CMAKE_COMMAND}" "-DBINARY=$<TARGET_FILE:gflags_strip_flags_test>"
+          -P "${CMAKE_CURRENT_SOURCE_DIR}/gflags_strip_flags_test.cmake"
+)
 
 # ----------------------------------------------------------------------------
 # unit tests
 configure_file (gflags_unittest.cc gflags_unittest-main.cc COPYONLY)
 configure_file (gflags_unittest.cc gflags_unittest_main.cc COPYONLY)
 
-add_executable (unittest  gflags_unittest.cc)
-add_executable (unittest2 gflags_unittest-main.cc)
-add_executable (unittest3 gflags_unittest_main.cc)
+add_executable (gflags_unittest      gflags_unittest.cc)
+add_executable (gflags_unittest-main gflags_unittest-main.cc)
+add_executable (gflags_unittest_main gflags_unittest_main.cc)
 
-if (UNIX)
-  set (SLASH "/")
-else ()
+if (WIN32 AND NOT CYGWIN)
   set (SLASH "\\\\")
+else ()
+  set (SLASH "/")
 endif ()
 
-# First, just make sure the unittest works as-is
-add_gflags_test(unittest 0 "" "" unittest)
+# First, just make sure the  gflags_unittest  works as-is
+add_gflags_test(unittest 0 "" "" gflags_unittest)
 
 # --help should show all flags, including flags from gflags_reporting
-add_gflags_test(help-reporting 1 "${SLASH}gflags_reporting.cc" "" unittest --help)
+add_gflags_test(help-reporting 1 "${SLASH}gflags_reporting.cc:" ""  gflags_unittest  --help)
 
 # Make sure that --help prints even very long helpstrings.
-add_gflags_test(long-helpstring 1 "end of a long helpstring" "" unittest --help)
+add_gflags_test(long-helpstring 1 "end of a long helpstring" ""  gflags_unittest  --help)
 
 # Make sure --help reflects flag changes made before flag-parsing
-add_gflags_test(changed_bool1 1 "-changed_bool1 (changed) type: bool default: true" "" unittest --help)
-add_gflags_test(changed_bool2 1 "-changed_bool2 (changed) type: bool default: false currently: true" "" unittest --help)
+add_gflags_test(changed_bool1 1 "-changed_bool1 (changed) type: bool default: true" ""  gflags_unittest  --help)
+add_gflags_test(changed_bool2 1 "-changed_bool2 (changed) type: bool default: false currently: true" ""  gflags_unittest  --help)
 # And on the command-line, too
-add_gflags_test(changeable_string_var 1 "-changeable_string_var () type: string default: \"1\" currently: \"2\"" "" unittest --changeable_string_var 2 --help)
+add_gflags_test(changeable_string_var 1 "-changeable_string_var () type: string default: \"1\" currently: \"2\"" ""  gflags_unittest  --changeable_string_var 2 --help)
 
 # --nohelp and --help=false should be as if we didn't say anything
-add_gflags_test(nohelp     0 "PASS" "" unittest --nohelp)
-add_gflags_test(help=false 0 "PASS" "" unittest --help=false)
+add_gflags_test(nohelp     0 "PASS" ""  gflags_unittest  --nohelp)
+add_gflags_test(help=false 0 "PASS" ""  gflags_unittest  --help=false)
 
 # --helpfull is the same as help
-add_gflags_test(helpfull 1 "${SLASH}gflags_reporting.cc" "" unittest --helpfull)
+add_gflags_test(helpfull 1 "${SLASH}gflags_reporting.cc:" ""  gflags_unittest  --helpfull)
 
-# --helpshort should show only flags from the unittest itself
-add_gflags_test(helpshort 1 "${SLASH}gflags_unittest.cc" "${SLASH}gflags_reporting.cc" unittest --helpshort)
+# --helpshort should show only flags from the  gflags_unittest  itself
+add_gflags_test(helpshort 1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags_reporting.cc:"  gflags_unittest  --helpshort)
 
-# --helpshort should show the tldflag we created in the unittest dir
-add_gflags_test(helpshort-tldflag1 1 "tldflag1" "${SLASH}google.cc" unittest --helpshort)
-add_gflags_test(helpshort-tldflag2 1 "tldflag2" "${SLASH}google.cc" unittest --helpshort)
+# --helpshort should show the tldflag we created in the  gflags_unittest  dir
+add_gflags_test(helpshort-tldflag1 1 "tldflag1" "${SLASH}google.cc:"  gflags_unittest  --helpshort)
+add_gflags_test(helpshort-tldflag2 1 "tldflag2" "${SLASH}google.cc:"  gflags_unittest  --helpshort)
 
 # --helpshort should work if the main source file is suffixed with [_-]main
-add_gflags_test(helpshort-main 1 "${SLASH}gflags_unittest-main.cc" "${SLASH}gflags_reporting.cc" unittest2 --helpshort)
-add_gflags_test(helpshort_main 1 "${SLASH}gflags_unittest_main.cc" "${SLASH}gflags_reporting.cc" unittest3 --helpshort)
+add_gflags_test(helpshort-main 1 "${SLASH}gflags_unittest-main.cc:" "${SLASH}gflags_reporting.cc:" gflags_unittest-main --helpshort)
+add_gflags_test(helpshort_main 1 "${SLASH}gflags_unittest_main.cc:" "${SLASH}gflags_reporting.cc:" gflags_unittest_main --helpshort)
 
 # --helpon needs an argument
-add_gflags_test(helpon 1 "'--helpon' is missing its argument; flag description: show help on" "" unittest --helpon)
-
-if (BUILD_SHARED_LIBS)
-  # --helpon argument indicates what file we'll show args from
-  # TODO(andreas): This test fails. Why is there no help for the gflags module ?
-  add_gflags_test(helpon=gflags 1 "${SLASH}gflags.cc" "${SLASH}gflags_unittest.cc" unittest --helpon=gflags)
-  # another way of specifying the argument
-  # TODO(andreas): This test fails. Why is there no help for the gflags module ?
-  add_gflags_test(helpon_gflags 1 "${SLASH}gflags.cc" "${SLASH}gflags_unittest.cc" unittest --helpon gflags)
-endif ()
-
+add_gflags_test(helpon 1 "'--helpon' is missing its argument; flag description: show help on" ""  gflags_unittest  --helpon)
+# --helpon argument indicates what file we'll show args from
+add_gflags_test(helpon=gflags 1 "${SLASH}gflags.cc:" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --helpon=gflags)
+# another way of specifying the argument
+add_gflags_test(helpon_gflags 1 "${SLASH}gflags.cc:" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --helpon gflags)
 # test another argument
-add_gflags_test(helpon=gflags_unittest 1 "${SLASH}gflags_unittest.cc" "${SLASH}gflags.cc" unittest --helpon=gflags_unittest)
+add_gflags_test(helpon=gflags_unittest 1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags.cc:"  gflags_unittest  --helpon=gflags_unittest)
 
 # helpmatch is like helpon but takes substrings
-add_gflags_test(helpmatch_reporting 1 "${SLASH}gflags_reporting.cc" "${SLASH}gflags_unittest.cc" unittest -helpmatch reporting)
-add_gflags_test(helpmatch=unittest  1 "${SLASH}gflags_unittest.cc" "${SLASH}gflags.cc:" unittest -helpmatch=unittest)
+add_gflags_test(helpmatch_reporting 1 "${SLASH}gflags_reporting.cc:" "${SLASH}gflags_unittest.cc:"  gflags_unittest  -helpmatch reporting)
+add_gflags_test(helpmatch=unittest  1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags.cc:"  gflags_unittest  -helpmatch=unittest)
 
 # if no flags are found with helpmatch or helpon, suggest --help
-add_gflags_test(helpmatch=nosuchsubstring 1 "No modules matched" "${SLASH}gflags_unittest.cc" unittest -helpmatch=nosuchsubstring)
-add_gflags_test(helpon=nosuchmodule       1 "No modules matched" "${SLASH}gflags_unittest.cc" unittest -helpon=nosuchmodule)
+add_gflags_test(helpmatch=nosuchsubstring 1 "No modules matched" "${SLASH}gflags_unittest.cc:"  gflags_unittest  -helpmatch=nosuchsubstring)
+add_gflags_test(helpon=nosuchmodule       1 "No modules matched" "${SLASH}gflags_unittest.cc:"  gflags_unittest  -helpon=nosuchmodule)
 
 # helppackage shows all the flags in the same dir as this unittest
 # --help should show all flags, including flags from google.cc
-add_gflags_test(helppackage 1 "${SLASH}gflags_reporting.cc" "" unittest --helppackage)
+add_gflags_test(helppackage 1 "${SLASH}gflags_reporting.cc:" ""  gflags_unittest  --helppackage)
 
 # xml!
-add_gflags_test(helpxml 1 "${SLASH}gflags_unittest.cc</file>" "${SLASH}gflags_unittest.cc:" unittest --helpxml)
+add_gflags_test(helpxml 1 "${SLASH}gflags_unittest.cc</file>" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --helpxml)
 
 # just print the version info and exit
-add_gflags_test(version-1 0 "gflags_unittest"      "${SLASH}gflags_unittest.cc" unittest --version)
-add_gflags_test(version-2 0 "version test_version" "${SLASH}gflags_unittest.cc" unittest --version)
+add_gflags_test(version-1 0 "gflags_unittest"      "${SLASH}gflags_unittest.cc:"  gflags_unittest  --version)
+add_gflags_test(version-2 0 "version test_version" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --version)
 
 # --undefok is a fun flag...
-add_gflags_test(undefok-1 1 "unknown command line flag 'foo'" "" unittest --undefok= --foo --unused_bool)
-add_gflags_test(undefok-2 0 "PASS" "" unittest --undefok=foo --foo --unused_bool)
+add_gflags_test(undefok-1 1 "unknown command line flag 'foo'" ""  gflags_unittest  --undefok= --foo --unused_bool)
+add_gflags_test(undefok-2 0 "PASS" ""  gflags_unittest  --undefok=foo --foo --unused_bool)
 # If you say foo is ok to be undefined, we'll accept --nofoo as well
-add_gflags_test(undefok-3 0 "PASS" "" unittest --undefok=foo --nofoo --unused_bool)
+add_gflags_test(undefok-3 0 "PASS" ""  gflags_unittest  --undefok=foo --nofoo --unused_bool)
 # It's ok if the foo is in the middle
-add_gflags_test(undefok-4 0 "PASS" "" unittest --undefok=fee,fi,foo,fum --foo --unused_bool)
+add_gflags_test(undefok-4 0 "PASS" ""  gflags_unittest  --undefok=fee,fi,foo,fum --foo --unused_bool)
 # But the spelling has to be just right...
-add_gflags_test(undefok-5 1 "unknown command line flag 'foo'" "" unittest --undefok=fo --foo --unused_bool)
-add_gflags_test(undefok-6 1 "unknown command line flag 'foo'" "" unittest --undefok=foot --foo --unused_bool)
+add_gflags_test(undefok-5 1 "unknown command line flag 'foo'" ""  gflags_unittest  --undefok=fo --foo --unused_bool)
+add_gflags_test(undefok-6 1 "unknown command line flag 'foo'" ""  gflags_unittest  --undefok=foot --foo --unused_bool)
 
 # See if we can successfully load our flags from the flagfile
-add_gflags_test(flagfile.1 0 "gflags_unittest" "${SLASH}gflags_unittest.cc" unittest "--flagfile=flagfile.1")
-add_gflags_test(flagfile.2 0 "PASS" "" unittest "--flagfile=flagfile.2")
-add_gflags_test(flagfile.3 0 "PASS" "" unittest "--flagfile=flagfile.3")
+add_gflags_test(flagfile.1 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:"  gflags_unittest  "--flagfile=flagfile.1")
+add_gflags_test(flagfile.2 0 "PASS" ""  gflags_unittest  "--flagfile=flagfile.2")
+add_gflags_test(flagfile.3 0 "PASS" ""  gflags_unittest  "--flagfile=flagfile.3")
 
 # Also try to load flags from the environment
-add_gflags_test(fromenv=version      0 "gflags_unittest" "${SLASH}gflags_unittest.cc" unittest --fromenv=version)
-add_gflags_test(tryfromenv=version   0 "gflags_unittest" "${SLASH}gflags_unittest.cc" unittest --tryfromenv=version)
-add_gflags_test(fromenv=help         0 "PASS" "" unittest --fromenv=help)
-add_gflags_test(tryfromenv=help      0 "PASS" "" unittest --tryfromenv=help)
-add_gflags_test(fromenv=helpfull     1 "helpfull not found in environment" "" unittest --fromenv=helpfull)
-add_gflags_test(tryfromenv=helpfull  0 "PASS" "" unittest --tryfromenv=helpfull)
-add_gflags_test(tryfromenv=undefok   0 "PASS" "" unittest --tryfromenv=undefok --foo)
-add_gflags_test(tryfromenv=weirdo    1 "unknown command line flag" "" unittest --tryfromenv=weirdo)
-add_gflags_test(tryfromenv-multiple  0 "gflags_unittest" "${SLASH}gflags_unittest.cc" unittest --tryfromenv=test_bool,version,unused_bool)
-add_gflags_test(fromenv=test_bool    1 "not found in environment" "" unittest --fromenv=test_bool)
-add_gflags_test(fromenv=test_bool-ok 1 "unknown command line flag" "" unittest --fromenv=test_bool,ok)
+add_gflags_test(fromenv=version      0 "gflags_unittest" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --fromenv=version)
+add_gflags_test(tryfromenv=version   0 "gflags_unittest" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --tryfromenv=version)
+add_gflags_test(fromenv=help         0 "PASS" ""  gflags_unittest  --fromenv=help)
+add_gflags_test(tryfromenv=help      0 "PASS" ""  gflags_unittest  --tryfromenv=help)
+add_gflags_test(fromenv=helpfull     1 "helpfull not found in environment" ""  gflags_unittest  --fromenv=helpfull)
+add_gflags_test(tryfromenv=helpfull  0 "PASS" ""  gflags_unittest  --tryfromenv=helpfull)
+add_gflags_test(tryfromenv=undefok   0 "PASS" ""  gflags_unittest  --tryfromenv=undefok --foo)
+add_gflags_test(tryfromenv=weirdo    1 "unknown command line flag" ""  gflags_unittest  --tryfromenv=weirdo)
+add_gflags_test(tryfromenv-multiple  0 "gflags_unittest" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --tryfromenv=test_bool,version,unused_bool)
+add_gflags_test(fromenv=test_bool    1 "not found in environment" ""  gflags_unittest  --fromenv=test_bool)
+add_gflags_test(fromenv=test_bool-ok 1 "unknown command line flag" ""  gflags_unittest  --fromenv=test_bool,ok)
 # Here, the --version overrides the fromenv
-add_gflags_test(version-overrides-fromenv 0 "gflags_unittest" "${SLASH}gflags_unittest.cc" unittest --fromenv=test_bool,version,ok)
+add_gflags_test(version-overrides-fromenv 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:"  gflags_unittest  --fromenv=test_bool,version,ok)
 
 # Make sure -- by itself stops argv processing
-add_gflags_test(dashdash 0 "PASS" "" unittest -- --help)
+add_gflags_test(dashdash 0 "PASS" ""  gflags_unittest  -- --help)
 
 # And we should die if the flag value doesn't pass the validator
-add_gflags_test(always_fail 1 "ERROR: failed validation of new value 'true' for flag 'always_fail'" "" unittest --always_fail)
+add_gflags_test(always_fail 1 "ERROR: failed validation of new value 'true' for flag 'always_fail'" ""  gflags_unittest  --always_fail)
 
 # And if locking in validators fails
 # TODO(andreas): Worked on Windows 7 Release configuration, but causes
 #                debugger abort() intervention in case of Debug configuration.
-#add_gflags_test(deadlock_if_cant_lock 0 "PASS" "" unittest --deadlock_if_cant_lock)
+#add_gflags_test(deadlock_if_cant_lock 0 "PASS" ""  gflags_unittest  --deadlock_if_cant_lock)
 
 # ----------------------------------------------------------------------------
 # (negative) compilation tests
@@ -159,15 +154,15 @@ if (BUILD_NEGATIVE_COMPILATION_TESTS)
   endif ()
   set (SRCDIR "${CMAKE_CURRENT_SOURCE_DIR}/nc")
   configure_file (gflags_nc.py.in "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/nc.py" @ONLY)
-  macro (add_nc_test name)
+  macro (add_gflags_nc_test name)
     add_test (
       NAME nc_${name}
       COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/nc.py" ${name}
     )
   endmacro ()
-  add_nc_test (sanity)
-  add_nc_test (swapped_args)
-  add_nc_test (int_instead_of_bool)
-  add_nc_test (bool_in_quotes)
-  add_nc_test (define_string_with_0)
+  add_gflags_nc_test (sanity)
+  add_gflags_nc_test (swapped_args)
+  add_gflags_nc_test (int_instead_of_bool)
+  add_gflags_nc_test (bool_in_quotes)
+  add_gflags_nc_test (define_string_with_0)
 endif ()
\ No newline at end of file
diff --git a/test/config_for_unittests.h b/test/config_for_unittests.h
index ac0df4c..914571b 100644
--- a/test/config_for_unittests.h
+++ b/test/config_for_unittests.h
@@ -55,9 +55,25 @@
 
 #include "config.h"
 
-#undef GFLAGS_DLL_DECL
+#ifdef GFLAGS_DLL_DECL
+#  undef GFLAGS_DLL_DECL
+#endif
+#ifdef GFLAGS_DLL_DEFINE_FLAG
+#  undef GFLAGS_DLL_DEFINE_FLAG
+#endif
+#ifdef GFLAGS_DLL_DECLARE_FLAG
+#  undef GFLAGS_DLL_DECLARE_FLAG
+#endif
+
 #ifdef GFLAGS_DLL_DECL_FOR_UNITTESTS
-# define GFLAGS_DLL_DECL  GFLAGS_DLL_DECL_FOR_UNITTESTS
+#  define GFLAGS_DLL_DECL  GFLAGS_DLL_DECL_FOR_UNITTESTS
 #else
-# define GFLAGS_DLL_DECL  // if DLL_DECL_FOR_UNITTESTS isn't defined, use ""
+#  define GFLAGS_DLL_DECL  // if DLL_DECL_FOR_UNITTESTS isn't defined, use ""
 #endif
+
+// Import flags defined by gflags.cc
+#if GFLAGS_IS_A_DLL && defined(_MSC_VER)
+#  define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport)
+#else
+#  define GFLAGS_DLL_DECLARE_FLAG
+#endif
\ No newline at end of file
diff --git a/test/gflags_strip_flags_test.cmake b/test/gflags_strip_flags_test.cmake
new file mode 100644
index 0000000..bd419c4
--- /dev/null
+++ b/test/gflags_strip_flags_test.cmake
@@ -0,0 +1,7 @@
+if (NOT BINARY)
+  message (FATAl_ERROR "BINARY file to check not specified!")
+endif ()
+file (STRINGS "${BINARY}" strings REGEX "This text should be stripped out")
+if (strings)
+  message (FATAL_ERROR "Text not stripped from binary like it should be: ${BINARY}")
+endif ()
\ No newline at end of file
diff --git a/test/gflags_strip_flags_test.sh b/test/gflags_strip_flags_test.sh
deleted file mode 100755
index 9ebb457..0000000
--- a/test/gflags_strip_flags_test.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2011, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (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: csilvers@google.com (Craig Silverstein)
-
-if [ -z "$1" ]; then
-  echo "USAGE: $0 <unittest exe>"
-  exit 1
-fi
-BINARY="$1"
-
-# Make sure the binary exists...
-if ! "$BINARY" >/dev/null 2>/dev/null
-then
-  echo "Cannot run binary $BINARY"
-  exit 1
-fi
-
-# Make sure the --help output doesn't print the stripped text.
-if "$BINARY" --help | grep "This text should be stripped out" >/dev/null 2>&1
-then
-  echo "Text not stripped from --help like it should be: $BINARY"
-  exit 1
-fi
-
-# Make sure the stripped text isn't in the binary at all.
-if strings --help >/dev/null 2>&1    # make sure the binary exists
-then
-  # Unfortunately, for us, libtool can replace executables with a
-  # shell script that does some work before calling the 'real'
-  # executable under a different name.  We need the 'real'
-  # executable name to run 'strings' on it, so we construct this
-  # binary to print the real name (argv[0]) on stdout when run.
-  REAL_BINARY=`"$BINARY"`
-  # On cygwin, we may need to add a '.exe' extension by hand.
-  [ -f "$REAL_BINARY.exe" ] && REAL_BINARY="$REAL_BINARY.exe"
-  if strings "$REAL_BINARY" | grep "This text should be stripped" >/dev/null 2>&1
-  then
-    echo "Text not stripped from binary like it should be: $BINARY"
-    exit 1
-  fi
-
-  # Let's also do a sanity check to make sure strings is working properly
-  if ! strings "$REAL_BINARY" | grep "Usage message" >/dev/null 2>&1
-  then
-    echo "Usage text not found in binary like it should be: $BINARY"
-    exit 1
-  fi
-fi
-
-echo "PASS"
diff --git a/test/gflags_unittest.cc b/test/gflags_unittest.cc
index cdcb600..cff9b7c 100644
--- a/test/gflags_unittest.cc
+++ b/test/gflags_unittest.cc
@@ -35,11 +35,6 @@
 #include "config_for_unittests.h"
 #include <gflags/gflags.h>
 
-#ifndef GFLAGS_SHARED_LIBS
-#  undef  GFLAGS_DLL_DECLARE_FLAG
-#  define GFLAGS_DLL_DECLARE_FLAG
-#endif
-
 #include <math.h>       // for isinf() and isnan()
 #include <stdio.h>
 #include <stdlib.h>