testsuite.c

samba服务器！

{
	/* FIXME */
	return true;
}

static int test_getpass(void)
{
	/* FIXME */
	return true;
}

static int test_inet_ntoa(void)
{
	/* FIXME */
	return true;
}

#define TEST_STRTO_X(type,fmt,func,str,base,res,diff,rrnoo) do {\
	type _v; \
	char _s[64]; \
	char *_p = NULL;\
	char *_ep = NULL; \
	strlcpy(_s, str, sizeof(_s));\
	if (diff >= 0) { \
		_ep = &_s[diff]; \
	} \
	errno = 0; \
	_v = func(_s, &_p, base); \
	if (errno != rrnoo) { \
		printf("failure: %s [\n" \
		       "\t%s\n" \
		       "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
		       "\terrno: %d != %d\n" \
		       "]\n", \
		        __STRING(func), __location__, __STRING(func), \
		       str, diff, base, res, _v, rrnoo, errno); \
		return false; \
	} else if (_v != res) { \
		printf("failure: %s [\n" \
		       "\t%s\n" \
		       "\t%s(\"%s\",%d,%d): " fmt " != " fmt "\n" \
		       "]\n", \
		       __STRING(func), __location__, __STRING(func), \
		       str, diff, base, res, _v); \
		return false; \
	} else if (_p != _ep) { \
		printf("failure: %s [\n" \
		       "\t%s\n" \
		       "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
		       "\tptr: %p - %p = %d != %d\n" \
		       "]\n", \
		       __STRING(func), __location__, __STRING(func), \
		       str, diff, base, res, _v, _ep, _p, (int)(diff - (_ep - _p)), diff); \
		return false; \
	} \
} while (0)

