Add test & bugfix

src/logger.c

 {
 	char *fmt;
 	size_t i;
-	void *tmp;
+	//void *tmp;
 	pyfcgi_conf_logger_t *conf;
 
 	conf = &PyFCGI_conf.logs;
 			   strerror(errno));
 		return PYFCGI_FATAL;
 	}
+	/*
 	conf->format_sz++;
 	if( !(tmp = realloc(conf->format,
 	                    sizeof(char*) * conf->format_sz)) )
 		return PYFCGI_FATAL;
 	}
 	conf->format[i] = fmt;
+	*/
 	return 0;
 }
 
 			continue;
 		}
 		// Name found ?
-		while(**ptr && **name && **ptr != ':')
+		while(**ptr && **name && **ptr != ':' && **ptr != '}')
 		{
 			if(**ptr != **name)
 			{
 			return 1;
 		}
 	}
-	(*ptr)++; //on field size or ':' or '}'
-	str_start = *ptr;
+	if(**ptr == ':') { (*ptr)++; } // next option
 	if(pyfcgi_logger_parse_field_sz(ptr, &(cur_field->len)))
 	{
 		snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
 			 str_start - start, str_start);
 		return 1;
 	}
-	if(**ptr != ':' && **ptr != '}')
-	{
-		snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
-			 "Unable to parse field '%s' at chr %ld",
-			 field_start , *ptr - start);
-		return 1;
-	}
+	if(**ptr == ':') { (*ptr)++; } // next option
+	str_start = *ptr;
+	cur_field->known_length = 1;
 	switch(cur_field->type)
 	{
 		case pyfcgi_logger_field_datetime:
 			default_len = 0;
 			break;
 		case pyfcgi_logger_field_msg:
+			cur_field->known_length = 0;
 			default_len = 0;
 			break;
 		default:
 
 	fmt_len = 0;
 	fmt = *ptr;
-printf("FUCKOFF");
 	while(**ptr && **ptr != '}' && *((*ptr)+1) != '}')
 	{
-		ptr++;
+		(*ptr)++;
 		fmt_len++;
 	}
+	if(!(**ptr))
+	{
+		//TODO error
+	}
 	if(!fmt_len)
 	{
+		(*ptr)++;
 		fmt_len = sizeof(PYFCGI_LOGGER_TIME_FMT_DEFAULT);
 		fmt = PYFCGI_LOGGER_TIME_FMT_DEFAULT;
 	}
-	if(!(*format = strndup(fmt, fmt_len)))
+	if(!(*format = strndup(fmt, fmt_len+1)))
 	{
 		pyfcgi_log(LOG_ALERT,
 		           "Unable to strdup field datetime format : %s",
 	char *end;
 	if(**ptr == '}' || **ptr == ':')
 	{
+		(*ptr)++;
 		return (*size = 0);
 	}
 	if(**ptr < '0' && **ptr > 9)
 		return 1; // parse error
 	}
 	*size = strtoull(*ptr, &end, 10);
+	*ptr = end;
 	return 0;
 }
 

src/main.c

 #include <sys/types.h>
 #include <sys/wait.h>
 
+#include "conf.h"
 #include "responder.h"
 
 #define IDENT_FMT "pyfcgi[%d]"

tests/check_logger.c

 #include <stdlib.h>
 #include <check.h>
+#include <time.h>
+#include <stdio.h>
 #include "logger.h"
 
 pyfcgi_conf_logger_t *conf = &PyFCGI_conf.logs;
 }
 END_TEST
 
