ENH: Teach CTest to handle Bazaar repositories

This creates cmCTestBZR to drive CTest Update handling on bzr-based work
trees.  Currently we always update to the head of the remote tracking
branch (bzr pull), so the nightly start time is ignored for Nightly
builds.  A later change will address this.  Patch from Tom Vercauteren.
See issue #6857.

Modules/CTest.cmake

@@ -104,6 +104,7 @@ IF(BUILD_TESTING)
   SET(CVS_UPDATE_OPTIONS "-d -A -P" CACHE STRING 
     "Options passed to the cvs update command.")
   FIND_PROGRAM(SVNCOMMAND svn)
+  FIND_PROGRAM(BZRCOMMAND bzr)
 
   IF(NOT UPDATE_TYPE)
     IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
@@ -111,6 +112,10 @@ IF(BUILD_TESTING)
     ELSE(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
       IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.svn")
         SET(UPDATE_TYPE svn)
+      ELSE(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.svn")
+        IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.bzr")
+          SET(UPDATE_TYPE bzr)
+        ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.bzr")
       ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.svn")
     ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
   ENDIF(NOT UPDATE_TYPE)
@@ -130,6 +135,11 @@ IF(BUILD_TESTING)
     IF("${_update_type}" STREQUAL "svn")
       SET(UPDATE_COMMAND "${SVNCOMMAND}")
       SET(UPDATE_OPTIONS "${SVN_UPDATE_OPTIONS}")
+    ELSE("${_update_type}" STREQUAL "svn")
+      IF("${_update_type}" STREQUAL "bzr")
+        SET(UPDATE_COMMAND "${BZRCOMMAND}")
+        SET(UPDATE_OPTIONS "${BZR_UPDATE_OPTIONS}")
+      ENDIF("${_update_type}" STREQUAL "bzr")
     ENDIF("${_update_type}" STREQUAL "svn")
   ENDIF("${_update_type}" STREQUAL "cvs")
 
@@ -207,8 +217,10 @@ IF(BUILD_TESTING)
     COVERAGE_COMMAND
     CVSCOMMAND
     SVNCOMMAND
+    BZRCOMMAND
     CVS_UPDATE_OPTIONS
     SVN_UPDATE_OPTIONS
+    BZR_UPDATE_OPTIONS
     MAKECOMMAND 
     MEMORYCHECK_COMMAND
     MEMORYCHECK_SUPPRESSIONS_FILE

Source/CMakeLists.txt

@@ -361,6 +361,8 @@ SET(CTEST_SRCS cmCTest.cxx
   CTest/cmCTestCVS.h
   CTest/cmCTestSVN.cxx
   CTest/cmCTestSVN.h
+  CTest/cmCTestBZR.cxx
+  CTest/cmCTestBZR.h
   CTest/cmCTestGIT.cxx
   CTest/cmCTestGIT.h
   )

Source/CTest/cmCTestBZR.cxx

@@ -0,0 +1,520 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc. All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#include "cmCTestBZR.h"
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+#include "cmXMLSafe.h"
+
+#include <cmsys/RegularExpression.hxx>
+
+#include <cm_expat.h>
+
+//----------------------------------------------------------------------------
+extern "C"
+int cmBZRXMLParserUnknownEncodingHandler(void*,
+                                         const XML_Char *name,
+                                         XML_Encoding *info)
+{
+  static const int latin1[]=
+    {
+      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+      0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+      0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+      0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+      0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
+      0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+      0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+      0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+      0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+      0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+      0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+      0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+      0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
+      0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+      0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+      0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+      0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
+    };
+
+  if ( name==std::string("ascii") || name==std::string("cp1252") )
+    {
+    for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
+    return 1;
+    }
+
+  return 0;
+}
+
+//----------------------------------------------------------------------------
+cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
+  cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+  // Even though it is specified in the documention, with bzr 1.13
+  // BZR_PROGRESS_BAR has no effect. In the future this bug might be fixed.
+  // Since it doesn't hurt, we specify this environment variable.
+  cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none");
+}
+
+//----------------------------------------------------------------------------
+cmCTestBZR::~cmCTestBZR()
+{
+}
+
+//----------------------------------------------------------------------------
+class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
+{
+public:
+  InfoParser(cmCTestBZR* bzr, const char* prefix):
+    BZR(bzr), CheckOutFound(false)
+    {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
+    this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
+    }
+private:
+  cmCTestBZR* BZR;
+  bool CheckOutFound;
+  cmsys::RegularExpression RegexCheckOut;
+  cmsys::RegularExpression RegexParent;
+  virtual bool ProcessLine()
+    {
+    if(this->RegexCheckOut.find(this->Line))
+      {
+      this->BZR->URL = this->RegexCheckOut.match(1);
+      CheckOutFound = true;
+      }
+    else if(!CheckOutFound && this->RegexParent.find(this->Line))
+      {
+      this->BZR->URL = this->RegexParent.match(1);
+      }
+    return true;
+    }
+};
+
+//----------------------------------------------------------------------------
+class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
+{
+public:
+  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
+    BZR(bzr), Rev(rev)
+    {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexRevno.compile("^([0-9]+)$");
+    }
+private:
+  cmCTestBZR* BZR;
+  std::string& Rev;
+  cmsys::RegularExpression RegexRevno;
+  virtual bool ProcessLine()
+    {
+    if(this->RegexRevno.find(this->Line))
+      {
+      this->Rev = this->RegexRevno.match(1);
+      }
+    return true;
+    }
+};
+
+//----------------------------------------------------------------------------
+std::string cmCTestBZR::LoadInfo()
+{
+  // Run "bzr info" to get the repository info from the work tree.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_info[] = {bzr, "info", 0};
+  InfoParser iout(this, "info-out> ");
+  OutputLogger ierr(this->Log, "info-err> ");
+  this->RunChild(bzr_info, &iout, &ierr);
+
+  // Run "bzr revno" to get the repository revision number from the work tree.
+  const char* bzr_revno[] = {bzr, "revno", 0};
+  std::string rev;
+  RevnoParser rout(this, "revno-out> ", rev);
+  OutputLogger rerr(this->Log, "revno-err> ");
+  this->RunChild(bzr_revno, &rout, &rerr);
+
+  return rev;
+}
+
+void cmCTestBZR::NoteOldRevision()
+{
+  this->OldRevision = this->LoadInfo();
+  this->Log << "Revision before update: " << this->OldRevision << "\n";
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
+             << this->OldRevision << "\n");
+  this->PriorRev.Rev = this->OldRevision;
+}
+
+//----------------------------------------------------------------------------
+void cmCTestBZR::NoteNewRevision()
+{
+  this->NewRevision = this->LoadInfo();
+  this->Log << "Revision after update: " << this->NewRevision << "\n";
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
+             << this->NewRevision << "\n");
+  this->Log << "URL = " << this->URL << "\n";
+}
+
+//----------------------------------------------------------------------------
+class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
+                             private cmXMLParser
+{
+public:
+  LogParser(cmCTestBZR* bzr, const char* prefix):
+    OutputLogger(bzr->Log, prefix), BZR(bzr),
+    EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
+    { this->InitializeParser(); }
+  ~LogParser() { this->CleanupParser(); }
+
+  virtual int InitializeParser()
+     {
+     int res = cmXMLParser::InitializeParser();
+     if (res)
+       {
+       XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
+                                     cmBZRXMLParserUnknownEncodingHandler, 0);
+       }
+     return res;
+     }
+private:
+  cmCTestBZR* BZR;
+
+  typedef cmCTestBZR::Revision Revision;
+  typedef cmCTestBZR::Change   Change;
+  Revision Rev;
+  std::vector<Change> Changes;
+  Change CurChange;
+  std::vector<char> CData;
+
+  cmsys::RegularExpression EmailRegex;
+
+  virtual bool ProcessChunk(const char* data, int length)
+    {
+    this->OutputLogger::ProcessChunk(data, length);
+    this->ParseChunk(data, length);
+    return true;
+    }
+
+  virtual void StartElement(const char* name, const char**)
+    {
+    this->CData.clear();
+    if(strcmp(name, "log") == 0)
+      {
+      this->Rev = Revision();
+      this->Changes.clear();
+      }
+    // affected-files can contain blocks of
+    // modified, unknown, renamed, kind-changed, removed, conflicts, added
+    else if(strcmp(name, "modified") == 0
+            || strcmp(name, "renamed") == 0
+            || strcmp(name, "kind-changed") == 0)
+      {
+      this->CurChange = Change();
+      this->CurChange.Action = 'M';
+      }
+    else if(strcmp(name, "added") == 0)
+      {
+      this->CurChange = Change();
+      this->CurChange = 'A';
+      }
+    else if(strcmp(name, "removed") == 0)
+      {
+      this->CurChange = Change();
+      this->CurChange = 'D';
+      }
+    else if(strcmp(name, "unknown") == 0
+            || strcmp(name, "conflicts") == 0)
+      {
+      // Should not happen here
+      this->CurChange = Change();
+      }
+    }
+
+  virtual void CharacterDataHandler(const char* data, int length)
+    {
+    this->CData.insert(this->CData.end(), data, data+length);
+    }
+
+  virtual void EndElement(const char* name)
+    {
+    if(strcmp(name, "log") == 0)
+      {
+      this->BZR->DoRevision(this->Rev, this->Changes);
+      }
+    else if((strcmp(name, "file") == 0 || strcmp(name, "directory") == 0)
+            && !this->CData.empty())
+      {
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size());
+      this->Changes.push_back(this->CurChange);
+      }
+    else if(strcmp(name, "symlink") == 0 && !this->CData.empty())
+      {
+      // symlinks have an arobase at the end in the log
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
+      this->Changes.push_back(this->CurChange);
+      }
+    else if(strcmp(name, "committer") == 0 && !this->CData.empty())
+      {
+      this->Rev.Author.assign(&this->CData[0], this->CData.size());
+      if(this->EmailRegex.find(this->Rev.Author))
+        {
+        this->Rev.Author = this->EmailRegex.match(1);
+        //email = email_regex.match(2);
+        }
+      }
+    else if(strcmp(name, "timestamp") == 0 && !this->CData.empty())
+      {
+      this->Rev.Date.assign(&this->CData[0], this->CData.size());
+      }
+    else if(strcmp(name, "message") == 0 && !this->CData.empty())
+      {
+      this->Rev.Log.assign(&this->CData[0], this->CData.size());
+      }
+    else if(strcmp(name, "revno") == 0 && !this->CData.empty())
+      {
+      this->Rev.Rev.assign(&this->CData[0], this->CData.size());
+      }
+    this->CData.clear();
+    }
+
+  virtual void ReportError(int, int, const char* msg)
+    {
+    this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
+    }
+};
+
+//----------------------------------------------------------------------------
+class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
+{
+public:
+  UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
+    {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
+    }
+private:
+  cmCTestBZR* BZR;
+  cmsys::RegularExpression RegexUpdate;
+
+  virtual bool ProcessChunk(const char* first, int length)
+    {
+    bool last_is_new_line = (*first == '\r' || *first == '\n');
+
+    const char* const last = first + length;
+    for(const char* c = first; c != last; ++c)
+      {
+      if(*c == '\r' || *c == '\n')
+        {
+        if(!last_is_new_line)
+          {
+          // Log this line.
+          if(this->Log && this->Prefix)
+            {
+            *this->Log << this->Prefix << this->Line << "\n";
+            }
+
+          // Hand this line to the subclass implementation.
+          if(!this->ProcessLine())
+            {
+            this->Line = "";
+            return false;
+            }
+
+          this->Line = "";
+          last_is_new_line = true;
+          }
+        }
+      else
+        {
+        // Append this character to the line under construction.
+        this->Line.append(1, *c);
+        last_is_new_line = false;
+        }
+      }
+    return true;
+    }
+
+  bool ProcessLine()
+    {
+    if(this->RegexUpdate.find(this->Line))
+      {
+      this->DoPath(this->RegexUpdate.match(1)[0],
+                   this->RegexUpdate.match(2)[0],
+                   this->RegexUpdate.match(3)[0],
+                   this->RegexUpdate.match(4));
+      }
+    return true;
+    }
+
+  void DoPath(char c0, char c1, char c2, std::string const& path)
+    {
+    if(path.empty()) return;
+
+    const std::string dir = cmSystemTools::GetFilenamePath(path);
+    const std::string name = cmSystemTools::GetFilenameName(path);
+
+    if ( c0=='C' )
+      {
+      this->BZR->Dirs[dir][name].Status = PathConflicting;
+      return;
+      }
+
+    if ( c1=='M' || c1=='K' || c1=='N' || c1=='D' || c2 =='*' )
+      {
+      this->BZR->Dirs[dir][name].Status = PathUpdated;
+      return;
+      }
+    }
+};
+
+//----------------------------------------------------------------------------
+bool cmCTestBZR::UpdateImpl()
+{
+  // Get user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if(opts.empty())
+    {
+    opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
+    }
+  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+
+  // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
+
+  // Use "bzr pull" to update the working tree.
+  std::vector<char const*> bzr_update;
+  bzr_update.push_back(this->CommandLineTool.c_str());
+  bzr_update.push_back("pull");
+
+  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+      ai != args.end(); ++ai)
+    {
+    bzr_update.push_back(ai->c_str());
+    }
+
+  bzr_update.push_back(this->URL.c_str());
+
+  bzr_update.push_back(0);
+
+  // For some reason bzr uses stderr to display the update status.
+  OutputLogger out(this->Log, "pull-out> ");
+  UpdateParser err(this, "pull-err> ");
+  return this->RunUpdateCommand(&bzr_update[0], &out, &err);
+}
+
+//----------------------------------------------------------------------------
+void cmCTestBZR::LoadRevisions()
+{
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Gathering version information (one . per revision):\n"
+             "    " << std::flush);
+
+  // We are interested in every revision included in the update.
+  this->Revisions.clear();
+  std::string revs;
+  if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
+    {
+    // DoRevision takes care of discarding the information about OldRevision
+    revs = this->OldRevision + ".." + this->NewRevision;
+    }
+  else
+    {
+    return;
+    }
+
+  // Run "bzr log" to get all global revisions of interest.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
+                           this->URL.c_str(), 0};
+  {
+  LogParser out(this, "log-out> ");
+  OutputLogger err(this->Log, "log-err> ");
+  this->RunChild(bzr_log, &out, &err);
+  }
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+}
+
+//----------------------------------------------------------------------------
+class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
+{
+public:
+  StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
+    {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
+    }
+private:
+  cmCTestBZR* BZR;
+  cmsys::RegularExpression RegexStatus;
+  bool ProcessLine()
+    {
+    if(this->RegexStatus.find(this->Line))
+      {
+      this->DoPath(this->RegexStatus.match(1)[0],
+                   this->RegexStatus.match(2)[0],
+                   this->RegexStatus.match(3)[0],
+                   this->RegexStatus.match(4));
+      }
+    return true;
+    }
+
+  void DoPath(char c0, char c1, char c2, std::string const& path)
+    {
+    if(path.empty()) return;
+
+    if ( c0=='C' )
+      {
+      this->BZR->DoModification(PathConflicting, path);
+      return;
+      }
+
+    if ( c0 == '+' || c0 == 'R' || c0 == 'P'
+         || c1=='M' || c1=='K' || c1=='N' || c1=='D'
+         || c2 =='*' )
+      {
+      this->BZR->DoModification(PathModified, path);
+      return;
+      }
+    }
+};
+
+//----------------------------------------------------------------------------
+void cmCTestBZR::LoadModifications()
+{
+  // Run "bzr status" which reports local modifications.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_status[] = {bzr, "status", "-SV", 0};
+  StatusParser out(this, "status-out> ");
+  OutputLogger err(this->Log, "status-err> ");
+  this->RunChild(bzr_status, &out, &err);
+}

