Tests

% AND-par "flow analysis" regression: independent deterministic user predicates
% should run concurrently when flowlog_parallel_and is enabled.

:- set_prolog_flag(flowlog_parallel_and, on).

complex(I, O) :-
  $flowlog_sleep_ms(250),
  O is I + 1.

merge(A, B, O) :-
  O is A + B.

doubleComplex(I, O) :-
  complex(I, A),
  complex(I, B),
  merge(A, B, O).

% Regression: findall/3 must work with a non-ground template that becomes ground
% per-solution (ISO semantics).

p(1).
p(2).

q(L) :- findall(X, p(X), L).

ok :-
  q(L),
  L = [1,2].

% WAM findall/3: non-ground template instances should be copied with fresh,
% bindable variables (ISO semantics).

:- catch(set_prolog_flag(flowlog_engine, wam), _, true).

p(1).
p(2).

q(L) :- findall(pair(X,Y), p(X), L).

ok :-
  q(L),
  L = [pair(1,Y1), pair(2,Y2)],
  var(Y1),
  var(Y2),
  Y1 \== Y2,
  Y1 = a,
  Y2 = b,
  findall(X, (p(X), !), Lcut),
  Lcut = [1],
  findall(Z, p(3), Lnone),
  Lnone = [],
  findall(T, \+ true, Lneg),
  Lneg = [],
  X0 = outer,
  findall(W, p(W), _),
  X0 == outer.

% Regression test: `length/2` must handle lists longer than internal guards.

ok :-
  length(L, 70000),
  length(L, N),
  N =:= 70000.

#include <errno.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__)
#include <libutil.h>
#else
#include <pty.h>
#endif

static bool wait_for_substr(int fd, const char *needle, int timeout_ms) {
  char buf[8192];
  size_t len = 0;
  buf[0] = '\0';

  const int step_ms = 20;
  int remaining = timeout_ms;

  while (remaining > 0) {
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(fd, &rfds);

    struct timeval tv;
    tv.tv_sec = step_ms / 1000;
    tv.tv_usec = (step_ms % 1000) * 1000;

    int rc = select(fd + 1, &rfds, NULL, NULL, &tv);
    if (rc < 0) {
      if (errno == EINTR) {
        continue;
      }
      return false;
    }
    if (rc == 0) {
      remaining -= step_ms;
      continue;
    }

    if (!FD_ISSET(fd, &rfds)) {
      remaining -= step_ms;
      continue;
    }

    ssize_t n = read(fd, buf + len, sizeof(buf) - 1 - len);
    if (n <= 0) {
      return false;
    }
    len += (size_t)n;
    buf[len] = '\0';

    if (strstr(buf, needle)) {
      return true;
    }

    if (len > sizeof(buf) / 2) {
      const size_t keep = sizeof(buf) / 3;
      memmove(buf, buf + (len - keep), keep);
      len = keep;
      buf[len] = '\0';
    }
  }

  return false;
}

static bool wait_for_exit(pid_t pid, int timeout_ms, int *status_out) {
  const int step_ms = 10;
  int remaining = timeout_ms;

  while (remaining > 0) {
    int st = 0;
    pid_t w = waitpid(pid, &st, WNOHANG);
    if (w == pid) {
      if (status_out) {
        *status_out = st;
      }
      return true;
    }
    if (w < 0) {
      if (errno == EINTR) {
        continue;
      }
      return false;
    }
    usleep(step_ms * 1000);
    remaining -= step_ms;
  }

  return false;
}

