Comment adapter les tests de mon unité à cmake et ctest?

Jusqu'à présent, j'ai utilisé une procédure improvisée de test d'unité - essentiellement une charge entière de programmes de test d'unité exécutés automatiquement par un fichier batch. Bien que beaucoup de ceux - ci vérifient explicitement leurs résultats, beaucoup plus tricher-ils déchargent les résultats dans les fichiers texte qui sont suivis en versions. Tout changement dans les résultats des tests est signalé par subversion et je peux facilement identifier ce qu'était le changement. De nombreux tests de sortie dot fichiers ou une autre forme qui me permet d'obtenir une représentation visuelle de l' sortie.

le problème est que je passe à l'utilisation de cmake. Aller avec le flux cmake signifie utiliser des compilations hors source, ce qui signifie que la commodité du dumping résulte en un dossier source/build partagé et les versionner avec la source ne fonctionne pas vraiment.

comme remplacement, ce que je faire est-à-dire l'unité de l'outil de test où trouver les fichiers de résultats attendus (dans l'arborescence des sources) et de lui faire faire la comparaison. En cas d'échec, il doit fournir les résultats réels et la liste des différences.

est-ce possible, ou devrais-je adopter une approche complètement différente?

Évidemment, Je ignorez ctest et adaptez ce que j'ai toujours fait à des constructions hors-source. Je pourrais modifier mon dossier-where-all-the-builds-live, par exemple (avec l'utilisation libérale de 'ignore' bien sûr). C'est que sain d'esprit? Probablement pas, car chaque Compilation se terminerait par une copie distincte des résultats attendus.

Aussi, tout conseils sur la façon recommandée de faire des tests unitaires avec cmake/ctest gratuitement reçu. J'ai perdu pas mal de temps avec cmake, pas parce que c'est mauvais, mais parce que je ne comprenais pas comment travailler avec ça.

EDIT

à la fin, j'ai décidé de garder le côté cake/ctest de l'Unité de test aussi simple que possible. Pour tester réels contre résultats prévus, j'ai trouvé une maison pour la fonction suivante dans ma bibliothèque...

bool Check_Results (std::ostream              &p_Stream  ,
                    const char                *p_Title   ,
                    const char               **p_Expected,
                    const std::ostringstream  &p_Actual   )
{
  std::ostringstream l_Expected_Stream;

  while (*p_Expected != 0)
  {
    l_Expected_Stream << (*p_Expected) << std::endl;
    p_Expected++;
  }

  std::string l_Expected (l_Expected_Stream.str ());
  std::string l_Actual   (p_Actual.str ());

  bool l_Pass = (l_Actual == l_Expected);

  p_Stream << "Test: " << p_Title << " : ";

  if (l_Pass)
  {
    p_Stream << "Pass" << std::endl;
  }
  else
  {
    p_Stream << "*** FAIL ***" << std::endl;
    p_Stream << "===============================================================================" << std::endl;
    p_Stream << "Expected Results For: " << p_Title << std::endl;
    p_Stream << "-------------------------------------------------------------------------------" << std::endl;
    p_Stream << l_Expected;
    p_Stream << "===============================================================================" << std::endl;
    p_Stream << "Actual Results For: " << p_Title << std::endl;
    p_Stream << "-------------------------------------------------------------------------------" << std::endl;
    p_Stream << l_Actual;
    p_Stream << "===============================================================================" << std::endl;
  }

  return l_Pass;
}

Une unité typique test ressemble maintenant...

bool Test0001 ()
{
  std::ostringstream l_Actual;

  const char* l_Expected [] =
  {
    "Some",
    "Expected",
    "Results",
    0
  };

  l_Actual << "Some" << std::endl
           << "Actual" << std::endl
           << "Results" << std::endl;

  return Check_Results (std::cout, "0001 - not a sane test", l_Expected, l_Actual);
}

là où j'ai besoin d'une fonction de vidage de données réutilisable, il faut un paramètre de type std::ostream&, de sorte qu'il peut se déverser dans un flux de résultats réels.