Revise C++ coding style using clang-format-6.0

Run the `clang-format.bash` script to update all our C and C++ code to a
new style defined by `.clang-format`.  Use `clang-format` version 6.0.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 34 insertions, 30 deletions

diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
index 8d8ebaa..e729eeb 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -41,8 +41,8 @@ cmCTestRunTest::cmCTestRunTest(cmCTestMultiProcessHandler& multiHandler)
 
 void cmCTestRunTest::CheckOutput(std::string const& line)
 {
-  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
-               << ": " << line << std::endl);
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             this->GetIndex() << ": " << line << std::endl);
   this->ProcessOutput += line;
   this->ProcessOutput += "\n";
 
@@ -50,7 +50,8 @@ void cmCTestRunTest::CheckOutput(std::string const& line)
   if (!this->TestProperties->TimeoutRegularExpressions.empty()) {
     for (auto& reg : this->TestProperties->TimeoutRegularExpressions) {
       if (reg.first.find(this->ProcessOutput.c_str())) {
-        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                   this->GetIndex()
                      << ": "
                      << "Test timeout changed to "
                      << std::chrono::duration_cast<std::chrono::seconds>(
@@ -380,10 +381,10 @@ void cmCTestRunTest::MemCheckPostProcess()
   if (!this->TestHandler->MemCheck) {
     return;
   }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-                       << ": process test output now: "
-                       << this->TestProperties->Name << " "
-                       << this->TestResult.Name << std::endl,
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     this->Index << ": process test output now: "
+                                 << this->TestProperties->Name << " "
+                                 << this->TestResult.Name << std::endl,
                      this->TestHandler->GetQuiet());
   cmCTestMemCheckHandler* handler =
     static_cast<cmCTestMemCheckHandler*>(this->TestHandler);
@@ -425,7 +426,8 @@ void cmCTestRunTest::StartFailure(std::string const& output)
 bool cmCTestRunTest::StartTest(size_t total)
 {
   this->TotalNumberOfTests = total; // save for rerun case
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(2 * getNumWidth(total) + 8)
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             std::setw(2 * getNumWidth(total) + 8)
                << "Start "
                << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
                << this->TestProperties->Index << ": "
@@ -592,20 +594,21 @@ void cmCTestRunTest::ComputeArguments()
   this->TestResult.FullCommandLine = testCommand;
 
   // Print the test command in verbose mode
-  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             std::endl
                << this->Index << ": "
                << (this->TestHandler->MemCheck ? "MemCheck" : "Test")
                << " command: " << testCommand << std::endl);
 
   // Print any test-specific env vars in verbose mode
   if (!this->TestProperties->Environment.empty()) {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-                 << ": "
-                 << "Environment variables: " << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               this->Index << ": "
+                           << "Environment variables: " << std::endl);
   }
   for (std::string const& env : this->TestProperties->Environment) {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ":  " << env
-                                                                << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               this->Index << ":  " << env << std::endl);
   }
 }
 
@@ -658,10 +661,11 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout,
   if (testTimeOut == cmDuration::zero() && explicitTimeout) {
     timeout = cmDuration::zero();
   }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-                       << ": "
-                       << "Test timeout computed to be: "
-                       << cmDurationTo<unsigned int>(timeout) << "\n",
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     this->Index << ": "
+                                 << "Test timeout computed to be: "
+                                 << cmDurationTo<unsigned int>(timeout)
+                                 << "\n",
                      this->TestHandler->GetQuiet());
 
   this->TestProcess->SetTimeout(timeout);
@@ -687,20 +691,20 @@ void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
   // got for run until pass.  Trick is when this is called we don't
   // yet know if we are passing or failing.
   if (this->NumberOfRunsLeft == 1) {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << completed << "/");
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << total << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << completed << "/");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << total << " ");
   }
   // if this is one of several runs of a test just print blank space
   // to keep things neat
   else {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << " "
-                 << " ");
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << " "
-                 << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << " "
+                                             << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << " "
+                                             << " ");
   }
 
   if (this->TestHandler->MemCheck) {
@@ -746,8 +750,8 @@ void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
                               << std::endl;
 
   cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
-  cmCTestLog(this->CTest, DEBUG, "Testing " << this->TestProperties->Name
-                                            << " ... ");
+  cmCTestLog(this->CTest, DEBUG,
+             "Testing " << this->TestProperties->Name << " ... ");
 }
 
 void cmCTestRunTest::FinalizeTest()