int main(int argc, char **argv) {
  if (argc < 2 || !argv[1] || !*argv[1]) {
    fprintf(stderr, "usage: %s /path/to/flowlog\n", argv[0]);
    return 2;
  }

  const char *bin = argv[1];

  int master = -1;
  pid_t pid = forkpty(&master, NULL, NULL, NULL);
  if (pid < 0) {
    perror("forkpty");
    return 2;
  }

  if (pid == 0) {
    execl(bin, bin, NULL);
    perror("exec");
    _exit(127);
  }

  if (master < 0) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "no pty master\n");
    return 2;
  }

  if (!wait_for_substr(master, "?- ", 2000)) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "did not see prompt\n");
    return 1;
  }

  const unsigned char ctrl_d = 0x04;
  ssize_t wr = write(master, &ctrl_d, 1);
  if (wr != 1) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "failed to write Ctrl-D\n");
    return 1;
  }

  int st = 0;
  if (!wait_for_exit(pid, 1000, &st)) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "timeout waiting for exit\n");
    return 1;
  }

  if (WIFEXITED(st) && WEXITSTATUS(st) == 0) {
    return 0;
  }
  if (WIFSIGNALED(st)) {
    fprintf(stderr, "exited via signal: %d\n", WTERMSIG(st));
  } else if (WIFEXITED(st)) {
    fprintf(stderr, "unexpected exit code: %d\n", WEXITSTATUS(st));
  } else {
    fprintf(stderr, "unexpected exit status: %d\n", st);
  }
  return 1;
}

#include <errno.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__)
#include <libutil.h>
#else
#include <pty.h>
#endif

static bool wait_for_substr(int fd, const char *needle, int timeout_ms) {
  char buf[8192];
  size_t len = 0;
  buf[0] = '\0';

  const int step_ms = 20;
  int remaining = timeout_ms;

  while (remaining > 0) {
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(fd, &rfds);

    struct timeval tv;
    tv.tv_sec = step_ms / 1000;
    tv.tv_usec = (step_ms % 1000) * 1000;

    int rc = select(fd + 1, &rfds, NULL, NULL, &tv);
    if (rc < 0) {
      if (errno == EINTR) {
        continue;
      }
      return false;
    }
    if (rc == 0) {
      remaining -= step_ms;
      continue;
    }

    if (!FD_ISSET(fd, &rfds)) {
      remaining -= step_ms;
      continue;
    }

    ssize_t n = read(fd, buf + len, sizeof(buf) - 1 - len);
    if (n <= 0) {
      return false;
    }
    len += (size_t)n;
    buf[len] = '\0';

    if (strstr(buf, needle)) {
      return true;
    }

    if (len > sizeof(buf) / 2) {
      const size_t keep = sizeof(buf) / 3;
      memmove(buf, buf + (len - keep), keep);
      len = keep;
      buf[len] = '\0';
    }
  }

  return false;
}

static void drain_fd(int fd) {
  char tmp[4096];
  for (;;) {
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(fd, &rfds);

    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 0;

    int rc = select(fd + 1, &rfds, NULL, NULL, &tv);
    if (rc <= 0 || !FD_ISSET(fd, &rfds)) {
      return;
    }
    ssize_t n = read(fd, tmp, sizeof(tmp));
    if (n <= 0) {
      return;
    }
  }
}

static bool wait_for_exit(int fd, pid_t pid, int timeout_ms, int *status_out) {
  const int step_ms = 10;
  int remaining = timeout_ms;

  while (remaining > 0) {
    int st = 0;
    pid_t w = waitpid(pid, &st, WNOHANG);
    if (w == pid) {
      if (status_out) {
        *status_out = st;
      }
      return true;
    }
    if (w < 0) {
      if (errno == EINTR) {
        continue;
      }
      return false;
    }
    drain_fd(fd);
    usleep(step_ms * 1000);
    remaining -= step_ms;
  }

  return false;
}

