tests: use assert instead of plain abort.

* tests/actions.at, tests/calc.at, tests/conflicts.at,
* tests/cxx-type.at, tests/glr-regression.at, tests/input.at,
* tests/named-refs.at, tests/regression.at, tests/torture.at,
* tests/local.at:
Prefer assert to abort.

diff --git a/tests/actions.at b/tests/actions.at
index e5a885ddcfdea2e44a44638d84c7beee676adc47..0cf2e75615924ca4efa1a192623082eaaf118182 100644 (file)
--- a/tests/actions.at
+++ b/tests/actions.at
@@ -324,8 +324,7 @@ static
   AT_LOC.last_line = AT_LOC.last_column = AT_LOC.first_line + 9;
 ])[
 
   AT_LOC.last_line = AT_LOC.last_column = AT_LOC.first_line + 9;
 ])[
 

-  if (! (0 <= c && c <= strlen (source)))
-    abort ();
+  assert (0 <= c && c <= strlen (source));

   if (source[c])
     printf ("sending: '%c'", source[c]);
   else
   if (source[c])
     printf ("sending: '%c'", source[c]);
   else

diff --git a/tests/calc.at b/tests/calc.at
index 836c3a3312ed31c268063f329777c7cc1e4105f3..58e7e895c0fe33045dbb2cbf9a52b2afebcea402 100644 (file)
--- a/tests/calc.at
+++ b/tests/calc.at
@@ -45,7 +45,7 @@ m4_define([_AT_DATA_CALC_Y],
        [m4_fatal([$0: Invalid arguments: $@])])dnl
 
 m4_pushdef([AT_CALC_MAIN],
        [m4_fatal([$0: Invalid arguments: $@])])dnl
 
 m4_pushdef([AT_CALC_MAIN],

-[#include <stdlib.h> /* abort */
+[#include <assert.h>

 #if HAVE_UNISTD_H
 # include <unistd.h>
 #else
 #if HAVE_UNISTD_H
 # include <unistd.h>
 #else


@@ -98,10 +98,8 @@ main (int argc, const char **argv)
   status = ]AT_NAME_PREFIX[parse (]AT_PARAM_IF([[&result, &count]])[);
   if (fclose (input))
     perror ("fclose");
   status = ]AT_NAME_PREFIX[parse (]AT_PARAM_IF([[&result, &count]])[);
   if (fclose (input))
     perror ("fclose");

-  if (global_result != result)
-    abort ();
-  if (global_count != count)
-    abort ();
+  assert (global_result == result);
+  assert (global_count == count);

   return status;
 }
 ]])
   return status;
 }
 ]])