static int test_strtoll(void)
{
	printf("test: strtoll\n");

#define TEST_STRTOLL(str,base,res,diff,errnoo) TEST_STRTO_X(int64_t, "%lld", strtoll,str,base,res,diff,errnoo)

	TEST_STRTOLL("15",	10,	15LL,	2, 0);
	TEST_STRTOLL("  15",	10,	15LL,	4, 0);
	TEST_STRTOLL("15",	0,	15LL,	2, 0);
	TEST_STRTOLL(" 15 ",	0,	15LL,	3, 0);
	TEST_STRTOLL("+15",	10,	15LL,	3, 0);
	TEST_STRTOLL("  +15",	10,	15LL,	5, 0);
	TEST_STRTOLL("+15",	0,	15LL,	3, 0);
	TEST_STRTOLL(" +15 ",	0,	15LL,	4, 0);
	TEST_STRTOLL("-15",	10,	-15LL,	3, 0);
	TEST_STRTOLL("  -15",	10,	-15LL,	5, 0);
	TEST_STRTOLL("-15",	0,	-15LL,	3, 0);
	TEST_STRTOLL(" -15 ",	0,	-15LL,	4, 0);
	TEST_STRTOLL("015",	10,	15LL,	3, 0);
	TEST_STRTOLL("  015",	10,	15LL,	5, 0);
	TEST_STRTOLL("015",	0,	13LL,	3, 0);
	TEST_STRTOLL("  015",	0,	13LL,	5, 0);
	TEST_STRTOLL("0x15",	10,	0LL,	1, 0);
	TEST_STRTOLL("  0x15",	10,	0LL,	3, 0);
	TEST_STRTOLL("0x15",	0,	21LL,	4, 0);
	TEST_STRTOLL("  0x15",	0,	21LL,	6, 0);

	TEST_STRTOLL("10",	16,	16LL,	2, 0);
	TEST_STRTOLL("  10 ",	16,	16LL,	4, 0);
	TEST_STRTOLL("0x10",	16,	16LL,	4, 0);
	TEST_STRTOLL("0x10",	0,	16LL,	4, 0);
	TEST_STRTOLL(" 0x10 ",	0,	16LL,	5, 0);
	TEST_STRTOLL("+10",	16,	16LL,	3, 0);
	TEST_STRTOLL("  +10 ",	16,	16LL,	5, 0);
	TEST_STRTOLL("+0x10",	16,	16LL,	5, 0);
	TEST_STRTOLL("+0x10",	0,	16LL,	5, 0);
	TEST_STRTOLL(" +0x10 ",	0,	16LL,	6, 0);
	TEST_STRTOLL("-10",	16,	-16LL,	3, 0);
	TEST_STRTOLL("  -10 ",	16,	-16LL,	5, 0);
	TEST_STRTOLL("-0x10",	16,	-16LL,	5, 0);
	TEST_STRTOLL("-0x10",	0,	-16LL,	5, 0);
	TEST_STRTOLL(" -0x10 ",	0,	-16LL,	6, 0);
	TEST_STRTOLL("010",	16,	16LL,	3, 0);
	TEST_STRTOLL("  010 ",	16,	16LL,	5, 0);
	TEST_STRTOLL("-010",	16,	-16LL,	4, 0);

	TEST_STRTOLL("11",	8,	9LL,	2, 0);
	TEST_STRTOLL("011",	8,	9LL,	3, 0);
	TEST_STRTOLL("011",	0,	9LL,	3, 0);
	TEST_STRTOLL("-11",	8,	-9LL,	3, 0);
	TEST_STRTOLL("-011",	8,	-9LL,	4, 0);
	TEST_STRTOLL("-011",	0,	-9LL,	4, 0);

	TEST_STRTOLL("011",	8,	9LL,	3, 0);
	TEST_STRTOLL("011",	0,	9LL,	3, 0);
	TEST_STRTOLL("-11",	8,	-9LL,	3, 0);
	TEST_STRTOLL("-011",	8,	-9LL,	4, 0);
	TEST_STRTOLL("-011",	0,	-9LL,	4, 0);

	TEST_STRTOLL("Text",	0,	0LL,	0, 0);

	TEST_STRTOLL("9223372036854775807",	10,	9223372036854775807LL,	19, 0);
	TEST_STRTOLL("9223372036854775807",	0,	9223372036854775807LL,	19, 0);
	TEST_STRTOLL("9223372036854775808",	0,	9223372036854775807LL,	19, ERANGE);
	TEST_STRTOLL("9223372036854775808",	10,	9223372036854775807LL,	19, ERANGE);
	TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",	0,	9223372036854775807LL,	18, 0);
	TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",	16,	9223372036854775807LL,	18, 0);
	TEST_STRTOLL("7FFFFFFFFFFFFFFF",	16,	9223372036854775807LL,	16, 0);
	TEST_STRTOLL("0x8000000000000000",	0,	9223372036854775807LL,	18, ERANGE);
	TEST_STRTOLL("0x8000000000000000",	16,	9223372036854775807LL,	18, ERANGE);
	TEST_STRTOLL("80000000000000000",	16,	9223372036854775807LL,	17, ERANGE);
	TEST_STRTOLL("0777777777777777777777",	0,	9223372036854775807LL,	22, 0);
	TEST_STRTOLL("0777777777777777777777",	8,	9223372036854775807LL,	22, 0);
	TEST_STRTOLL("777777777777777777777",	8,	9223372036854775807LL,	21, 0);
	TEST_STRTOLL("01000000000000000000000",	0,	9223372036854775807LL,	23, ERANGE);
	TEST_STRTOLL("01000000000000000000000",	8,	9223372036854775807LL,	23, ERANGE);
	TEST_STRTOLL("1000000000000000000000",	8,	9223372036854775807LL,	22, ERANGE);

	TEST_STRTOLL("-9223372036854775808",	10,	-9223372036854775807LL -1,	20, 0);
	TEST_STRTOLL("-9223372036854775808",	0,	-9223372036854775807LL -1,	20, 0);
	TEST_STRTOLL("-9223372036854775809",	0,	-9223372036854775807LL -1,	20, ERANGE);
	TEST_STRTOLL("-9223372036854775809",	10,	-9223372036854775807LL -1,	20, ERANGE);
	TEST_STRTOLL("-0x8000000000000000",	0,	-9223372036854775807LL -1,	19, 0);
	TEST_STRTOLL("-0x8000000000000000",	16,	-9223372036854775807LL -1,	19, 0);
	TEST_STRTOLL("-8000000000000000",	16,	-9223372036854775807LL -1,	17, 0);
	TEST_STRTOLL("-0x8000000000000001",	0,	-9223372036854775807LL -1,	19, ERANGE);
	TEST_STRTOLL("-0x8000000000000001",	16,	-9223372036854775807LL -1,	19, ERANGE);
	TEST_STRTOLL("-80000000000000001",	16,	-9223372036854775807LL -1,	18, ERANGE);
	TEST_STRTOLL("-01000000000000000000000",0,	-9223372036854775807LL -1,	24, 0);
	TEST_STRTOLL("-01000000000000000000000",8,	-9223372036854775807LL -1,	24, 0);
	TEST_STRTOLL("-1000000000000000000000",	8,	-9223372036854775807LL -1,	23, 0);
	TEST_STRTOLL("-01000000000000000000001",0,	-9223372036854775807LL -1,	24, ERANGE);
	TEST_STRTOLL("-01000000000000000000001",8,	-9223372036854775807LL -1,	24, ERANGE);
	TEST_STRTOLL("-1000000000000000000001",	8,	-9223372036854775807LL -1,	23, ERANGE);

	printf("success: strtoll\n");
	return true;
}