int main(int argc, char **argv) {
  if (argc < 2 || !argv[1] || !*argv[1]) {
    fprintf(stderr, "usage: %s /path/to/flowlog\n", argv[0]);
    return 2;
  }

  const char *bin = argv[1];

  int master = -1;
  pid_t pid = forkpty(&master, NULL, NULL, NULL);
  if (pid < 0) {
    perror("forkpty");
    return 2;
  }

  if (pid == 0) {
    execl(bin, bin, NULL);
    perror("exec");
    _exit(127);
  }

  if (master < 0) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "no pty master\n");
    return 2;
  }

  if (!wait_for_substr(master, "?- ", 5000)) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "did not see prompt\n");
    return 1;
  }

  // Ctrl-T: Flowlog SIGINFO keybinding (BSD SIGINFO equivalent).
  const unsigned char ctrl_t = 0x14;
  if (write(master, &ctrl_t, 1) != 1) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "failed to write Ctrl-T\n");
    return 1;
  }

  // In raw mode, the terminal must still translate '\n' to CRLF, otherwise
  // the status report "staircases" to the right.
  if (!wait_for_substr(master, "\r\nFlowlog SIGINFO (status)\r\n", 5000)) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "siginfo output missing CRLF framing\n");
    return 1;
  }

  // Exit via Ctrl-D at a fresh prompt.
  const unsigned char ctrl_d = 0x04;
  if (write(master, &ctrl_d, 1) != 1) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "failed to write Ctrl-D\n");
    return 1;
  }

  int st = 0;
  if (!wait_for_exit(master, pid, 3000, &st)) {
    kill(pid, SIGKILL);
    (void)waitpid(pid, NULL, 0);
    fprintf(stderr, "timeout waiting for exit\n");
    return 1;
  }

  if (WIFEXITED(st) && WEXITSTATUS(st) == 0) {
    return 0;
  }
  if (WIFSIGNALED(st)) {
    fprintf(stderr, "exited via signal: %d\n", WTERMSIG(st));
  } else if (WIFEXITED(st)) {
    fprintf(stderr, "unexpected exit code: %d\n", WEXITSTATUS(st));
  } else {
    fprintf(stderr, "unexpected exit status: %d\n", st);
  }
  return 1;
}

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

mkdir -p "$ROOT/build"

BIN="$ROOT/flowlog"
PROG="$ROOT/tests/and_par_user_pred.pl"

fail() {
  echo "fail: $1" >&2
  exit 1
}

run_out() {
  "$BIN" --threads 2 -f "$PROG" -g "$1" | tr -d '\r'
}

run_prog_out() {
  local prog="$1"
  local goal="$2"
  "$BIN" --threads 2 -f "$prog" -g "$goal" | tr -d '\r'
}

time_real() {
  if command -v /usr/bin/time >/dev/null 2>&1; then
    (/usr/bin/time -p "$@" >/dev/null) 2>&1 | awk '/^real[[:space:]]+/{print $2; exit}'
    return 0
  fi

  # Fallback: coarse (seconds).
  local t0 t1
  t0="$(date +%s)"
  "$@" >/dev/null
  t1="$(date +%s)"
  echo "$((t1 - t0))"
}

out="$("$BIN" --threads 1 --engine interp -g '\+ (true -> fail).' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "parse_not_if_then"
fi

out="$(run_out 'doubleComplex(1,O).')"
out="${out%$'\n'}"
if [[ "$out" != "O = 4" ]]; then
  echo "--- expected ---" >&2
  echo "O = 4" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "and_par_user_pred_output"
fi

seq="$(time_real "$BIN" --threads 2 --engine interp -f "$PROG" -g 'set_prolog_flag(flowlog_parallel_and,off), doubleComplex(1,O).')"
par="$(time_real "$BIN" --threads 2 --engine interp -f "$PROG" -g 'set_prolog_flag(flowlog_parallel_and,on), doubleComplex(1,O).')"

awk -v seq="$seq" -v par="$par" 'BEGIN {
  if (seq + 0.0 <= 0.0 || par + 0.0 <= 0.0) exit 1;
  # Expect a noticeable wall-time reduction when AND-par is enabled.
  if ((seq / par) < 1.3) exit 2;
}' || fail "and_par_user_pred_timing (seq=$seq par=$par)"

seq_wam="$(time_real "$BIN" --threads 2 --engine wam -f "$PROG" -g 'current_prolog_flag(flowlog_engine_active,wam), set_prolog_flag(flowlog_parallel_and,off), doubleComplex(1,O).')"
par_wam="$(time_real "$BIN" --threads 2 --engine wam -f "$PROG" -g 'current_prolog_flag(flowlog_engine_active,wam), set_prolog_flag(flowlog_parallel_and,on), doubleComplex(1,O).')"

awk -v seq="$seq_wam" -v par="$par_wam" 'BEGIN {
  if (seq + 0.0 <= 0.0 || par + 0.0 <= 0.0) exit 1;
  # Expect a noticeable wall-time reduction when AND-par is enabled.
  if ((seq / par) < 1.3) exit 2;
}' || fail "and_par_user_pred_timing_wam (seq=$seq_wam par=$par_wam)"

