Merge topic 'cmake-W-options'

aac633d5 Explicitly enable deprecated warnings by default.
e8974b62 Modify dev warning options to affect deprecated warnings.
b146747e Consistent documentation for deprecation message variables.
da688bcb Add -W options to control deprecated warning messages.
07388f83 Refactor the -W options parser to be generic.
246b0bfb Explicitly enable author (dev) warnings by default.
deec3a3f Make message suppression more consistent.
aa427a42 Tests: Revise message in RunCMake.CommandLine -Wdev case

Help/manual/OPTIONS_BUILD.txt

@@ -77,10 +77,23 @@
  Suppress developer warnings.
 
  Suppress warnings that are meant for the author of the
- CMakeLists.txt files.
+ CMakeLists.txt files. By default this will also turn off
+ deprecation warnings.
 
 ``-Wdev``
  Enable developer warnings.
 
  Enable warnings that are meant for the author of the CMakeLists.txt
- files.
+ files. By default this will also turn on deprecation warnings.
+
+``-Wdeprecated``
+ Enable deprecated functionality warnings.
+
+ Enable warnings for usage of deprecated functionality, that are meant
+ for the author of the CMakeLists.txt files.
+
+``-Wno-deprecated``
+ Suppress deprecated functionality warnings.
+
+ Suppress warnings for usage of deprecated functionality, that are meant
+ for the author of the CMakeLists.txt files.

Help/release/dev/cmake-W-options.rst

@@ -0,0 +1,12 @@
+cmake-W-options
+---------------
+
+* The :variable:`CMAKE_WARN_DEPRECATED` variable can now be set using the
+  ``-Wdeprecated`` and ``-Wno-deprecated`` :manual:`cmake(1)` options.
+
+* The ``-Wdev`` and ``-Wno-dev`` :manual:`cmake(1)` options now also enable
+  and suppress the deprecated warnings output by default.
+
+* Warnings about deprecated functionality are now enabled by default.
+  They may be suppressed with ``-Wno-deprecated`` or by setting the
+  :variable:`CMAKE_WARN_DEPRECATED` variable to false.

Help/variable/CMAKE_ERROR_DEPRECATED.rst

@@ -1,8 +1,7 @@
 CMAKE_ERROR_DEPRECATED
 ----------------------
 
-Whether to issue deprecation errors for macros and functions.
+Whether to issue errors for deprecated functionality.
 
-If ``TRUE``, this can be used by macros and functions to issue fatal
+If ``TRUE``, use of deprecated functionality will issue fatal errors.
-errors when deprecated macros or functions are used.  This variable is
+If this variable is not set, CMake behaves as if it were set to ``FALSE``.
-``FALSE`` by default.

Help/variable/CMAKE_WARN_DEPRECATED.rst

@@ -1,7 +1,10 @@
 CMAKE_WARN_DEPRECATED
 ---------------------
 
-Whether to issue deprecation warnings for macros and functions.
+Whether to issue warnings for deprecated functionality.
 
-If ``TRUE``, this can be used by macros and functions to issue deprecation
+If not ``FALSE``, use of deprecated functionality will issue warnings.
-warnings.  This variable is ``FALSE`` by default.
+If this variable is not set, CMake behaves as if it were set to ``TRUE``.
+
+When running :manual:`cmake(1)`, this option can be enabled with the
+``-Wdeprecated`` option, or disabled with the ``-Wno-deprecated`` option.

Source/cmMakefile.cxx

@@ -105,7 +105,8 @@ cmMakefile::~cmMakefile()
 
 //----------------------------------------------------------------------------
 void cmMakefile::IssueMessage(cmake::MessageType t,
-                              std::string const& text) const
+                              std::string const& text,
+                              bool force) const
 {
   // Collect context information.
   if(!this->ExecutionStatusStack.empty())
@@ -114,7 +115,8 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
       {
       this->ExecutionStatusStack.back()->SetNestedError(true);
       }
-    this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace());
+    this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace(),
+                                           force);
     }
   else
     {
@@ -129,7 +131,7 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
       lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
       }
     lfc.Line = 0;
-    this->GetCMakeInstance()->IssueMessage(t, text, lfc);
+    this->GetCMakeInstance()->IssueMessage(t, text, lfc, force);
     }
 }
 

