From 97c569defcf77f83aaf796635897f509ee87b426 Mon Sep 17 00:00:00 2001
From: Ben Pfaff <blp@cs.stanford.edu>
Date: Sun, 18 Sep 2022 18:15:55 -0700
Subject: [PATCH] NPAR TESTS: Improve error messages and coding style.

---
 src/language/stats/npar.c    | 1155 +++++++++++-----------------------
 tests/language/stats/npar.at |  262 +++++++-
 2 files changed, 626 insertions(+), 791 deletions(-)

diff --git a/src/language/stats/npar.c b/src/language/stats/npar.c
index d7b2cff853..5dabe25a16 100644
--- a/src/language/stats/npar.c
+++ b/src/language/stats/npar.c
@@ -62,53 +62,7 @@
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
-/* Settings for subcommand specifiers. */
-enum missing_type
-  {
-    MISS_ANALYSIS,
-    MISS_LISTWISE,
-  };
-
-/* Array indices for STATISTICS subcommand. */
-enum
-  {
-    NPAR_ST_DESCRIPTIVES = 0,
-    NPAR_ST_QUARTILES = 1,
-    NPAR_ST_ALL = 2,
-    NPAR_ST_count
-  };
-
 /* NPAR TESTS structure. */
-struct cmd_npar_tests
-  {
-    /* Count variables indicating how many
-       of the subcommands have been given. */
-    int chisquare;
-    int cochran;
-    int binomial;
-    int ks_one_sample;
-    int wilcoxon;
-    int sign;
-    int runs;
-    int friedman;
-    int kendall;
-    int kruskal_wallis;
-    int mann_whitney;
-    int mcnemar;
-    int median;
-    int jonckheere_terpstra;
-    int missing;
-    int method;
-    int statistics;
-
-    /* How missing values should be treated */
-    long miss;
-
-    /* Which statistics have been requested */
-    int a_statistics[NPAR_ST_count];
-  };
-
-
 struct npar_specs
 {
   struct pool *pool;
@@ -120,6 +74,7 @@ struct npar_specs
   int n_vars; /* Number of variables in vv */
 
   enum mv_class filter;    /* Missing values to filter. */
+  bool listwise_missing;
 
   bool descriptives;       /* Descriptive statistics should be calculated */
   bool quartiles;          /* Quartiles should be calculated */
@@ -130,317 +85,140 @@ struct npar_specs
 
 
 /* Prototype for custom subcommands of NPAR TESTS. */
-static int npar_chisquare (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_binomial (struct lexer *, struct dataset *,  struct npar_specs *);
-static int npar_ks_one_sample (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_runs (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_friedman (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_kendall (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_cochran (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_wilcoxon (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_sign (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_kruskal_wallis (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_jonckheere_terpstra (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_mann_whitney (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_mcnemar (struct lexer *, struct dataset *, struct npar_specs *);
-static int npar_median (struct lexer *, struct dataset *, struct npar_specs *);
-
-static int npar_method (struct lexer *, struct npar_specs *);
+static bool npar_chisquare (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_binomial (struct lexer *, struct dataset *,  struct npar_specs *);
+static bool npar_ks_one_sample (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_runs (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_friedman (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_kendall (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_cochran (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_wilcoxon (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_sign (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_kruskal_wallis (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_jonckheere_terpstra (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_mann_whitney (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_mcnemar (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_median (struct lexer *, struct dataset *, struct npar_specs *);
+static bool npar_method (struct lexer *, struct npar_specs *);
 
 /* Command parsing functions. */
-static int parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests *p,
-			     struct npar_specs *npar_specs);
 
 static int
-parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests *npt,
-		  struct npar_specs *nps)
+parse_npar_tests (struct lexer *lexer, struct dataset *ds,
+                  struct npar_specs *nps)
 {
-  npt->chisquare = 0;
-  npt->cochran = 0;
-  npt->binomial = 0;
-  npt->ks_one_sample = 0;
-  npt->wilcoxon = 0;
-  npt->sign = 0;
-  npt->runs = 0;
-  npt->friedman = 0;
-  npt->kendall = 0;
-  npt->kruskal_wallis = 0;
-  npt->mann_whitney = 0;
-  npt->mcnemar = 0;
-  npt->median = 0;
-  npt->jonckheere_terpstra = 0;
-
-  npt->miss = MISS_ANALYSIS;
-  npt->missing = 0;
-  npt->method = 0;
-  npt->statistics = 0;
-
-  memset (npt->a_statistics, 0, sizeof npt->a_statistics);
-  for (;;)
+  bool seen_missing = false;
+  bool seen_method = false;
+  lex_match (lexer, T_SLASH);
+  do
     {
       if (lex_match_id (lexer, "COCHRAN"))
 	{
-          npt->cochran++;
-          switch (npar_cochran (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_cochran (lexer, ds, nps))
+            return false;
 	}
       else if (lex_match_id (lexer, "FRIEDMAN"))
 	{
-          npt->friedman++;
-          switch (npar_friedman (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_friedman (lexer, ds, nps))
+            return false;
 	}
       else if (lex_match_id (lexer, "KENDALL"))
 	{
-          npt->kendall++;
-          switch (npar_kendall (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_kendall (lexer, ds, nps))
+            return false;
 	}
       else if (lex_match_id (lexer, "RUNS"))
 	{
-          npt->runs++;
-          switch (npar_runs (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_runs (lexer, ds, nps))
+            return false;
 	}
       else if (lex_match_id (lexer, "CHISQUARE"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->chisquare++;
-          switch (npar_chisquare (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            case 3:
-              continue;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_chisquare (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_id (lexer, "BINOMIAL"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->binomial++;
-          switch (npar_binomial (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_binomial (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_phrase (lexer, "K-S") ||
 	       lex_match_phrase (lexer, "KOLMOGOROV-SMIRNOV"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->ks_one_sample++;
-          switch (npar_ks_one_sample (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_ks_one_sample (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_phrase (lexer, "J-T") ||
 	       lex_match_phrase (lexer, "JONCKHEERE-TERPSTRA"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->jonckheere_terpstra++;
-          switch (npar_jonckheere_terpstra (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_jonckheere_terpstra (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_phrase (lexer, "K-W") ||
 	       lex_match_phrase (lexer, "KRUSKAL-WALLIS"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->kruskal_wallis++;
-          switch (npar_kruskal_wallis (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_kruskal_wallis (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_phrase (lexer, "MCNEMAR"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->mcnemar++;
-          switch (npar_mcnemar (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_mcnemar (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_phrase (lexer, "M-W") ||
 	       lex_match_phrase (lexer, "MANN-WHITNEY"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->mann_whitney++;
-          switch (npar_mann_whitney (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_mann_whitney (lexer, ds, nps))
+            return false;
 	}
       else if (lex_match_phrase (lexer, "MEDIAN"))
         {
-          npt->median++;
-
-          switch (npar_median (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_median (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_id (lexer, "WILCOXON"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->wilcoxon++;
-          switch (npar_wilcoxon (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_wilcoxon (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_id (lexer, "SIGN"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->sign++;
-          switch (npar_sign (lexer, ds, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
-            }
+          if (!npar_sign (lexer, ds, nps))
+            return false;
         }
       else if (lex_match_id (lexer, "MISSING"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->missing++;
-          if (npt->missing > 1)
+          if (seen_missing)
             {
               lex_sbc_only_once (lexer, "MISSING");
-              goto lossage;
+              return false;
             }
+          seen_missing = true;
           while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD)
             {
               if (lex_match_id (lexer, "ANALYSIS"))
-                npt->miss = MISS_ANALYSIS;
+                nps->listwise_missing = false;
               else if (lex_match_id (lexer, "LISTWISE"))
-                npt->miss = MISS_LISTWISE;
+                nps->listwise_missing = true;
               else if (lex_match_id (lexer, "INCLUDE"))
                 nps->filter = MV_SYSTEM;
               else if (lex_match_id (lexer, "EXCLUDE"))
                 nps->filter = MV_ANY;
               else
                 {
-                  lex_error (lexer, NULL);
-                  goto lossage;
+                  lex_error_expecting (lexer, "ANALYSIS", "LISTWISE",
+                                       "INCLUDE", "EXCLUDE");
+                  return false;
                 }
               lex_match (lexer, T_COMMA);
             }
@@ -448,69 +226,63 @@ parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests
       else if (lex_match_id (lexer, "METHOD"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->method++;
-          if (npt->method > 1)
+          if (seen_method)
             {
               lex_sbc_only_once (lexer, "METHOD");
-              goto lossage;
-            }
-          switch (npar_method (lexer, nps))
-            {
-            case 0:
-              goto lossage;
-            case 1:
-              break;
-            case 2:
-              lex_error (lexer, NULL);
-              goto lossage;
-            default:
-              NOT_REACHED ();
+              return false;
             }
+          seen_method = true;
+          if (!npar_method (lexer, nps))
+            return false;
         }
       else if (lex_match_id (lexer, "STATISTICS"))
         {
           lex_match (lexer, T_EQUALS);
-          npt->statistics++;
           while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD)
             {
               if (lex_match_id (lexer, "DESCRIPTIVES"))
-                npt->a_statistics[NPAR_ST_DESCRIPTIVES] = 1;
+                nps->descriptives = true;
               else if (lex_match_id (lexer, "QUARTILES"))
-                npt->a_statistics[NPAR_ST_QUARTILES] = 1;
+                nps->quartiles = true;
               else if (lex_match (lexer, T_ALL))
-                npt->a_statistics[NPAR_ST_ALL] = 1;
+                nps->descriptives = nps->quartiles = true;
               else
                 {
-                  lex_error (lexer, NULL);
-                  goto lossage;
+                  lex_error_expecting (lexer, "DESCRIPTIVES", "QUARTILES",
+                                       "ALL");
+                  return false;
                 }
               lex_match (lexer, T_COMMA);
             }
         }
-      else if (settings_get_syntax () != COMPATIBLE && lex_match_id (lexer, "ALGORITHM"))
+      else if (lex_match_id (lexer, "ALGORITHM"))
         {
           lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "COMPATIBLE"))
             settings_set_cmd_algorithm (COMPATIBLE);
           else if (lex_match_id (lexer, "ENHANCED"))
             settings_set_cmd_algorithm (ENHANCED);
-          }
-        if (!lex_match (lexer, T_SLASH))
-          break;
-      }
-    if (lex_token (lexer) != T_ENDCMD)
-      {
-        lex_error (lexer, _("Syntax error expecting end of command."));
-        goto lossage;
-      }
+          else
+            {
+              lex_error_expecting (lexer, "COMPATIBLE", "ENHANCED");
+              return false;
+            }
+        }
+      else
+        {
+          lex_error_expecting (lexer, "COCHRAN", "FRIEDMAN", "KENDALL", "RUNS",
+                               "CHISQUARE", "BINOMIAL", "K-S", "J-T", "K-W",
+                               "MCNEMAR", "M-W", "MEDIAN", "WILCOXON",
+                               "SIGN", "MISSING", "METHOD", "STATISTICS",
+                               "ALGORITHM");
+          return false;
+        }
+    }
+  while (lex_match (lexer, T_SLASH));
 
   return true;
-
-lossage:
-  return false;
 }
 
-
 static void one_sample_insert_variables (const struct npar_test *test,
 					 struct hmapx *);
 
@@ -525,18 +297,13 @@ npar_execute (struct casereader *input,
              const struct npar_specs *specs,
 	     const struct dataset *ds)
 {
-  int t;
   struct descriptives *summary_descriptives = NULL;
 
-  for (t = 0 ; t < specs->n_tests; ++t)
+  for (size_t t = 0; t < specs->n_tests; ++t)
     {
       const struct npar_test *test = specs->test[t];
-      if (NULL == test->execute)
-	{
-	  msg (SW, _("%s subcommand not currently implemented."), "NPAR");
-	  continue;
-	}
-      test->execute (ds, casereader_clone (input), specs->filter, test, specs->exact, specs->timer);
+      test->execute (ds, casereader_clone (input), specs->filter,
+                     test, specs->exact, specs->timer);
     }
 
   if (specs->descriptives && specs->n_vars > 0)
@@ -563,90 +330,49 @@ npar_execute (struct casereader *input,
 int
 cmd_npar_tests (struct lexer *lexer, struct dataset *ds)
 {
-  struct cmd_npar_tests cmd;
-  bool ok;
-  int i;
-  struct npar_specs npar_specs = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  struct casegrouper *grouper;
-  struct casereader *input, *group;
-  struct hmapx var_map = HMAPX_INITIALIZER (var_map);
-
-
-  npar_specs.pool = pool_create ();
-  npar_specs.filter = MV_ANY;
-  npar_specs.n_vars = -1;
-  npar_specs.vv = NULL;
+  struct npar_specs npar_specs = {
+    .pool = pool_create (),
+    .filter = MV_ANY,
+    .listwise_missing = false,
+  };
 
-  if (! parse_npar_tests (lexer, ds, &cmd, &npar_specs))
+  if (!parse_npar_tests (lexer, ds, &npar_specs))
     {
       pool_destroy (npar_specs.pool);
       return CMD_FAILURE;
     }
 
-  for (i = 0; i < npar_specs.n_tests; ++i)
+  struct hmapx var_map = HMAPX_INITIALIZER (var_map);
+  for (size_t i = 0; i < npar_specs.n_tests; ++i)
     {
       const struct npar_test *test = npar_specs.test[i];
       test->insert_variables (test, &var_map);
     }
 
-  {
-    struct hmapx_node *node;
-    struct variable *var;
-    npar_specs.n_vars = 0;
-
-    HMAPX_FOR_EACH (var, node, &var_map)
-      {
-	npar_specs.n_vars ++;
-	npar_specs.vv = pool_nrealloc (npar_specs.pool, npar_specs.vv, npar_specs.n_vars, sizeof (*npar_specs.vv));
-	npar_specs.vv[npar_specs.n_vars - 1] = var;
-      }
-  }
-
-  sort (npar_specs.vv, npar_specs.n_vars, sizeof (*npar_specs.vv),
+  struct hmapx_node *node;
+  struct variable *var;
+  npar_specs.vv = pool_alloc (npar_specs.pool,
+                              hmapx_count (&var_map) * sizeof *npar_specs.vv);
+  HMAPX_FOR_EACH (var, node, &var_map)
+    npar_specs.vv[npar_specs.n_vars++] = var;
+  assert (npar_specs.n_vars == hmapx_count (&var_map));
+
+  sort (npar_specs.vv, npar_specs.n_vars, sizeof *npar_specs.vv,
 	 compare_var_ptrs_by_name, NULL);
 
-  if (cmd.statistics)
-    {
-      int i;
-
-      for (i = 0 ; i < NPAR_ST_count; ++i)
-	{
-	  if (cmd.a_statistics[i])
-	    {
-	      switch (i)
-		{
-		case NPAR_ST_DESCRIPTIVES:
-		  npar_specs.descriptives = true;
-		  break;
-		case NPAR_ST_QUARTILES:
-		  npar_specs.quartiles = true;
-		  break;
-		case NPAR_ST_ALL:
-		  npar_specs.quartiles = true;
-		  npar_specs.descriptives = true;
-		  break;
-		default:
-		  NOT_REACHED ();
-		};
-	    }
-	}
-    }
-
-  input = proc_open (ds);
-  if (cmd.miss == MISS_LISTWISE)
-    {
-      input = casereader_create_filter_missing (input,
-						npar_specs.vv,
-						npar_specs.n_vars,
-						npar_specs.filter,
-						NULL, NULL);
-    }
-
+  struct casereader *input = proc_open (ds);
+  if (npar_specs.listwise_missing)
+    input = casereader_create_filter_missing (input,
+                                              npar_specs.vv,
+                                              npar_specs.n_vars,
+                                              npar_specs.filter,
+                                              NULL, NULL);
 
-  grouper = casegrouper_create_splits (input, dataset_dict (ds));
+  struct casegrouper *grouper = casegrouper_create_splits (input, dataset_dict (ds));
+  struct casereader *group;
   while (casegrouper_get_next_group (grouper, &group))
     npar_execute (group, &npar_specs, ds);
-  ok = casegrouper_destroy (grouper);
+  bool ok = casegrouper_destroy (grouper);
   ok = proc_commit (ds) && ok;
 
   pool_destroy (npar_specs.pool);
@@ -655,7 +381,16 @@ cmd_npar_tests (struct lexer *lexer, struct dataset *ds)
   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 }
 
-static int
+static void
+add_test (struct npar_specs *specs, struct npar_test *nt)
+{
+  specs->test = pool_realloc (specs->pool, specs->test,
+			      (specs->n_tests + 1) * sizeof *specs->test);
+
+  specs->test[specs->n_tests++] = nt;
+}
+
+static bool
 npar_runs (struct lexer *lexer, struct dataset *ds,
 	   struct npar_specs *specs)
 {
@@ -666,58 +401,42 @@ npar_runs (struct lexer *lexer, struct dataset *ds,
   nt->execute = runs_execute;
   nt->insert_variables = one_sample_insert_variables;
 
-  if (lex_force_match (lexer, T_LPAREN))
-    {
-      if (lex_match_id (lexer, "MEAN"))
-	{
-	  rt->cp_mode = CP_MEAN;
-	}
-      else if (lex_match_id (lexer, "MEDIAN"))
-	{
-	  rt->cp_mode = CP_MEDIAN;
-	}
-      else if (lex_match_id (lexer, "MODE"))
-	{
-	  rt->cp_mode = CP_MODE;
-	}
-      else if (lex_is_number (lexer))
-	{
-	  rt->cutpoint = lex_number (lexer);
-	  rt->cp_mode = CP_CUSTOM;
-	  lex_get (lexer);
-	}
-      else
-	{
-	  lex_error (lexer, _("Syntax error expecting %s, %s, %s or a number."),
-                     "MEAN", "MEDIAN", "MODE");
-	  return 0;
-	}
-
-      if (! lex_force_match (lexer, T_RPAREN))
-	return 2;
-
-      if (! lex_force_match (lexer, T_EQUALS))
-	return 2;
+  if (!lex_force_match (lexer, T_LPAREN))
+    return false;
 
-      if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
-				  &tp->vars, &tp->n_vars,
-				  PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC))
-	{
-	  return 2;
-	}
+  if (lex_match_id (lexer, "MEAN"))
+    rt->cp_mode = CP_MEAN;
+  else if (lex_match_id (lexer, "MEDIAN"))
+    rt->cp_mode = CP_MEDIAN;
+  else if (lex_match_id (lexer, "MODE"))
+    rt->cp_mode = CP_MODE;
+  else if (lex_is_number (lexer))
+    {
+      rt->cutpoint = lex_number (lexer);
+      rt->cp_mode = CP_CUSTOM;
+      lex_get (lexer);
+    }
+  else
+    {
+      lex_error (lexer, _("Syntax error expecting %s, %s, %s or a number."),
+                 "MEAN", "MEDIAN", "MODE");
+      return false;
     }
 
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
+  if (!lex_force_match (lexer, T_RPAREN)
+      || !lex_force_match (lexer, T_EQUALS))
+    return false;
 
-  specs->test[specs->n_tests - 1] = nt;
+  if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
+                                   &tp->vars, &tp->n_vars,
+                                   PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC))
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-static int
+static bool
 npar_friedman (struct lexer *lexer, struct dataset *ds,
 	       struct npar_specs *specs)
 {
@@ -734,21 +453,13 @@ npar_friedman (struct lexer *lexer, struct dataset *ds,
   if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
 				   &ost->vars, &ost->n_vars,
 				   PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC))
-    {
-      return 2;
-    }
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-static int
+static bool
 npar_kendall (struct lexer *lexer, struct dataset *ds,
 	       struct npar_specs *specs)
 {
@@ -765,22 +476,14 @@ npar_kendall (struct lexer *lexer, struct dataset *ds,
   if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
 				   &ost->vars, &ost->n_vars,
 				   PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC))
-    {
-      return 2;
-    }
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
 
-static int
+static bool
 npar_cochran (struct lexer *lexer, struct dataset *ds,
 	       struct npar_specs *specs)
 {
@@ -795,29 +498,19 @@ npar_cochran (struct lexer *lexer, struct dataset *ds,
   if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
 				   &ft->vars, &ft->n_vars,
 				   PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC))
-    {
-      return 2;
-    }
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_chisquare (struct lexer *lexer, struct dataset *ds,
 		struct npar_specs *specs)
 {
   struct chisquare_test *cstp = pool_alloc (specs->pool, sizeof (*cstp));
   struct one_sample_test *tp = &cstp->parent;
   struct npar_test *nt = &tp->parent;
-  int retval = 1;
 
   nt->execute = chisquare_execute;
   nt->insert_variables = one_sample_insert_variables;
@@ -825,53 +518,50 @@ npar_chisquare (struct lexer *lexer, struct dataset *ds,
   if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
 				   &tp->vars, &tp->n_vars,
 				   PV_NO_SCRATCH | PV_NO_DUPLICATE))
-    {
-      return 2;
-    }
+    return false;
 
   cstp->ranged = false;
 
   if (lex_match (lexer, T_LPAREN))
     {
       cstp->ranged = true;
-      if (! lex_force_num (lexer)) return 0;
+      if (!lex_force_num (lexer))
+        return false;
       cstp->lo = lex_number (lexer);
       lex_get (lexer);
-      if (! lex_force_match (lexer, T_COMMA)) return 0;
-      if (! lex_force_num (lexer)) return 0;
+
+      if (!lex_force_match (lexer, T_COMMA))
+        return false;
+      if (!lex_force_num_range_open (lexer, "HI", cstp->lo, DBL_MAX))
+        return false;
       cstp->hi = lex_number (lexer);
-      if (cstp->lo >= cstp->hi)
-	{
-	  msg (ME,
-	      _("The specified value of HI (%d) is "
-		"lower than the specified value of LO (%d)"),
-	      cstp->hi, cstp->lo);
-	  return 0;
-	}
       lex_get (lexer);
-      if (! lex_force_match (lexer, T_RPAREN)) return 0;
+      if (!lex_force_match (lexer, T_RPAREN))
+        return false;
     }
 
   cstp->n_expected = 0;
   cstp->expected = NULL;
+  int expected_start = 0;
+  int expected_end = 0;
   if (lex_match_phrase (lexer, "/EXPECTED"))
     {
-      if (! lex_force_match (lexer, T_EQUALS)) return 0;
-      if (! lex_match_id (lexer, "EQUAL"))
+      if (!lex_force_match (lexer, T_EQUALS))
+        return false;
+
+      if (!lex_match_id (lexer, "EQUAL"))
         {
-          double f;
-          int n;
+          expected_start = lex_ofs (lexer);
           while (lex_is_number (lexer))
             {
-              int i;
-              n = 1;
-              f = lex_number (lexer);
+              int n = 1;
+              double f = lex_number (lexer);
               lex_get (lexer);
               if (lex_match (lexer, T_ASTERISK))
                 {
                   n = f;
                   if (!lex_force_num (lexer))
-                    return 0;
+                    return false;
                   f = lex_number (lexer);
                   lex_get (lexer);
                 }
@@ -880,47 +570,36 @@ npar_chisquare (struct lexer *lexer, struct dataset *ds,
               cstp->n_expected += n;
               cstp->expected = pool_realloc (specs->pool,
                                              cstp->expected,
-                                             sizeof (double) *
-                                             cstp->n_expected);
-              for (i = cstp->n_expected - n ;
-                    i < cstp->n_expected;
-                    ++i)
+                                             sizeof (double) * cstp->n_expected);
+              for (int i = cstp->n_expected - n; i < cstp->n_expected; ++i)
                 cstp->expected[i] = f;
-
             }
+          expected_end = lex_ofs (lexer) - 1;
         }
     }
 
   if (cstp->ranged && cstp->n_expected > 0 &&
        cstp->n_expected != cstp->hi - cstp->lo + 1)
     {
-      msg (ME,
-	  _("%d expected values were given, but the specified "
-	    "range (%d-%d) requires exactly %d values."),
-	  cstp->n_expected, cstp->lo, cstp->hi,
-	  cstp->hi - cstp->lo +1);
-      return 0;
+      lex_ofs_error (lexer, expected_start, expected_end,
+                     _("%d expected values were given, but the specified "
+                       "range (%d-%d) requires exactly %d values."),
+                     cstp->n_expected, cstp->lo, cstp->hi,
+                     cstp->hi - cstp->lo +1);
+      return false;
     }
 
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-
-  specs->test[specs->n_tests - 1] = nt;
-
-  return retval;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_binomial (struct lexer *lexer, struct dataset *ds,
 	       struct npar_specs *specs)
 {
   struct binomial_test *btp = pool_alloc (specs->pool, sizeof (*btp));
   struct one_sample_test *tp = &btp->parent;
   struct npar_test *nt = &tp->parent;
-  bool equals = false;
 
   nt->execute = binomial_execute;
   nt->insert_variables = one_sample_insert_variables;
@@ -931,68 +610,44 @@ npar_binomial (struct lexer *lexer, struct dataset *ds,
 
   if (lex_match (lexer, T_LPAREN))
     {
-      equals = false;
-      if (lex_force_num (lexer))
-	{
-	  btp->p = lex_number (lexer);
-	  lex_get (lexer);
-	  if (!lex_force_match (lexer, T_RPAREN))
-	    return 0;
-	}
-      else
-	return 0;
+      if (!lex_force_num (lexer))
+	return false;
+      btp->p = lex_number (lexer);
+      lex_get (lexer);
+      if (!lex_force_match (lexer, T_RPAREN))
+        return false;
+      if (!lex_force_match (lexer, T_EQUALS))
+        return false;
     }
-  else
-    equals = true;
-
-  if (!equals)
-    if (!lex_force_match (lexer, T_EQUALS))
-      return 0;
-
-  {
-    if (parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
-                                    &tp->vars, &tp->n_vars,
-                                    PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE))
-      {
-        if (lex_match (lexer, T_LPAREN))
-          {
-            if (! lex_force_num (lexer))
-              return 2;
-            btp->category1 = lex_number (lexer);
-            lex_get (lexer);
-            if (lex_match (lexer, T_COMMA))
-              {
-                if (! lex_force_num (lexer)) return 2;
-                btp->category2 = lex_number (lexer);
-                lex_get (lexer);
-              }
-            else
-              {
-                btp->cutpoint = btp->category1;
-              }
-
-            if (! lex_force_match (lexer, T_RPAREN))
-              return 0;
-          }
-      }
-    else
-      {
-        return 2;
-      }
-  }
 
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
+  if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
+                                   &tp->vars, &tp->n_vars,
+                                   PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE))
+    return false;
+  if (lex_match (lexer, T_LPAREN))
+    {
+      if (!lex_force_num (lexer))
+        return false;
+      btp->category1 = lex_number (lexer);
+      lex_get (lexer);
+      if (lex_match (lexer, T_COMMA))
+        {
+          if (!lex_force_num (lexer))
+            return false;
+          btp->category2 = lex_number (lexer);
+          lex_get (lexer);
+        }
+      else
+        btp->cutpoint = btp->category1;
 
-  specs->test[specs->n_tests - 1] = nt;
+      if (!lex_force_match (lexer, T_RPAREN))
+        return false;
+    }
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-
 static void
 ks_one_sample_parse_params (struct lexer *lexer, struct ks_one_sample_test *kst, int params)
 {
@@ -1015,7 +670,7 @@ ks_one_sample_parse_params (struct lexer *lexer, struct ks_one_sample_test *kst,
     }
 }
 
-static int
+static bool
 npar_ks_one_sample (struct lexer *lexer, struct dataset *ds, struct npar_specs *specs)
 {
   struct ks_one_sample_test *kst = pool_alloc (specs->pool, sizeof (*kst));
@@ -1027,8 +682,8 @@ npar_ks_one_sample (struct lexer *lexer, struct dataset *ds, struct npar_specs *
 
   kst->p[0] = kst->p[1] = SYSMIS;
 
-  if (! lex_force_match (lexer, T_LPAREN))
-    return 2;
+  if (!lex_force_match (lexer, T_LPAREN))
+    return false;
 
   if (lex_match_id (lexer, "NORMAL"))
     {
@@ -1051,165 +706,133 @@ npar_ks_one_sample (struct lexer *lexer, struct dataset *ds, struct npar_specs *
       ks_one_sample_parse_params (lexer, kst, 1);
     }
   else
-    return 2;
+    {
+      lex_error_expecting (lexer, "NORMAL", "POISSON", "UNIFORM",
+                           "EXPONENTIAL");
+      return false;
+    }
 
-  if (! lex_force_match (lexer, T_RPAREN))
-    return 2;
+  if (!lex_force_match (lexer, T_RPAREN))
+    return false;
 
   lex_match (lexer, T_EQUALS);
 
-  if (! parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
-				  &tp->vars, &tp->n_vars,
-				  PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE))
-    return 2;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
+  if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
+                                   &tp->vars, &tp->n_vars,
+                                   PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE))
+    return false;
 
-  specs->test[specs->n_tests - 1] = nt;
+  add_test (specs, nt);
 
-  return 1;
+  return true;
 }
 
-
 static bool
 parse_two_sample_related_test (struct lexer *lexer,
 			       const struct dictionary *dict,
-			       struct two_sample_test *test_parameters,
+			       struct two_sample_test *tp,
 			       struct pool *pool)
 {
-  int n = 0;
-  bool paired = false;
-  bool with = false;
-  const struct variable **vlist1;
-  size_t n_vlist1;
+  tp->parent.insert_variables = two_sample_insert_variables;
 
-  const struct variable **vlist2;
-  size_t n_vlist2;
-
-  test_parameters->parent.insert_variables = two_sample_insert_variables;
-
-  if (!parse_variables_const_pool (lexer, pool,
-				   dict,
-				   &vlist1, &n_vlist1,
+  const struct variable **v1;
+  size_t n1;
+  int vars_start = lex_ofs (lexer);
+  if (!parse_variables_const_pool (lexer, pool, dict, &v1, &n1,
 				   PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE))
     return false;
 
+  bool with = false;
+  bool paired = false;
+  const struct variable **v2 = NULL;
+  size_t n2 = 0;
   if (lex_match (lexer, T_WITH))
     {
       with = true;
-      if (!parse_variables_const_pool (lexer, pool, dict,
-					&vlist2, &n_vlist2,
-					PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE))
+      if (!parse_variables_const_pool (lexer, pool, dict, &v2, &n2,
+                                       PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE))
 	return false;
+      int vars_end = lex_ofs (lexer) - 1;
 
-      paired = (lex_match (lexer, T_LPAREN) &&
-		lex_match_id (lexer, "PAIRED") && lex_match (lexer, T_RPAREN));
-    }
-
+      if (lex_match (lexer, T_LPAREN))
+        {
+          if (!lex_force_match_id (lexer, "PAIRED")
+              || !lex_force_match (lexer, T_RPAREN))
+            return false;
+          paired = true;
 
-  if (with)
-    {
-      if (paired)
-	{
-	  if (n_vlist1 != n_vlist2)
+	  if (n1 != n2)
             {
-	      msg (SE, _("PAIRED was specified but the number of variables "
-		       "preceding WITH (%zu) did not match the number "
-		       "following (%zu)."), n_vlist1, n_vlist2);
+	      lex_ofs_error (lexer, vars_start, vars_end,
+                             _("PAIRED was specified, but the number of "
+                               "variables preceding WITH (%zu) does not match "
+                               "the number following (%zu)."),
+                             n1, n2);
               return false;
             }
-
-	  test_parameters->n_pairs = n_vlist1 ;
-	}
-      else
-	{
-	  test_parameters->n_pairs = n_vlist1 * n_vlist2;
-	}
-    }
-  else
-    {
-      test_parameters->n_pairs = (n_vlist1 * (n_vlist1 - 1)) / 2 ;
+        }
     }
 
-  test_parameters->pairs =
-    pool_alloc (pool, sizeof (variable_pair) * test_parameters->n_pairs);
+  tp->n_pairs = (paired ? n1
+                 : with ? n1 * n2
+                 : (n1 * (n1 - 1)) / 2);
+  tp->pairs = pool_alloc (pool, sizeof (variable_pair) * tp->n_pairs);
 
-  if (with)
+  size_t n = 0;
+  if (!with)
+    for (size_t i = 0; i < n1 - 1; ++i)
+      for (size_t j = i + 1; j < n1; ++j)
+        {
+          assert (n < tp->n_pairs);
+          tp->pairs[n][0] = v1[i];
+          tp->pairs[n][1] = v1[j];
+          n++;
+        }
+  else if (paired)
     {
-      if (paired)
-	{
-	  int i;
-	  assert (n_vlist1 == n_vlist2);
-	  for (i = 0 ; i < n_vlist1; ++i)
-	    {
-	      test_parameters->pairs[n][0] = vlist1[i];
-	      test_parameters->pairs[n][1] = vlist2[i];
-	      n++;
-	    }
-	}
-      else
-	{
-	  int i,j;
-	  for (i = 0 ; i < n_vlist1; ++i)
-	    {
-	      for (j = 0 ; j < n_vlist2; ++j)
-		{
-		  test_parameters->pairs[n][0] = vlist1[i];
-		  test_parameters->pairs[n][1] = vlist2[j];
-		  n++;
-		}
-	    }
-	}
+      assert (n1 == n2);
+      for (size_t i = 0; i < n1; ++i)
+        {
+          tp->pairs[n][0] = v1[i];
+          tp->pairs[n][1] = v2[i];
+          n++;
+        }
     }
   else
     {
-      int i,j;
-      for (i = 0 ; i < n_vlist1 - 1; ++i)
-	{
-	  for (j = i + 1 ; j < n_vlist1; ++j)
-	    {
-	      assert (n < test_parameters->n_pairs);
-	      test_parameters->pairs[n][0] = vlist1[i];
-	      test_parameters->pairs[n][1] = vlist1[j];
-	      n++;
-	    }
-	}
+      for (size_t i = 0; i < n1; ++i)
+        for (size_t j = 0; j < n2; ++j)
+          {
+            tp->pairs[n][0] = v1[i];
+            tp->pairs[n][1] = v2[j];
+            n++;
+          }
     }
-
-  assert (n == test_parameters->n_pairs);
+  assert (n == tp->n_pairs);
 
   return true;
 }
 
-
 static bool
-parse_n_sample_related_test (struct lexer *lexer,
-			     const struct dictionary *dict,
-			     struct n_sample_test *nst,
-			     struct pool *pool
-			)
+parse_n_sample_related_test (struct lexer *lexer, const struct dictionary *dict,
+			     struct n_sample_test *nst, struct pool *pool)
 {
-  if (!parse_variables_const_pool (lexer, pool,
-				   dict,
-				   &nst->vars, &nst->n_vars,
+  if (!parse_variables_const_pool (lexer, pool, dict, &nst->vars, &nst->n_vars,
 				   PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE))
     return false;
 
-  if (! lex_force_match (lexer, T_BY))
+  if (!lex_force_match (lexer, T_BY))
     return false;
 
   nst->indep_var = parse_variable_const (lexer, dict);
   if (!nst->indep_var)
     return false;
 
-  if (! lex_force_match (lexer, T_LPAREN))
+  if (!lex_force_match (lexer, T_LPAREN))
     return false;
 
   value_init (&nst->val1, var_get_width (nst->indep_var));
-  if (! parse_value (lexer, &nst->val1, nst->indep_var))
+  if (!parse_value (lexer, &nst->val1, nst->indep_var))
     {
       value_destroy (&nst->val1, var_get_width (nst->indep_var));
       return false;
@@ -1218,19 +841,19 @@ parse_n_sample_related_test (struct lexer *lexer,
   lex_match (lexer, T_COMMA);
 
   value_init (&nst->val2, var_get_width (nst->indep_var));
-  if (! parse_value (lexer, &nst->val2, nst->indep_var))
+  if (!parse_value (lexer, &nst->val2, nst->indep_var))
     {
       value_destroy (&nst->val2, var_get_width (nst->indep_var));
       return false;
     }
 
-  if (! lex_force_match (lexer, T_RPAREN))
+  if (!lex_force_match (lexer, T_RPAREN))
     return false;
 
   return true;
 }
 
-static int
+static bool
 npar_wilcoxon (struct lexer *lexer,
 	       struct dataset *ds,
 	       struct npar_specs *specs)
@@ -1241,22 +864,16 @@ npar_wilcoxon (struct lexer *lexer,
 
   if (!parse_two_sample_related_test (lexer, dataset_dict (ds),
 				      tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_mann_whitney (struct lexer *lexer,
-	       struct dataset *ds,
-	       struct npar_specs *specs)
+                   struct dataset *ds,
+                   struct npar_specs *specs)
 {
   struct n_sample_test *tp = pool_alloc (specs->pool, sizeof (*tp));
   struct npar_test *nt = &tp->parent;
@@ -1264,21 +881,14 @@ npar_mann_whitney (struct lexer *lexer,
   nt->insert_variables = n_sample_insert_variables;
   nt->execute = mann_whitney_execute;
 
-  if (!parse_n_sample_related_test (lexer, dataset_dict (ds),
-				    tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+  if (!parse_n_sample_related_test (lexer, dataset_dict (ds), tp, specs->pool))
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_median (struct lexer *lexer,
 	     struct dataset *ds,
 	     struct npar_specs *specs)
@@ -1289,12 +899,15 @@ npar_median (struct lexer *lexer,
 
   mt->median = SYSMIS;
 
-  if (lex_match (lexer, T_LPAREN) && lex_force_num (lexer))
+  if (lex_match (lexer, T_LPAREN))
     {
+      if (!lex_force_num (lexer))
+        return false;
       mt->median = lex_number (lexer);
       lex_get (lexer);
-      if (! lex_force_match (lexer, T_RPAREN))
-	return 0;
+
+      if (!lex_force_match (lexer, T_RPAREN))
+	return false;
     }
 
   lex_match (lexer, T_EQUALS);
@@ -1302,21 +915,14 @@ npar_median (struct lexer *lexer,
   nt->insert_variables = n_sample_insert_variables;
   nt->execute = median_execute;
 
-  if (!parse_n_sample_related_test (lexer, dataset_dict (ds),
-				    tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+  if (!parse_n_sample_related_test (lexer, dataset_dict (ds), tp, specs->pool))
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_sign (struct lexer *lexer, struct dataset *ds,
 	   struct npar_specs *specs)
 {
@@ -1327,19 +933,13 @@ npar_sign (struct lexer *lexer, struct dataset *ds,
 
   if (!parse_two_sample_related_test (lexer, dataset_dict (ds),
 				      tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-
-static int
+static bool
 npar_mcnemar (struct lexer *lexer, struct dataset *ds,
 	   struct npar_specs *specs)
 {
@@ -1350,19 +950,14 @@ npar_mcnemar (struct lexer *lexer, struct dataset *ds,
 
   if (!parse_two_sample_related_test (lexer, dataset_dict (ds),
 				      tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
 
-static int
+static bool
 npar_jonckheere_terpstra (struct lexer *lexer, struct dataset *ds,
 		      struct npar_specs *specs)
 {
@@ -1370,23 +965,16 @@ npar_jonckheere_terpstra (struct lexer *lexer, struct dataset *ds,
   struct npar_test *nt = &tp->parent;
 
   nt->insert_variables = n_sample_insert_variables;
-
   nt->execute = jonckheere_terpstra_execute;
 
-  if (!parse_n_sample_related_test (lexer, dataset_dict (ds),
-				      tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+  if (!parse_n_sample_related_test (lexer, dataset_dict (ds), tp, specs->pool))
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
-static int
+static bool
 npar_kruskal_wallis (struct lexer *lexer, struct dataset *ds,
 		      struct npar_specs *specs)
 {
@@ -1397,17 +985,11 @@ npar_kruskal_wallis (struct lexer *lexer, struct dataset *ds,
 
   nt->execute = kruskal_wallis_execute;
 
-  if (!parse_n_sample_related_test (lexer, dataset_dict (ds),
-				      tp, specs->pool))
-    return 0;
-
-  specs->n_tests++;
-  specs->test = pool_realloc (specs->pool,
-			      specs->test,
-			      sizeof (*specs->test) * specs->n_tests);
-  specs->test[specs->n_tests - 1] = nt;
+  if (!parse_n_sample_related_test (lexer, dataset_dict (ds), tp, specs->pool))
+    return false;
 
-  return 1;
+  add_test (specs, nt);
+  return true;
 }
 
 static void
@@ -1418,10 +1000,8 @@ insert_variable_into_map (struct hmapx *var_map, const struct variable *var)
   const struct variable *v = NULL;
 
   HMAPX_FOR_EACH_WITH_HASH (v, node, hash, var_map)
-    {
-      if (v == var)
-	return ;
-    }
+    if (v == var)
+      return;
 
   hmapx_insert (var_map, CONST_CAST (struct variable *, var), hash);
 }
@@ -1431,10 +1011,9 @@ static void
 one_sample_insert_variables (const struct npar_test *test,
 			     struct hmapx *var_map)
 {
-  int i;
   const struct one_sample_test *ost = UP_CAST (test, const struct one_sample_test, parent);
 
-  for (i = 0 ; i < ost->n_vars ; ++i)
+  for (size_t i = 0; i < ost->n_vars; ++i)
     insert_variable_into_map (var_map, ost->vars[i]);
 }
 
@@ -1443,10 +1022,9 @@ static void
 two_sample_insert_variables (const struct npar_test *test,
 			     struct hmapx *var_map)
 {
-  int i;
   const struct two_sample_test *tst = UP_CAST (test, const struct two_sample_test, parent);
 
-  for (i = 0 ; i < tst->n_pairs ; ++i)
+  for (size_t i = 0; i < tst->n_pairs; ++i)
     {
       variable_pair *pair = &tst->pairs[i];
 
@@ -1459,17 +1037,15 @@ static void
 n_sample_insert_variables (const struct npar_test *test,
 			   struct hmapx *var_map)
 {
-  int i;
   const struct n_sample_test *tst = UP_CAST (test, const struct n_sample_test, parent);
 
-  for (i = 0 ; i < tst->n_vars ; ++i)
+  for (size_t i = 0; i < tst->n_vars; ++i)
     insert_variable_into_map (var_map, tst->vars[i]);
 
   insert_variable_into_map (var_map, tst->indep_var);
 }
 
-
-static int
+static bool
 npar_method (struct lexer *lexer,  struct npar_specs *specs)
 {
   if (lex_match_id (lexer, "EXACT"))
@@ -1482,16 +1058,15 @@ npar_method (struct lexer *lexer,  struct npar_specs *specs)
 
 	  if (lex_match (lexer, T_LPAREN))
 	    {
-	      if (lex_force_num (lexer))
-		{
-		  specs->timer = lex_number (lexer);
-		  lex_get (lexer);
-		}
-	      if (lex_force_match (lexer, T_RPAREN))
-		return 0;
+	      if (!lex_force_num (lexer))
+                return false;
+              specs->timer = lex_number (lexer);
+              lex_get (lexer);
+	      if (!lex_force_match (lexer, T_RPAREN))
+		return false;
 	    }
 	}
     }
 
-  return 1;
+  return true;
 }
diff --git a/tests/language/stats/npar.at b/tests/language/stats/npar.at
index 93624925ae..2836b4685b 100644
--- a/tests/language/stats/npar.at
+++ b/tests/language/stats/npar.at
@@ -1926,9 +1926,269 @@ NPAR TESTS
 " CHISQUARE=x y(-2,5)
   /STATISTICS=DESCRIPTIVES
   .
-])
+]) dnl "
 
 AT_CHECK([pspp -O format=csv npar.sps], [1], [ignore])
 
 AT_CLEANUP
 
+AT_SETUP([NPAR TESTS - syntax errors])
+AT_DATA([npar.sps], [dnl
+DATA LIST LIST NOTABLE /x y z.
+NPAR TESTS COCHRAN **.
+NPAR TESTS FRIEDMAN **.
+NPAR TESTS KENDALL **.
+NPAR TESTS RUNS **.
+NPAR TESTS RUNS (**).
+NPAR TESTS RUNS (MEAN **).
+NPAR TESTS RUNS (MEAN)=**.
+NPAR TESTS CHISQUARE **.
+NPAR TESTS CHISQUARE x **.
+NPAR TESTS CHISQUARE x (**).
+NPAR TESTS CHISQUARE x (1 **).
+NPAR TESTS CHISQUARE x (1, -1).
+NPAR TESTS CHISQUARE x (1, 2 **).
+NPAR TESTS CHISQUARE x /EXPECTED **.
+NPAR TESTS CHISQUARE x /EXPECTED=1* **.
+NPAR TESTS CHISQUARE x (1,5)/EXPECTED=2.
+NPAR TESTS BINOMIAL (**).
+NPAR TESTS BINOMIAL (1 **).
+NPAR TESTS BINOMIAL (1)**.
+NPAR TESTS BINOMIAL x(**).
+NPAR TESTS BINOMIAL x(1,**).
+NPAR TESTS BINOMIAL x(1,2**).
+NPAR TESTS BINOMIAL x(1**).
+NPAR TESTS K-S **.
+NPAR TESTS K-S (**).
+NPAR TESTS K-S (NORMAL **).
+NPAR TESTS K-S (NORMAL)=**.
+NPAR TESTS J-T **.
+NPAR TESTS J-T x **.
+NPAR TESTS J-T x BY **.
+NPAR TESTS J-T x BY y **.
+NPAR TESTS J-T x BY y (**).
+NPAR TESTS J-T x BY y (1, **).
+NPAR TESTS J-T x BY y (1, 2 **).
+NPAR TESTS MCNEMAR **.
+NPAR TESTS MCNEMAR x **.
+NPAR TESTS MCNEMAR x WITH **.
+NPAR TESTS MCNEMAR x WITH y (**).
+NPAR TESTS MCNEMAR x WITH y (PAIRED **).
+NPAR TESTS MCNEMAR x WITH y z (PAIRED).
+NPAR TESTS MEDIAN (**).
+NPAR TESTS MEDIAN (1 **).
+NPAR TESTS MISSING/MISSING.
+NPAR TESTS MISSING **.
+NPAR TESTS METHOD/METHOD.
+NPAR TESTS METHOD EXACT TIMER(**).
+NPAR TESTS METHOD EXACT TIMER(5 **).
+NPAR TESTS STATISTICS **.
+NPAR TESTS ALGORITHM **.
+NPAR TESTS **.
+])
+AT_CHECK([pspp -O format=csv npar.sps], [1], [dnl
+"npar.sps:2.20-2.21: error: NPAR TESTS: Syntax error expecting variable name.
+    2 | NPAR TESTS COCHRAN **.
+      |                    ^~"
+
+"npar.sps:3.21-3.22: error: NPAR TESTS: Syntax error expecting variable name.
+    3 | NPAR TESTS FRIEDMAN **.
+      |                     ^~"
+
+"npar.sps:4.20-4.21: error: NPAR TESTS: Syntax error expecting variable name.
+    4 | NPAR TESTS KENDALL **.
+      |                    ^~"
+
+"npar.sps:5.17-5.18: error: NPAR TESTS: Syntax error expecting `@{:@'.
+    5 | NPAR TESTS RUNS **.
+      |                 ^~"
+
+"npar.sps:6.18-6.19: error: NPAR TESTS: Syntax error expecting MEAN, MEDIAN, MODE or a number.
+    6 | NPAR TESTS RUNS (**).
+      |                  ^~"
+
+"npar.sps:7.23-7.24: error: NPAR TESTS: Syntax error expecting `@:}@'.
+    7 | NPAR TESTS RUNS (MEAN **).
+      |                       ^~"
+
+"npar.sps:8.24-8.25: error: NPAR TESTS: Syntax error expecting variable name.
+    8 | NPAR TESTS RUNS (MEAN)=**.
+      |                        ^~"
+
+"npar.sps:9.22-9.23: error: NPAR TESTS: Syntax error expecting variable name.
+    9 | NPAR TESTS CHISQUARE **.
+      |                      ^~"
+
+"npar.sps:10.24-10.25: error: NPAR TESTS: Syntax error expecting BEGIN.
+   10 | NPAR TESTS CHISQUARE x **.
+      |                        ^~"
+
+"npar.sps:10.24-10.25: error: NPAR TESTS: Syntax error expecting end of command.
+   10 | NPAR TESTS CHISQUARE x **.
+      |                        ^~"
+
+"npar.sps:11.25-11.26: error: NPAR TESTS: Syntax error expecting number.
+   11 | NPAR TESTS CHISQUARE x (**).
+      |                         ^~"
+
+"npar.sps:12.27-12.28: error: NPAR TESTS: Syntax error expecting `,'.
+   12 | NPAR TESTS CHISQUARE x (1 **).
+      |                           ^~"
+
+"npar.sps:13.28-13.29: error: NPAR TESTS: Syntax error expecting number greater than 1 for HI.
+   13 | NPAR TESTS CHISQUARE x (1, -1).
+      |                            ^~"
+
+"npar.sps:14.30-14.31: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   14 | NPAR TESTS CHISQUARE x (1, 2 **).
+      |                              ^~"
+
+"npar.sps:15.34-15.35: error: NPAR TESTS: Syntax error expecting `='.
+   15 | NPAR TESTS CHISQUARE x /EXPECTED **.
+      |                                  ^~"
+
+"npar.sps:16.37-16.38: error: NPAR TESTS: Syntax error expecting number.
+   16 | NPAR TESTS CHISQUARE x /EXPECTED=1* **.
+      |                                     ^~"
+
+"npar.sps:17.39: error: NPAR TESTS: 1 expected values were given, but the specified range (1-5) requires exactly 5 values.
+   17 | NPAR TESTS CHISQUARE x (1,5)/EXPECTED=2.
+      |                                       ^"
+
+"npar.sps:18.22-18.23: error: NPAR TESTS: Syntax error expecting number.
+   18 | NPAR TESTS BINOMIAL (**).
+      |                      ^~"
+
+"npar.sps:19.24-19.25: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   19 | NPAR TESTS BINOMIAL (1 **).
+      |                        ^~"
+
+"npar.sps:20.24-20.25: error: NPAR TESTS: Syntax error expecting `='.
+   20 | NPAR TESTS BINOMIAL (1)**.
+      |                        ^~"
+
+"npar.sps:21.23-21.24: error: NPAR TESTS: Syntax error expecting number.
+   21 | NPAR TESTS BINOMIAL x(**).
+      |                       ^~"
+
+"npar.sps:22.25-22.26: error: NPAR TESTS: Syntax error expecting number.
+   22 | NPAR TESTS BINOMIAL x(1,**).
+      |                         ^~"
+
+"npar.sps:23.26-23.27: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   23 | NPAR TESTS BINOMIAL x(1,2**).
+      |                          ^~"
+
+"npar.sps:24.24-24.25: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   24 | NPAR TESTS BINOMIAL x(1**).
+      |                        ^~"
+
+"npar.sps:25.16-25.17: error: NPAR TESTS: Syntax error expecting `@{:@'.
+   25 | NPAR TESTS K-S **.
+      |                ^~"
+
+"npar.sps:26.17-26.18: error: NPAR TESTS: Syntax error expecting NORMAL, POISSON, UNIFORM, or EXPONENTIAL.
+   26 | NPAR TESTS K-S (**).
+      |                 ^~"
+
+"npar.sps:27.24-27.25: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   27 | NPAR TESTS K-S (NORMAL **).
+      |                        ^~"
+
+"npar.sps:28.25-28.26: error: NPAR TESTS: Syntax error expecting variable name.
+   28 | NPAR TESTS K-S (NORMAL)=**.
+      |                         ^~"
+
+"npar.sps:29.16-29.17: error: NPAR TESTS: Syntax error expecting variable name.
+   29 | NPAR TESTS J-T **.
+      |                ^~"
+
+"npar.sps:30.18-30.19: error: NPAR TESTS: Syntax error expecting `BY'.
+   30 | NPAR TESTS J-T x **.
+      |                  ^~"
+
+"npar.sps:31.21-31.22: error: NPAR TESTS: Syntax error expecting variable name.
+   31 | NPAR TESTS J-T x BY **.
+      |                     ^~"
+
+"npar.sps:32.23-32.24: error: NPAR TESTS: Syntax error expecting `@{:@'.
+   32 | NPAR TESTS J-T x BY y **.
+      |                       ^~"
+
+"npar.sps:33.24-33.25: error: NPAR TESTS: Syntax error expecting number.
+   33 | NPAR TESTS J-T x BY y (**).
+      |                        ^~"
+
+"npar.sps:34.27-34.28: error: NPAR TESTS: Syntax error expecting number.
+   34 | NPAR TESTS J-T x BY y (1, **).
+      |                           ^~"
+
+"npar.sps:35.29-35.30: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   35 | NPAR TESTS J-T x BY y (1, 2 **).
+      |                             ^~"
+
+"npar.sps:36.20-36.21: error: NPAR TESTS: Syntax error expecting variable name.
+   36 | NPAR TESTS MCNEMAR **.
+      |                    ^~"
+
+"npar.sps:37.22-37.23: error: NPAR TESTS: Syntax error expecting end of command.
+   37 | NPAR TESTS MCNEMAR x **.
+      |                      ^~"
+
+"npar.sps:38.27-38.28: error: NPAR TESTS: Syntax error expecting variable name.
+   38 | NPAR TESTS MCNEMAR x WITH **.
+      |                           ^~"
+
+"npar.sps:39.30-39.31: error: NPAR TESTS: Syntax error expecting PAIRED.
+   39 | NPAR TESTS MCNEMAR x WITH y (**).
+      |                              ^~"
+
+"npar.sps:40.37-40.38: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   40 | NPAR TESTS MCNEMAR x WITH y (PAIRED **).
+      |                                     ^~"
+
+"npar.sps:41.20-41.29: error: NPAR TESTS: PAIRED was specified, but the number of variables preceding WITH (1) does not match the number following (2).
+   41 | NPAR TESTS MCNEMAR x WITH y z (PAIRED).
+      |                    ^~~~~~~~~~"
+
+"npar.sps:42.20-42.21: error: NPAR TESTS: Syntax error expecting number.
+   42 | NPAR TESTS MEDIAN (**).
+      |                    ^~"
+
+"npar.sps:43.22-43.23: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   43 | NPAR TESTS MEDIAN (1 **).
+      |                      ^~"
+
+"npar.sps:44.20-44.26: error: NPAR TESTS: Subcommand MISSING may only be specified once.
+   44 | NPAR TESTS MISSING/MISSING.
+      |                    ^~~~~~~"
+
+"npar.sps:45.20-45.21: error: NPAR TESTS: Syntax error expecting ANALYSIS, LISTWISE, INCLUDE, or EXCLUDE.
+   45 | NPAR TESTS MISSING **.
+      |                    ^~"
+
+"npar.sps:46.19-46.24: error: NPAR TESTS: Subcommand METHOD may only be specified once.
+   46 | NPAR TESTS METHOD/METHOD.
+      |                   ^~~~~~"
+
+"npar.sps:47.31-47.32: error: NPAR TESTS: Syntax error expecting number.
+   47 | NPAR TESTS METHOD EXACT TIMER(**).
+      |                               ^~"
+
+"npar.sps:48.33-48.34: error: NPAR TESTS: Syntax error expecting `@:}@'.
+   48 | NPAR TESTS METHOD EXACT TIMER(5 **).
+      |                                 ^~"
+
+"npar.sps:49.23-49.24: error: NPAR TESTS: Syntax error expecting DESCRIPTIVES, QUARTILES, or ALL.
+   49 | NPAR TESTS STATISTICS **.
+      |                       ^~"
+
+"npar.sps:50.22-50.23: error: NPAR TESTS: Syntax error expecting COMPATIBLE or ENHANCED.
+   50 | NPAR TESTS ALGORITHM **.
+      |                      ^~"
+
+"npar.sps:51.12-51.13: error: NPAR TESTS: Syntax error expecting one of the following: COCHRAN, FRIEDMAN, KENDALL, RUNS, CHISQUARE, BINOMIAL, K-S, J-T, K-W, MCNEMAR, M-W, MEDIAN, WILCOXON, SIGN, MISSING, METHOD, STATISTICS, ALGORITHM.
+   51 | NPAR TESTS **.
+      |            ^~"
+])
+AT_CLEANUP
\ No newline at end of file
-- 
2.30.2