testcases/kernel/syscalls/string/string01.c

/*
 *
 *   Copyright (c) International Business Machines  Corp., 2002
 *
 *   This program is free software;  you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program;  if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/* 01/02/2003	Port to LTP avenkat@us.ibm.com */
/* 06/30/2001	Port to Linux	nsharoff@us.ibm.com */

/*
 * NAME
 *	string01.c -  check string functions.
 *
 * CALLS
 *	strchr, strrchr, strcat, strcmp, strcpy, strlen,
 *	  strncat, strncmp, strncpy
 *
 * ALGORITHM
 *	Test functionality of the string functions:
 *		(strchr, strrchr, strcat, strcmp, strcpy, strlen,
 *		 strncat, strncmp, strncpy )
 *
 */

#include <stdio.h>
#include <sys/types.h>
#include <string.h>

/*****	LTP Port	*****/
#include <errno.h>
#include <stdlib.h>
#include "test.h"

#define FAILED 0
#define PASSED 1

char *TCID = "string01";

int local_flag = PASSED;
int block_number;
FILE *temp;
int TST_TOTAL = 1;
/*****	**	** *****/

#define LONGSTR	(96*1024-1)
/* #define LONGSTR	(1024-1)		*/

/*
 *	Miscellaneous data strings for testing.
 */

char tiat[] = "This is a test of the string functions.  ";
char yat[] = "This is yet another test.";
char tiatyat[] =
    "This is a test of the string functions.  This is yet another test.";

char longstr[LONGSTR + 1];	/* a very long string */
char dst0[LONGSTR + 1];		/* place holders for various tests */
char dst1[LONGSTR + 1];
char dst2[LONGSTR + 1];

/*
 *	Data structures for testing.
 */

/*	Strlen	(strlen( s ) == e_res)		*/
struct t_strlen {
	char *s;
	int e_res;
} t_len[] = {
	{
	"", 0}, {
	"12345", 5}, {
	tiat, 41}, {
	longstr, LONGSTR}, {
	NULL, 0}
};

/*	Index	(index( s, c ) == e_res)		*/
struct t_index {
	char *s;
	char c;
	char *e_res;
} t_index[] = {
	{
	"", 'z', NULL}, {
	tiat, 'a', tiat + 8}, {
	tiat, 's', tiat + 3}, {
	tiat, 'o', tiat + 15}, {
	tiat, 'z', NULL}, {
	NULL, 0, NULL}
};

/*	Rindex	(rindex( s, c ) == e_res)		*/
struct t_rindex {
	char *s;
	char c;
	char *e_res;
} t_rindex[] = {
	{
	"", 'z', NULL}, {
	tiat, 'a', tiat + 8}, {
	tiat, 's', tiat + 37}, {
	tiat, 'o', tiat + 35}, {
	tiat, 'z', NULL}, {
	NULL, 0, NULL}
};

/*	Strcmp	(strcmp( s1, s2 ) == e_res)		*/
struct t_strcmp {
	char *s1;
	char *s2;
	int e_res;
} t_cmp[] = {
	{
	"", "", 0}, {
	"", tiat, -((int)'T')}, {
	tiat, "", 'T'}, {
	tiat, tiat, 0}, {
	yat, tiat, 'y' - 'a'}, {
	NULL, NULL, 0}
};

/*	Strcat	(strcmp( strcat(s1, s2),  s1s2 ) == e_res)		*/
/*	ASSUMES strcmp is working -- it is tested prior to strcat	*/
struct t_strcat {
	char *s1;
	char *s2;
	char *s1s2;
	int e_res;
} t_cat[] = {
	{
	dst0, "", "", 0}, {
	dst0, tiat, tiat, 0}, {
	dst0, "", tiat, 0}, {
	dst0, yat, tiatyat, 0}, {
	dst1, longstr, longstr, 0}, {
	NULL, NULL, NULL, 0}
};

/*	Strcpy	(strcmp( strcpy(s1, s2),  s1s2 ) == e_res)		*/
/*	ASSUMES strcmp is working -- it is tested prior to strcpy	*/
/*	No overlapping copies are tested				*/
struct t_strcpy {
	char *s1;
	char *s2;
	int e_res;
} t_cpy[] = {
	{
	dst0, "", 0}, {
	dst0, tiat, 0}, {
	dst0, longstr, 0}, {
	NULL, NULL, 0}
};