Source/cmMakefile.h

@@ -709,7 +709,8 @@ public:
   };
 
   void IssueMessage(cmake::MessageType t,
-                    std::string const& text) const;
+                    std::string const& text,
+                    bool force = false) const;
 
   /** Set whether or not to report a CMP0000 violation.  */
   void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; }

Source/cmMessageCommand.cxx

@@ -43,7 +43,15 @@ bool cmMessageCommand
     }
   else if (*i == "AUTHOR_WARNING")
     {
-    type = cmake::AUTHOR_WARNING;
+    if (this->Makefile->GetCMakeInstance()->GetSuppressDevWarnings(
+        this->Makefile))
+      {
+      return true;
+      }
+    else
+      {
+      type = cmake::AUTHOR_WARNING;
+      }
     ++i;
     }
   else if (*i == "STATUS")
@@ -58,13 +66,17 @@ bool cmMessageCommand
       fatal = true;
       type = cmake::DEPRECATION_ERROR;
       }
-    else if (this->Makefile->IsOn("CMAKE_WARN_DEPRECATED"))
-      {
-      type = cmake::DEPRECATION_WARNING;
-      }
     else
       {
-      return true;
+      if (this->Makefile->GetCMakeInstance()->GetSuppressDeprecatedWarnings(
+          this->Makefile))
+        {
+        return true;
+        }
+      else
+        {
+        type = cmake::DEPRECATION_WARNING;
+        }
       }
     ++i;
     }
@@ -73,7 +85,8 @@ bool cmMessageCommand
 
   if (type != cmake::MESSAGE)
     {
-    this->Makefile->IssueMessage(type, message);
+    // we've overriden the message type, above, so force IssueMessage to use it
+    this->Makefile->IssueMessage(type, message, true);
     }
   else
     {

Source/cmake.cxx

@@ -127,8 +127,6 @@ cmake::cmake()
   this->WarnUnused = false;
   this->WarnUnusedCli = true;
   this->CheckSystemVars = false;
-  this->SuppressDevWarnings = false;
-  this->DoSuppressDevWarnings = false;
   this->DebugOutput = false;
   this->DebugTryCompile = false;
   this->ClearBuildSystem = false;
@@ -274,15 +272,51 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
         return false;
         }
       }
-    else if(arg.find("-Wno-dev",0) == 0)
+    else if(cmHasLiteralPrefix(arg, "-W"))
       {
-      this->SuppressDevWarnings = true;
+      std::string entry = arg.substr(2);
-      this->DoSuppressDevWarnings = true;
+      if (entry.empty())
-      }
+        {
-    else if(arg.find("-Wdev",0) == 0)
+        ++i;
-      {
+        if (i < args.size())
-      this->SuppressDevWarnings = false;
+          {
-      this->DoSuppressDevWarnings = true;
+          entry = args[i];
+          }
+        else
+          {
+          cmSystemTools::Error("-W must be followed with [no-]<name>.");
+          return false;
+          }
+        }
+
+      std::string name;
+      bool foundNo = false;
+      unsigned int nameStartPosition = 0;
+
+      if (entry.find("no-", nameStartPosition) == 0)
+        {
+        foundNo = true;
+        nameStartPosition += 3;
+        }
+
+      name = entry.substr(nameStartPosition);
+      if (name.empty())
+        {
+        cmSystemTools::Error("No warning name provided.");
+        return false;
+        }
+
+      if (!foundNo)
+        {
+        // -W<name>
+        this->DiagLevels[name] = std::max(this->DiagLevels[name],
+                                          DIAG_WARN);
+        }
+      else
+        {
+        // -Wno<name>
+        this->DiagLevels[name] = DIAG_IGNORE;
+        }
       }
     else if(arg.find("-U",0) == 0)
       {
@@ -618,11 +652,7 @@ void cmake::SetArgs(const std::vector<std::string>& args,
       // skip for now
       i++;
       }
-    else if(arg.find("-Wno-dev",0) == 0)
+    else if(arg.find("-W",0) == 0)
-      {
-      // skip for now
-      }
-    else if(arg.find("-Wdev",0) == 0)
       {
       // skip for now
       }
@@ -1231,25 +1261,74 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
 
 int cmake::Configure()
 {
-  if(this->DoSuppressDevWarnings)
+  DiagLevel diagLevel;
+
+  if (this->DiagLevels.count("deprecated") == 1)
     {
-    if(this->SuppressDevWarnings)
+
+    diagLevel = this->DiagLevels["deprecated"];
+    if (diagLevel == DIAG_IGNORE)
       {
-      this->
+      this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE",
-        AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
+                          "Whether to issue warnings for deprecated "
-                      "Suppress Warnings that are meant for"
+                          "functionality.",
-                      " the author of the CMakeLists.txt files.",
+                          cmState::INTERNAL);
-                      cmState::INTERNAL);
       }
-    else
+    else if (diagLevel == DIAG_WARN)
       {
-      this->
+      this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE",
-        AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
+                          "Whether to issue warnings for deprecated "
-                      "Suppress Warnings that are meant for"
+                          "functionality.",
-                      " the author of the CMakeLists.txt files.",
+                          cmState::INTERNAL);
-                      cmState::INTERNAL);
       }
     }
