#include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <unistd.h>

 #include <errno.h>

 #ifdef WIN32

 #include <io.h>

 #endif

 #include <fcntl.h>

 #include <bl/bl.h>

 #include "testcase.h"

 GQuark testcase_error_quark(void)

 {

     return g_quark_from_static_string("testcase-error-quark");

 }

 #if !HAVE_MKSTEMP

 /*

  * An insecure implementation of mkstemp(), for those platforms that

  * don't support it.

  */

 int mkstemp(char *template)

 {

     int fd;

     char *s;

     for(;;)

     {

 	s=g_strdup(template);

 	mktemp(s);

 	if (!*s)

 	{

 	    errno=EEXIST;

 	    g_free(s);

 	    return -1;

 	}

 	fd=open(s,O_RDWR|O_CREAT|O_EXCL,0600);

 	if (fd>0)

 	{

 	    strcpy(template,s);

 	    g_free(s);

 	    return fd;

 	}

 	else

 	    g_free(s);

     }

 }

 #endif	/* !HAVE_MKSTEMP */

 /*

  * As write(), but always convert NL to CR NL.

  */

 static size_t write_text(int fd,const char *buf,size_t count,GError **error)

 {

     size_t i;

     FILE *fp;

     fd=dup(fd);

     if (fd<0)

 	return -1;

 #ifdef WIN32

     if (_setmode(fd,_O_BINARY)<0)

     {

 	close(fd);

 	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 	  "Failed to set mode of bookloupe input file to binary: %s",

 	  g_strerror(errno));

 	return -1;

     }

 #endif

     fp=fdopen(fd,"wb");

     if (!fp)

     {

 	close(fd);

 	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 	  "Failed to open stream to bookloupe input file: %s",

 	  g_strerror(errno));

 	return -1;

     }

     for(i=0;i<count;i++)

     {

 	if (buf[i]=='\n')

 	    if (putc('\r',fp)==EOF)

 	    {

 		g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 		  "Error writing bookloupe input file: %s",g_strerror(errno));

 		(void)fclose(fp);

 		return -1;

 	    }

 	if (putc(buf[i],fp)==EOF)

 	{

 	    g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 	      "Error writing bookloupe input file: %s",g_strerror(errno));

 	    (void)fclose(fp);

 	    return -1;

 	}

     }

     if (fclose(fp))

     {

 	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 	  "Error writing bookloupe input file: %s",g_strerror(errno));

 	return -1;

     }

     return count;

 }

 /*

  * Return the length (in bytes) or any common prefix between s1 and s2.

  */

 size_t common_prefix_length(const char *s1,const char *s2)

 {

     size_t i;

     for(i=0;s1[i] && s2[i] && s1[i]==s2[i];i++)

 	;

     return i;

 }

 void print_unexpected(const char *unexpected,gsize differs_at)

 {

     int col;

     const char *endp,*bol;

     GString *string;

     endp=strchr(unexpected+differs_at,'\n');

     if (!endp)

 	endp=unexpected+strlen(unexpected);

     string=g_string_new_len(unexpected,endp-unexpected);

     bol=strrchr(string->str,'\n');

     if (bol)

 	bol++;

     else

 	bol=string->str;

     col=differs_at-(bol-string->str);

     fprintf(stderr,"%s\n%*s^\n",string->str,col,"");

     g_string_free(string,TRUE);

 }

 gboolean spawn_bootloupe(const char *encoding,const char *standard_input,

   char **standard_output,char **filename,GError **error)

 {

     gboolean r;

     int fd,exit_status;

     size_t n,pos,offset;

     FILE *fp;

     char input[]="TEST-XXXXXX";

     char *command[3];

     char *output,*s;

     GError *tmp_err=NULL;

     if (standard_input)

     {

 	if (encoding)

 	{

 	    s=g_convert(standard_input,-1,encoding,"UTF-8",NULL,&n,&tmp_err);

 	    if (!s)

 	    {

 		g_propagate_prefixed_error(error,tmp_err,

 		  "Conversion to %s failed: ",encoding);

 		return FALSE;

 	    }

 	}

 	else

 	{

 	    s=g_strdup(standard_input);

 	    n=strlen(s);

 	}

     }

     else

     {

 	n=0;

 	s=NULL;

     }

     fd=mkstemp(input);

     if (n && write_text(fd,s,n,error)!=n)

     {

 	g_free(s);

 	close(fd);

 	(void)remove(input);

 	return FALSE;

     }

     g_free(s);

     close(fd);

     command[0]=getenv("BOOKLOUPE");

     if (!command[0])

 	command[0]="." G_DIR_SEPARATOR_S "bookloupe";

     command[1]=input;

     command[2]=NULL;

     if (standard_output)

     {

 	r=spawn_sync(command,&s,&exit_status,error);

 	if (r)

 	{

 	    if (encoding)

 	    {

 		output=g_convert(s,-1,"UTF-8",encoding,NULL,NULL,&tmp_err);

 		g_free(s);

 		if (!output)

 		{

 		    g_propagate_prefixed_error(error,tmp_err,

 		      "Conversion from %s failed: ",encoding);

 		    r=FALSE;

 		}

 	    }

 	    else

 	    {

 		output=s;

 		if (!g_utf8_validate(s,-1,NULL))

 		{

 		    g_set_error_literal(error,TESTCASE_ERROR,

 		      TESTCASE_ERROR_FAILED,

 		      "bookloupe output is not valid UTF-8");

 		    r=FALSE;

 		}

 	    }

 	}

     }

     else

     {

 	r=spawn_sync(command,NULL,&exit_status,error);

 	output=NULL;

     }

     (void)remove(input);

     if (r && exit_status)

     {

 	g_set_error(error,TESTCASE_ERROR,TESTCASE_ERROR_FAILED,

 	  "bookloupe exited with code %d",exit_status);

 	r=FALSE;

     }

     if (r && filename)

 	*filename=g_strdup(input);

     if (r && standard_output)

 	*standard_output=output;

     return r;

 }

 /*

  * Run a testcase, returning FALSE on fail or error and

  * TRUE on pass or expected-fail.

  * Suitable message(s) will be printed in all cases.

  */

 gboolean testcase_run(Testcase *testcase)

 {

     gboolean r;

     size_t pos,offset;

     GString *header,*expected;

     char *output,*filename,*s;

     GError *error=NULL;

     if (testcase->expected)

 	r=spawn_bootloupe(testcase->encoding,testcase->input,&output,&filename,

 	  &error);

     else

     {

 	r=spawn_bootloupe(testcase->encoding,testcase->input,NULL,NULL,&error);

         output=filename=NULL;

     }

     if (!r)

     {

 	fprintf(stderr,"%s: FAIL\n",testcase->basename);

 	fprintf(stderr,"%s\n",error->message);

 	g_error_free(error);

 	return FALSE;

     }

     if (testcase->expected)

     {

 	header=g_string_new("\n\nFile: ");

 	g_string_append(header,filename);

 	g_string_append(header,"\n");

 	expected=g_string_new(testcase->expected);

 	if (!g_str_has_prefix(output,header->str))

 	{

 	    fprintf(stderr,"%s: FAIL\n",testcase->basename);

 	    offset=common_prefix_length(output,header->str);

 	    fprintf(stderr,"Unexpected header from bookloupe:\n");

 	    print_unexpected(output,offset);

 	    r=FALSE;

 	}

 	pos=header->len;

 	if (r)

 	{

 	    /* Skip the summary */

 	    s=strstr(output+pos,"\n\n");

 	    if (s)

 		pos=s-output+2;

 	    else

 	    {

 		fprintf(stderr,"%s: FAIL\n",testcase->basename);

 		offset=common_prefix_length(output,header->str);

 		fprintf(stderr,"Unterminated summary from bookloupe:\n%s\n",

 		  output+pos);

 		r=FALSE;

 	    }

 	}

 	if (r && strcmp(output+pos,expected->str))

 	{

 	    fprintf(stderr,"%s: FAIL\n",testcase->basename);

 	    offset=common_prefix_length(output+pos,expected->str);

 	    if (!offset && !output[pos+offset])

 		fprintf(stderr,"Unexpected zero warnings from bookloupe.\n");

 	    else

 	    {

 		fprintf(stderr,"Unexpected output from bookloupe:\n");

 		print_unexpected(output+pos,offset);

 	    }

 	    r=FALSE;

 	}

 	g_string_free(header,TRUE);

 	g_string_free(expected,TRUE);

     }

     g_free(output);

     g_free(filename);

     if (r)

 	fprintf(stderr,"%s: PASS\n",testcase->basename);

     return r;

 }

 /*

  * Free a testcase.

  */

 void testcase_free(Testcase *testcase)

 {

     g_free(testcase->basename);

     g_free(testcase->input);

     g_free(testcase->expected);

     g_free(testcase->encoding);

     g_free(testcase);

 }