bash "$ROOT/tests/run_sigint_repl.sh" >/dev/null
bash "$ROOT/tests/run_siginfo_repl.sh" >/dev/null
bash "$ROOT/tests/run_siginfo_key_repl.sh" >/dev/null
bash "$ROOT/tests/run_ctrld_repl.sh" >/dev/null
bash "$ROOT/tests/run_bracket_consult_repl.sh" >/dev/null
bash "$ROOT/tests/run_orpar_nesting.sh" >/dev/null
bash "$ROOT/tests/run_orpar_nesting_wam.sh" >/dev/null

out="$("$BIN" --threads 2 -f "$ROOT/tests/length_long.pl" -g 'ok.' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "length_long"
fi

WAM_PROG="$ROOT/tests/wam_engine_smoke.pl"
out="$(run_prog_out "$WAM_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_engine_ok"
fi

out="$(run_prog_out "$WAM_PROG" 'fact(5,F).')"
out="${out%$'\n'}"
if [[ "$out" != "F = 120" ]]; then
  echo "--- expected ---" >&2
  echo "F = 120" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_engine_fact"
fi

out="$(run_prog_out "$WAM_PROG" 'count(C).')"
out="${out%$'\n'}"
if [[ "$out" != "C = 2" ]]; then
  echo "--- expected ---" >&2
  echo "C = 2" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_engine_findall_length"
fi

WAM_TABLING_PROG="$ROOT/tests/wam_tabling.pl"
out="$(run_prog_out "$WAM_TABLING_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_tabling"
fi

FINDALL_PROG="$ROOT/tests/findall_non_ground.pl"
out="$(run_prog_out "$FINDALL_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "findall_non_ground_fallback"
fi

FINDALL_VARS_PROG="$ROOT/tests/findall_vars.pl"
out="$(run_prog_out "$FINDALL_VARS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "findall_vars_wam"
fi

WAM_CTRL_PROG="$ROOT/tests/wam_control_constructs.pl"
out="$(run_prog_out "$WAM_CTRL_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_control_constructs"
fi

WAM_TERM_OPS_PROG="$ROOT/tests/wam_term_ops.pl"
out="$(run_prog_out "$WAM_TERM_OPS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_term_ops"
fi

WAM_SORTING_PROG="$ROOT/tests/wam_sorting.pl"
out="$(run_prog_out "$WAM_SORTING_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_sorting"
fi

WAM_SUB_STRING_PROG="$ROOT/tests/wam_sub_string.pl"
out="$(run_prog_out "$WAM_SUB_STRING_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_sub_string"
fi

WAM_EXTRA_BUILTINS_PROG="$ROOT/tests/wam_extra_builtins.pl"
out="$(run_prog_out "$WAM_EXTRA_BUILTINS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_extra_builtins"
fi

WAM_EXC_PROG="$ROOT/tests/wam_exceptions.pl"
out="$(run_prog_out "$WAM_EXC_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_exceptions"
fi

WAM_COPY_VARS_PROG="$ROOT/tests/wam_copy_vars.pl"
out="$(run_prog_out "$WAM_COPY_VARS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_copy_vars"
fi

WAM_CONV_PROG="$ROOT/tests/wam_conversions.pl"
out="$(run_prog_out "$WAM_CONV_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_conversions"
fi

WAM_BAGOF_PROG="$ROOT/tests/wam_bagof_setof.pl"
out="$(run_prog_out "$WAM_BAGOF_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_bagof_setof"
fi

WAM_OPS_PROG="$ROOT/tests/wam_ops.pl"
out="$(run_prog_out "$WAM_OPS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_ops"
fi

WAM_FLAGS_PROG="$ROOT/tests/wam_flags.pl"
out="$(run_prog_out "$WAM_FLAGS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_flags"
fi

WAMVM_FLAGS_PROG="$ROOT/tests/wamvm_flags.pl"
out="$(run_prog_out "$WAMVM_FLAGS_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_flags"
fi

WAMVM_VM_SMOKE_PROG="$ROOT/tests/wamvm_vm_smoke.pl"
out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm -f "$WAMVM_VM_SMOKE_PROG" -g 'findall(X,p(X),Xs).' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "Xs = [1,2]" ]]; then
  echo "--- expected ---" >&2
  echo "Xs = [1,2]" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_vm_smoke"
