aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build2/test/script/parser.cxx21
-rw-r--r--build2/test/script/runner.cxx480
-rw-r--r--build2/test/script/script2
-rw-r--r--tests/test/script/runner/buildfile2
-rw-r--r--tests/test/script/runner/expr.test522
-rw-r--r--tests/test/script/runner/if.test25
-rw-r--r--tests/test/script/runner/pipe.test35
-rw-r--r--tests/test/script/runner/redirect.test52
-rw-r--r--unit-tests/test/script/parser/pipe-expr.test44
9 files changed, 973 insertions, 210 deletions
diff --git a/build2/test/script/parser.cxx b/build2/test/script/parser.cxx
index 0b00861..5822d9e 100644
--- a/build2/test/script/parser.cxx
+++ b/build2/test/script/parser.cxx
@@ -1367,17 +1367,23 @@ namespace build2
// leave: <newline>
command_expr expr;
- expr.emplace_back (expr_term ());
+
+ // OR-ed to an implied false for the first term.
+ //
+ expr.push_back ({expr_operator::log_or, command_pipe ()});
command c; // Command being assembled.
// Make sure the command makes sense.
//
- auto check_command = [&c, this] (const location& l)
+ auto check_command = [&c, this] (const location& l, bool last)
{
if (c.out.type == redirect_type::merge &&
c.err.type == redirect_type::merge)
fail (l) << "stdout and stderr redirected to each other";
+
+ if (!last && c.out.type != redirect_type::none)
+ fail (l) << "stdout is both redirected and piped";
};
// Check that the introducer character differs from '/' if the
@@ -1629,7 +1635,7 @@ namespace build2
// Parse the redirect operator.
//
auto parse_redirect =
- [&c, &p, &mod, this] (token& t, const location& l)
+ [&c, &expr, &p, &mod, this] (token& t, const location& l)
{
// Our semantics is the last redirect seen takes effect.
//
@@ -1676,6 +1682,9 @@ namespace build2
if ((fd = fd == 3 ? 0 : fd) != 0)
fail (l) << "invalid in redirect file descriptor " << fd;
+ if (!expr.back ().pipe.empty ())
+ fail (l) << "stdin is both piped and redirected";
+
break;
}
case type::out_pass:
@@ -2030,7 +2039,7 @@ namespace build2
{
// Check that the previous command makes sense.
//
- check_command (l);
+ check_command (l, tt != type::pipe);
expr.back ().pipe.push_back (move (c));
c = command ();
@@ -2302,7 +2311,7 @@ namespace build2
{
// Check that the previous command makes sense.
//
- check_command (l);
+ check_command (l, tt != type::pipe);
expr.back ().pipe.push_back (move (c));
c = command ();
@@ -2373,7 +2382,7 @@ namespace build2
// command makes sense.
//
check_pending (l);
- check_command (l);
+ check_command (l, true);
expr.back ().pipe.push_back (move (c));
}
diff --git a/build2/test/script/runner.cxx b/build2/test/script/runner.cxx
index 2eefdb7..dcfaec9 100644
--- a/build2/test/script/runner.cxx
+++ b/build2/test/script/runner.cxx
@@ -218,13 +218,14 @@ namespace build2
// Check if the test command output matches the expected result (redirect
// value). Noop for redirect types other than none, here_*.
//
- static void
+ static bool
check_output (const path& pr,
const path& op,
const path& ip,
const redirect& rd,
const location& ll,
scope& sp,
+ bool diag,
const char* what)
{
auto input_info = [&ip, &ll] (diag_record& d)
@@ -246,29 +247,35 @@ namespace build2
if (rd.type == redirect_type::none)
{
- assert (!op.empty ());
-
// Check that there is no output produced.
//
- if (non_empty (op, ll))
+ assert (!op.empty ());
+
+ if (!non_empty (op, ll))
+ return true;
+
+ if (diag)
{
- diag_record d (fail (ll));
+ diag_record d (error (ll));
d << pr << " unexpectedly writes to " << what <<
info << what << ": " << op;
input_info (d);
}
+
+ // Fall through (to return false).
+ //
}
else if (rd.type == redirect_type::here_str_literal ||
rd.type == redirect_type::here_doc_literal ||
(rd.type == redirect_type::file &&
rd.file.mode == redirect_fmode::compare))
{
- assert (!op.empty ());
-
// The expected output is provided as a file or as a string. Save the
// string to a file in the later case.
//
+ assert (!op.empty ());
+
path eop;
if (rd.type == redirect_type::file)
@@ -327,21 +334,24 @@ namespace build2
efd.reset ();
if (p.wait ())
- return;
+ return true;
// Output doesn't match the expected result.
//
- diag_record d (error (ll));
- d << pr << " " << what << " doesn't match the expected output";
+ if (diag)
+ {
+ diag_record d (error (ll));
+ d << pr << " " << what << " doesn't match the expected output";
- output_info (d, op);
- output_info (d, eop, "expected ");
- output_info (d, ep, "", " diff");
- input_info (d);
+ output_info (d, op);
+ output_info (d, eop, "expected ");
+ output_info (d, ep, "", " diff");
+ input_info (d);
- print_file (d, ep, ll);
+ print_file (d, ep, ll);
+ }
- // Fall through.
+ // Fall through (to return false).
//
}
catch (const process_error& e)
@@ -350,15 +360,13 @@ namespace build2
if (e.child ())
exit (1);
- }
- throw failed ();
+ throw failed ();
+ }
}
else if (rd.type == redirect_type::here_str_regex ||
rd.type == redirect_type::here_doc_regex)
{
- assert (!op.empty ());
-
// The overall plan is:
//
// 1. Create regex line string. While creating it's line characters
@@ -377,6 +385,8 @@ namespace build2
//
using namespace regex;
+ assert (!op.empty ());
+
// Create regex line string.
//
line_pool pool;
@@ -621,17 +631,31 @@ namespace build2
// Match the output with the regex.
//
if (regex_match (ls, regex)) // Doesn't throw.
- return;
+ return true;
- // Output doesn't match the regex.
+ // Output doesn't match the regex. We save the regex to file for
+ // troubleshooting regardless of whether we print the diagnostics or
+ // not.
//
- diag_record d (fail (ll));
- d << pr << " " << what << " doesn't match the regex";
+ path rp (save_regex ());
- output_info (d, op);
- output_info (d, save_regex (), "", " regex");
- input_info (d);
+ if (diag)
+ {
+ diag_record d (error (ll));
+ d << pr << " " << what << " doesn't match the regex";
+
+ output_info (d, op);
+ output_info (d, rp, "", " regex");
+ input_info (d);
+ }
+
+ // Fall through (to return false).
+ //
}
+ else // Noop.
+ return true;
+
+ return false;
}
bool default_runner::
@@ -750,10 +774,26 @@ namespace build2
: sp.wd_path.directory ());
}
- void default_runner::
- run (scope& sp, const command_expr& expr, size_t li, const location& ll)
+ static bool
+ run_pipe (scope& sp,
+ command_pipe::const_iterator bc,
+ command_pipe::const_iterator ec,
+ auto_fd ifd,
+ size_t ci, size_t li, const location& ll,
+ bool diag)
{
- const command& c (expr.back ().pipe.back ()); // @@ TMP
+ if (bc == ec) // End of the pipeline.
+ return true;
+
+ // The overall plan is to run the first command in the pipe, reading
+ // its input from the file descriptor passed (or, for the first
+ // command, according to stdin redirect specification) and redirecting
+ // its output to the right-hand part of the pipe recursively. Fail if
+ // the right-hand part fails. Otherwise check the process exit code,
+ // match stderr (and stdout for the last command in the pipe) according
+ // to redirect specification(s) and fail if any of the above fails.
+ //
+ const command& c (*bc);
if (verb >= 3)
text << c;
@@ -785,7 +825,7 @@ namespace build2
// Create a unique path for a command standard stream cache file.
//
- auto std_path = [&li, &sp, &ll] (const char* n) -> path
+ auto std_path = [&sp, &ci, &li, &ll] (const char* n) -> path
{
path p (n);
@@ -795,146 +835,145 @@ namespace build2
if (li > 0)
p += "-" + to_string (li);
+ // 0 if belongs to a single-command expression, otherwise is the
+ // command number (start from one) in the expression.
+ //
+ // Note that the name like stdin-N can relate to N-th command of a
+ // single-line test or to N-th single-command line of multi-line
+ // test. These cases are mutually exclusive and so are unambiguous.
+ //
+ if (ci > 0)
+ p += "-" + to_string (ci);
+
return normalize (move (p), sp, ll);
};
- // Assign file descriptors to pass as a builtin or a process standard
- // streams. Eventually the raw descriptors should gone when the process
- // is fully moved to auto_fd usage.
+ // If stdin file descriptor is not open then this is the first pipeline
+ // command. Open stdin descriptor according to the redirect specified.
//
path isp;
- auto_fd ifd;
- int id (0); // @@ TMP
const redirect& in (c.in.effective ());
- // Open a file for passing to the command stdin.
- //
- auto open_stdin = [&isp, &ifd, &id, &ll] ()
+ if (ifd.get () != -1)
+ assert (in.type == redirect_type::none); // No redirect expected.
+ else
{
- assert (!isp.empty ());
-
- try
- {
- ifd = fdopen (isp, fdopen_mode::in);
- id = ifd.get ();
- }
- catch (const io_error& e)
+ // Open a file for passing to the command stdin.
+ //
+ auto open_stdin = [&isp, &ifd, &ll] ()
{
- fail (ll) << "unable to read " << isp << ": " << e;
- }
- };
+ assert (!isp.empty ());
- switch (in.type)
- {
- case redirect_type::pass:
- {
try
{
- ifd = fddup (id);
- id = 0;
+ ifd = fdopen (isp, fdopen_mode::in);
}
catch (const io_error& e)
{
- fail (ll) << "unable to duplicate stdin: " << e;
+ fail (ll) << "unable to read " << isp << ": " << e;
}
+ };
- break;
- }
-
- case redirect_type::none:
- // Somehow need to make sure that the child process doesn't read from
- // stdin. That is tricky to do in a portable way. Here we suppose
- // that the program which (erroneously) tries to read some data from
- // stdin being redirected to /dev/null fails not being able to read
- // the expected data, and so the test doesn't pass through.
- //
- // @@ Obviously doesn't cover the case when the process reads
- // whatever available.
- // @@ Another approach could be not to redirect stdin and let the
- // process to hang which can be interpreted as a test failure.
- // @@ Both ways are quite ugly. Is there some better way to do this?
- //
- // Fall through.
- //
- case redirect_type::null:
+ switch (in.type)
{
- try
+ case redirect_type::pass:
{
- ifd.reset (fdnull ()); // @@ Eventually will be throwing.
-
- if (ifd.get () == -1) // @@ TMP
- throw io_error (
- error_code (errno, system_category ()).message ());
+ try
+ {
+ ifd = fddup (0);
+ }
+ catch (const io_error& e)
+ {
+ fail (ll) << "unable to duplicate stdin: " << e;
+ }
- id = -2;
+ break;
}
- catch (const io_error& e)
+
+ case redirect_type::none:
+ // Somehow need to make sure that the child process doesn't read
+ // from stdin. That is tricky to do in a portable way. Here we
+ // suppose that the program which (erroneously) tries to read some
+ // data from stdin being redirected to /dev/null fails not being
+ // able to read the expected data, and so the test doesn't pass
+ // through.
+ //
+ // @@ Obviously doesn't cover the case when the process reads
+ // whatever available.
+ // @@ Another approach could be not to redirect stdin and let the
+ // process to hang which can be interpreted as a test failure.
+ // @@ Both ways are quite ugly. Is there some better way to do
+ // this?
+ //
+ // Fall through.
+ //
+ case redirect_type::null:
{
- fail (ll) << "unable to write to null device: " << e;
+ try
+ {
+ ifd.reset (fdnull ()); // @@ Eventually will be throwing.
+
+ if (ifd.get () == -1) // @@ TMP
+ throw io_error (
+ error_code (errno, system_category ()).message ());
+ }
+ catch (const io_error& e)
+ {
+ fail (ll) << "unable to write to null device: " << e;
+ }
+
+ break;
}
- break;
- }
+ case redirect_type::file:
+ {
+ isp = normalize (in.file.path, sp, ll);
- case redirect_type::file:
- {
- isp = normalize (in.file.path, sp, ll);
+ open_stdin ();
+ break;
+ }
- open_stdin ();
- break;
- }
+ case redirect_type::here_str_literal:
+ case redirect_type::here_doc_literal:
+ {
+ // We could write to the command stdin directly but instead will
+ // cache the data for potential troubleshooting.
+ //
+ isp = std_path ("stdin");
- case redirect_type::here_str_literal:
- case redirect_type::here_doc_literal:
- {
- // We could write to the command stdin directly but instead will
- // cache the data for potential troubleshooting.
- //
- isp = std_path ("stdin");
+ save (
+ isp, transform (in.str, false, in.modifiers, *sp.root), ll);
- save (isp, transform (in.str, false, in.modifiers, *sp.root), ll);
- sp.clean ({cleanup_type::always, isp}, true);
+ sp.clean ({cleanup_type::always, isp}, true);
- open_stdin ();
- break;
- }
+ open_stdin ();
+ break;
+ }
- case redirect_type::merge:
- case redirect_type::here_str_regex:
- case redirect_type::here_doc_regex:
- case redirect_type::here_doc_ref: assert (false); break;
+ case redirect_type::merge:
+ case redirect_type::here_str_regex:
+ case redirect_type::here_doc_regex:
+ case redirect_type::here_doc_ref: assert (false); break;
+ }
}
- // Dealing with stdout and stderr redirect types other than 'null'
- // using pipes is tricky in the general case. Going this path we would
- // need to read both streams in non-blocking manner which we can't
- // (easily) do in a portable way. Using diff utility to get a
- // nice-looking actual/expected outputs difference would complicate
- // things further.
- //
- // So the approach is the following. Child standard streams are
- // redirected to files. When the child exits and the exit status is
- // validated we just sequentially compare each file content with the
- // expected output. The positive side-effect of this approach is that
- // the output of a faulty command can be provided for troubleshooting.
- //
-
// Open a file for command output redirect if requested explicitly
- // (file redirect) or for the purpose of the output validation (none,
- // here_*), register the file for cleanup, return the file descriptor.
- // Return the specified, default or -2 file descriptors for merge, pass
- // or null redirects respectively not opening a file.
+ // (file overwrite/append redirects) or for the purpose of the output
+ // validation (none, here_*, file comparison redirects), register the
+ // file for cleanup, return the file descriptor. Return nullfd,
+ // standard stream descriptor duplicate or null-device descriptor for
+ // merge, pass or null redirects respectively (not opening any file).
//
auto open = [&sp, &ll, &std_path] (const redirect& r,
int dfd,
- path& p,
- auto_fd& fd) -> int
- {
+ path& p) -> auto_fd
+ {
assert (dfd == 1 || dfd == 2);
const char* what (dfd == 1 ? "stdout" : "stderr");
fdopen_mode m (fdopen_mode::out | fdopen_mode::create);
+ auto_fd fd;
switch (r.type)
{
case redirect_type::pass:
@@ -948,7 +987,7 @@ namespace build2
fail (ll) << "unable to duplicate " << what << ": " << e;
}
- return dfd;
+ return fd;
}
case redirect_type::null:
@@ -966,14 +1005,14 @@ namespace build2
fail (ll) << "unable to write to null device: " << e;
}
- return -2;
+ return fd;
}
case redirect_type::merge:
{
// Duplicate the paired file descriptor later.
//
- return r.fd;
+ return fd; // nullfd
}
case redirect_type::file:
@@ -1020,18 +1059,51 @@ namespace build2
fail (ll) << "unable to write " << p << ": " << e;
}
- return fd.get ();
+ return fd;
};
path osp;
- auto_fd ofd;
const redirect& out (c.out.effective ());
- int od (open (out, 1, osp, ofd));
+ auto_fd ofd;
+
+ // If this is the last command in the pipeline than redirect the
+ // command process stdout to a file. Otherwise create a pipe and
+ // redirect the stdout to the write-end of the pipe. The read-end will
+ // be passed as stdin for the next command in the pipeline.
+ //
+ // @@ Shouldn't we allow the here-* and file output redirects for a
+ // command with pipelined output? Say if such redirect is present
+ // then the process output is redirected to a file first (as it is
+ // when no output pipelined), and only after the process exit code
+ // and the output are validated the next command in the pipeline is
+ // executed taking the file as an input. This could be usefull for
+ // test failures investigation and for tests "tightening".
+ //
+ fdpipe p;
+ command_pipe::const_iterator nc (bc + 1);
+ bool last (nc == ec);
+
+ if (last)
+ ofd = open (out, 1, osp);
+ else
+ {
+ assert (out.type == redirect_type::none); // No redirect expected.
+
+ try
+ {
+ p = fdopen_pipe ();
+ }
+ catch (const io_error& e)
+ {
+ fail (ll) << "unable to open pipe: " << e;
+ }
+
+ ofd = move (p.out);
+ }
path esp;
- auto_fd efd;
const redirect& err (c.err.effective ());
- int ed (open (err, 2, esp, efd));
+ auto_fd efd (open (err, 2, esp));
// Merge standard streams.
//
@@ -1053,9 +1125,15 @@ namespace build2
}
}
+ // All descriptors should be open to the date.
+ //
+ assert (ifd.get () != -1 && ofd.get () != -1 && efd.get () != -1);
+
optional<process_exit> exit;
builtin* b (builtins.find (c.program.string ()));
+ bool success;
+
if (b != nullptr)
{
// Execute the builtin.
@@ -1065,12 +1143,14 @@ namespace build2
future<uint8_t> f (
(*b) (sp, c.arguments, move (ifd), move (ofd), move (efd)));
+ success = run_pipe (sp, nc, ec, move (p.in), ci + 1, li, ll, diag);
+
exit = process_exit (f.get ());
}
catch (const system_error& e)
{
fail (ll) << "unable to execute " << c.program << " builtin: "
- << e;
+ << e << endf;
}
}
else
@@ -1094,13 +1174,16 @@ namespace build2
process pr (sp.wd_path.string ().c_str (),
pp,
args.data (),
- id, od, ed);
+ ifd.get (), ofd.get (), efd.get ());
ifd.reset ();
ofd.reset ();
efd.reset ();
+ success = run_pipe (sp, nc, ec, move (p.in), ci + 1, li, ll, diag);
+
pr.wait ();
+
exit = move (pr.exit);
}
catch (const process_error& e)
@@ -1116,11 +1199,19 @@ namespace build2
assert (exit);
- const path& p (c.program);
+ // If the righ-hand side pipeline failed than the whole pipeline fails,
+ // and no further checks are required.
+ //
+ if (!success)
+ return false;
+
+ const path& pr (c.program);
- // If there is no correct exit code by whatever reason then print the
- // proper diagnostics, dump stderr (if cached and not too large) and
- // fail.
+ // If there is no valid exit code available by whatever reason then we
+ // print the proper diagnostics, dump stderr (if cached and not too
+ // large) and fail the whole test. Otherwise if the exit code is not
+ // correct then we print diagnostics if requested and fail the
+ // pipeline.
//
bool valid (exit->normal ());
@@ -1133,17 +1224,18 @@ namespace build2
#endif
bool eq (c.exit.comparison == exit_comparison::eq);
- bool correct (valid && eq == (exit->code () == c.exit.status));
+ success = valid && eq == (exit->code () == c.exit.status);
- if (!correct)
+ if (!valid || (!success && diag))
{
- // Fail with a proper diagnostics.
+ // In the presense of a valid exit code we print the diagnostics and
+ // return false rather than throw.
//
- diag_record d (fail (ll));
+ diag_record d (valid ? error (ll) : fail (ll));
if (!exit->normal ())
{
- d << p << " terminated abnormally" <<
+ d << pr << " terminated abnormally" <<
info << exit->description ();
#ifndef _WIN32
@@ -1156,11 +1248,14 @@ namespace build2
uint16_t ec (exit->code ()); // Make sure is printed as integer.
if (!valid)
- d << p << " exit status " << ec << " is invalid" <<
+ d << pr << " exit status " << ec << " is invalid" <<
info << "must be an unsigned integer < 256";
- else if (!correct)
- d << p << " exit status " << ec << (eq ? " != " : " == ")
- << static_cast<uint16_t> (c.exit.status);
+ else if (!success)
+ {
+ if (diag)
+ d << pr << " exit status " << ec << (eq ? " != " : " == ")
+ << static_cast<uint16_t> (c.exit.status);
+ }
else
assert (false);
}
@@ -1179,18 +1274,83 @@ namespace build2
print_file (d, esp, ll);
}
- // Exit code is correct. Check if the standard outputs match the
- // expectations.
+ // If exit code is correct then check if the standard outputs match the
+ // expectations. Note that stdout is only redirected to file for the
+ // last command in the pipeline.
//
- check_output (p, osp, isp, out, ll, sp, "stdout");
- check_output (p, esp, isp, err, ll, sp, "stderr");
+ if (success)
+ success =
+ (!last ||
+ check_output (pr, osp, isp, out, ll, sp, diag, "stdout")) &&
+ check_output (pr, esp, isp, err, ll, sp, diag, "stderr");
+
+ return success;
+ }
+
+ static bool
+ run_expr (scope& sp,
+ const command_expr& expr,
+ size_t li, const location& ll,
+ bool diag)
+ {
+ bool r (false);
+
+ // Commands are numbered sequentially throughout the expression
+ // starting with 1. Number 0 means the command is a single one.
+ //
+ size_t ci (expr.size () == 1 && expr.back ().pipe.size () == 1
+ ? 0
+ : 1);
+
+ // If there is no ORs to the right of a pipe then the pipe failure is
+ // fatal for the whole expression. In particular, the pipe must print
+ // the diagnostics on failure (if generally allowed). So we find the
+ // pipe that "switches on" the diagnostics potential printing.
+ //
+ command_expr::const_iterator trailing_ands; // Undefined if diag is
+ // disallowed.
+ if (diag)
+ {
+ auto i (expr.crbegin ());
+ for (; i != expr.crend () && i->op == expr_operator::log_and; ++i) ;
+ trailing_ands = i.base ();
+ }
+
+ bool print (false);
+ for (auto b (expr.cbegin ()), i (b), e (expr.cend ()); i != e; ++i)
+ {
+ if (diag && i + 1 == trailing_ands)
+ print = true;
+
+ const command_pipe& p (i->pipe);
+ bool or_op (i->op == expr_operator::log_or);
+
+ // Short-circuit if the pipe result must be OR-ed with true or AND-ed
+ // with false.
+ //
+ if (!((or_op && r) || (!or_op && !r)))
+ r = run_pipe (
+ sp, p.begin (), p.end (), auto_fd (), ci, li, ll, print);
+
+ ci += p.size ();
+ }
+
+ return r;
+ }
+
+ void default_runner::
+ run (scope& sp, const command_expr& expr, size_t li, const location& ll)
+ {
+ if (!run_expr (sp, expr, li, ll, true))
+ throw failed (); // Assume diagnostics is already printed.
}
bool default_runner::
- run_if (scope&, const command_expr& expr, size_t, const location&)
+ run_if (scope& sp,
+ const command_expr& expr,
+ size_t li, const location& ll)
{
- const command& c (expr.back ().pipe.back ()); // @@ TMP
- return c.program.string () == "true"; // @@ TMP
+ return run_expr (sp, expr, li, ll, false);
}
}
}
diff --git a/build2/test/script/script b/build2/test/script/script
index 90b71bf..e528cdd 100644
--- a/build2/test/script/script
+++ b/build2/test/script/script
@@ -301,7 +301,7 @@ namespace build2
struct expr_term
{
- expr_operator op; // Ignored for the first term.
+ expr_operator op; // OR-ed to an implied false for the first term.
command_pipe pipe;
};
diff --git a/tests/test/script/runner/buildfile b/tests/test/script/runner/buildfile
index 86c18e2..df37c6d 100644
--- a/tests/test/script/runner/buildfile
+++ b/tests/test/script/runner/buildfile
@@ -2,7 +2,7 @@
# copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
# license : MIT; see accompanying LICENSE file
-./: test{cleanup redirect regex status} exe{driver} $b
+./: test{cleanup expr if pipe redirect regex status} exe{driver} $b
test{*}: target = exe{driver}
diff --git a/tests/test/script/runner/expr.test b/tests/test/script/runner/expr.test
new file mode 100644
index 0000000..454da1e
--- /dev/null
+++ b/tests/test/script/runner/expr.test
@@ -0,0 +1,522 @@
+# file : tests/test/script/runner/expr.test
+# copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
+# license : MIT; see accompanying LICENSE file
+
+.include ../common.test
+
+: short-circuit
+:
+: Test expression result calculation and short-circuiting. We verify the
+: correctness of the above for all possible expressions of a length up to 3
+: operands. While some of tests may look redundant the full expression tree is
+: easier to maintain than the one with gaps (also much less chances that we
+: have missed something useful). Each pipe-operand has a label which is printed
+: to stdout when the pipe is executed. Pipes stdouts are pass-redirected, so we
+: just check that build2 output matches expectations.
+:
+: Note that expression evaluation goes left-to-right with AND and OR having the
+: same precedence.
+:
+{
+ true = '$* >| -o'
+ false = '$* -s 1 >| -o'
+
+ bf = $b 2>/~'%.+/driver(\.exe)? exit status 1 != 0%'
+
+ : true
+ :
+ {
+ : TERM
+ :
+ $c <"$true 1" && $b >>EOO
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ : TERM
+ :
+ $c <"$true 1 || $true 2" && $b >>EOO
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 || $true 2 || $true 3" && $b >>EOO
+ 1
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 || $true 2 || $false 3" && $b >>EOO
+ 1
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 || $true 2 && $true 3" && $b >>EOO
+ 1
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 || $true 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 3
+ EOO
+ }
+ }
+ }
+
+ : false
+ :
+ {
+ : TERM
+ :
+ $c <"$true 1 || $false 2" && $b >>EOO
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 || $false 2 || $true 3" && $b >>EOO
+ 1
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 || $false 2 || $false 3" && $b >>EOO
+ 1
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 || $false 2 && $true 3" && $b >>EOO
+ 1
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 || $false 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 3
+ EOO
+ }
+ }
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ : TERM
+ :
+ $c <"$true 1 && $true 2" && $b >>EOO
+ 1
+ 2
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 && $true 2 || $true 3" && $b >>EOO
+ 1
+ 2
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 && $true 2 || $false 3" && $b >>EOO
+ 1
+ 2
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 && $true 2 && $true 3" && $b >>EOO
+ 1
+ 2
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 && $true 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ 3
+ EOO
+ }
+ }
+ }
+
+ : false
+ :
+ {
+ : TERM
+ :
+ $c <"$true 1 && $false 2" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 && $false 2 || $true 3" && $b >>EOO
+ 1
+ 2
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 && $false 2 || $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ 3
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$true 1 && $false 2 && $true 3" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$true 1 && $false 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+ }
+ }
+ }
+ }
+ }
+
+ : false
+ :
+ {
+ : TERM
+ :
+ $c <"$false 1" && $bf >>EOO != 0
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ : TERM
+ :
+ $c <"$false 1 || $true 2" && $b >>EOO
+ 1
+ 2
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 || $true 2 || $true 3" && $b >>EOO
+ 1
+ 2
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 || $true 2 || $false 3" && $b >>EOO
+ 1
+ 2
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 || $true 2 && $true 3" && $b >>EOO
+ 1
+ 2
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 || $true 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ 3
+ EOO
+ }
+ }
+ }
+
+ : false
+ :
+ {
+ : TERM
+ :
+ $c <"$false 1 || $false 2" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 || $false 2 || $true 3" && $b >>EOO
+ 1
+ 2
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 || $false 2 || $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ 3
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 || $false 2 && $true 3" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 || $false 2 && $false 3" && $bf >>EOO != 0
+ 1
+ 2
+ EOO
+ }
+ }
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ : TERM
+ :
+ $c <"$false 1 && $true 2" && $bf >>EOO != 0
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 && $true 2 || $true 3" && $b >>EOO
+ 1
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 && $true 2 || $false 3" && $bf >>EOO != 0
+ 1
+ 3
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 && $true 2 && $true 3" && $bf >>EOO != 0
+ 1
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 && $true 2 && $false 3" && $bf >>EOO != 0
+ 1
+ EOO
+ }
+ }
+ }
+
+ : false
+ :
+ {
+ : TERM
+ :
+ $c <"$false 1 && $false 2" && $bf >>EOO != 0
+ 1
+ EOO
+
+ : OR
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 && $false 2 || $true 3" && $b >>EOO
+ 1
+ 3
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 && $false 2 || $false 3" && $bf >>EOO != 0
+ 1
+ 3
+ EOO
+ }
+ }
+
+ : AND
+ :
+ {
+ : true
+ :
+ {
+ $c <"$false 1 && $false 2 && $true 3" && $bf >>EOO != 0
+ 1
+ EOO
+ }
+
+ : false
+ :
+ {
+ $c <"$false 1 && $false 2 && $false 3" && $bf >>EOO != 0
+ 1
+ EOO
+ }
+ }
+ }
+ }
+ }
+}
+
+: diagnostics
+:
+: Check that the diagnostics is printed for only the last faulty pipe.
+:
+{
+ true = '$*'
+ false = '$* -s 1 2>'X' -e' # Compares stderr to value that never matches.
+
+ : trailing
+ :
+ $c <"$false 1 != 0 || $true && $false 2 != 0" && $b 2>>~/EOE/ != 0
+ /.{7}
+ -X
+ +2
+ EOE
+
+ : non-trailing
+ :
+ $c <"$false 1 != 0 || $true && $false 2 != 0 && $true" && $b 2>>~/EOE/ != 0
+ /.{7}
+ -X
+ +2
+ EOE
+}
diff --git a/tests/test/script/runner/if.test b/tests/test/script/runner/if.test
new file mode 100644
index 0000000..d9c3601
--- /dev/null
+++ b/tests/test/script/runner/if.test
@@ -0,0 +1,25 @@
+# file : tests/test/script/runner/if.test
+# copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
+# license : MIT; see accompanying LICENSE file
+
+.include ../common.test
+
+: if-branch
+:
+$c <<EOI && $b >'if'
+if cat <'foo' >'foo'
+ echo 'if' >|
+else
+ echo 'else' >|
+end
+EOI
+
+: else-branch
+:
+$c <<EOI && $b >'else'
+if cat <'foo' >'bar'
+ echo 'if' >|
+else
+ echo 'else' >|
+end
+EOI
diff --git a/tests/test/script/runner/pipe.test b/tests/test/script/runner/pipe.test
new file mode 100644
index 0000000..bfbe8cb
--- /dev/null
+++ b/tests/test/script/runner/pipe.test
@@ -0,0 +1,35 @@
+# file : tests/test/script/runner/pipe.test
+# copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
+# license : MIT; see accompanying LICENSE file
+
+.include ../common.test
+
+$c <'cat <foo | $* -i 1 >foo' && $b : builtin-to-process
+$c <'$* -o foo | cat >foo' && $b : process-to-builtin
+
+
+: failure
+:
+: Note that while both commands for the pipe are faulty the diagnostics for
+: only the last one is printed.
+:
+{
+ : exit-code
+ :
+ $c <'$* -o foo -s 1 | $* -i 1 >foo -s 2' && $b 2>>/~%EOE% != 0
+ %testscript:1:1: error: .+ exit status 2 != 0%
+ info: stdout: test/1/stdout-2
+ EOE
+
+ : stderr
+ :
+ $c <'$* -o foo -e foo 2>bar | $* -i 2 2>baz' && $b 2>>/~%EOE% != 0
+ %testscript:1:1: error: .+ stderr doesn't match the expected output%
+ info: stderr: test/1/stderr-2
+ info: expected stderr: test/1/stderr-2.orig
+ info: stderr diff: test/1/stderr-2.diff
+ %.{3}
+ -baz
+ +foo
+ EOE
+}
diff --git a/tests/test/script/runner/redirect.test b/tests/test/script/runner/redirect.test
index 7cb6316..cfc12c5 100644
--- a/tests/test/script/runner/redirect.test
+++ b/tests/test/script/runner/redirect.test
@@ -9,6 +9,16 @@ b += --no-column
ps = ($cxx.target.class != 'windows' ? '/' : '\') # Path separator.
psr = ($cxx.target.class != 'windows' ? '/' : '\\') # Path separator in regex.
+: pass
+:
+{
+ $c <'$* -i 1 -e bar <| >| 2>|';
+ cat <<EOI >=buildfile;
+ test{testscript}: $target
+ EOI
+ $0 --jobs 1 --quiet test <foo >foo 2>bar
+}
+
: null
:
{
@@ -540,45 +550,3 @@ psr = ($cxx.target.class != 'windows' ? '/' : '\\') # Path separator in regex.
EOI
$b
}
-
-# @@ That will probably become redundant when builtins and process obtain file
-# descriptors uniformly.
-#
-: builtins
-:
-{
- : out-null
- :
- $c <'echo "abc" >-';
- $b
-
- : err-null
- :
- $c <'echo "abc" 1>&2 2>-';
- $b
-
- : in-str
- :
- $c <'echo <foo 1>-';
- $b
-
- : out-str
- :
- $c <'echo "foo" >foo';
- $b
-
- : err-str
- :
- $c <'echo "foo" 2>foo 1>&2';
- $b
-
- : inout-str
- :
- $c <'cat <foo >foo';
- $b
-
- : inerr-str
- :
- $c <'cat <foo 2>foo 1>&2';
- $b
-}
diff --git a/unit-tests/test/script/parser/pipe-expr.test b/unit-tests/test/script/parser/pipe-expr.test
index cc0bd7e..d789f56 100644
--- a/unit-tests/test/script/parser/pipe-expr.test
+++ b/unit-tests/test/script/parser/pipe-expr.test
@@ -87,3 +87,47 @@ cmd &&
EOI
testscript:1:7: error: missing program
EOE
+
+: redirected
+:
+{
+ : input
+ :
+ {
+ : first
+ :
+ $* <<EOI >>EOO
+ cmd1 <foo | cmd2
+ EOI
+ cmd1 <foo | cmd2
+ EOO
+
+ : non-first
+ :
+ $* <<EOI 2>>EOE != 0
+ cmd1 | cmd2 <foo
+ EOI
+ testscript:1:13: error: stdin is both piped and redirected
+ EOE
+ }
+
+ : output
+ :
+ {
+ : last
+ :
+ $* <<EOI >>EOO
+ cmd1 | cmd2 >foo
+ EOI
+ cmd1 | cmd2 >foo
+ EOO
+
+ : non-last
+ :
+ $* <<EOI 2>>EOE != 0
+ cmd1 >foo | cmd2
+ EOI
+ testscript:1:11: error: stdout is both redirected and piped
+ EOE
+ }
+}