Sono su C ++ e utilizzo gtest come framework principale. Diciamo che ho una funzione di rilevamento dei bordi che voglio testare che prende un'immagine come input e restituisce l'immagine rilevata dal bordo. Ho 3 immagini pronte per essere controllate.
È meglio scriverlo in un modo che è autonomo come
void EdgeCheck(const std::string& input, const std::string& ans) {
cv::Mat in_img = cv::imread(input);
cv::Mat ans_img = cv::imread(ans);
// Do some checks here
}
TEST(Edge) {
EdgeCheck(std::string("path to image 1"),std::string("path to ans image 1"));
EdgeCheck(std::string("path to image 2"),std::string("path to ans image 2"));
EdgeCheck(std::string("path to image 3"),std::string("path to ans image 3"));
}
int main(int argc, char** argv) {
return UnitTest::RunAllTests();
}
quindi il test può essere eseguito con ./unit-test o è meglio scrivere come
TEST(Edge) {
cv::Mat in_img = cv::imread(argv[1]);
cv::Mat ans_img = cv::imread(argv[2]);
// Do some check here
}
int main(int argc, char** argv) {
return UnitTest::RunAllTests();
}
ma deve essere eseguito da
./unit-test image1 ans_image1
./unit-test image2 ans_image2
./unit-test image3 ans_image3
Da quanto ho capito, il vantaggio del primo approccio in base agli argomenti della riga di comando UnitTest ++ è "un'unità ben scritta- il test è autonomo e parametrizzare un test significa che il test non è più solo un test, ma ora è una funzione piuttosto che un test unitario. "
Tuttavia, il vantaggio del secondo approccio è che è più flessibile nel senso che se voglio aggiungere image4 e image5, non ho bisogno di ricompilare il codice e può essere fatto su uno script bash, ma poi rende il test non autonomo.
Quale approccio è considerato una pratica migliore?