static int test_strtoull(void)
{
	printf("test: strtoull\n");

#define TEST_STRTOULL(str,base,res,diff,errnoo) TEST_STRTO_X(uint64_t,"%llu",strtoull,str,base,res,diff,errnoo)

	TEST_STRTOULL("15",	10,	15LLU,	2, 0);
	TEST_STRTOULL("  15",	10,	15LLU,	4, 0);
	TEST_STRTOULL("15",	0,	15LLU,	2, 0);
	TEST_STRTOULL(" 15 ",	0,	15LLU,	3, 0);
	TEST_STRTOULL("+15",	10,	15LLU,	3, 0);
	TEST_STRTOULL("  +15",	10,	15LLU,	5, 0);
	TEST_STRTOULL("+15",	0,	15LLU,	3, 0);
	TEST_STRTOULL(" +15 ",	0,	15LLU,	4, 0);
	TEST_STRTOULL("-15",	10,	18446744073709551601LLU,	3, 0);
	TEST_STRTOULL("  -15",	10,	18446744073709551601LLU,	5, 0);
	TEST_STRTOULL("-15",	0,	18446744073709551601LLU,	3, 0);
	TEST_STRTOULL(" -15 ",	0,	18446744073709551601LLU,	4, 0);
	TEST_STRTOULL("015",	10,	15LLU,	3, 0);
	TEST_STRTOULL("  015",	10,	15LLU,	5, 0);
	TEST_STRTOULL("015",	0,	13LLU,	3, 0);
	TEST_STRTOULL("  015",	0,	13LLU,	5, 0);
	TEST_STRTOULL("0x15",	10,	0LLU,	1, 0);
	TEST_STRTOULL("  0x15",	10,	0LLU,	3, 0);
	TEST_STRTOULL("0x15",	0,	21LLU,	4, 0);
	TEST_STRTOULL("  0x15",	0,	21LLU,	6, 0);

	TEST_STRTOULL("10",	16,	16LLU,	2, 0);
	TEST_STRTOULL("  10 ",	16,	16LLU,	4, 0);
	TEST_STRTOULL("0x10",	16,	16LLU,	4, 0);
	TEST_STRTOULL("0x10",	0,	16LLU,	4, 0);
	TEST_STRTOULL(" 0x10 ",	0,	16LLU,	5, 0);
	TEST_STRTOULL("+10",	16,	16LLU,	3, 0);
	TEST_STRTOULL("  +10 ",	16,	16LLU,	5, 0);
	TEST_STRTOULL("+0x10",	16,	16LLU,	5, 0);
	TEST_STRTOULL("+0x10",	0,	16LLU,	5, 0);
	TEST_STRTOULL(" +0x10 ",	0,	16LLU,	6, 0);
	TEST_STRTOULL("-10",	16,	-16LLU,	3, 0);
	TEST_STRTOULL("  -10 ",	16,	-16LLU,	5, 0);
	TEST_STRTOULL("-0x10",	16,	-16LLU,	5, 0);
	TEST_STRTOULL("-0x10",	0,	-16LLU,	5, 0);
	TEST_STRTOULL(" -0x10 ",	0,	-16LLU,	6, 0);
	TEST_STRTOULL("010",	16,	16LLU,	3, 0);
	TEST_STRTOULL("  010 ",	16,	16LLU,	5, 0);
	TEST_STRTOULL("-010",	16,	-16LLU,	4, 0);

	TEST_STRTOULL("11",	8,	9LLU,	2, 0);
	TEST_STRTOULL("011",	8,	9LLU,	3, 0);
	TEST_STRTOULL("011",	0,	9LLU,	3, 0);
	TEST_STRTOULL("-11",	8,	-9LLU,	3, 0);
	TEST_STRTOULL("-011",	8,	-9LLU,	4, 0);
	TEST_STRTOULL("-011",	0,	-9LLU,	4, 0);

	TEST_STRTOULL("011",	8,	9LLU,	3, 0);
	TEST_STRTOULL("011",	0,	9LLU,	3, 0);
	TEST_STRTOULL("-11",	8,	-9LLU,	3, 0);
	TEST_STRTOULL("-011",	8,	-9LLU,	4, 0);
	TEST_STRTOULL("-011",	0,	-9LLU,	4, 0);

	TEST_STRTOULL("Text",	0,	0LLU,	0, 0);

	TEST_STRTOULL("9223372036854775807",	10,	9223372036854775807LLU,	19, 0);
	TEST_STRTOULL("9223372036854775807",	0,	9223372036854775807LLU,	19, 0);
	TEST_STRTOULL("9223372036854775808",	0,	9223372036854775808LLU,	19, 0);
	TEST_STRTOULL("9223372036854775808",	10,	9223372036854775808LLU,	19, 0);
	TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",	0,	9223372036854775807LLU,	18, 0);
	TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",	16,	9223372036854775807LLU,	18, 0);
	TEST_STRTOULL("7FFFFFFFFFFFFFFF",	16,	9223372036854775807LLU,	16, 0);
	TEST_STRTOULL("0x8000000000000000",	0,	9223372036854775808LLU,	18, 0);
	TEST_STRTOULL("0x8000000000000000",	16,	9223372036854775808LLU,	18, 0);
	TEST_STRTOULL("8000000000000000",	16,	9223372036854775808LLU,	16, 0);
	TEST_STRTOULL("0777777777777777777777",	0,	9223372036854775807LLU,	22, 0);
	TEST_STRTOULL("0777777777777777777777",	8,	9223372036854775807LLU,	22, 0);
	TEST_STRTOULL("777777777777777777777",	8,	9223372036854775807LLU,	21, 0);
	TEST_STRTOULL("01000000000000000000000",0,	9223372036854775808LLU,	23, 0);
	TEST_STRTOULL("01000000000000000000000",8,	9223372036854775808LLU,	23, 0);
	TEST_STRTOULL("1000000000000000000000",	8,	9223372036854775808LLU,	22, 0);

	TEST_STRTOULL("-9223372036854775808",	10,	9223372036854775808LLU,	20, 0);
	TEST_STRTOULL("-9223372036854775808",	0,	9223372036854775808LLU,	20, 0);
	TEST_STRTOULL("-9223372036854775809",	0,	9223372036854775807LLU,	20, 0);
	TEST_STRTOULL("-9223372036854775809",	10,	9223372036854775807LLU,	20, 0);
	TEST_STRTOULL("-0x8000000000000000",	0,	9223372036854775808LLU,	19, 0);
	TEST_STRTOULL("-0x8000000000000000",	16,	9223372036854775808LLU,	19, 0);
	TEST_STRTOULL("-8000000000000000",	16,	9223372036854775808LLU,	17, 0);
	TEST_STRTOULL("-0x8000000000000001",	0,	9223372036854775807LLU,	19, 0);
	TEST_STRTOULL("-0x8000000000000001",	16,	9223372036854775807LLU,	19, 0);
	TEST_STRTOULL("-8000000000000001",	16,	9223372036854775807LLU,	17, 0);
	TEST_STRTOULL("-01000000000000000000000",0,	9223372036854775808LLU,	24, 0);
	TEST_STRTOULL("-01000000000000000000000",8,	9223372036854775808LLU,	24, 0);
	TEST_STRTOULL("-1000000000000000000000",8,	9223372036854775808LLU,	23, 0);
	TEST_STRTOULL("-01000000000000000000001",0,	9223372036854775807LLU,	24, 0);
	TEST_STRTOULL("-01000000000000000000001",8,	9223372036854775807LLU,	24, 0);
	TEST_STRTOULL("-1000000000000000000001",8,	9223372036854775807LLU,	23, 0);

	TEST_STRTOULL("18446744073709551615",	0,	18446744073709551615LLU,	20, 0);
	TEST_STRTOULL("18446744073709551615",	10,	18446744073709551615LLU,	20, 0);
	TEST_STRTOULL("18446744073709551616",	0,	18446744073709551615LLU,	20, ERANGE);
	TEST_STRTOULL("18446744073709551616",	10,	18446744073709551615LLU,	20, ERANGE);
	TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",	0,	18446744073709551615LLU,	18, 0);
	TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",	16,	18446744073709551615LLU,	18, 0);
	TEST_STRTOULL("FFFFFFFFFFFFFFFF",	16,	18446744073709551615LLU,	16, 0);
	TEST_STRTOULL("0x10000000000000000",	0,	18446744073709551615LLU,	19, ERANGE);
	TEST_STRTOULL("0x10000000000000000",	16,	18446744073709551615LLU,	19, ERANGE);
	TEST_STRTOULL("10000000000000000",	16,	18446744073709551615LLU,	17, ERANGE);
	TEST_STRTOULL("01777777777777777777777",0,	18446744073709551615LLU,	23, 0);
	TEST_STRTOULL("01777777777777777777777",8,	18446744073709551615LLU,	23, 0);
	TEST_STRTOULL("1777777777777777777777",	8,	18446744073709551615LLU,	22, 0);
	TEST_STRTOULL("02000000000000000000000",0,	18446744073709551615LLU,	23, ERANGE);
	TEST_STRTOULL("02000000000000000000000",8,	18446744073709551615LLU,	23, ERANGE);
	TEST_STRTOULL("2000000000000000000000",	8,	18446744073709551615LLU,	22, ERANGE);

	TEST_STRTOULL("-18446744073709551615",	0,	1LLU,				21, 0);
	TEST_STRTOULL("-18446744073709551615",	10,	1LLU,				21, 0);
	TEST_STRTOULL("-18446744073709551616",	0,	18446744073709551615LLU,	21, ERANGE);
	TEST_STRTOULL("-18446744073709551616",	10,	18446744073709551615LLU,	21, ERANGE);
	TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",	0,	1LLU,				19, 0);
	TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",	16,	1LLU,				19, 0);
	TEST_STRTOULL("-FFFFFFFFFFFFFFFF",	16,	1LLU,				17, 0);
	TEST_STRTOULL("-0x10000000000000000",	0,	18446744073709551615LLU,	20, ERANGE);
	TEST_STRTOULL("-0x10000000000000000",	16,	18446744073709551615LLU,	20, ERANGE);
	TEST_STRTOULL("-10000000000000000",	16,	18446744073709551615LLU,	18, ERANGE);
	TEST_STRTOULL("-01777777777777777777777",0,	1LLU,				24, 0);
	TEST_STRTOULL("-01777777777777777777777",8,	1LLU,				24, 0);
	TEST_STRTOULL("-1777777777777777777777",8,	1LLU,				23, 0);
	TEST_STRTOULL("-02000000000000000000000",0,	18446744073709551615LLU,	24, ERANGE);
	TEST_STRTOULL("-02000000000000000000000",8,	18446744073709551615LLU,	24, ERANGE);
	TEST_STRTOULL("-2000000000000000000000",8,	18446744073709551615LLU,	23, ERANGE);

	printf("success: strtuoll\n");
	return true;
}