Source/CTest/cmCTestBZR.h

@@ -0,0 +1,60 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc. All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef cmCTestBZR_h
+#define cmCTestBZR_h
+
+#include "cmCTestGlobalVC.h"
+
+/** \class cmCTestBZR
+ * \brief Interaction with bzr command-line tool
+ *
+ */
+class cmCTestBZR: public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestBZR(cmCTest* ctest, std::ostream& log);
+
+  virtual ~cmCTestBZR();
+
+private:
+  // Implement cmCTestVC internal API.
+  virtual void NoteOldRevision();
+  virtual void NoteNewRevision();
+  virtual bool UpdateImpl();
+
+  // URL of repository directory checked out in the working tree.
+  std::string URL;
+
+  std::string LoadInfo();
+  void LoadModifications();
+  void LoadRevisions();
+
+  // Parsing helper classes.
+  class InfoParser;
+  class RevnoParser;
+  class LogParser;
+  class UpdateParser;
+  class StatusParser;
+  friend class InfoParser;
+  friend class RevnoParser;
+  friend class LogParser;
+  friend class UpdateParser;
+  friend class StatusParser;
+};
+
+#endif

Source/CTest/cmCTestUpdateCommand.cxx

@@ -48,6 +48,10 @@ cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
     "SVNCommand", "CTEST_SVN_COMMAND");
   this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS");
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
+    "BZRCommand", "CTEST_BZR_COMMAND");
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
+    "BZRUpdateOptions", "CTEST_BZR_UPDATE_OPTIONS");
   this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "GITCommand", "CTEST_GIT_COMMAND");
   this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,