+
+  if (this->DiagLevels.count("dev") == 1)
+    {
+    bool setDeprecatedVariables = false;
+
+    const char* cachedWarnDeprecated =
+           this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
+
+    // don't overwrite deprecated warning setting from a previous invocation
+    if (!cachedWarnDeprecated)
+      {
+      setDeprecatedVariables = true;
+      }
+
+    diagLevel = this->DiagLevels["dev"];
+    if (diagLevel == DIAG_IGNORE)
+      {
+      this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
+                          "Suppress Warnings that are meant for"
+                          " the author of the CMakeLists.txt files.",
+                          cmState::INTERNAL);
+
+      if (setDeprecatedVariables)
+        {
+        this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE",
+                            "Whether to issue warnings for deprecated "
+                            "functionality.",
+                            cmState::INTERNAL);
+        }
+      }
+    else if (diagLevel == DIAG_WARN)
+      {
+      this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
+                          "Suppress Warnings that are meant for"
+                          " the author of the CMakeLists.txt files.",
+                          cmState::INTERNAL);
+
+      if (setDeprecatedVariables)
+        {
+        this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE",
+                            "Whether to issue warnings for deprecated "
+                            "functionality.",
+                            cmState::INTERNAL);
+        }
+      }
+    }
+
   int ret = this->ActualConfigure();
   const char* delCacheVars = this->State
                     ->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_");
@@ -1580,6 +1659,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
     {
     this->AddCMakePaths();
     }
+
   // Add any cache args
   if ( !this->SetCacheArgs(args) )
     {
@@ -2485,6 +2565,38 @@ static bool cmakeCheckStampList(const char* stampList)
   return true;
 }
 
+bool cmake::IsMessageTypeVisible(cmake::MessageType t)
+{
+  bool isVisible = true;
+
+  if(t == cmake::DEPRECATION_ERROR)
+    {
+    // if CMAKE_ERROR_DEPRECATED is on, show the message, otherwise suppress it
+    const char* errorDeprecated = this->State->GetCacheEntryValue(
+                                                "CMAKE_ERROR_DEPRECATED");
+    if(cmSystemTools::IsOff(errorDeprecated))
+      {
+      isVisible = false;
+      }
+    }
+  else if (t == cmake::DEPRECATION_WARNING)
+    {
+    if (this->GetSuppressDeprecatedWarnings())
+      {
+      isVisible = false;
+      }
+    }
+  else if (t == cmake::AUTHOR_WARNING)
+    {
+    if (this->GetSuppressDevWarnings())
+      {
+      isVisible = false;
+      }
+    }
+
+  return isVisible;
+}
+
 bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
 {
   // Construct the message header.
@@ -2508,20 +2620,13 @@ bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
     {
     msg << "CMake Deprecation Warning";
     }
+  else if (t == cmake::AUTHOR_WARNING)
+    {
+    msg << "CMake Warning (dev)";
+    }
   else
     {
     msg << "CMake Warning";
-    if(t == cmake::AUTHOR_WARNING)
-      {
-      // Allow suppression of these warnings.
-      const char* suppress = this->State->GetCacheEntryValue(
-                                        "CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
-      if(suppress && cmSystemTools::IsOn(suppress))
-        {
-        return false;
-        }
-      msg << " (dev)";
-      }
     }
   return true;
 }
@@ -2579,10 +2684,16 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg)
 
 //----------------------------------------------------------------------------
 void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
