test/harness/testcase.c
author ali <ali@juiblex.co.uk>
Tue Feb 14 22:17:03 2012 +0000 (2012-02-14)
changeset 23 38ea5c71f04f
parent 11 4a80c6053a66
child 93 9fb13a5dde3b
permissions -rw-r--r--
Add testcase for checks around periods
     1 #include <stdlib.h>
     2 #include <stdio.h>
     3 #include <string.h>
     4 #include <errno.h>
     5 #include <glib.h>
     6 #include <glib/gstdio.h>
     7 #include <bl/bl.h>
     8 #include "testcase.h"
     9 #include "testcaseinput.h"
    10 
    11 GQuark testcase_error_quark(void)
    12 {
    13     return g_quark_from_static_string("testcase-error-quark");
    14 }
    15 
    16 /*
    17  * Return the length (in bytes) of any common prefix between s1 and s2.
    18  * The returned length will always represent an exact number of characters.
    19  */
    20 size_t common_prefix_length(const char *s1,const char *s2)
    21 {
    22     gunichar c1,c2;
    23     const char *s=s1;
    24     while(*s1 && *s2)
    25     {
    26 	c1=g_utf8_get_char(s1);
    27 	c2=g_utf8_get_char(s2);
    28 	if (c1!=c2)
    29 	    break;
    30 	s1=g_utf8_next_char(s1);
    31 	s2=g_utf8_next_char(s2);
    32     }
    33     return s1-s;
    34 }
    35 
    36 void print_unexpected(const char *unexpected,gsize differs_at)
    37 {
    38     int col;
    39     gunichar c;
    40     const char *endp,*bol,*s;
    41     GString *string;
    42     endp=strchr(unexpected+differs_at,'\n');
    43     if (!endp)
    44 	endp=unexpected+strlen(unexpected);
    45     string=g_string_new_len(unexpected,endp-unexpected);
    46     bol=strrchr(string->str,'\n');
    47     if (bol)
    48 	bol++;
    49     else
    50 	bol=string->str;
    51     col=0;
    52     s=bol;
    53     endp=string->str+differs_at;
    54     while(s<endp)
    55     {
    56 	c=g_utf8_get_char(s);
    57 	s=g_utf8_next_char(s);
    58 	if (c=='\t')
    59 	    col=(col&~7)+8;
    60 	else if (g_unichar_iswide(c))
    61 	    col+=2;
    62 	else if (!g_unichar_iszerowidth(c))
    63 	    col++;
    64     }
    65     g_print("%s\n%*s^\n",string->str,col,"");
    66     g_string_free(string,TRUE);
    67 }
    68 
    69 /*
    70  * Create all the input files needed by a testcase and, if required,
    71  * a temporary directory in which to store them.
    72  */
    73 gboolean testcase_create_input_files(Testcase *testcase,GError **error)
    74 {
    75     GSList *link,*link2;
    76     if (testcase->flags&TESTCASE_TMP_DIR)
    77     {
    78 	testcase->tmpdir=g_strdup("TEST-XXXXXX");
    79 	if (!g_mkdtemp(testcase->tmpdir))
    80 	{
    81 	    g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
    82 	      "Failed to create temporary directory: %s",g_strerror(errno));
    83 	    g_free(testcase->tmpdir);
    84 	    testcase->tmpdir=NULL;
    85 	    return FALSE;
    86 	}
    87     }
    88     for(link=testcase->inputs;link;link=link->next)
    89 	if (!testcase_input_create(testcase,link->data,error))
    90 	{
    91 	    for(link2=testcase->inputs;link2!=link;link2=link2->next)
    92 		(void)testcase_input_remove(testcase,link2->data,NULL);
    93 	    if (testcase->tmpdir)
    94 	    {
    95 		(void)g_rmdir(testcase->tmpdir);
    96 		g_free(testcase->tmpdir);
    97 		testcase->tmpdir=NULL;
    98 	    }
    99 	    return FALSE;
   100 	}
   101     return TRUE;
   102 }
   103 
   104 /*
   105  * Remove all the input files used by a testcase and, if created,
   106  * the temporary directory in which they are stored.
   107  */
   108 gboolean testcase_remove_input_files(Testcase *testcase,GError **error)
   109 {
   110     GSList *link;
   111     GError *tmp_err=NULL;
   112     gboolean retval=TRUE;
   113     for(link=testcase->inputs;link;link=link->next)
   114 	if (!testcase_input_remove(testcase,link->data,&tmp_err))
   115 	{
   116 	    if (error && !*error)
   117 		g_propagate_error(error,tmp_err);
   118 	    else
   119 		g_clear_error(&tmp_err);
   120 	    retval=FALSE;
   121 	}
   122     if (testcase->tmpdir)
   123     {
   124 	if (g_rmdir(testcase->tmpdir))
   125 	{
   126 	    if (error && !*error)
   127 		g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
   128 		  "Failed to remove temporary directory: %s",g_strerror(errno));
   129 	    retval=FALSE;
   130 	}
   131 	g_free(testcase->tmpdir);
   132 	testcase->tmpdir=NULL;
   133     }
   134     return retval;
   135 }
   136 
   137 /*
   138  * Replace every occurance of an input file name in <str> with the
   139  * filename which holds that input. For input files with fixed names,
   140  * this is a noop. For input files which use the "XXXXXX" sequence
   141  * to create a unique filename, the XXXXXX will be replaced with the
   142  * 6 characters that were chosen to be unique.
   143  */
   144 char *testcase_resolve_input_files(Testcase *testcase,const char *str)
   145 {
   146     GSList *link;
   147     gsize offset,pos;
   148     char *s;
   149     TestcaseInput *input;
   150     GString *filename=g_string_new(str);
   151     for(link=testcase->inputs;link;link=link->next)
   152     {
   153 	input=link->data;
   154 	if (!input->name_used)
   155 	{
   156 	    g_warning("%s: Input file uninstantiated",input->name);
   157 	    continue;
   158 	}
   159 	offset=0;
   160 	do
   161 	{
   162 	    s=strstr(filename->str+offset,input->name);
   163 	    if (s)
   164 	    {
   165 		pos=s-filename->str;
   166 		g_string_overwrite(filename,pos,input->name_used);
   167 		offset=pos+strlen(input->name);
   168 	    }
   169 	} while(s);
   170     }
   171     return g_string_free(filename,FALSE);
   172 }
   173 
   174 gboolean testcase_spawn_bookloupe(Testcase *testcase,char **standard_output,
   175   GError **error)
   176 {
   177     gboolean r;
   178     int i,exit_status;
   179     char **argv;
   180     char *output,*s;
   181     GError *tmp_err=NULL;
   182     if (testcase->options)
   183 	argv=g_new(char *,g_strv_length(testcase->options)+3);
   184     else
   185 	argv=g_new(char *,3);
   186     s=getenv("BOOKLOUPE");
   187     if (!s)
   188 	s="bookloupe";
   189     argv[0]=path_to_absolute(s);
   190     for(i=0;testcase->options && testcase->options[i];i++)
   191 	argv[i+1]=testcase_resolve_input_files(testcase,testcase->options[i]);
   192     argv[i+1]=testcase_resolve_input_files(testcase,"TEST-XXXXXX");
   193     argv[i+2]=NULL;
   194     if (standard_output)
   195     {
   196 	r=spawn_sync(testcase->tmpdir,argv,&s,&exit_status,error);
   197 	if (r)
   198 	{
   199 	    if (testcase->encoding)
   200 	    {
   201 		output=g_convert(s,-1,"UTF-8",testcase->encoding,NULL,NULL,
   202 		  &tmp_err);
   203 		g_free(s);
   204 		if (!output)
   205 		{
   206 		    g_propagate_prefixed_error(error,tmp_err,
   207 		      "Conversion from %s failed: ",testcase->encoding);
   208 		    r=FALSE;
   209 		}
   210 	    }
   211 	    else
   212 	    {
   213 		output=s;
   214 		if (!g_utf8_validate(s,-1,NULL))
   215 		{
   216 		    g_set_error_literal(error,TESTCASE_ERROR,
   217 		      TESTCASE_ERROR_FAILED,
   218 		      "bookloupe output is not valid UTF-8");
   219 		    r=FALSE;
   220 		}
   221 	    }
   222 	}
   223     }
   224     else
   225     {
   226 	r=spawn_sync(testcase->tmpdir,argv,NULL,&exit_status,error);
   227 	output=NULL;
   228     }
   229     g_strfreev(argv);
   230     if (r && exit_status)
   231     {
   232 	g_set_error(error,TESTCASE_ERROR,TESTCASE_ERROR_FAILED,
   233 	  "bookloupe exited with code %d",exit_status);
   234 	r=FALSE;
   235     }
   236     if (r && standard_output)
   237 	*standard_output=output;
   238     return r;
   239 }
   240 
   241 /*
   242  * Parse a warning of the form:
   243  *	[blank line]
   244  *	<echoed line> (ignored)
   245  *	"    Line " <number> [" column " <number>] " - " <text> "\n"
   246  * If not specified, the column is returned as 0.
   247  * Returns: the number of bytes parsed, or -1 on error.
   248  */
   249 static ssize_t testcase_parse_warning(Testcase *testcase,const char *output,
   250   guint *line,guint *column,char **text)
   251 {
   252     ssize_t offset=0;
   253     guint64 tmp;
   254     char *s,*endp;
   255     if (output[offset]!='\n')
   256     {
   257 	g_print("%s: FAIL\n",testcase->basename);
   258 	g_print("Unexpected output from bookloupe:\n");
   259 	print_unexpected(output,offset);
   260 	return -1;
   261     }
   262     offset++;
   263     s=strchr(output+offset,'\n');
   264     if (!s)
   265     {
   266 	g_print("%s: FAIL\n",testcase->basename);
   267 	g_print("Missing new-line in output from bookloupe:\n");
   268 	print_unexpected(output,offset);
   269 	return -1;
   270     }
   271     offset=s-output+1;
   272     if (!g_str_has_prefix(output+offset,"    Line "))
   273     {
   274 	g_print("%s: FAIL\n",testcase->basename);
   275 	g_print("Unexpected output from bookloupe:\n");
   276 	offset+=common_prefix_length(output+offset,"    Line ");
   277 	print_unexpected(output,offset);
   278 	return -1;
   279     }
   280     offset+=9;
   281     tmp=g_ascii_strtoull(output+offset,&endp,10);
   282     if (tmp<1 || tmp>G_MAXUINT || tmp==G_MAXUINT64)
   283     {
   284 	g_print("%s: FAIL\n",testcase->basename);
   285 	g_print("Unexpected output from bookloupe:\n");
   286 	print_unexpected(output,offset);
   287 	return -1;
   288     }
   289     *line=tmp;
   290     offset=endp-output;
   291     if (g_str_has_prefix(output+offset," column "))
   292     {
   293 	offset+=8;
   294 	tmp=g_ascii_strtoull(output+offset,&endp,10);
   295 	if (tmp<1 || tmp>G_MAXUINT || tmp==G_MAXUINT64)
   296 	{
   297 	    g_print("%s: FAIL\n",testcase->basename);
   298 	    g_print("Unexpected output from bookloupe:\n");
   299 	    print_unexpected(output,offset);
   300 	    return -1;
   301 	}
   302 	*column=tmp;
   303 	offset=endp-output;
   304     }
   305     else
   306 	*column=0;
   307     if (!g_str_has_prefix(output+offset," - "))
   308     {
   309 	g_print("%s: FAIL\n",testcase->basename);
   310 	g_print("Unexpected output from bookloupe:\n");
   311 	offset+=common_prefix_length(output+offset," - ");
   312 	print_unexpected(output,offset);
   313 	return -1;
   314     }
   315     offset+=3;
   316     s=strchr(output+offset,'\n');
   317     if (!s)
   318     {
   319 	g_print("%s: FAIL\n",testcase->basename);
   320 	g_print("Missing new-line in output from bookloupe:\n");
   321 	print_unexpected(output,offset);
   322 	return -1;
   323     }
   324     *text=g_strndup(output+offset,s-(output+offset));
   325     return s-output+1;
   326 }
   327 
   328 /*
   329  * Check the warnings produced by bookloupe against either the
   330  * unstructured testcase->expected or the structured testcase->warnings
   331  * as appropriate.
   332  */
   333 static gboolean testcase_check_warnings(Testcase *testcase,const char *output,
   334   char **xfail)
   335 {
   336     gboolean r=TRUE;
   337     size_t offset;
   338     ssize_t off;
   339     int i,count_false_positive,count_false_negative;
   340     int total_false_positive,total_false_negative;
   341     char *text;
   342     guint *counts,line,column;
   343     GSList *link,*link2;
   344     TestcaseWarning *warning;
   345     TestcaseLocation *location;
   346     *xfail=NULL;
   347     if (testcase->expected)
   348     {
   349 	if (strcmp(output,testcase->expected))
   350 	{
   351 	    g_print("%s: FAIL\n",testcase->basename);
   352 	    offset=common_prefix_length(output,testcase->expected);
   353 	    if (!offset && !output[offset])
   354 		g_print("Unexpected zero warnings from bookloupe.\n");
   355 	    else
   356 	    {
   357 		g_print("Unexpected output from bookloupe:\n");
   358 		print_unexpected(output,offset);
   359 	    }
   360 	    return FALSE;
   361 	}
   362 	return TRUE;
   363     }
   364     counts=g_new0(guint,g_slist_length(testcase->warnings));
   365     for(offset=0;output[offset];)
   366     {
   367 	off=testcase_parse_warning(testcase,output+offset,&line,&column,&text);
   368 	if (off<0)
   369 	{
   370 	    r=FALSE;
   371 	    break;
   372 	}
   373 	offset+=off;
   374 	for(link=testcase->warnings,i=0;link;link=link->next,i++)
   375 	{
   376 	    warning=link->data;
   377 	    if (strcmp(warning->text,text))
   378 		continue;
   379 	    for(link2=warning->locations;link2;link2=link2->next)
   380 	    {
   381 		location=link2->data;
   382 		if (location->line!=line || location->column!=column)
   383 		    continue;
   384 		counts[i]++;
   385 		break;
   386 	    }
   387 	    if (link2)
   388 		break;
   389 	}
   390 	if (!link)
   391 	{
   392 	    g_print("%s: FAIL\n",testcase->basename);
   393 	    g_print("Unexpected warning from bookloupe:\n");
   394 	    if (column)
   395 		g_print("    Line %u column %u - %s\n",line,column,text);
   396 	    else
   397 		g_print("    Line %u - %s\n",line,text);
   398 	    r=FALSE;
   399 	    g_free(text);
   400 	    break;
   401 	}
   402 	g_free(text);
   403     }
   404     count_false_positive=total_false_positive=0;
   405     count_false_negative=total_false_negative=0;
   406     for(link=testcase->warnings,i=0;r && link;link=link->next,i++)
   407     {
   408 	warning=link->data;
   409 	if (!counts[i] && warning->is_real && !warning->xfail)
   410 	{
   411 	    location=warning->locations->data;
   412 	    g_print("%s: FAIL\n",testcase->basename);
   413 	    g_print("Missing warning from bookloupe:\n");
   414 	    if (location->column)
   415 		g_print("    Line %u column %u - %s\n",location->line,
   416 		  location->column,warning->text);
   417 	    else
   418 		g_print("    Line %u - %s\n",location->line,warning->text);
   419 	    r=FALSE;
   420 	    break;
   421 	}
   422 	else if (warning->xfail)
   423 	{
   424 	    if (warning->is_real)
   425 	    {
   426 		total_false_negative++;
   427 		if (!counts[i])
   428 		    count_false_negative++;
   429 	    }
   430 	    else if (!warning->is_real)
   431 	    {
   432 		total_false_positive++;
   433 		if (counts[i])
   434 		    count_false_positive++;
   435 	    }
   436 	}
   437     }
   438     g_free(counts);
   439     if (count_false_positive && count_false_negative)
   440 	*xfail=g_strdup_printf(
   441 	  "with %d of %d false positives and %d of %d false negatives",
   442 	  count_false_positive,total_false_positive,
   443 	  count_false_negative,total_false_negative);
   444     else if (count_false_positive)
   445 	*xfail=g_strdup_printf("with %d of %d false positives",
   446 	  count_false_positive,total_false_positive);
   447     else if (count_false_negative)
   448 	*xfail=g_strdup_printf("with %d of %d false negatives",
   449 	  count_false_negative,total_false_negative);
   450     return r;
   451 }
   452 
   453 /*
   454  * Run a testcase, returning FALSE on fail or error and
   455  * TRUE on pass or expected-fail.
   456  * Suitable message(s) will be printed in all cases.
   457  */
   458 gboolean testcase_run(Testcase *testcase)
   459 {
   460     gboolean r;
   461     size_t pos,offset;
   462     GString *header;
   463     char *output,*filename,*s,*xfail=NULL;
   464     GError *error=NULL;
   465     if (!testcase_create_input_files(testcase,&error))
   466     {
   467 	g_print("%s: FAIL\n",testcase->basename);
   468 	g_print("%s\n",error->message);
   469 	g_error_free(error);
   470 	return FALSE;
   471     }
   472     if (testcase->expected || testcase->warnings)
   473 	r=testcase_spawn_bookloupe(testcase,&output,&error);
   474     else
   475     {
   476 	r=testcase_spawn_bookloupe(testcase,NULL,&error);
   477         output=NULL;
   478     }
   479     if (!r)
   480     {
   481 	g_print("%s: FAIL\n",testcase->basename);
   482 	g_print("%s\n",error->message);
   483 	g_error_free(error);
   484 	(void)testcase_remove_input_files(testcase,NULL);
   485 	return FALSE;
   486     }
   487     filename=testcase_resolve_input_files(testcase,"TEST-XXXXXX");
   488     if (!testcase_remove_input_files(testcase,&error))
   489     {
   490 	g_print("%s: FAIL\n",testcase->basename);
   491 	g_print("%s\n",error->message);
   492 	g_error_free(error);
   493 	return FALSE;
   494     }
   495     if (testcase->expected || testcase->warnings)
   496     {
   497 	header=g_string_new("\n\nFile: ");
   498 	g_string_append(header,filename);
   499 	g_string_append(header,"\n");
   500 	if (!g_str_has_prefix(output,header->str))
   501 	{
   502 	    g_print("%s: FAIL\n",testcase->basename);
   503 	    g_print("Unexpected header from bookloupe:\n");
   504 	    offset=common_prefix_length(output,header->str);
   505 	    print_unexpected(output,offset);
   506 	    r=FALSE;
   507 	}
   508 	pos=header->len;
   509 	if (r)
   510 	{
   511 	    /* Skip the summary */
   512 	    s=strstr(output+pos,"\n\n");
   513 	    if (s)
   514 		pos=s-output+2;
   515 	    else
   516 	    {
   517 		g_print("%s: FAIL\n",testcase->basename);
   518 		g_print("Unterminated summary from bookloupe:\n%s\n",
   519 		  output+pos);
   520 		r=FALSE;
   521 	    }
   522 	}
   523 	g_string_free(header,TRUE);
   524 	r=testcase_check_warnings(testcase,output+pos,&xfail);
   525     }
   526     g_free(filename);
   527     g_free(output);
   528     if (r)
   529     {
   530 	if (xfail)
   531 	    g_print("%s: PASS (%s)\n",testcase->basename,xfail);
   532 	else
   533 	    g_print("%s: PASS\n",testcase->basename);
   534     }
   535     g_free(xfail);
   536     return r;
   537 }
   538 
   539 /*
   540  * Free a testcase warning.
   541  */
   542 void testcase_warning_free(TestcaseWarning *warning)
   543 {
   544     g_slist_foreach(warning->locations,(GFunc)g_free,NULL);
   545     g_slist_free(warning->locations);
   546     g_free(warning->text);
   547     g_free(warning);
   548 }
   549 
   550 /*
   551  * Free a testcase.
   552  */
   553 void testcase_free(Testcase *testcase)
   554 {
   555     g_free(testcase->basename);
   556     g_slist_foreach(testcase->inputs,(GFunc)testcase_input_free,NULL);
   557     g_slist_free(testcase->inputs);
   558     g_free(testcase->expected);
   559     g_slist_foreach(testcase->warnings,(GFunc)testcase_warning_free,NULL);
   560     g_slist_free(testcase->warnings);
   561     g_free(testcase->encoding);
   562     g_strfreev(testcase->options);
   563     g_free(testcase);
   564 }