diff --git a/tests/conflicts.at b/tests/conflicts.at
index 54df05112fe6344f3e5964319fb0dd1cd80d2b56..cafa3338afc54ff95004c16229181d828eab0122 100644 (file)
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -57,6 +57,7 @@ AT_DATA_GRAMMAR([input.y],
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

+#include <assert.h>

 
 #define YYERROR_VERBOSE 1
 ]AT_YYERROR_DEFINE[
 
 #define YYERROR_VERBOSE 1
 ]AT_YYERROR_DEFINE[


@@ -67,8 +68,7 @@ static int
 yylex (void)
 {
   static size_t toknum;
 yylex (void)
 {
   static size_t toknum;

-  if (! (toknum <= strlen (input)))
-    abort ();
+  assert (toknum <= strlen (input));

   return input[toknum++];
 }
 
   return input[toknum++];
 }
 

diff --git a/tests/cxx-type.at b/tests/cxx-type.at
index e172033a7a8fdfa520cdc8fbefc129ce050eb89d..f5e7c559a5014c69b3e23692fc026bae56e73481 100644 (file)
--- a/tests/cxx-type.at
+++ b/tests/cxx-type.at
@@ -122,12 +122,12 @@ declarator : ID
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>

+#include <assert.h>

 
 int
 main (int argc, char **argv)
 {
 
 int
 main (int argc, char **argv)
 {

-  if (argc != 2)
-    abort ();
+  assert (argc == 2);

   if (!freopen (argv[1], "r", stdin))
     return 3;
   return yyparse ();
   if (!freopen (argv[1], "r", stdin))
     return 3;
   return yyparse ();


@@ -152,8 +152,7 @@ main (int argc, char **argv)
 
   while (1)
     {
 
   while (1)
     {

-      if (feof (stdin))
-        abort ();
+      assert (!feof (stdin));

       c = getchar ();
       switch (c)
         {
       c = getchar ();
       switch (c)
         {


@@ -182,8 +181,7 @@ main (int argc, char **argv)
                   {
                     buffer[i++] = c;
                     colNum += 1;
                   {
                     buffer[i++] = c;
                     colNum += 1;

-                    if (i == sizeof buffer - 1)
-                      abort ();
+                    assert (i != sizeof buffer - 1);

                     c = getchar ();
                   }
                 while (isalnum (c) || c == '_');
                     c = getchar ();
                   }
                 while (isalnum (c) || c == '_');

diff --git a/tests/glr-regression.at b/tests/glr-regression.at
index 479303df1391432c2893bc85dc6d597b4f2f244b..288de258faa946747cf9c003d2044523eec206f4 100644 (file)
--- a/tests/glr-regression.at
+++ b/tests/glr-regression.at
@@ -32,6 +32,7 @@ AT_DATA_GRAMMAR([glr-regr1.y],
 %{
 #include <stdio.h>
 #include <stdlib.h>
 %{
 #include <stdio.h>
 #include <stdlib.h>

+#include <assert.h>

 
 #define YYSTYPE int
 static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
 
 #define YYSTYPE int
 static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);


@@ -80,8 +81,7 @@ yylex (void)
   for (;;)
     {
       int ch;
   for (;;)
     {
       int ch;

-      if (feof (stdin))
-       abort ();
+      assert (!feof (stdin));

       ch = getchar ();
       if (ch == EOF)
        return 0;
       ch = getchar ();
       if (ch == EOF)
        return 0;


@@ -128,6 +128,7 @@ AT_DATA_GRAMMAR([glr-regr2a.y],
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>

+  #include <assert.h>

   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
 %}
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
 %}


@@ -177,8 +178,7 @@ yylex (void)
 {
   char buf[50];
   char *s;
 {
   char buf[50];
   char *s;

-  if (feof (stdin))
-    abort ();
+  assert (!feof (stdin));

   switch (fscanf (input, " %1[a-z,]", buf))
   {
   case 1:
   switch (fscanf (input, " %1[a-z,]", buf))
   {
   case 1:


@@ -190,8 +190,7 @@ yylex (void)
   }
   if (fscanf (input, "%49s", buf) != 1)
     return 0;
   }
   if (fscanf (input, "%49s", buf) != 1)
     return 0;

-  if (sizeof buf - 1 <= strlen (buf))
-    abort ();
+  assert (strlen (buf) < sizeof buf - 1);

   s = (char *) malloc (strlen (buf) + 1);
   strcpy (s, buf);
   yylval = s;
   s = (char *) malloc (strlen (buf) + 1);
   strcpy (s, buf);
   yylval = s;


@@ -242,6 +241,7 @@ AT_DATA_GRAMMAR([glr-regr3.y],
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>

+#include <assert.h>

 
 static int MergeRule (int x0, int x1);
 ]AT_YYERROR_DECLARE[
 
 static int MergeRule (int x0, int x1);
 ]AT_YYERROR_DECLARE[


@@ -302,8 +302,7 @@ int T[] = { T1, T2, T3, T4 };
 int yylex (void)
 {
   char inp[3];
 int yylex (void)
 {
   char inp[3];

-  if (feof (stdin))
-    abort ();
+  assert (!feof (stdin));

   if (fscanf (input, "%2s", inp) == EOF)
     return 0;
   switch (inp[0])
   if (fscanf (input, "%2s", inp) == EOF)
     return 0;
   switch (inp[0])


@@ -935,6 +934,7 @@ AT_DATA_GRAMMAR([glr-regr12.y],
 
 %{
 # include <stdlib.h>
 
 %{
 # include <stdlib.h>

+# include <assert.h>

   static int merge (YYSTYPE, YYSTYPE);
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static int merge (YYSTYPE, YYSTYPE);
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[


@@ -1003,8 +1003,7 @@ yylex (void)
 {
   static int const input[] = { PARENT_RHS_AFTER, 0 };
   static size_t toknum;
 {
   static int const input[] = { PARENT_RHS_AFTER, 0 };
   static size_t toknum;

-  if (! (toknum < sizeof input / sizeof *input))
-    abort ();
+  assert (toknum < sizeof input / sizeof *input);

   if (input[toknum] == PARENT_RHS_AFTER)
     parent_rhs_after_value = 1;
   return input[toknum++];
   if (input[toknum] == PARENT_RHS_AFTER)
     parent_rhs_after_value = 1;
   return input[toknum++];


@@ -1064,6 +1063,7 @@ AT_DATA_GRAMMAR([glr-regr13.y],
 
 %{
   #include <stdio.h>
 
 %{
   #include <stdio.h>

+  #include <assert.h>

   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static void print_lookahead (char const *);
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static void print_lookahead (char const *);


@@ -1122,8 +1122,7 @@ yylex (void)
 {
   static char const input[] = "ab";
   static size_t toknum;
 {
   static char const input[] = "ab";
   static size_t toknum;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   yylloc.first_line = yylloc.last_line = 1;
   yylloc.first_column = yylloc.last_column = toknum + 1;
   yylval.value = input[toknum] + 'A' - 'a';
   yylloc.first_line = yylloc.last_line = 1;
   yylloc.first_column = yylloc.last_column = toknum + 1;
   yylval.value = input[toknum] + 'A' - 'a';


@@ -1212,6 +1211,7 @@ AT_DATA_GRAMMAR([glr-regr14.y],
 %{
   #include <stdlib.h>
   #include <stdio.h>
 %{
   #include <stdlib.h>
   #include <stdio.h>

+  #include <assert.h>

   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static void print_lookahead (char const *);
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static void print_lookahead (char const *);


@@ -1328,8 +1328,7 @@ yylex (void)
 {
   static char const input[] = "abcdddd";
   static size_t toknum;
 {
   static char const input[] = "abcdddd";
   static size_t toknum;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   yylloc.first_line = yylloc.last_line = 1;
   yylloc.first_column = yylloc.last_column = toknum + 1;
   yylval.value = input[toknum] + 'A' - 'a';
   yylloc.first_line = yylloc.last_line = 1;
   yylloc.first_column = yylloc.last_column = toknum + 1;
   yylval.value = input[toknum] + 'A' - 'a';


@@ -1492,6 +1491,7 @@ AT_DATA_GRAMMAR([glr-regr16.y],
 
 %{
 # include <stdlib.h>
 
 %{
 # include <stdlib.h>

+# include <assert.h>

   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static int lookahead_value = 0;
   ]AT_YYERROR_DECLARE[
   ]AT_YYLEX_DECLARE[
   static int lookahead_value = 0;


@@ -1512,8 +1512,7 @@ yylex (void)
 {
   static char const input[] = "ab";
   static size_t toknum;
 {
   static char const input[] = "ab";
   static size_t toknum;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   if (input[toknum] == 'b')
     lookahead_value = 1;
   return input[toknum++];
   if (input[toknum] == 'b')
     lookahead_value = 1;
   return input[toknum++];


@@ -1593,6 +1592,7 @@ empty1: ;
 empty2: ;
 
 %%
 empty2: ;
 
 %%

+# include <assert.h>

 
 static void
 yyerror (YYLTYPE *locp, char const *msg)
 
 static void
 yyerror (YYLTYPE *locp, char const *msg)


@@ -1606,8 +1606,7 @@ yylex (YYSTYPE *lvalp, YYLTYPE *llocp)
 {
   static char const input[] = "ab";
   static size_t toknum;
 {
   static char const input[] = "ab";
   static size_t toknum;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   lvalp->dummy = 0;
   llocp->first_line = llocp->last_line = 2;
   llocp->first_column = toknum + 1;
   lvalp->dummy = 0;
   llocp->first_line = llocp->last_line = 2;
   llocp->first_column = toknum + 1;

diff --git a/tests/input.at b/tests/input.at
index 6d8d552c57a8695269012a639d217f38839d5d1a..0ed8635f9cbc109cb3622de2a6fe7321c95c16e3 100644 (file)
--- a/tests/input.at
+++ b/tests/input.at
@@ -442,6 +442,7 @@ char apostrophe = '\'';
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <stdio.h>
 #include <stdlib.h>

+#include <assert.h>

 %}
 /* %{ and %} can be here too. */
 
 %}
 /* %{ and %} can be here too. */
 


@@ -509,8 +510,7 @@ yylex (void)
 #output "; /* "
   */
   static size_t toknum;
 #output "; /* "
   */
   static size_t toknum;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   yylval = value_as_yystype (input[toknum]);
   return input[toknum++];
 }
   yylval = value_as_yystype (input[toknum]);
   return input[toknum++];
 }

diff --git a/tests/local.at b/tests/local.at
index c1fcd60f068e6bae5707c350b90ec678740b4c29..4de2f7b365b57d3d2be7b5b44169635b53fe7bdc 100644 (file)
--- a/tests/local.at
+++ b/tests/local.at
@@ -304,7 +304,7 @@ m4_define([AT_YYLEX_DECLARE],
 ])
 
 m4_define([AT_YYLEX_DEFINE],
 ])
 
 m4_define([AT_YYLEX_DEFINE],

-[[#include <stdlib.h> /* abort */
+[[#include <assert.h>

 static
 ]AT_YYLEX_PROTOTYPE[
 {
 static
 ]AT_YYLEX_PROTOTYPE[
 {


@@ -312,8 +312,7 @@ static
   static size_t toknum = 0;
   int res;
   ]AT_USE_LEX_ARGS[;
   static size_t toknum = 0;
   int res;
   ]AT_USE_LEX_ARGS[;

-  if (! (toknum < sizeof input))
-    abort ();
+  assert (toknum < sizeof input);

   res = input[toknum++];
   ]$2[;]AT_LOCATION_IF([[
   ]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1;
   res = input[toknum++];
   ]$2[;]AT_LOCATION_IF([[
   ]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1;

diff --git a/tests/named-refs.at b/tests/named-refs.at
index c9b91a0e1dbf2d4517b39f0dd6a31108b4fe0da1..3ccf1f6669067dc818249cf6245d6623877f4a4f 100644 (file)
--- a/tests/named-refs.at
+++ b/tests/named-refs.at
@@ -162,10 +162,8 @@ int main (int argc, const char **argv)
     }
   status = yyparse ();
   fclose (input);
     }
   status = yyparse ();
   fclose (input);

-  if (global_result != result)
-    abort ();
-  if (global_count != count)
-    abort ();
+  assert (global_result == result);
+  assert (global_count == count);

   return status;
 }
 ]])
   return status;
 }
 ]])

diff --git a/tests/regression.at b/tests/regression.at
index 4208153a37bd99446d38834861f27c5a0b005c61..ac7d55ee8c7ae97f8b20b28320a33bf261ceff84 100644 (file)
--- a/tests/regression.at
+++ b/tests/regression.at
@@ -910,6 +910,7 @@ yyparse ()
 }
 ])
 
 }
 ])
 

+#include <assert.h>

 static int
 yylex (AT_LALR1_CC_IF([int *lval], [void]))
 [{
 static int
 yylex (AT_LALR1_CC_IF([int *lval], [void]))
 [{


@@ -919,8 +920,7 @@ yylex (AT_LALR1_CC_IF([int *lval], [void]))
     };
   static size_t toknum;
   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
     };
   static size_t toknum;
   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[

-  if (! (toknum < sizeof tokens / sizeof *tokens))
-    abort ();
+  assert (toknum < sizeof tokens / sizeof *tokens);

   return tokens[toknum++];
 }]
 
   return tokens[toknum++];
 }]
 


@@ -995,6 +995,7 @@ yyparse ()
 }
 ])[
 
 }
 ])[
 

+#include <assert.h>

 static int
 yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
 {
 static int
 yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
 {


@@ -1004,8 +1005,7 @@ yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
     };
   static size_t toknum;
   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
     };
   static size_t toknum;
   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[

-  if (! (toknum < sizeof tokens / sizeof *tokens))
-    abort ();
+  assert (toknum < sizeof tokens / sizeof *tokens);

   return tokens[toknum++];
 }
 
   return tokens[toknum++];
 }
 

diff --git a/tests/torture.at b/tests/torture.at
index a8837b2246713777c3c61da329df97ee86b40f9f..338c1648e9453e5549a89f1917ba8532e3667dc6 100644 (file)
--- a/tests/torture.at
+++ b/tests/torture.at
@@ -56,6 +56,7 @@ print <<EOF;
 %{
 #include <stdio.h>
 #include <stdlib.h>
 %{
 #include <stdio.h>
 #include <stdlib.h>

+#include <assert.h>

 #define MAX $max
 ]AT_YYLEX_DECLARE[
 ]AT_YYERROR_DECLARE[
 #define MAX $max
 ]AT_YYLEX_DECLARE[
 ]AT_YYERROR_DECLARE[


@@ -77,8 +78,8 @@ for my $size (1 .. $max)
 print <<EOF;
 %%
 input:
 print <<EOF;
 %%
 input:

-  exp        { if (\@S|@1 != 0) abort (); \$\$ = \@S|@1; }
-| input exp  { if (\@S|@2 != \@S|@1 + 1) abort (); \$\$ = \@S|@2; }
+  exp        { assert (\@S|@1 == 0); \$\$ = \@S|@1; }
+| input exp  { assert (\@S|@2 == \@S|@1 + 1); \$\$ = \@S|@2; }

 ;
 
 exp:
 ;
 
 exp:


@@ -192,6 +193,7 @@ print
 
 print <<\EOF;
 %%
 
 print <<\EOF;
 %%

+#include <assert.h>

 ]AT_YYERROR_DEFINE[
 static int
 yylex (void)
 ]AT_YYERROR_DEFINE[
 static int
 yylex (void)


@@ -199,8 +201,7 @@ yylex (void)
   static int counter = 1;
   if (counter <= MAX)
     return counter++;
   static int counter = 1;
   if (counter <= MAX)
     return counter++;

-  if (counter++ != MAX + 1)
-    abort ();
+  assert (counter++ == MAX + 1);

   return 0;
 }
 
   return 0;
 }
 


@@ -328,8 +329,7 @@ yylex (void)
   static int counter = 1;
   if (counter > MAX)
     {
   static int counter = 1;
   if (counter > MAX)
     {

-      if (counter++ != MAX + 1)
-       abort ();
+      assert (counter++ == MAX + 1);

       return 0;
     }
   if (return_token)
       return 0;
     }
   if (return_token)


@@ -401,11 +401,11 @@ AT_DATA([input.y],
 exp: WAIT_FOR_EOF exp | ;
 %%
 ]AT_YYERROR_DEFINE[
 exp: WAIT_FOR_EOF exp | ;
 %%
 ]AT_YYERROR_DEFINE[

+#include <assert.h>

 static int
 yylex (void)
 {
 static int
 yylex (void)
 {

-  if (yylval < 0)
-    abort ();
+  assert (0 <= yylval);

   if (yylval--)
     return WAIT_FOR_EOF;
   else
   if (yylval--)
     return WAIT_FOR_EOF;
   else


@@ -417,13 +417,12 @@ main (int argc, const char **argv)
 {
   char *endp;
   YYSTYPE yylval_init;
 {
   char *endp;
   YYSTYPE yylval_init;

-  if (argc != 2)
-    abort ();
+  assert (argc == 2);

   yylval_init = strtol (argv[1], &endp, 10);
   yylval_init = strtol (argv[1], &endp, 10);

-  if (! (argv[1] != endp
-        && 0 <= yylval_init && yylval_init <= INT_MAX
-        && errno != ERANGE))
-    abort ();
+  assert (argv[1] != endp);
+  assert (0 <= yylval_init);
+  assert (yylval_init <= INT_MAX);
+  assert (errno != ERANGE);

   yydebug = 1;
   {
     int count;
   yydebug = 1;
   {
     int count;


@@ -438,8 +437,7 @@ main (int argc, const char **argv)
 [[        new_status = yypull_parse (ps);
 ]],
 [[        new_status = yyparse ();
 [[        new_status = yypull_parse (ps);
 ]],
 [[        new_status = yyparse ();

-]])[        if (count > 0 && new_status != status)
-          abort ();
+]])[        assert (0 <= count || new_status == status);

         status = new_status;
       }
 ]m4_bmatch([$2], [%push-],
         status = new_status;
       }
 ]m4_bmatch([$2], [%push-],