/*	Strncmp	(strncmp( s1, s2 ) == e_res)		*/
struct t_strncmp {
	char *s1;
	char *s2;
	int n;
	int e_res;
	int a_res;		/* Allowable results, some platforms only return 1 or -1 */
} t_ncmp[] = {
	{
	"", "", 0, 0, 0}, {
	"", "", 80, 0, 0}, {
	tiat, "", 0, 0, 0}, {
	"", tiat, 80, -((int)'T'), -1}, {
	tiat, "", 80, 'T', 1}, {
	tiat, tiat, 80, 0, 0}, {
	yat, tiat, 80, 'y' - 'a', 1}, {
	yat, tiat, 8, 0, 1}, {
	yat, tiat, 9, 'y' - 'a', 1}, {
	NULL, NULL, 0, 0, 0}

};

/*	Strncat	(strcmp( strncat(s1, s2, n),  s1ns2 ) == e_res)	*/
/*	ASSUMES strcmp is working -- it is tested prior to strncat	*/
/*	dest is guaranteed to be all '\0' s at start of test		*/
struct t_strncat {
	char *s1;
	char *s2;
	int n;
	char *s1ns2;
	int e_res;
} t_ncat[] = {
	/*      Regular strcat stuff -- i.e., n is large enough         */
	{
	dst0, "", LONGSTR, "", 0}, {
	dst0, tiat, LONGSTR, tiat, 0}, {
	dst0, "", LONGSTR, tiat, 0}, {
	dst0, yat, LONGSTR, tiatyat, 0}, {
	dst1, longstr, LONGSTR, longstr, 0},
	    /*      Restricted strcat stuff                                 */
	{
	dst2, longstr, 0, "", 0}, {
	dst2, longstr, 1, "t", 0}, {
	dst2, longstr, LONGSTR - 1, longstr, 0}, {
	NULL, NULL, 0, NULL, 0}

};

/*	Strncpy	(strcmp( strncpy(s1, s2),  s1n ) == e_res)		*/
/*	ASSUMES strcmp is working -- it is tested prior to strncpy	*/
/*	No overlapping copies are tested				*/
struct t_strncpy {
	char *s1;
	char *s2;
	int n;
	char *s1n;
	int e_res;
} t_ncpy[] = {
	/*      Regular strcpy stuff -- i.e., n is large enough         */
	{
	dst0, "", LONGSTR, "", 0}, {
	dst0, tiat, LONGSTR, tiat, 0}, {
	dst0, longstr, LONGSTR, longstr, 0},
	    /*      Restricted strcpy stuff                                 */
	{
	dst1, tiat, 0, "", 0}, {
	dst1, longstr, 5, "ttttt", 0}, {
	NULL, NULL, 0, NULL, 0}
};

/*****	LTP Port	*****/
void setup();
int blenter();
int blexit();
int anyfail();

void setup(void)
{
	temp = stderr;
}

int blenter(void)
{
	local_flag = PASSED;
	return 0;
}

int blexit(void)
{
	(local_flag == PASSED) ? tst_resm(TPASS,
					  "Test passed") : tst_resm(TFAIL,
								    "Test failed");
	return 0;
}

int anyfail(void)
{
	tst_exit();
}

/*****	**	**	*****/

/*--------------------------------------------------------------*/

