DISTRHO
/
DISTRHO-Ports
mirror of https://github.com/DISTRHO/DISTRHO-Ports
1
0
Fork 0
Code Releases 5 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
681 Commits
6 Branches
132MB
Tree: d3b62da2e8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd3b62da2e8'
${ noResults }
DISTRHO-Ports/libs/juced/source/dependancies/cpptest/htmloutput.cpp

443 lines
12KB
Raw Blame History 

  1. // ---

  2. //

  3. // $Id: htmloutput.cpp,v 1.7 2008/07/15 20:33:31 hartwork Exp $

  4. //

  5. // CppTest - A C++ Unit Testing Framework

  6. // Copyright (c) 2003 Niklas Lundell

  7. //

  8. // ---

  9. //

  10. // This library is free software; you can redistribute it and/or

  11. // modify it under the terms of the GNU Lesser General Public

  12. // License as published by the Free Software Foundation; either

  13. // version 2 of the License, or (at your option) any later version.

  14. //

  15. // This library is distributed in the hope that it will be useful,

  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  18. // Lesser General Public License for more details.

  19. //

  20. // You should have received a copy of the GNU Lesser General Public

  21. // License along with this library; if not, write to the

  22. // Free Software Foundation, Inc., 59 Temple Place - Suite 330,

  23. // Boston, MA 02111-1307, USA.

  24. //

  25. // ---

  26. 

  27. #include "cpptest-htmloutput.h"

  28. #include "utils.h"

  29. 

  30. namespace Test

  31. {

  32. 	namespace

  33. 	{

  34. 		void

  35. 		strreplace(std::string &value, char search, const std::string &replace)

  36. 		{

  37. 			std::string::size_type idx = 0;

  38. 			while((idx = value.find(search, idx)) != std::string::npos)

  39. 			{

  40. 				value.replace(idx, 1, replace);

  41. 				idx += replace.size();

  42. 			}

  43. 		}

  44. 		

  45. 		std::string

  46. 		escape(std::string value)

  47. 		{

  48. 			strreplace(value, '&', "&");

  49. 			strreplace(value, '<', "&lt;");

  50. 			strreplace(value, '>', "&gt;");

  51. 			strreplace(value, '"', "&quot;");

  52. 			strreplace(value, '\'', "&#39;");

  53. 			return value;

  54. 		}

  55. 		

  56. 		void

  57. 		header(std::ostream& os, std::string name)

  58. 		{

  59. 			if (!name.empty())

  60. 				name += " ";

  61. 			name = escape(name);

  62. 			os <<

  63. 				"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"

  64. 				"<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n"

  65. 				"<head>\n"

  66. 				"  <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" />\n"

  67. 				"  <meta name=\"generator\" content=\"CppTest - http://cpptest.sourceforge.net\" />\n"

  68. 				"  \n"

  69. 				"  <title>" << name << "Unit Tests Results</title>\n"

  70. 				"  \n"

  71. 				"  <style type=\"text/css\" media=\"screen\">\n"

  72. 				"    <!--\n"

  73. 				"    hr  {\n"

  74. 				"      width: 100%;\n"

  75. 				"      border-width: 0px;\n"

  76. 				"      height: 1px;\n"

  77. 				"      color: #cccccc;\n"

  78. 				"      background-color: #cccccc;\n"

  79. 				"      padding: 0px;\n"

  80. 				"    }\n"

  81. 				"    \n"

  82. 				"    table {\n"

  83. 				"      width:100%;\n"

  84. 				"      border-collapse:separate;\n"

  85. 				"      border-spacing: 2px;\n"

  86. 				"      border:0px;\n"

  87. 				"    }\n"

  88. 				"    tr {\n"

  89. 				"      margin:0px;\n"

  90. 				"      padding:0px;\n"

  91. 				"    }\n"

  92. 				"    td {\n"

  93. 				"      margin:0px;\n"

  94. 				"      padding:1px;\n"

  95. 				"    }\n"

  96. 				"    .table_summary {\n"

  97. 				"    }\n"

  98. 				"    .table_suites {\n"

  99. 				"    }\n"

  100. 				"    .table_suite {\n"

  101. 				"    }\n"

  102. 				"    .table_result {\n"

  103. 				"      margin: 0px 0px 1em 0px;\n"

  104. 				"    }\n"

  105. 				"    .tablecell_title {\n"

  106. 				"      background-color: #a5cef7;\n"

  107. 				"      font-weight: bold;\n"

  108. 				"    }\n"

  109. 				"    \n"

  110. 				"    .tablecell_success {\n"

  111. 				"      background-color: #efefe7;\n"

  112. 				"    }\n"

  113. 				"    \n"

  114. 				"    .tablecell_error {\n"

  115. 				"      color: #ff0808;\n"

  116. 				"      background-color: #efefe7;\n"

  117. 				"      font-weight: bold;\n"

  118. 				"    }\n"

  119. 				"    p.spaced {\n"

  120. 				"      margin: 0px;\n"

  121. 				"      padding: 1em 0px 2em 0px;\n"

  122. 				"    }\n"

  123. 				"    p.unspaced {\n"

  124. 				"      margin: 0px;\n"

  125. 				"      padding: 0px 0px 2em 0px;\n"

  126. 				"    }\n"

  127. 				"    -->\n"

  128. 				"  </style>\n"

  129. 				"</head>\n"

  130. 				"\n"

  131. 				"<body>\n"

  132. 				"\n"

  133. 				"<h1><a name=\"top\"></a>" << name << "Unit Tests Results</h1>\n"

  134. 				"\n"

  135. 				"<div style=\"text-align:right\">\n"

  136. 				"Designed by <a href=\"http://cpptest.sourceforge.net\">CppTest</a>\n"

  137. 				"</div>\n"

  138. 				"<hr />\n"

  139. 				"\n";

  140. 		}

  141. 		

  142. 		void

  143. 		footer(std::ostream& os)

  144. 		{

  145. 			os <<

  146. 				"\n"

  147. 				"<p>\n"

  148. 				"  <a href=\"http://validator.w3.org/#validate-by-upload\">\n"

  149. 				"    Valid XHTML 1.0 Strict\n"

  150. 				"  </a>\n"

  151. 				"</p>\n"

  152. 				"</body>\n</html>\n";

  153. 		}

  154. 				

  155. 		void

  156. 		back_ref(std::ostream& os, const std::string& ref, bool prepend_newline = true)

  157. 		{

  158. 			

  159. 			os	<< "<p class=\"" << (prepend_newline ? "spaced" : "unspaced") << "\"><a href=\"#" << ref

  160. 				<< "\">Back to " << escape(ref) << "</a>\n</p>\n";

  161. 		}

  162. 		

  163. 		void

  164. 		sub_title(std::ostream& os, const std::string& title, int size)

  165. 		{

  166. 			std::ostringstream h;

  167. 			h << "h" << size;

  168. 			os << "<" << h.str() << ">" << escape(title) << "</" << h.str() << ">\n";

  169. 		}

  170. 

  171. 		void

  172. 		sub_title(std::ostream& os, const std::string& title, int size, const std::string& mark)

  173. 		{

  174. 			std::ostringstream h;

  175. 			h << "h" << size;

  176. 			os << "<" << h.str() << "><a name=\"" << mark << "\"></a>" << escape(title) << "</" << h.str() << ">\n";

  177. 		}

  178. 			

  179. 		enum ClassTableType { TableClass_Summary, TableClass_Suites, TableClass_Suite, TableClass_Result };

  180. 		

  181. 		void

  182. 		table_header(std::ostream& os, ClassTableType type, const std::string &summary = "")

  183. 		{

  184. 			static const char* class_tabletypes[] = { "summary", "suites", "suite", "result" };

  185. 			

  186. 			os << "<table summary=\"" << escape(summary) << "\" class=\"table_" << class_tabletypes[type] << "\">\n";

  187. 		}

  188. 		

  189. 		void

  190. 		table_footer(std::ostream& os)

  191. 		{

  192. 			os << "</table>\n";

  193. 		}

  194. 		

  195. 		void

  196. 		table_tr_header(std::ostream& os)

  197. 		{

  198. 			os << "  <tr>\n";

  199. 		}

  200. 		

  201. 		void

  202. 		table_tr_footer(std::ostream& os)

  203. 		{

  204. 			os << "  </tr>\n";

  205. 		}

  206. 		

  207. 		enum ClassType { Title, Success, Error };

  208. 		

  209. 		void

  210. 		table_entry(std::ostream& os, ClassType type, const std::string& s,

  211. 					int width = 0, const std::string& link = "")

  212. 		{

  213. 			static const char* class_types[] = { "title", "success", "error" };

  214. 			

  215. 			os << "    <td";

  216. 			if (width)

  217. 				os << " style=\"width:" << width << "%\"";

  218. 			if (!link.empty())

  219. 				os << " class=\"tablecell_" << class_types[type] << "\"><a href=\"#" << link << "\">" << escape(s) << "</a>";

  220. 			else

  221. 				os << " class=\"tablecell_" << class_types[type] << "\">" << escape(s);

  222. 			os << "</td>\n";	

  223. 		}

  224. 						

  225. 	} // anonymous namespace

  226. 	

  227. 	// Test suite table

  228. 	//

  229. 	struct HtmlOutput::SuiteRow

  230. 	{

  231. 		std::ostream& _os;

  232. 		SuiteRow(std::ostream& os) : _os(os) {}

  233. 		void operator()(const SuiteInfo& si)

  234. 		{

  235. 			ClassType 		type(si._errors > 0 ? Error : Success);

  236.             std::ostringstream 	ss;

  237. 

  238. 			table_tr_header(_os);

  239. 			  table_entry(_os, type, si._name, 0, si._name);

  240. 			  ss.str(""), ss << si._tests.size();

  241. 			  table_entry(_os, type, ss.str(), 10);

  242. 			  ss.str(""), ss << si._errors;

  243. 			  table_entry(_os, type, ss.str(), 10);

  244. 			  ss.str(""),  ss << correct(si._tests.size(), si._errors) << "%";

  245. 			  table_entry(_os, type, ss.str(), 10);

  246. 			  ss.str(""), ss << si._time;

  247. 			  table_entry(_os, type, ss.str(), 10);

  248. 			table_tr_footer(_os);

  249. 		}

  250. 	};

  251. 	

  252. 	// Individual tests tables, tests

  253. 	//

  254. 	struct HtmlOutput::TestRow

  255. 	{

  256. 		bool		_incl_ok_tests;

  257. 		std::ostream& 	_os;

  258. 		TestRow(std::ostream& os, bool incl_ok_tests)

  259. 			: _incl_ok_tests(incl_ok_tests), _os(os) {}

  260. 		void operator()(const TestInfo& ti)

  261. 		{

  262. 			if (!ti._success || _incl_ok_tests)

  263. 			{

  264. 				std::string			link = ti._success ? std::string(""):

  265. 									       ti._sources.front().suite() + "_" + ti._name;

  266. 				ClassType 		type(ti._success ? Success : Error);

  267. 				std::ostringstream 	ss;

  268. 				

  269. 				table_tr_header(_os);

  270. 				  table_entry(_os, type, ti._name, 0, link);

  271. 				  ss.str(""),  ss << ti._sources.size();

  272. 				  table_entry(_os, type, ss.str());

  273. 				  table_entry(_os, type, ti._success ? "true" : "false");

  274. 				  ss.str(""), ss << ti._time;

  275. 				  table_entry(_os, type, ss.str());

  276. 				table_tr_footer(_os);

  277. 			}

  278. 		}

  279. 	};

  280. 	

  281. 	// Individual tests tables, header

  282. 	//

  283. 	struct HtmlOutput::TestSuiteRow

  284. 	{

  285. 		bool		_incl_ok_tests;

  286. 		std::ostream& 	_os;

  287. 		TestSuiteRow(std::ostream& os, bool incl_ok_tests) 

  288. 			: _incl_ok_tests(incl_ok_tests), _os(os) {}

  289. 		void operator()(const SuiteInfo& si)

  290. 		{

  291. 			std::ostringstream ss;

  292. 			

  293. 			sub_title(_os, "Suite: " + si._name, 3, si._name);

  294. 			table_header(_os, TableClass_Suite, "Details for suite " + si._name);

  295. 			  table_tr_header(_os);

  296. 			    table_entry(_os, Title, "Name");

  297. 			    table_entry(_os, Title, "Errors", 10);

  298. 			    table_entry(_os, Title, "Success", 10);

  299. 			    table_entry(_os, Title, "Time (s)", 10);

  300. 			  table_tr_footer(_os);

  301. 			  std::for_each(si._tests.begin(), si._tests.end(), 

  302. 					        TestRow(_os, _incl_ok_tests));

  303. 			table_footer(_os);

  304. 			back_ref(_os, "top");

  305. 		}

  306. 	};

  307. 	

  308. 	// Individual tests result tables

  309. 	//

  310. 	struct HtmlOutput::TestResult

  311. 	{

  312. 		std::ostream& _os;

  313. 		TestResult(std::ostream& os) : _os(os) {}

  314. 		void operator()(const Source& s)

  315. 		{

  316. 			const int TitleSize = 15;

  317. 			

  318. 			std::ostringstream ss;

  319. 			

  320. 			table_header(_os, TableClass_Result, "Test Failure");

  321. 			  table_tr_header(_os);

  322. 				table_entry(_os, Title, "Test", TitleSize);

  323. 				table_entry(_os, Success, s.suite() + "::" + s.test());

  324. 			  table_tr_footer(_os);

  325. 			  table_tr_header(_os);

  326. 				table_entry(_os, Title, "File", TitleSize);

  327. 				ss << s.file() << ":" << s.line();

  328. 				table_entry(_os, Success, ss.str());

  329. 			  table_tr_footer(_os);

  330. 			  table_tr_header(_os);

  331. 				table_entry(_os, Title, "Message", TitleSize);

  332. 				table_entry(_os, Success, s.message());

  333. 			  table_tr_footer(_os);

  334. 			table_footer(_os);

  335. 		}

  336. 	};

  337. 	

  338. 	// All tests result tables

  339. 	//

  340. 	struct HtmlOutput::TestResultAll

  341. 	{

  342. 		std::ostream& _os;

  343. 		TestResultAll(std::ostream& os) : _os(os) {}

  344. 		void operator()(const TestInfo& ti)

  345. 		{

  346. 			if (!ti._success)

  347. 			{

  348. 				const std::string& suite = ti._sources.front().suite();

  349. 				

  350. 				sub_title(_os, suite + "::" + ti._name, 3, suite + "_" + ti._name);

  351. 				std::for_each(ti._sources.begin(), ti._sources.end(), TestResult(_os));

  352. 				back_ref(_os, suite, false);

  353. 			}

  354. 		}

  355. 	};

  356. 	

  357. 	// Individual tests result tables, iterator

  358. 	//

  359. 	struct HtmlOutput::SuiteTestResult

  360. 	{

  361. 		std::ostream& _os;

  362. 		SuiteTestResult(std::ostream& os) : _os(os) {}

  363. 		void operator()(const SuiteInfo& si)

  364. 		{

  365. 			std::for_each(si._tests.begin(), si._tests.end(), TestResultAll(_os));

  366. 		}

  367. 	};

  368. 	

  369. 	/// Generates the HTML table. This function should only be called after

  370. 	/// run(), when all tests have been executed.

  371. 	///

  372. 	/// \param os            Output stream.

  373. 	/// \param incl_ok_tests Set if successful tests should be shown; 

  374. 	///                      false otherwise.

  375. 	/// \param name          Name of generated report.

  376. 	///

  377.     void

  378. 	HtmlOutput::generate(std::ostream& os, bool incl_ok_tests, const std::string& name)

  379. 	{

  380. 		ClassType 		type(_total_errors > 0 ? Error : Success);

  381. 		std::ostringstream 	ss;

  382. 		

  383. 		header(os, name);

  384. 		

  385. 		// Table: Summary

  386. 		//

  387. 		sub_title(os, "Summary", 2);

  388. 		table_header(os, TableClass_Summary, "Summary of test results");

  389. 		  table_tr_header(os);

  390. 		    table_entry(os, Title, "Tests", 30);

  391. 		    table_entry(os, Title, "Errors", 30);

  392. 		    table_entry(os, Title, "Success", 30);

  393. 		    table_entry(os, Title, "Time (s)", 10);

  394. 		  table_tr_footer(os);

  395. 		  table_tr_header(os);

  396. 		    ss.str(""), ss << _total_tests;

  397.  		    table_entry(os, type, ss.str(), 30);

  398. 			ss.str(""),  ss << _total_errors;

  399. 		    table_entry(os, type, ss.str(), 30);

  400. 			ss.str(""),  ss << correct(_total_tests, _total_errors) << "%";

  401. 		    table_entry(os, type, ss.str(), 30);

  402. 			ss.str(""), ss << _total_time;

  403. 		    table_entry(os, type, ss.str(), 10);

  404. 		  table_tr_footer(os);

  405. 		table_footer(os);

  406. 		os << "<hr />\n\n";

  407. 		

  408. 		// Table: Test suites

  409. 		//

  410. 		sub_title(os, "Test suites", 2);

  411. 		table_header(os, TableClass_Suites, "Test Suites");

  412. 		  table_tr_header(os);

  413. 		    table_entry(os, Title, "Name");

  414. 		    table_entry(os, Title, "Tests",   10);

  415. 		    table_entry(os, Title, "Errors",  10);

  416. 		    table_entry(os, Title, "Success",    10);

  417. 		    table_entry(os, Title, "Time (s)", 10);

  418. 		  table_tr_footer(os);

  419. 		  std::for_each(_suites.begin(), _suites.end(), SuiteRow(os));

  420. 		table_footer(os);

  421. 		os << "<hr />\n\n";

  422. 		

  423. 		// Individual tests tables

  424. 		//

  425. 		std::for_each(_suites.begin(), _suites.end(), TestSuiteRow(os, incl_ok_tests));

  426. 		os << "<hr />\n\n";

  427. 		

  428. 		// Individual tests result tables

  429. 		//

  430. 		if(_total_errors != 0)

  431. 		{

  432. 			sub_title(os, "Test results", 2);

  433. 			std::for_each(_suites.begin(), _suites.end(), SuiteTestResult(os));

  434. 			os << "<hr />\n\n";

  435. 		}		

  436. 		// EOF

  437. 		//

  438. 		footer(os);

  439. 	}

  440. 	

  441. } // namespace Test