fi

WAMVM_FINDALL_VAR_GOAL_PROG="$ROOT/tests/wamvm_findall_var_goal_vm.pl"
out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm -f "$WAMVM_FINDALL_VAR_GOAL_PROG" -g 'ok.' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_findall_var_goal_vm"
fi

WAMVM_SELECT1_VM_PROG="$ROOT/tests/wamvm_select1_vm.pl"
out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm -f "$WAMVM_SELECT1_VM_PROG" -g 'ok.' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_select1_vm"
fi

WAMVM_TERM_OPS_VM_PROG="$ROOT/tests/wamvm_term_ops_vm.pl"
out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm -f "$WAMVM_TERM_OPS_VM_PROG" -g 'ok.' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_term_ops_vm"
fi

WAMVM_EXCEPTIONS_VM_PROG="$ROOT/tests/wamvm_exceptions_vm.pl"
out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm -f "$WAMVM_EXCEPTIONS_VM_PROG" -g 'ok.' | tr -d '\r')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wamvm_exceptions_vm"
fi

# VM-only compatibility pass: ensure common WAM-era ISO tests run entirely in WAMVM mode.
for f in "$ROOT"/tests/wam_*.pl; do
  base="$(basename "$f")"
  case "$base" in
    wam_flags.pl|wam_tabling.pl) continue ;;
  esac
  out="$(FLOWLOG_WAMVM_REQUIRE_VM=1 "$BIN" --threads 2 --engine wamvm --parallel-profile off -f "$f" -g 'ok.' | tr -d '\r')"
  out="${out%$'\n'}"
  if [[ "$out" != "true" ]]; then
    echo "--- expected ---" >&2
    echo "true" >&2
    echo "--- got ---" >&2
    printf '%s\n' "$out" >&2
    fail "wamvm_vm_only_${base%.pl}"
  fi
done

WAM_REFL_PROG="$ROOT/tests/wam_reflective.pl"
out="$(run_prog_out "$WAM_REFL_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_reflective"
fi

WAM_PROP_PROG="$ROOT/tests/wam_properties.pl"
out="$(run_prog_out "$WAM_PROP_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_properties"
fi

WAM_DYN_DB_PROG="$ROOT/tests/wam_dynamic_db.pl"
out="$(run_prog_out "$WAM_DYN_DB_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_dynamic_db"
fi

WAM_IO_PROG="$ROOT/tests/wam_stream_io.pl"
out="$(run_prog_out "$WAM_IO_PROG" 'ok.')"
out="${out%$'\n'}"
if [[ "$out" != "true" ]]; then
  echo "--- expected ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "wam_stream_io"
fi

echo "ok"

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

BIN="$ROOT/flowlog"

fail() {
  echo "fail: $1" >&2
  exit 1
}

tmpdir="$(mktemp -d -t flowlog_ctrld_repl.XXXXXX)"
cleanup() {
  rm -rf "$tmpdir" >/dev/null 2>&1 || true
}
trap cleanup EXIT

tester="$tmpdir/ctrld_repl_tty"
cc -O2 -Wall -Wextra "$ROOT/tests/repl_ctrld_tty.c" -lutil -o "$tester" || fail "ctrld_repl_build"

"$tester" "$BIN" >/dev/null 2>&1 || fail "ctrld_repl_exit"

echo "ok"

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
BIN="$ROOT/flowlog"

make -C "$ROOT" -s >/dev/null

out="$(
  printf '%s\n' \
    '[bench/nqueens_length].' \
    'queens_solutions(4,2).' \
    'halt.' \
  | "$BIN" --threads 1 \
  | tr -d '\r'
)"

if ! printf '%s\n' "$out" | grep -Eq '^true$'; then
  echo "--- expected output containing ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  exit 1