-                         cmListFileBacktrace const& bt)
+                         cmListFileBacktrace const& bt,
+                         bool force)
 {
   cmListFileBacktrace backtrace = bt;
 
+  if (!force && !this->IsMessageTypeVisible(t))
+    {
+    return;
+    }
+
   std::ostringstream msg;
   if (!this->PrintMessagePreamble(t, msg))
     {
@@ -2602,8 +2713,14 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
 
 //----------------------------------------------------------------------------
 void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
-                         cmListFileContext const& lfc)
+                         cmListFileContext const& lfc,
+                         bool force)
 {
+  if (!force && !this->IsMessageTypeVisible(t))
+    {
+    return;
+    }
+
   std::ostringstream msg;
   if (!this->PrintMessagePreamble(t, msg))
     {
@@ -2763,3 +2880,55 @@ void cmake::RunCheckForUnusedVariables()
     }
 #endif
 }
+
+void cmake::SetSuppressDevWarnings(bool b)
+{
+  // equivalent to -Wno-dev
+  if (b)
+    {
+    this->DiagLevels["dev"] = DIAG_IGNORE;
+    }
+  // equivalent to -Wdev
+  else
+    {
+    this->DiagLevels["dev"] = std::max(this->DiagLevels["dev"],
+                                       DIAG_WARN);
+    }
+}
+
+bool cmake::GetSuppressDevWarnings(cmMakefile const* mf)
+{
+  /*
+   * The suppression CMake variable may be set in the CMake configuration file
+   * itself, so we have to check what its set to in the makefile if we can.
+   */
+  if (mf)
+    {
+    return mf->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
+    }
+  else
+    {
+    const char* cacheEntryValue = this->State->GetCacheEntryValue(
+      "CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
+    return cmSystemTools::IsOn(cacheEntryValue);
+    }
+}
+
+bool cmake::GetSuppressDeprecatedWarnings(cmMakefile const* mf)
+{
+  /*
+   * The suppression CMake variable may be set in the CMake configuration file
+   * itself, so we have to check what its set to in the makefile if we can.
+   */
+  if (mf)
+    {
+    return (mf->IsSet("CMAKE_WARN_DEPRECATED") &&
+            !mf->IsOn("CMAKE_WARN_DEPRECATED"));
+    }
+  else
+    {
+    const char* cacheEntryValue = this->State->GetCacheEntryValue(
+      "CMAKE_WARN_DEPRECATED");
+    return cacheEntryValue && cmSystemTools::IsOff(cacheEntryValue);
+    }
+}

Source/cmake.h

@@ -68,6 +68,11 @@ class cmake
     DEPRECATION_WARNING
   };
 
+  enum DiagLevel
+  {
+    DIAG_IGNORE,
+    DIAG_WARN
+  };
 
   /** \brief Describes the working modes of cmake */
   enum WorkingMode
@@ -303,17 +308,28 @@ class cmake
   std::string const& GetCMakeEditCommand() const
     { return this->CMakeEditCommand; }
 