int main(int argc, char *argv[])
{
	register int n, i;
	char *s, *pr;

	/*
	 * Init longstr
	 */

	s = longstr;
	n = LONGSTR;
	while (n--)
		*s++ = 't';
	*s = '\0';

	setup();
/*--------------------------------------------------------------*/

	/*
	 * Index
	 */
	//fprintf(temp, "\tStrchr\n" );
	i = 0;
	while (t_index[i].s) {
		if ((pr =
		     strchr(t_index[i].s, t_index[i].c)) != t_index[i].e_res) {
			fprintf(temp, "(Strchr) test %d", i);
			local_flag = FAILED;
		}
		i++;
	}
	/*
	 * Strrchr
	 */
	//fprintf(temp, "\tStrrchr\n" );
	i = 0;
	while (t_rindex[i].s) {
		if ((pr = strrchr(t_rindex[i].s, t_rindex[i].c))
		    != t_rindex[i].e_res) {
			fprintf(temp, "(Strrchr) test %d", i);
			local_flag = FAILED;
		}
		i++;
	}
	/*
	 * Strlen
	 */
	//fprintf(temp, "\tStrlen\n" );
	i = 0;
	while (t_len[i].s) {
		if ((n = strlen(t_len[i].s)) != t_len[i].e_res) {
			fprintf(temp, "(Strlen) test %d: expected %d, got %d",
				i, t_len[i].e_res, n);
			local_flag = FAILED;
		}
		i++;
	}

	/*
	 * Strcmp
	 */
	//fprintf(temp, "\tStrcmp\n" );
	i = 0;
#define sign(x) ((x) < 0 ? -1 : ((x) > 0 ? 1 : 0))
	while (t_cmp[i].s1) {
		n = strcmp(t_cmp[i].s1, t_cmp[i].s2);
		if (sign(n) != sign(t_cmp[i].e_res)) {
			fprintf(temp, "(Strcmp) test %d: expected %d, got %d",
				i, sign(t_cmp[i].e_res), sign(n));
			local_flag = FAILED;
		}
		i++;
	}

	/*
	 * Strcat
	 */
	//fprintf(temp, "\tStrcat\n" );
	memset(dst0, 0, LONGSTR + 1);	/* clean slate */
	memset(dst1, 0, LONGSTR + 1);	/* clean slate */
	i = 0;
	while (t_cat[i].s1) {
		if ((n =
		     strcmp(strcat(t_cat[i].s1, t_cat[i].s2), t_cat[i].s1s2))
		    != t_cat[i].e_res) {
			fprintf(temp, "(Strcat) test %d: expected %d, got %d",
				i, t_cat[i].e_res, n);
			local_flag = FAILED;
		}
		i++;
	}

	/*
	 * Strcpy
	 */
	//fprintf(temp, "\tStrcpy\n" );
	i = 0;
	while (t_cpy[i].s1) {
		if ((n = strcmp(strcpy(t_cpy[i].s1, t_cpy[i].s2), t_cpy[i].s2))
		    != t_cpy[i].e_res) {
			fprintf(temp, "(Strcpy) test %d: expected %d, got %d",
				i, t_cpy[i].e_res, n);
			local_flag = FAILED;
		}
		i++;
	}

	/*
	 * Strncat
	 */
	//fprintf(temp, "\tStrncat\n" );
	memset(dst0, 0, LONGSTR + 1);	/* clean slate */
	memset(dst1, 0, LONGSTR + 1);	/* clean slate */
	memset(dst2, 0, LONGSTR + 1);	/* clean slate */
	i = 0;
	while (t_ncat[i].s1) {
		if ((n =
		     strcmp(strncat(t_ncat[i].s1, t_ncat[i].s2, t_ncat[i].n),
			    t_ncat[i].s1ns2)) != t_ncat[i].e_res) {
			fprintf(temp, "(Strncat) test %d: expected %d, got %d",
				i, t_ncat[i].e_res, n);
			local_flag = FAILED;
		}
		i++;
	}

	/*
	 * Strncmp
	 */
	//fprintf(temp, "\tStrncmp\n" );
	i = 0;
	while (t_ncmp[i].s1) {
		if ((n = strncmp(t_ncmp[i].s1, t_ncmp[i].s2, t_ncmp[i].n))
		    != t_ncmp[i].e_res) {
			if ((t_ncmp[i].a_res < 0 && n > t_ncmp[i].a_res)
			    || (t_ncmp[i].a_res > 0 && n < t_ncmp[i].a_res)) {
				fprintf(temp,
					"(Strncmp) test %d: expected %d, got %d",
					i, t_ncmp[i].e_res, n);
				local_flag = FAILED;
			}
		}
		i++;
	}

	/*
	 * Strncpy
	 */
	//fprintf(temp, "\tStrncpy\n" );
	i = 0;
	memset(dst0, 0, LONGSTR + 1);	/* clean slate */
	memset(dst1, 0, LONGSTR + 1);	/* clean slate */
	while (t_ncpy[i].s1) {
		if ((n =
		     strcmp(strncpy(t_ncpy[i].s1, t_ncpy[i].s2, t_ncpy[i].n),
			    t_ncpy[i].s1n)) != t_ncpy[i].e_res) {
			fprintf(temp, "(Strncpy) test %d: expected %d, got %d",
				i, t_ncpy[i].e_res, n);
			local_flag = FAILED;
		}
		i++;
	}

	blexit();
	anyfail();
	tst_exit();
}