fi

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
FLOWLOG_BIN="${FLOWLOG_BIN:-$ROOT/flowlog}"
FLOWLOG_TIMEOUT="${FLOWLOG_TIMEOUT:-120s}"
FLOWLOG_ENGINE="${FLOWLOG_ENGINE:-interp}"
FLOWLOG_PARALLEL_PROFILE="${FLOWLOG_PARALLEL_PROFILE:-off}"
# By default, suppress per-test stderr noise (the INRIA suite intentionally
# triggers a couple of "unknown procedure" warnings when `unknown=warning`).
# Set to 1 to see stderr for every file.
FLOWLOG_INRIA_SHOW_STDERR="${FLOWLOG_INRIA_SHOW_STDERR:-0}"

if [[ ! -x "$FLOWLOG_BIN" ]]; then
  make -C "$ROOT" >/dev/null
fi

suite_dir="$ROOT/build/inria_suite/inriasuite"
suite_driver="$suite_dir/inriasuite.pl"
suite_wrapper="$ROOT/build/inria_suite/flowlog_inriasuite.pl"

if [[ ! -f "$suite_driver" || ! -f "$suite_wrapper" ]]; then
  "$ROOT/tests/setup_inria_suite.sh" >/dev/null
fi

if [[ ! -f "$suite_driver" || ! -f "$suite_wrapper" ]]; then
  echo "inria: suite not set up (missing: $suite_driver and/or $suite_wrapper)" >&2
  exit 1
fi

mapfile -t files < <(
  rg '^file\(' "$suite_driver" \
    | sed -E 's/^file\((.*)\)\..*/\1/' \
    | sed -E 's/[[:space:]]+$//'
)

failures=0
total_files=0

echo "INRIA suite file-by-file, timeout=$FLOWLOG_TIMEOUT"

err_tmp=""
if [[ "$FLOWLOG_INRIA_SHOW_STDERR" == "0" || "$FLOWLOG_INRIA_SHOW_STDERR" == "off" || "$FLOWLOG_INRIA_SHOW_STDERR" == "false" ]]; then
  err_tmp="$(mktemp "$ROOT/build/inria_suite/flowlog_inria_stderr.XXXXXX")"
  trap 'rm -f "$err_tmp"' EXIT
fi

for f in "${files[@]}"; do
  [[ -n "$f" ]] || continue
  total_files=$((total_files + 1))

  out=""
  st=0
  set +e
  if [[ -n "$err_tmp" ]]; then
    : >"$err_tmp"
    out="$(
      timeout "$FLOWLOG_TIMEOUT" \
        "$FLOWLOG_BIN" --engine "$FLOWLOG_ENGINE" --parallel-profile "$FLOWLOG_PARALLEL_PROFILE" \
          "$suite_wrapper" -g "run_tests_score($f,T,W)." 2>"$err_tmp"
    )"
  else
    out="$(
      timeout "$FLOWLOG_TIMEOUT" \
        "$FLOWLOG_BIN" --engine "$FLOWLOG_ENGINE" --parallel-profile "$FLOWLOG_PARALLEL_PROFILE" \
          "$suite_wrapper" -g "run_tests_score($f,T,W)."
    )"
  fi
  st=$?
  set -e

  if [[ "$st" -ne 0 ]]; then
    echo "  $f: exit=$st" >&2
    if [[ -n "$err_tmp" && -s "$err_tmp" ]]; then
      sed -e 's/^/    /' "$err_tmp" >&2
    fi
    failures=$((failures + 1))
    continue
  fi

  t="$(printf '%s' "$out" | sed -nE 's/.*T = ([0-9]+).*/\1/p' | head -n 1 || true)"
  w="$(printf '%s' "$out" | sed -nE 's/.*W = ([0-9]+).*/\1/p' | head -n 1 || true)"

  if [[ -z "$t" || -z "$w" ]]; then
    echo "  $f: unable to parse output: $out" >&2
    if [[ -n "$err_tmp" && -s "$err_tmp" ]]; then
      sed -e 's/^/    /' "$err_tmp" >&2
    fi
    failures=$((failures + 1))
    continue
  fi

  if [[ "$w" != "0" ]]; then
    echo "  $f: wrong=$w/$t" >&2
    if [[ -n "$err_tmp" && -s "$err_tmp" ]]; then
      sed -e 's/^/    /' "$err_tmp" >&2
    fi
    failures=$((failures + 1))
  fi
done

if [[ "$failures" -eq 0 ]]; then
  echo "OK: $total_files files, 0 failing"