-  void SetSuppressDevWarnings(bool v)
+  void SetSuppressDevWarnings(bool v);
-    {
+  /*
-      this->SuppressDevWarnings = v;
+   * Get the state of the suppression of developer (author) warnings.
-      this->DoSuppressDevWarnings = true;
+   * Returns false, by default, if developer warnings should be shown, true
-    }
+   * otherwise.
+   */
+  bool GetSuppressDevWarnings(cmMakefile const* mf = NULL);
+
+  /*
+   * Get the state of the suppression of deprecated warnings.
+   * Returns false, by default, if deprecated warnings should be shown, true
+   * otherwise.
+   */
+  bool GetSuppressDeprecatedWarnings(cmMakefile const* mf = NULL);
 
   /** Display a message to the user.  */
   void IssueMessage(cmake::MessageType t, std::string const& text,
-        cmListFileBacktrace const& backtrace = cmListFileBacktrace());
+        cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
+        bool force = false);
   void IssueMessage(cmake::MessageType t, std::string const& text,
-        cmListFileContext const& lfc);
+        cmListFileContext const& lfc,
+        bool force = false);
 
   ///! run the --build option
   int Build(const std::string& dir,
@@ -351,8 +367,7 @@ protected:
 
   cmGlobalGenerator *GlobalGenerator;
   cmCacheManager *CacheManager;
-  bool SuppressDevWarnings;
+  std::map<std::string, DiagLevel> DiagLevels;
-  bool DoSuppressDevWarnings;
   std::string GeneratorPlatform;
   std::string GeneratorToolset;
 
@@ -419,6 +434,12 @@ private:
   // Print a list of valid generators to stderr.
   void PrintGeneratorList();
 
+  /*
+   * Check if messages of this type should be output, based on the state of the
+   * warning and error output CMake variables, in the cache.
+   */
+  bool IsMessageTypeVisible(cmake::MessageType t);
+
   bool PrintMessagePreamble(cmake::MessageType t, std::ostream& msg);
 };
 
@@ -430,7 +451,9 @@ private:
   {"-T <toolset-name>", "Specify toolset name if supported by generator."}, \
   {"-A <platform-name>", "Specify platform name if supported by generator."}, \
   {"-Wno-dev", "Suppress developer warnings."},\
-  {"-Wdev", "Enable developer warnings."}
+  {"-Wdev", "Enable developer warnings."},\
+  {"-Wdeprecated", "Enable deprecation warnings."},\
+  {"-Wno-deprecated", "Suppress deprecation warnings."}
 
 #define FOR_EACH_C_FEATURE(F) \
   F(c_function_prototypes) \

Tests/RunCMake/CommandLine/RunCMakeTest.cmake

@@ -129,9 +129,47 @@ set(RunCMake_TEST_OPTIONS -Wno-dev)
 run_cmake(Wno-dev)
 unset(RunCMake_TEST_OPTIONS)
 
+set(RunCMake_TEST_OPTIONS -Wdev)
+run_cmake(Wdev)
+unset(RunCMake_TEST_OPTIONS)
+
+# -Wdev should not override deprecated options if specified
+set(RunCMake_TEST_OPTIONS -Wdev -Wno-deprecated)
+run_cmake(Wno-deprecated)
+unset(RunCMake_TEST_OPTIONS)
+set(RunCMake_TEST_OPTIONS -Wno-deprecated -Wdev)
+run_cmake(Wno-deprecated)
+unset(RunCMake_TEST_OPTIONS)
+
+# -Wdev should enable deprecated warnings as well
+set(RunCMake_TEST_OPTIONS -Wdev)
+run_cmake(Wdeprecated)
+unset(RunCMake_TEST_OPTIONS)
+
+set(RunCMake_TEST_OPTIONS -Wdeprecated)
+run_cmake(Wdeprecated)
+unset(RunCMake_TEST_OPTIONS)
+
+set(RunCMake_TEST_OPTIONS -Wno-deprecated)
+run_cmake(Wno-deprecated)
+unset(RunCMake_TEST_OPTIONS)
+
+# Dev warnings should be on by default
+run_cmake(Wdev)
+
+# Deprecated warnings should be on by default
+run_cmake(Wdeprecated)
+
+# Conflicting -W options should honor the last value
 set(RunCMake_TEST_OPTIONS -Wno-dev -Wdev)
 run_cmake(Wdev)
 unset(RunCMake_TEST_OPTIONS)
+set(RunCMake_TEST_OPTIONS -Wdev -Wno-dev)
+run_cmake(Wno-dev)
+unset(RunCMake_TEST_OPTIONS)
+
+run_cmake_command(W_bad-arg1 ${CMAKE_COMMAND} -W)
+run_cmake_command(W_bad-arg2 ${CMAKE_COMMAND} -Wno-)
 
 set(RunCMake_TEST_OPTIONS --debug-output)
 run_cmake(debug-output)

Tests/RunCMake/CommandLine/W_bad-arg1-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/CommandLine/W_bad-arg1-stderr.txt

