| /* |
| * |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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" |
| #include "usctest.h" |
| |
| #define FAILED 0 |
| #define PASSED 1 |
| |
| |
| char *TCID = "string01"; |
| |
| int local_flag = PASSED; |
| int block_number; |
| int errno; |
| FILE *temp; |
| int TST_TOTAL = 1; |
| extern int Tst_count; |
| /***** ** ** *****/ |
| |
| #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', (char *) NULL }, |
| { tiat, 'a', tiat+8 }, |
| { tiat, 's', tiat+3 }, |
| { tiat, 'o', tiat+15 }, |
| { tiat, 'z', (char *) NULL }, |
| {NULL,0,NULL} |
| }; |
| |
| /* Rindex (rindex( s, c ) == e_res) */ |
| struct t_rindex { |
| char *s; |
| char c; |
| char *e_res; |
| } t_rindex[] = { |
| { "", 'z', (char *) NULL }, |
| { tiat, 'a', tiat+8 }, |
| { tiat, 's', tiat+37 }, |
| { tiat, 'o', tiat+35 }, |
| { tiat, 'z', (char *) 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; |
| } t_ncmp[] = { |
| { "", "", 0, 0 }, |
| { "", "", 80, 0 }, |
| { tiat, "", 0, 0 }, |
| { "", tiat, 80, -((int) 'T') }, |
| { tiat, "", 80, 'T' }, |
| { tiat, tiat, 80, 0 }, |
| { yat, tiat, 80, 'y'-'a' }, |
| { yat, tiat, 8, 0 }, |
| { yat, tiat, 9, 'y'-'a' }, |
| {NULL,NULL,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() |
| { |
| temp = stderr; |
| } |
| |
| |
| int blenter() |
| { |
| local_flag = PASSED; |
| return(0); |
| } |
| |
| |
| int blexit() |
| { |
| (local_flag == PASSED ) ? tst_resm(TPASS, "Test passed\n") : tst_resm(TFAIL, "Test failed\n"); |
| return(0); |
| } |
| |
| int anyfail() |
| { |
| tst_exit(); |
| return(0); |
| } |
| |
| /***** ** ** *****/ |
| |
| |
| |
| |
| |
| |
| /*--------------------------------------------------------------*/ |
| |
| int main (argc, argv) |
| 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) { |
| 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(); |
| return(0); |
| } |