else
  echo "FAIL: $failures/$total_files files failing" >&2
  exit 1
fi

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

BIN="$ROOT/flowlog"

fail() {
  echo "fail: $1" >&2
  exit 1
}

tmpdir="$(mktemp -d -t flowlog_orpar_nesting.XXXXXX)"
cleanup() {
  rm -rf "$tmpdir" >/dev/null 2>&1 || true
}
trap cleanup EXIT

log="$tmpdir/orpar.log"

# Use a small deterministic goal that triggers nested select/3 OR-par:
# - outer select_: 9 alternatives (spawns OR-par)
# - inner select_: 8 alternatives within an OR-par chunk (requires nesting)
out="$(
  FLOWLOG_DEBUG_ORPAR=all \
  FLOWLOG_DEBUG_ORPAR_LOG="$log" \
  "$BIN" --threads 10 -g \
    'set_prolog_flag(flowlog_parallel_profile, fast), set_prolog_flag(flowlog_parallel_or_nesting, 1), countall((select_(X,[1,2,3,4,5,6,7,8,9],R), select_(Y,R,_)), C).' \
    | tr -d '\r'
)"

out="${out%$'\n'}"
if [[ "$out" != "C = 72" ]]; then
  echo "--- expected ---" >&2
  echo "C = 72" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "orpar_nesting_output"
fi

starts="$(grep -c '^flowlog: ORPAR start' "$log" 2>/dev/null || true)"
if [[ "${starts:-0}" -lt 2 ]]; then
  echo "--- expected ORPAR starts >= 2 ---" >&2
  echo "--- got log ---" >&2
  cat "$log" >&2 || true
  fail "orpar_nesting_missing_nested_start"
fi

echo "ok"

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

BIN="$ROOT/flowlog"

fail() {
  echo "fail: $1" >&2
  exit 1
}

tmpdir="$(mktemp -d -t flowlog_orpar_nesting_wam.XXXXXX)"
cleanup() {
  rm -rf "$tmpdir" >/dev/null 2>&1 || true
}
trap cleanup EXIT

log="$tmpdir/orpar.log"

# Use a small deterministic goal that triggers nested select/3 OR-par:
# - outer select_: 9 alternatives (spawns OR-par)
# - inner select_: 8 alternatives within an OR-par chunk (requires nesting)
out="$(
  FLOWLOG_DEBUG_ORPAR=all \
  FLOWLOG_DEBUG_ORPAR_LOG="$log" \
  "$BIN" --threads 10 --engine wam --parallel-profile fast -g \
    'set_prolog_flag(flowlog_parallel_or_nesting, 1), countall((select_(X,[1,2,3,4,5,6,7,8,9],R), select_(Y,R,_)), C).' \
    | tr -d '\r'
)"

out="${out%$'\n'}"
if [[ "$out" != "C = 72" ]]; then
  echo "--- expected ---" >&2
  echo "C = 72" >&2
  echo "--- got ---" >&2
  printf '%s\n' "$out" >&2
  fail "orpar_nesting_output_wam"
fi

starts="$(grep -c '^flowlog: ORPAR start' "$log" 2>/dev/null || true)"
if [[ "${starts:-0}" -lt 2 ]]; then
  echo "--- expected ORPAR starts >= 2 ---" >&2
  echo "--- got log ---" >&2
  cat "$log" >&2 || true
  fail "orpar_nesting_missing_nested_start_wam"
fi

echo "ok"

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

BIN="$ROOT/flowlog"

fail() {
  echo "fail: $1" >&2
  exit 1
}

tmpdir="$(mktemp -d -t flowlog_siginfo_key.XXXXXX)"
cleanup() {
  rm -rf "$tmpdir" >/dev/null 2>&1 || true
}
trap cleanup EXIT

tester="$tmpdir/siginfo_key_tty"
cc -O2 -Wall -Wextra "$ROOT/tests/repl_siginfo_key_tty.c" -lutil -o "$tester" || fail "siginfo_key_build"

"$tester" "$BIN" >/dev/null 2>&1 || fail "siginfo_key_output"

echo "ok"

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

make -C "$ROOT" -s >/dev/null

BIN="$ROOT/flowlog"

