Remove building with NOCRYPTO option
[minix3.git] / external / bsd / atf / dist / tools / atffile_test.cpp
blobcb358dfa8b9fcc5516adfec82b22135b90a4f44f
1 //
2 // Automated Testing Framework (atf)
3 //
4 // Copyright (c) 2009 The NetBSD Foundation, Inc.
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 // 1. Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // 2. Redistributions in binary form must reproduce the above copyright
13 // notice, this list of conditions and the following disclaimer in the
14 // documentation and/or other materials provided with the distribution.
16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 extern "C" {
31 #include <sys/types.h>
32 #include <sys/stat.h>
35 #include <algorithm>
36 #include <fstream>
37 #include <memory>
39 #include <atf-c++.hpp>
41 #include "atffile.hpp"
42 #include "exceptions.hpp"
43 #include "test_helpers.hpp"
45 namespace detail = tools::detail;
47 // ------------------------------------------------------------------------
48 // Auxiliary functions.
49 // ------------------------------------------------------------------------
51 namespace {
53 typedef std::map< std::string, std::string > vars_map;
55 static
56 std::auto_ptr< std::ofstream >
57 new_atffile(void)
59 std::auto_ptr< std::ofstream > os(new std::ofstream("Atffile"));
60 ATF_REQUIRE(*os);
62 (*os) << "Content-Type: application/X-atf-atffile; version=\"1\"\n\n";
63 return os;
66 static
67 void
68 touch_exec(const char* name)
70 std::ofstream os(name);
71 ATF_REQUIRE(os);
72 os.close();
73 ATF_REQUIRE(::chmod(name, S_IRWXU) != -1);
76 static inline
77 bool
78 is_in(const std::string& value, const std::vector< std::string >& v)
80 return std::find(v.begin(), v.end(), value) != v.end();
83 } // anonymous namespace
85 // ------------------------------------------------------------------------
86 // Tests cases for the "atffile" parser.
87 // ------------------------------------------------------------------------
89 class atffile_reader : protected detail::atf_atffile_reader {
90 void
91 got_conf(const std::string& name, const std::string& val)
93 m_calls.push_back("got_conf(" + name + ", " + val + ")");
96 void
97 got_prop(const std::string& name, const std::string& val)
99 m_calls.push_back("got_prop(" + name + ", " + val + ")");
102 void
103 got_tp(const std::string& name, bool isglob)
105 m_calls.push_back("got_tp(" + name + ", " + (isglob ? "true" : "false")
106 + ")");
109 void
110 got_eof(void)
112 m_calls.push_back("got_eof()");
115 public:
116 atffile_reader(std::istream& is) :
117 detail::atf_atffile_reader(is)
121 void
122 read(void)
124 atf_atffile_reader::read();
127 std::vector< std::string > m_calls;
130 ATF_TEST_CASE_WITHOUT_HEAD(atffile_1);
131 ATF_TEST_CASE_BODY(atffile_1)
133 const char* input =
134 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
135 "\n"
138 const char* exp_calls[] = {
139 "got_eof()",
140 NULL
143 const char* exp_errors[] = {
144 NULL
147 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
150 ATF_TEST_CASE_WITHOUT_HEAD(atffile_2);
151 ATF_TEST_CASE_BODY(atffile_2)
153 const char* input =
154 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
155 "\n"
156 "# This is a comment on a line of its own.\n"
157 "# And this is another one.\n"
158 "\n"
159 " # Another after some whitespace.\n"
160 "\n"
161 "# The last one after an empty line.\n"
164 const char* exp_calls[] = {
165 "got_eof()",
166 NULL
169 const char* exp_errors[] = {
170 NULL
173 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
176 ATF_TEST_CASE_WITHOUT_HEAD(atffile_3);
177 ATF_TEST_CASE_BODY(atffile_3)
179 const char* input =
180 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
181 "\n"
182 "conf: var1=value1\n"
183 "conf: var2 = value2\n"
184 "conf: var3 = value3\n"
185 "conf: var4 = value4\n"
186 "\n"
187 "conf:var5=value5\n"
188 " conf:var6=value6\n"
189 "\n"
190 "conf: var7 = \"This is a long value.\"\n"
191 "conf: var8 = \"Single-word\"\n"
192 "conf: var9 = \" Single-word \"\n"
193 "conf: var10 = Single-word\n"
196 const char* exp_calls[] = {
197 "got_conf(var1, value1)",
198 "got_conf(var2, value2)",
199 "got_conf(var3, value3)",
200 "got_conf(var4, value4)",
201 "got_conf(var5, value5)",
202 "got_conf(var6, value6)",
203 "got_conf(var7, This is a long value.)",
204 "got_conf(var8, Single-word)",
205 "got_conf(var9, Single-word )",
206 "got_conf(var10, Single-word)",
207 "got_eof()",
208 NULL
211 const char* exp_errors[] = {
212 NULL
215 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
218 ATF_TEST_CASE_WITHOUT_HEAD(atffile_4);
219 ATF_TEST_CASE_BODY(atffile_4)
221 const char* input =
222 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
223 "\n"
224 "prop: var1=value1\n"
225 "prop: var2 = value2\n"
226 "prop: var3 = value3\n"
227 "prop: var4 = value4\n"
228 "\n"
229 "prop:var5=value5\n"
230 " prop:var6=value6\n"
231 "\n"
232 "prop: var7 = \"This is a long value.\"\n"
233 "prop: var8 = \"Single-word\"\n"
234 "prop: var9 = \" Single-word \"\n"
235 "prop: var10 = Single-word\n"
238 const char* exp_calls[] = {
239 "got_prop(var1, value1)",
240 "got_prop(var2, value2)",
241 "got_prop(var3, value3)",
242 "got_prop(var4, value4)",
243 "got_prop(var5, value5)",
244 "got_prop(var6, value6)",
245 "got_prop(var7, This is a long value.)",
246 "got_prop(var8, Single-word)",
247 "got_prop(var9, Single-word )",
248 "got_prop(var10, Single-word)",
249 "got_eof()",
250 NULL
253 const char* exp_errors[] = {
254 NULL
257 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
260 ATF_TEST_CASE_WITHOUT_HEAD(atffile_5);
261 ATF_TEST_CASE_BODY(atffile_5)
263 const char* input =
264 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
265 "\n"
266 "tp:foo\n"
267 "tp: foo\n"
268 "tp: foo\n"
269 "tp: foo\n"
270 "tp: foo\n"
271 "tp: \"name with spaces\"\n"
272 "tp: \"single-word\"\n"
273 "tp: single-word\n"
274 "\n"
275 "tp-glob:foo*?bar\n"
276 "tp-glob: foo*?bar\n"
277 "tp-glob: foo*?bar\n"
278 "tp-glob: foo*?bar\n"
279 "tp-glob: foo*?bar\n"
280 "tp-glob: \"glob * with ? spaces\"\n"
281 "tp-glob: \"single-*-word\"\n"
282 "tp-glob: single-*-word\n"
285 const char* exp_calls[] = {
286 "got_tp(foo, false)",
287 "got_tp(foo, false)",
288 "got_tp(foo, false)",
289 "got_tp(foo, false)",
290 "got_tp(foo, false)",
291 "got_tp(name with spaces, false)",
292 "got_tp(single-word, false)",
293 "got_tp(single-word, false)",
294 "got_tp(foo*?bar, true)",
295 "got_tp(foo*?bar, true)",
296 "got_tp(foo*?bar, true)",
297 "got_tp(foo*?bar, true)",
298 "got_tp(foo*?bar, true)",
299 "got_tp(glob * with ? spaces, true)",
300 "got_tp(single-*-word, true)",
301 "got_tp(single-*-word, true)",
302 "got_eof()",
303 NULL
306 const char* exp_errors[] = {
307 NULL
310 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
313 ATF_TEST_CASE_WITHOUT_HEAD(atffile_6);
314 ATF_TEST_CASE_BODY(atffile_6)
316 const char* input =
317 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
318 "\n"
319 "prop: foo = bar # A comment.\n"
320 "conf: foo = bar # A comment.\n"
321 "tp: foo # A comment.\n"
322 "tp-glob: foo # A comment.\n"
325 const char* exp_calls[] = {
326 "got_prop(foo, bar)",
327 "got_conf(foo, bar)",
328 "got_tp(foo, false)",
329 "got_tp(foo, true)",
330 "got_eof()",
331 NULL
334 const char* exp_errors[] = {
335 NULL
338 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
341 ATF_TEST_CASE_WITHOUT_HEAD(atffile_50);
342 ATF_TEST_CASE_BODY(atffile_50)
344 const char* input =
345 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
346 "\n"
347 "foo\n"
350 const char* exp_calls[] = {
351 NULL
354 // NO_CHECK_STYLE_BEGIN
355 const char* exp_errors[] = {
356 "3: Unexpected token `foo'; expected conf, #, prop, tp, tp-glob, a new line or eof",
357 NULL
359 // NO_CHECK_STYLE_END
361 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
364 ATF_TEST_CASE_WITHOUT_HEAD(atffile_51);
365 ATF_TEST_CASE_BODY(atffile_51)
367 const char* input =
368 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
369 "\n"
370 "foo bar\n"
371 "baz\n"
374 const char* exp_calls[] = {
375 NULL
378 // NO_CHECK_STYLE_BEGIN
379 const char* exp_errors[] = {
380 "3: Unexpected token `foo'; expected conf, #, prop, tp, tp-glob, a new line or eof",
381 "4: Unexpected token `baz'; expected conf, #, prop, tp, tp-glob, a new line or eof",
382 NULL
384 // NO_CHECK_STYLE_END
386 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
389 ATF_TEST_CASE_WITHOUT_HEAD(atffile_52);
390 ATF_TEST_CASE_BODY(atffile_52)
392 const char* input =
393 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
394 "\n"
395 "conf\n"
396 "conf:\n"
397 "conf: foo =\n"
398 "conf: bar = # A comment.\n"
399 "\n"
400 "prop\n"
401 "prop:\n"
402 "prop: foo =\n"
403 "prop: bar = # A comment.\n"
404 "\n"
405 "tp\n"
406 "tp:\n"
407 "tp: # A comment.\n"
408 "\n"
409 "tp-glob\n"
410 "tp-glob:\n"
411 "tp-glob: # A comment.\n"
414 const char* exp_calls[] = {
415 NULL
418 const char* exp_errors[] = {
419 "3: Unexpected token `<<NEWLINE>>'; expected `:'",
420 "4: Unexpected token `<<NEWLINE>>'; expected variable name",
421 "5: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
422 "6: Unexpected token `#'; expected word or quoted string",
423 "8: Unexpected token `<<NEWLINE>>'; expected `:'",
424 "9: Unexpected token `<<NEWLINE>>'; expected property name",
425 "10: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
426 "11: Unexpected token `#'; expected word or quoted string",
427 "13: Unexpected token `<<NEWLINE>>'; expected `:'",
428 "14: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
429 "15: Unexpected token `#'; expected word or quoted string",
430 "17: Unexpected token `<<NEWLINE>>'; expected `:'",
431 "18: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
432 "19: Unexpected token `#'; expected word or quoted string",
433 NULL
436 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
439 ATF_TEST_CASE_WITHOUT_HEAD(atffile_53);
440 ATF_TEST_CASE_BODY(atffile_53)
442 const char* input =
443 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
444 "\n"
445 "prop: foo = \"Correct value\" # With comment.\n"
446 "\n"
447 "prop: bar = # A comment.\n"
448 "\n"
449 "prop: baz = \"Last variable\"\n"
450 "\n"
451 "# End of file.\n"
454 const char* exp_calls[] = {
455 "got_prop(foo, Correct value)",
456 NULL
459 const char* exp_errors[] = {
460 "5: Unexpected token `#'; expected word or quoted string",
461 NULL
464 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
467 ATF_TEST_CASE_WITHOUT_HEAD(atffile_54);
468 ATF_TEST_CASE_BODY(atffile_54)
470 const char* input =
471 "Content-Type: application/X-atf-atffile; version=\"1\"\n"
472 "\n"
473 "prop: foo = \"\n"
474 "prop: bar = \"text\n"
475 "prop: baz = \"te\\\"xt\n"
476 "prop: last = \"\\\"\n"
479 const char* exp_calls[] = {
480 NULL
483 const char* exp_errors[] = {
484 "3: Missing double quotes before end of line",
485 "4: Missing double quotes before end of line",
486 "5: Missing double quotes before end of line",
487 "6: Missing double quotes before end of line",
488 NULL
491 do_parser_test< atffile_reader >(input, exp_calls, exp_errors);
494 // ------------------------------------------------------------------------
495 // Tests cases for the "atffile" class.
496 // ------------------------------------------------------------------------
498 ATF_TEST_CASE(atffile_getters);
499 ATF_TEST_CASE_HEAD(atffile_getters) {}
500 ATF_TEST_CASE_BODY(atffile_getters) {
501 vars_map config_vars;
502 config_vars["config-var-1"] = "value 1";
504 std::vector< std::string > test_program_names;
505 test_program_names.push_back("test-program-1");
507 vars_map properties;
508 properties["test-suite"] = "a test name";
510 const tools::atffile atffile(config_vars, test_program_names, properties);
511 ATF_REQUIRE(config_vars == atffile.conf());
512 ATF_REQUIRE(test_program_names == atffile.tps());
513 ATF_REQUIRE(properties == atffile.props());
516 // ------------------------------------------------------------------------
517 // Tests cases for the free functions.
518 // ------------------------------------------------------------------------
520 ATF_TEST_CASE_WITHOUT_HEAD(read_ok_simple);
521 ATF_TEST_CASE_BODY(read_ok_simple) {
522 std::auto_ptr< std::ofstream > os = new_atffile();
523 (*os) << "prop: test-suite = foo\n";
524 (*os) << "tp: tp-1\n";
525 (*os) << "conf: var1 = value1\n";
526 (*os) << "tp: tp-2\n";
527 (*os) << "tp: tp-3\n";
528 (*os) << "prop: prop1 = propvalue1\n";
529 (*os) << "conf: var2 = value2\n";
530 (*os).close();
532 touch_exec("tp-1");
533 touch_exec("tp-2");
534 touch_exec("tp-3");
536 const tools::atffile atffile = tools::read_atffile(
537 tools::fs::path("Atffile"));
538 ATF_REQUIRE_EQ(2, atffile.conf().size());
539 ATF_REQUIRE_EQ("value1", atffile.conf().find("var1")->second);
540 ATF_REQUIRE_EQ("value2", atffile.conf().find("var2")->second);
541 ATF_REQUIRE_EQ(3, atffile.tps().size());
542 ATF_REQUIRE(is_in("tp-1", atffile.tps()));
543 ATF_REQUIRE(is_in("tp-2", atffile.tps()));
544 ATF_REQUIRE(is_in("tp-3", atffile.tps()));
545 ATF_REQUIRE_EQ(2, atffile.props().size());
546 ATF_REQUIRE_EQ("foo", atffile.props().find("test-suite")->second);
547 ATF_REQUIRE_EQ("propvalue1", atffile.props().find("prop1")->second);
550 ATF_TEST_CASE_WITHOUT_HEAD(read_ok_some_globs);
551 ATF_TEST_CASE_BODY(read_ok_some_globs) {
552 std::auto_ptr< std::ofstream > os = new_atffile();
553 (*os) << "prop: test-suite = foo\n";
554 (*os) << "tp: foo\n";
555 (*os) << "tp-glob: *K*\n";
556 (*os) << "tp: bar\n";
557 (*os) << "tp-glob: t_*\n";
558 (*os).close();
560 touch_exec("foo");
561 touch_exec("bar");
562 touch_exec("aK");
563 touch_exec("KKKKK");
564 touch_exec("t_hello");
565 touch_exec("zzzt_hello");
567 const tools::atffile atffile = tools::read_atffile(
568 tools::fs::path("Atffile"));
569 ATF_REQUIRE_EQ(5, atffile.tps().size());
570 ATF_REQUIRE(is_in("foo", atffile.tps()));
571 ATF_REQUIRE(is_in("bar", atffile.tps()));
572 ATF_REQUIRE(is_in("aK", atffile.tps()));
573 ATF_REQUIRE(is_in("KKKKK", atffile.tps()));
574 ATF_REQUIRE(is_in("t_hello", atffile.tps()));
577 ATF_TEST_CASE_WITHOUT_HEAD(read_missing_test_suite);
578 ATF_TEST_CASE_BODY(read_missing_test_suite) {
579 std::auto_ptr< std::ofstream > os = new_atffile();
580 (*os).close();
582 try {
583 (void)tools::read_atffile(tools::fs::path("Atffile"));
584 ATF_FAIL("Missing property 'test-suite' did not raise an error");
585 } catch (const tools::not_found_error< std::string >& e) {
586 ATF_REQUIRE_EQ("test-suite", e.get_value());
590 ATF_TEST_CASE_WITHOUT_HEAD(read_missing_test_program);
591 ATF_TEST_CASE_BODY(read_missing_test_program) {
592 std::auto_ptr< std::ofstream > os = new_atffile();
593 (*os) << "tp: foo\n";
594 (*os) << "tp: bar\n";
595 (*os) << "tp: baz\n";
596 (*os).close();
598 touch_exec("foo");
599 touch_exec("baz");
601 try {
602 (void)tools::read_atffile(tools::fs::path("Atffile"));
603 ATF_FAIL("Missing file 'bar' did not raise an error");
604 } catch (const tools::not_found_error< tools::fs::path >& e) {
605 ATF_REQUIRE_EQ("bar", e.get_value().str());
609 // ------------------------------------------------------------------------
610 // Main.
611 // ------------------------------------------------------------------------
613 ATF_INIT_TEST_CASES(tcs)
615 // Add the test cases for the parser class.
616 ATF_ADD_TEST_CASE(tcs, atffile_1);
617 ATF_ADD_TEST_CASE(tcs, atffile_2);
618 ATF_ADD_TEST_CASE(tcs, atffile_3);
619 ATF_ADD_TEST_CASE(tcs, atffile_4);
620 ATF_ADD_TEST_CASE(tcs, atffile_5);
621 ATF_ADD_TEST_CASE(tcs, atffile_6);
622 ATF_ADD_TEST_CASE(tcs, atffile_50);
623 ATF_ADD_TEST_CASE(tcs, atffile_51);
624 ATF_ADD_TEST_CASE(tcs, atffile_52);
625 ATF_ADD_TEST_CASE(tcs, atffile_53);
626 ATF_ADD_TEST_CASE(tcs, atffile_54);
628 // Add the test cases for the atffile class.
629 ATF_ADD_TEST_CASE(tcs, atffile_getters);
631 // Add the test cases for the free functions.
632 ATF_ADD_TEST_CASE(tcs, read_ok_simple);
633 ATF_ADD_TEST_CASE(tcs, read_ok_some_globs);
634 ATF_ADD_TEST_CASE(tcs, read_missing_test_suite);
635 ATF_ADD_TEST_CASE(tcs, read_missing_test_program);