/* 
FIXME:
Types:
bool
socklen_t
uint_t
uint{8,16,32,64}_t
int{8,16,32,64}_t
intptr_t

Constants:
PATH_NAME_MAX
UINT{16,32,64}_MAX
INT32_MAX
*/

static int test_va_copy(void)
{
	/* FIXME */
	return true;
}

static int test_FUNCTION(void)
{
	printf("test: FUNCTION\n");
	if (strcmp(__FUNCTION__, "test_FUNCTION") != 0) {
		printf("failure: FAILURE [\nFAILURE invalid\n]\n");
		return false;
	}
	printf("success: FUNCTION\n");
	return true;
}

static int test_MIN(void)
{
	printf("test: MIN\n");
	if (MIN(20, 1) != 1) {
		printf("failure: MIN [\nMIN invalid\n]\n");
		return false;
	}
	if (MIN(1, 20) != 1) {
		printf("failure: MIN [\nMIN invalid\n]\n");
		return false;
	}
	printf("success: MIN\n");
	return true;
}

static int test_MAX(void)
{
	printf("test: MAX\n");
	if (MAX(20, 1) != 20) {
		printf("failure: MAX [\nMAX invalid\n]\n");
		return false;
	}
	if (MAX(1, 20) != 20) {
		printf("failure: MAX [\nMAX invalid\n]\n");
		return false;
	}
	printf("success: MAX\n");
	return true;
}