fail() {
  echo "fail: $1" >&2
  exit 1
}

if ! kill -l INFO >/dev/null 2>&1; then
  echo "skip (no SIGINFO)"
  exit 0
fi

out_file="$(mktemp -t flowlog_siginfo_repl.XXXXXX)"
cleanup() {
  rm -f "$out_file"
}
trap cleanup EXIT

coproc "$BIN" --threads 2 2>&1
pid="$COPROC_PID"
infd="${COPROC[1]}"
outfd="${COPROC[0]}"

printf 'write(start), nl, flush_output, repeat, fail.\n' >&"$infd"

seen_start=0
for ((i = 0; i < 200; i++)); do
  if IFS= read -r -t 0.05 -u "$outfd" line 2>/dev/null; then
    line="${line%$'\r'}"
    printf '%s\n' "$line" >>"$out_file"
    if [[ "$line" == "start" ]]; then
      seen_start=1
      break
    fi
  fi
done

if [[ "$seen_start" -ne 1 ]]; then
  kill -KILL "$pid" 2>/dev/null || true
  fail "siginfo_repl_no_start"
fi

kill -INFO "$pid" 2>/dev/null || kill -SIGINFO "$pid" 2>/dev/null || true

seen_info=0
seen_pred=0
timeouts_after_info=0
for ((i = 0; i < 400; i++)); do
  if IFS= read -r -t 0.05 -u "$outfd" line 2>/dev/null; then
    line="${line%$'\r'}"
    printf '%s\n' "$line" >>"$out_file"
    timeouts_after_info=0
    if [[ "$line" == "Flowlog SIGINFO (status)" ]]; then
      seen_info=1
    elif [[ "$line" == "  predicate:"* ]]; then
      seen_pred=1
    fi
    continue
  else
    rc=$?
    if [[ "$rc" -eq 142 ]]; then
      if [[ "$seen_info" -eq 1 ]]; then
        timeouts_after_info=$((timeouts_after_info + 1))
        if [[ "$timeouts_after_info" -ge 5 ]]; then
          break
        fi
      fi
      continue
    fi
    break
  fi
done

if [[ "$seen_info" -ne 1 ]]; then
  kill -KILL "$pid" 2>/dev/null || true
  fail "siginfo_repl_no_status"
fi
if [[ "$seen_pred" -ne 1 ]]; then
  kill -KILL "$pid" 2>/dev/null || true
  fail "siginfo_repl_no_predicate"
fi

# Cancel the running query and ensure the REPL continues to accept input.
kill -INT "$pid"
printf 'true.\n' >&"$infd"

# Wait until the REPL produces output for the next query before closing stdin.
seen_true=0
for ((i = 0; i < 400; i++)); do
  if IFS= read -r -t 0.05 -u "$outfd" line 2>/dev/null; then
    line="${line%$'\r'}"
    printf '%s\n' "$line" >>"$out_file"
    if [[ "$line" == "true" ]]; then
      seen_true=1
      break
    fi
    continue
  else
    rc=$?
    if [[ "$rc" -eq 142 ]]; then
      continue
    fi
    break
  fi
done

if [[ "$seen_true" -ne 1 ]]; then
  kill -KILL "$pid" 2>/dev/null || true
  echo "--- expected output containing ---" >&2
  echo "true" >&2
  echo "--- got ---" >&2
  cat "$out_file" >&2
  fail "siginfo_repl_missing_true"
fi

printf 'halt.\n' >&"$infd"
exec {infd}>&-

seen_eof=0
for ((i = 0; i < 400; i++)); do
  if IFS= read -r -t 0.05 -u "$outfd" line 2>/dev/null; then
    line="${line%$'\r'}"
    printf '%s\n' "$line" >>"$out_file"
    continue
  else
    rc=$?
    if [[ "$rc" -eq 142 ]]; then
      continue
    fi
    seen_eof=1
    break
  fi
done

if [[ "$seen_eof" -ne 1 ]]; then
  kill -KILL "$pid" 2>/dev/null || true
  fail "siginfo_repl_timeout"
fi

wait "$pid" 2>/dev/null || true
{ exec {outfd}<&-; } 2>/dev/null || true

echo "ok"