+/*
 START_TEST(test_logger_format_add)
 {
 	int ret;
 	ck_assert_str_eq(conf->format[0], "TEST");
 }
 END_TEST
+*/
 
 START_TEST(test_logger_parse_field_dtfmt_default)
 {
 	ptr = orig;
 	fmt = NULL;
 
-printf("FUCKOFF");
 	ret = pyfcgi_logger_parse_field_dtfmt((const char**)&ptr, &fmt);
 	ck_assert_int_eq(ret, 0);
 	ck_assert_str_eq(fmt, PYFCGI_LOGGER_TIME_FMT_DEFAULT);
+	ck_assert_ptr_eq(ptr, orig+1);
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_sz_default)
+{
+	int ret;
+	size_t val;
+	char *ptr, **orig;
+	char *vals[] = {":%F}", ":}", "}", NULL};
+
+	orig = vals;
+	while(*orig)
+	{
+		ptr = *orig;
+
+		ret = pyfcgi_logger_parse_field_sz((const char**)&ptr, &val);
+		ck_assert_int_eq(val, 0);
+		ck_assert_ptr_eq(ptr, (*orig)+1);
+		orig++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_datetime_default)
+{
+	int ret;
+	char *ptr, **orig, err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	pyfcgi_logger_fmt_field_t field;
+	char *vals[] = {"datetime}", "datetime::}", "datetime:}", NULL};
+
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	orig = vals;
+	while(*orig)
+	{
+		ptr = *orig;
+
+		ret = pyfcgi_logger_parse_field((const char**)&ptr,
+		                                (const char*)ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_datetime);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, 10);
+		ck_assert_ptr_eq(field.val, strftime);
+		ck_assert_str_eq(field.args.datetime.format,
+		                 PYFCGI_LOGGER_TIME_FMT_DEFAULT);
+		ck_assert_ptr_eq(field.buf_ptr, NULL);
+		orig++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_sz)
+{
+	int ret, *res;
+	size_t val;
+	char *ptr, **orig;
+	char *vals[] = {"42:%F}", "1337:}", "0}", NULL};
+	int _res[] = {42,1337,0};
+
+	orig = vals;
+	res = _res;
+	while(*orig)
+	{
+		ptr = *orig;
+
+		ret = pyfcgi_logger_parse_field_sz((const char**)&ptr, &val);
+		ck_assert_int_eq(val, *res);
+		ck_assert_ptr_eq(ptr, (*orig)+snprintf(NULL, 0, "%d", *res));
+		orig++;
+		res++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_Tdatetime)
+{
+	int ret, *len;
+	char *ptr, **orig, **fmt, err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	pyfcgi_logger_fmt_field_t field;
+	char *vals[] = {"datetime:42}", "datetime::%s%F}",
+	                "datetime:42:COUCOU}", NULL};
+	int _len[] = {42, 10, 42};
+	char *_fmt[] = {PYFCGI_LOGGER_TIME_FMT_DEFAULT, "%s%F", "COUCOU"};
+
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+	
+	len = _len;
+	fmt = _fmt;
+	orig = vals;
+	while(*orig)
+	{
+		ptr = *orig;
+
+dprintf(2, "ORIG='%s'\n", *orig);
+		ret = pyfcgi_logger_parse_field((const char**)&ptr,
+		                                (const char*)ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_datetime);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, *len);
+		ck_assert_ptr_eq(field.val, strftime);
+		ck_assert_str_eq(field.args.datetime.format, *fmt);
+		ck_assert_ptr_eq(field.buf_ptr, NULL);
+		orig++;
+		len++;
+		fmt++;
+	}
 }
 END_TEST
 
 
 	tc_init = tcase_create("Initialisation");
 	tcase_add_test(tc_init, test_logger_init);
-	tcase_add_test(tc_init, test_logger_format_add);
+	//tcase_add_test(tc_init, test_logger_format_add);
 	suite_add_tcase(s, tc_init);
 
 	tc_fmt_default = tcase_create("Logger format default values");
 	tcase_add_test(tc_fmt_default, test_logger_parse_field_dtfmt_default);
+	tcase_add_test(tc_fmt_default, test_logger_parse_field_sz_default);
+	tcase_add_test(tc_fmt_default, test_logger_parse_field_datetime_default);
 	suite_add_tcase(s, tc_fmt_default);
 
-	//tc_fmt = tcase_create("Logger format");
-	//suite_add_tcase(s, tc_fmt);
+	tc_fmt = tcase_create("Logger format");
+	tcase_add_test(tc_fmt_default, test_logger_parse_field_sz);
+	tcase_add_test(tc_fmt_default, test_logger_parse_field_Tdatetime);
+	suite_add_tcase(s, tc_fmt);
 
 	return s;
 }