static int test_socketpair(void)
{
	int sock[2];
	char buf[20];

	printf("test: socketpair\n");

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock) == -1) {
		printf("failure: socketpair [\n"
			   "socketpair() failed\n"
			   "]\n");
		return false;
	}

	if (write(sock[1], "automatisch", 12) == -1) {
		printf("failure: socketpair [\n"
			   "write() failed: %s\n"
			   "]\n", strerror(errno));
		return false;
	}

	if (read(sock[0], buf, 12) == -1) {
		printf("failure: socketpair [\n"
			   "read() failed: %s\n"
			   "]\n", strerror(errno));
		return false;
	}

	if (strcmp(buf, "automatisch") != 0) {
		printf("failure: socketpair [\n"
			   "expected: automatisch, got: %s\n"
			   "]\n", buf);
		return false;
	}

	printf("success: socketpair\n");

	return true;
}

extern int libreplace_test_strptime(void);

static int test_strptime(void)
{
	return libreplace_test_strptime();
}

struct torture_context;
bool torture_local_replace(struct torture_context *ctx)
{
	bool ret = true;
	ret &= test_ftruncate();
	ret &= test_strlcpy();
	ret &= test_strlcat();
	ret &= test_mktime();
	ret &= test_initgroups();
	ret &= test_memmove();
	ret &= test_strdup();
	ret &= test_setlinebuf();
	ret &= test_vsyslog();
	ret &= test_timegm();
	ret &= test_setenv();
	ret &= test_strndup();
	ret &= test_strnlen();
	ret &= test_waitpid();
	ret &= test_seteuid();
	ret &= test_setegid();
	ret &= test_asprintf();
	ret &= test_snprintf();
	ret &= test_vasprintf();
	ret &= test_vsnprintf();
	ret &= test_opendir();
	ret &= test_readdir();
	ret &= test_telldir();
	ret &= test_seekdir();
	ret &= test_dlopen();
	ret &= test_chroot();
	ret &= test_bzero();
	ret &= test_strerror();
	ret &= test_errno();
	ret &= test_mkdtemp();
	ret &= test_mkstemp();
	ret &= test_pread();
	ret &= test_pwrite();
	ret &= test_getpass();
	ret &= test_inet_ntoa();
	ret &= test_strtoll();
	ret &= test_strtoull();
	ret &= test_va_copy();
	ret &= test_FUNCTION();
	ret &= test_MIN();
	ret &= test_MAX();
	ret &= test_socketpair();
	ret &= test_strptime();

	return ret;
}

#if _SAMBA_BUILD_<4
int main(void)
{
	bool ret = torture_local_replace(NULL);
	if (ret) 
		return 0;
	return -1;
}
#endif