Source/CTest/cmCTestUpdateHandler.cxx

@@ -30,6 +30,7 @@
 #include "cmCTestVC.h"
 #include "cmCTestCVS.h"
 #include "cmCTestSVN.h"
+#include "cmCTestBZR.h"
 #include "cmCTestGIT.h"
 
 #include <cmsys/auto_ptr.hxx>
@@ -52,6 +53,7 @@ static const char* cmCTestUpdateHandlerUpdateStrings[] =
   "Unknown",
   "CVS",
   "SVN",
+  "BZR",
   "GIT"
 };
 
@@ -135,6 +137,10 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
       {
       return cmCTestUpdateHandler::e_SVN;
       }
+    if ( stype.find("bzr") != std::string::npos )
+      {
+      return cmCTestUpdateHandler::e_BZR;
+      }
     if ( stype.find("git") != std::string::npos )
       {
       return cmCTestUpdateHandler::e_GIT;
@@ -153,6 +159,10 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
       {
       return cmCTestUpdateHandler::e_SVN;
       }
+    if ( stype.find("bzr") != std::string::npos )
+      {
+      return cmCTestUpdateHandler::e_BZR;
+      }
     if ( stype.find("git") != std::string::npos )
       {
       return cmCTestUpdateHandler::e_GIT;
@@ -214,6 +224,7 @@ int cmCTestUpdateHandler::ProcessHandler()
     {
     case e_CVS: vc.reset(new cmCTestCVS(this->CTest, ofs)); break;
     case e_SVN: vc.reset(new cmCTestSVN(this->CTest, ofs)); break;
+    case e_BZR: vc.reset(new cmCTestBZR(this->CTest, ofs)); break;
     case e_GIT: vc.reset(new cmCTestGIT(this->CTest, ofs)); break;
     default:    vc.reset(new cmCTestVC(this->CTest, ofs));  break;
     }
@@ -349,6 +360,12 @@ int cmCTestUpdateHandler::DetectVCS(const char* dir)
     return cmCTestUpdateHandler::e_CVS;
     }
   sourceDirectory = dir;
+  sourceDirectory += "/.bzr";
+  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
+    {
+    return cmCTestUpdateHandler::e_BZR;
+    }
+  sourceDirectory = dir;
   sourceDirectory += "/.git";
   if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
     {
@@ -381,6 +398,7 @@ bool cmCTestUpdateHandler::SelectVCS()
       {
       case e_CVS: key = "CVSCommand"; break;
       case e_SVN: key = "SVNCommand"; break;
+      case e_BZR: key = "BZRCommand"; break;
       case e_GIT: key = "GITCommand"; break;
       default: break;
       }

Source/CTest/cmCTestUpdateHandler.h

@@ -46,6 +46,7 @@ public:
     e_UNKNOWN = 0,
     e_CVS,
     e_SVN,
+    e_BZR,
     e_GIT,
     e_LAST
   };

Tests/CMakeLists.txt

@@ -925,6 +925,24 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=CVS -P ${CMake_SOURCE_DIR}/Utilities/Rel
       LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
     ENDIF(CTEST_TEST_UPDATE_CVS AND CVS_FOUND)
 
+    # Test CTest Update with BZR
+    FIND_PROGRAM(BZR_EXECUTABLE NAMES bzr)
+    MARK_AS_ADVANCED(BZR_EXECUTABLE)
+    IF(BZR_EXECUTABLE)
+      # Check if xmloutput plugin is there
+      EXECUTE_PROCESS(COMMAND ${BZR_EXECUTABLE} xmlplugins RESULT_VARIABLE xmlplugres
+        OUTPUT_QUIET ERROR_QUIET)
+      IF( NOT ${xmlplugres} )
+        SET(CTestUpdateBZR_DIR "CTest UpdateBZR")
+        CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
+          "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
+        ADD_TEST(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
+          -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
+          )
+        LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
+      ENDIF( NOT ${xmlplugres} )
+    ENDIF(BZR_EXECUTABLE)
+
     # Test CTest Update with GIT
     FIND_PROGRAM(GIT_EXECUTABLE NAMES git)
     MARK_AS_ADVANCED(GIT_EXECUTABLE)

Tests/CTestUpdateBZR.cmake.in

@@ -0,0 +1,146 @@
+# This script drives creation of a bzr repository and checks
+# that CTest can update from it.
+
+#-----------------------------------------------------------------------------
+# Test in a directory next to this script.
+get_filename_component(TOP "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(TOP "${TOP}/@CTestUpdateBZR_DIR@")
+
+# Include code common to all update tests.
+include("@CMAKE_CURRENT_SOURCE_DIR@/CTestUpdateCommon.cmake")
+
+#-----------------------------------------------------------------------------
+# Report bzr tools in use.
+message("Using BZR tools:")
+set(BZR "@BZR_EXECUTABLE@")
+message(" bzr = ${BZR}")
+
+#-----------------------------------------------------------------------------
+# Initialize the testing directory.
+message("Creating test directory...")
+init_testing()
+
+#-----------------------------------------------------------------------------
+# Create the repository.
+message("Creating repository...")
+file(MAKE_DIRECTORY ${TOP}/repo.bzr)
+run_child(
+  WORKING_DIRECTORY ${TOP}/repo.bzr
+  COMMAND ${BZR} init
+  )
+set(REPO file://${TOP}/repo.bzr)
+
+#-----------------------------------------------------------------------------
+# Import initial content into the repository.
+message("Importing content...")
+create_content(import)
+
+# Import the content into the repository.
+run_child(WORKING_DIRECTORY ${TOP}/import
+  COMMAND ${BZR} init
+  )
+
+run_child(WORKING_DIRECTORY ${TOP}/import
+  COMMAND ${BZR} add .
+  )
+run_child(WORKING_DIRECTORY ${TOP}/import
+  COMMAND ${BZR} commit -m "Initial content"
+  )
+run_child(WORKING_DIRECTORY ${TOP}/import
+  COMMAND ${BZR} push --create-prefix "${REPO}"
+  )
+
+#-----------------------------------------------------------------------------
+# Create a working tree.
+message("Checking out revision 1...")
+run_child(
+  WORKING_DIRECTORY ${TOP}
+  COMMAND ${BZR} branch "${REPO}" user-source
+  )
+
+#-----------------------------------------------------------------------------
+# Make changes in the working tree.
+message("Changing content...")
+update_content(user-source files_added files_removed dirs_added)
+if(dirs_added)
+  run_child(
+    WORKING_DIRECTORY ${TOP}/user-source
+    COMMAND ${BZR} add ${dirs_added}
+    )
+endif(dirs_added)
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} add ${files_added}
+  )
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} rm ${files_removed}
+  )
+
+#-----------------------------------------------------------------------------
+# Commit the changes to the repository.
+message("Committing revision 2...")
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} commit -m "Changed content"
+  )
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} push "${REPO}"
+  )
+
+#-----------------------------------------------------------------------------
+# Make changes in the working tree.
+message("Changing content again...")
+change_content(user-source)
+
+#-----------------------------------------------------------------------------
+# Commit the changes to the repository.
+message("Committing revision 3...")
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} commit -m "Changed content again"
+  )
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} push "${REPO}"
+  )
+
+#-----------------------------------------------------------------------------
+# Go back to before the changes so we can test updating.
+message("Backing up to revision 1...")
+run_child(
+  WORKING_DIRECTORY ${TOP}/user-source
+  COMMAND ${BZR} pull --overwrite -r1
+  )
+
+# Create a modified file.
+modify_content(user-source)
+
+#-----------------------------------------------------------------------------
+# Test updating the user work directory with the command-line interface.
+message("Running CTest Dashboard Command Line...")
+
+# Create the user build tree.
+create_build_tree(user-source user-binary)
+file(APPEND ${TOP}/user-binary/CTestConfiguration.ini
+  "# BZR command configuration
+UpdateCommand: ${BZR}
+")
+
+# Run the dashboard command line interface.
+run_dashboard_command_line(user-binary)
+
+#-----------------------------------------------------------------------------
+# Test initial checkout and update with a dashboard script.
+message("Running CTest Dashboard Script...")
+
+create_dashboard_script(dashboard.cmake
+  "# bzr command configuration
+set(CTEST_BZR_COMMAND \"${BZR}\")
+set(CTEST_CHECKOUT_COMMAND
+  \"\\\"\${CTEST_BZR_COMMAND}\\\" branch -r1 \\\"${REPO}\\\" dash-source\")
+")
+
+# Run the dashboard script with CTest.
+run_dashboard_script(dashboard.cmake)