@@ -0,0 +1,2 @@
+CMake Error: -W must be followed with \[no-\]<name>.
+CMake Error: Problem processing arguments. Aborting.

Tests/RunCMake/CommandLine/W_bad-arg2-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/CommandLine/W_bad-arg2-stderr.txt

@@ -0,0 +1,2 @@
+CMake Error: No warning name provided.
+CMake Error: Problem processing arguments. Aborting.

Tests/RunCMake/CommandLine/Wdeprecated-stderr.txt

@@ -0,0 +1,4 @@
+^CMake Deprecation Warning at Wdeprecated.cmake:1 \(message\):
+  Some deprecated warning
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)

Tests/RunCMake/CommandLine/Wdeprecated.cmake

@@ -0,0 +1 @@
+message(DEPRECATION "Some deprecated warning")

Tests/RunCMake/CommandLine/Wdev-stderr.txt

@@ -1,5 +1,5 @@
 ^CMake Warning \(dev\) at Wdev.cmake:1 \(message\):
-  Some Author Warning
+  Some author warning
 Call Stack \(most recent call first\):
   CMakeLists.txt:3 \(include\)
 This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CommandLine/Wdev.cmake

@@ -1,4 +1,4 @@
-message(AUTHOR_WARNING "Some Author Warning")
+message(AUTHOR_WARNING "Some author warning")
 
 # with -Wdev this will also cause an AUTHOR_WARNING message, checks that
 # messages issued outside of the message command, by other CMake commands, also

Tests/RunCMake/CommandLine/Wno-deprecated.cmake

@@ -0,0 +1 @@
+message(DEPRECATION "Some deprecated warning")

Tests/RunCMake/CommandLine/Wno-dev.cmake

@@ -1,4 +1,4 @@
-message(AUTHOR_WARNING "Some Author Warning")
+message(AUTHOR_WARNING "Some author warning")
 
 # without -Wno-dev this will also cause an AUTHOR_WARNING message, checks that
 # messages issued outside of the message command, by other CMake commands, also

Tests/RunCMake/message/RunCMakeTest.cmake

@@ -1,5 +1,6 @@
 include(RunCMake)
 
+run_cmake(defaultmessage)
 run_cmake(nomessage)
 run_cmake(warnmessage)
 run_cmake(errormessage)

Tests/RunCMake/message/defaultmessage-result.txt

@@ -0,0 +1 @@
+0

Tests/RunCMake/message/defaultmessage-stderr.txt

@@ -0,0 +1,11 @@
+^CMake Deprecation Warning at defaultmessage.cmake:2 \(message\):
+  This is a deprecation warning
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)
+
+
+CMake Warning \(dev\) at defaultmessage.cmake:4 \(message\):
+  This is a author warning
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)
+This warning is for project developers.  Use -Wno-dev to suppress it.$

Tests/RunCMake/message/defaultmessage.cmake

@@ -0,0 +1,4 @@
+
+message(DEPRECATION "This is a deprecation warning")
+
+message(AUTHOR_WARNING "This is a author warning")

Tests/RunCMake/message/nomessage.cmake

@@ -1,2 +1,8 @@
 
+set(CMAKE_WARN_DEPRECATED OFF)
+
 message(DEPRECATION "This is not issued")
+
+set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS ON)
+
+message(AUTHOR_WARNING "This is not issued")

Tests/RunCMake/message/warnmessage-stderr.txt

@@ -1,4 +1,11 @@
-CMake Deprecation Warning at warnmessage.cmake:4 \(message\):
+^CMake Deprecation Warning at warnmessage.cmake:4 \(message\):
-  This is a warning
+  This is a deprecation warning
 Call Stack \(most recent call first\):
   CMakeLists.txt:3 \(include\)
+
+
+CMake Warning \(dev\) at warnmessage.cmake:8 \(message\):
+  This is a author warning
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)
+This warning is for project developers.  Use -Wno-dev to suppress it.$

Tests/RunCMake/message/warnmessage.cmake

@@ -1,4 +1,8 @@
 
 set(CMAKE_WARN_DEPRECATED ON)
 
-message(DEPRECATION "This is a warning")
+message(DEPRECATION "This is a deprecation warning")
+
+set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS OFF)
+
+message(AUTHOR_WARNING "This is a author warning")