* [PATCH] testcase for builtin expansion of strncmp and strcmp
@ 2017-01-18 1:50 Aaron Sawdey
0 siblings, 0 replies; only message in thread
From: Aaron Sawdey @ 2017-01-18 1:50 UTC (permalink / raw)
To: gcc-patches
Cc: Richard Biener, Kaz Kojima, olegendo, Nick Clifton, Jeff Law,
David Edelsohn, bergner
[-- Attachment #1: Type: text/plain, Size: 713 bytes --]
This patch adds test gcc.dg/strncmp-2.c for builtin expansion of
strncmp and strcmp. This tests a couple more things such as differences
that occur after the zero byte, and something that glibc does which is
to call strncmp with SIZE_MAX for the length which looks for overflow
issues.
I've included interested parties from targets that have a strncmp
builtin.
The test passes on x86_64 and on ppc64le with -mcpu=power6. It will not
pass on ppc64/ppc64le -mcpu=power[78] until I check in my patch that
segher ack'd yesterday and is currently regtesting. OK for trunk?
--
Aaron Sawdey, Ph.D. acsawdey@linux.vnet.ibm.com
050-2/C113 (507) 253-7520 home: 507/263-0782
IBM Linux Technology Center - PPC Toolchain
[-- Attachment #2: strncmp-2-test.patch --]
[-- Type: text/x-patch, Size: 14218 bytes --]
Index: gcc/testsuite/gcc.dg/strncmp-2.c
===================================================================
--- gcc/testsuite/gcc.dg/strncmp-2.c (revision 0)
+++ gcc/testsuite/gcc.dg/strncmp-2.c (working copy)
@@ -0,0 +1,715 @@
+/* Test strcmp/strncmp builtin expansion for compilation and proper execution. */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target ptr32plus } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#define MAX_SZ 200
+
+static void test_driver_strcmp (void (test_func)(const char *, const char *, int), int align)
+{
+ char buf1[2*MAX_SZ+10],buf2[2*MAX_SZ+10];
+ int sz, diff_pos, zero_pos;
+ int e;
+ for(sz = 1; sz < MAX_SZ; sz++)
+ for(diff_pos = ((sz>10)?(sz-10):0); diff_pos < sz+10; diff_pos++)
+ for(zero_pos = ((sz>10)?(sz-10):0); zero_pos < sz+10; zero_pos++)
+ {
+ memset(buf1, 'A', sizeof(buf1));
+ memset(buf2, 'A', sizeof(buf2));
+ buf2[diff_pos] = 'B';
+ buf1[zero_pos] = 0;
+ buf2[zero_pos] = 0;
+ e = -1;
+ if ( zero_pos == 0 || zero_pos <= diff_pos ) e = 0;
+ (*test_func)(buf1,buf2,e);
+ (*test_func)(buf2,buf1,-e);
+ (*test_func)(buf2,buf2,0);
+ /* differing length: */
+ buf2[diff_pos] = 0;
+ (*test_func)(buf1,buf2,-e);
+ memset(buf2+diff_pos,'B',sizeof(buf2)-diff_pos);
+ buf2[zero_pos] = 0;
+ (*test_func)(buf1,buf2,e);
+ (*test_func)(buf2,buf1,-e);
+ }
+}
+
+static void test_driver_strncmp (void (test_func)(const char *, const char *, int), size_t sz, int align)
+{
+ char buf1[MAX_SZ*2+10],buf2[MAX_SZ*2+10];
+ size_t test_sz = (sz<MAX_SZ)?sz:MAX_SZ;
+ size_t diff_pos, zero_pos;
+ int e;
+ for(diff_pos = ((test_sz>10)?(test_sz-10):0);
+ diff_pos < test_sz+10; diff_pos++)
+ for(zero_pos = ((test_sz>10)?(test_sz-10):0);
+ zero_pos < test_sz+10; zero_pos++)
+ {
+ memset(buf1, 'A', 2*test_sz);
+ memset(buf2, 'A', 2*test_sz);
+ buf2[diff_pos] = 'B';
+ buf1[zero_pos] = 0;
+ buf2[zero_pos] = 0;
+ e = -1;
+ if ( diff_pos >= sz ) e = 0;
+ if ( zero_pos <= diff_pos ) e = 0;
+ (*test_func)(buf1,buf2,e);
+ (*test_func)(buf2,buf1,-e);
+ (*test_func)(buf2,buf2,0);
+ /* differing length: */
+ buf2[diff_pos] = 0;
+ (*test_func)(buf1,buf2,-e);
+ memset(buf2+diff_pos,'B',sizeof(buf2)-diff_pos);
+ buf2[zero_pos] = 0;
+ (*test_func)(buf1,buf2,e);
+ (*test_func)(buf2,buf1,-e);
+ }
+}
+
+#define RUN_TESTN(SZ, ALIGN) test_driver_strncmp (test_strncmp_ ## SZ ## _ ## ALIGN, SZ, ALIGN);
+#define RUN_TEST(ALIGN) test_driver_strcmp (test_strcmp_ ## ALIGN, ALIGN);
+
+#define DEF_TESTN(SZ, ALIGN) \
+static void test_strncmp_ ## SZ ## _ ## ALIGN (const char *str1, const char *str2, int expect) \
+{ \
+ char three[8192] __attribute__ ((aligned (4096))); \
+ char four[8192] __attribute__ ((aligned (4096))); \
+ char *a, *b; \
+ int i,j,r; \
+ for (j = 0; j < 2; j++) \
+ { \
+ for (i = 0; i < 2; i++) \
+ { \
+ a = three+i*ALIGN+j*(4096-2*i*ALIGN); \
+ b = four+i*ALIGN+j*(4096-2*i*ALIGN); \
+ strcpy(a,str1); \
+ strcpy(b,str2); \
+ r = strncmp(a,b,SZ); \
+ if ( r < 0 && !(expect < 0) ) \
+ { abort(); } \
+ if ( r > 0 && !(expect > 0) ) \
+ { abort(); } \
+ if ( r == 0 && !(expect == 0) ) \
+ { abort(); } \
+ } \
+ } \
+}
+#define DEF_TEST(ALIGN) \
+static void test_strcmp_ ## ALIGN (const char *str1, const char *str2, int expect) \
+{ \
+ char three[8192] __attribute__ ((aligned (4096))); \
+ char four[8192] __attribute__ ((aligned (4096))); \
+ char *a, *b; \
+ int i,j,r; \
+ for (j = 0; j < 2; j++) \
+ { \
+ for (i = 0; i < 2; i++) \
+ { \
+ a = three+i*ALIGN+j*(4096-2*i*ALIGN); \
+ b = four+i*ALIGN+j*(4096-2*i*ALIGN); \
+ strcpy(a,str1); \
+ strcpy(b,str2); \
+ r = strcmp(a,b); \
+ if ( r < 0 && !(expect < 0) ) \
+ { abort(); } \
+ if ( r > 0 && !(expect > 0) ) \
+ { abort(); } \
+ if ( r == 0 && !(expect == 0) ) \
+ { abort(); } \
+ } \
+ } \
+}
+
+#ifdef TEST_ALL
+DEF_TESTN(1,1)
+DEF_TESTN(1,2)
+DEF_TESTN(1,4)
+DEF_TESTN(1,8)
+DEF_TESTN(1,16)
+DEF_TESTN(2,1)
+DEF_TESTN(2,2)
+DEF_TESTN(2,4)
+DEF_TESTN(2,8)
+DEF_TESTN(2,16)
+DEF_TESTN(3,1)
+DEF_TESTN(3,2)
+DEF_TESTN(3,4)
+DEF_TESTN(3,8)
+DEF_TESTN(3,16)
+DEF_TESTN(4,1)
+DEF_TESTN(4,2)
+DEF_TESTN(4,4)
+DEF_TESTN(4,8)
+DEF_TESTN(4,16)
+DEF_TESTN(5,1)
+DEF_TESTN(5,2)
+DEF_TESTN(5,4)
+DEF_TESTN(5,8)
+DEF_TESTN(5,16)
+DEF_TESTN(6,1)
+DEF_TESTN(6,2)
+DEF_TESTN(6,4)
+DEF_TESTN(6,8)
+DEF_TESTN(6,16)
+DEF_TESTN(7,1)
+DEF_TESTN(7,2)
+DEF_TESTN(7,4)
+DEF_TESTN(7,8)
+DEF_TESTN(7,16)
+DEF_TESTN(8,1)
+DEF_TESTN(8,2)
+DEF_TESTN(8,4)
+DEF_TESTN(8,8)
+DEF_TESTN(8,16)
+DEF_TESTN(9,1)
+DEF_TESTN(9,2)
+DEF_TESTN(9,4)
+DEF_TESTN(9,8)
+DEF_TESTN(9,16)
+DEF_TESTN(10,1)
+DEF_TESTN(10,2)
+DEF_TESTN(10,4)
+DEF_TESTN(10,8)
+DEF_TESTN(10,16)
+DEF_TESTN(11,1)
+DEF_TESTN(11,2)
+DEF_TESTN(11,4)
+DEF_TESTN(11,8)
+DEF_TESTN(11,16)
+DEF_TESTN(12,1)
+DEF_TESTN(12,2)
+DEF_TESTN(12,4)
+DEF_TESTN(12,8)
+DEF_TESTN(12,16)
+DEF_TESTN(13,1)
+DEF_TESTN(13,2)
+DEF_TESTN(13,4)
+DEF_TESTN(13,8)
+DEF_TESTN(13,16)
+DEF_TESTN(14,1)
+DEF_TESTN(14,2)
+DEF_TESTN(14,4)
+DEF_TESTN(14,8)
+DEF_TESTN(14,16)
+DEF_TESTN(15,1)
+DEF_TESTN(15,2)
+DEF_TESTN(15,4)
+DEF_TESTN(15,8)
+DEF_TESTN(15,16)
+DEF_TESTN(16,1)
+DEF_TESTN(16,2)
+DEF_TESTN(16,4)
+DEF_TESTN(16,8)
+DEF_TESTN(16,16)
+DEF_TESTN(17,1)
+DEF_TESTN(17,2)
+DEF_TESTN(17,4)
+DEF_TESTN(17,8)
+DEF_TESTN(17,16)
+DEF_TESTN(18,1)
+DEF_TESTN(18,2)
+DEF_TESTN(18,4)
+DEF_TESTN(18,8)
+DEF_TESTN(18,16)
+DEF_TESTN(19,1)
+DEF_TESTN(19,2)
+DEF_TESTN(19,4)
+DEF_TESTN(19,8)
+DEF_TESTN(19,16)
+DEF_TESTN(20,1)
+DEF_TESTN(20,2)
+DEF_TESTN(20,4)
+DEF_TESTN(20,8)
+DEF_TESTN(20,16)
+DEF_TESTN(21,1)
+DEF_TESTN(21,2)
+DEF_TESTN(21,4)
+DEF_TESTN(21,8)
+DEF_TESTN(21,16)
+DEF_TESTN(22,1)
+DEF_TESTN(22,2)
+DEF_TESTN(22,4)
+DEF_TESTN(22,8)
+DEF_TESTN(22,16)
+DEF_TESTN(23,1)
+DEF_TESTN(23,2)
+DEF_TESTN(23,4)
+DEF_TESTN(23,8)
+DEF_TESTN(23,16)
+DEF_TESTN(24,1)
+DEF_TESTN(24,2)
+DEF_TESTN(24,4)
+DEF_TESTN(24,8)
+DEF_TESTN(24,16)
+DEF_TESTN(25,1)
+DEF_TESTN(25,2)
+DEF_TESTN(25,4)
+DEF_TESTN(25,8)
+DEF_TESTN(25,16)
+DEF_TESTN(26,1)
+DEF_TESTN(26,2)
+DEF_TESTN(26,4)
+DEF_TESTN(26,8)
+DEF_TESTN(26,16)
+DEF_TESTN(27,1)
+DEF_TESTN(27,2)
+DEF_TESTN(27,4)
+DEF_TESTN(27,8)
+DEF_TESTN(27,16)
+DEF_TESTN(28,1)
+DEF_TESTN(28,2)
+DEF_TESTN(28,4)
+DEF_TESTN(28,8)
+DEF_TESTN(28,16)
+DEF_TESTN(29,1)
+DEF_TESTN(29,2)
+DEF_TESTN(29,4)
+DEF_TESTN(29,8)
+DEF_TESTN(29,16)
+DEF_TESTN(30,1)
+DEF_TESTN(30,2)
+DEF_TESTN(30,4)
+DEF_TESTN(30,8)
+DEF_TESTN(30,16)
+DEF_TESTN(31,1)
+DEF_TESTN(31,2)
+DEF_TESTN(31,4)
+DEF_TESTN(31,8)
+DEF_TESTN(31,16)
+DEF_TESTN(32,1)
+DEF_TESTN(32,2)
+DEF_TESTN(32,4)
+DEF_TESTN(32,8)
+DEF_TESTN(32,16)
+DEF_TESTN(33,1)
+DEF_TESTN(33,2)
+DEF_TESTN(33,4)
+DEF_TESTN(33,8)
+DEF_TESTN(33,16)
+DEF_TESTN(34,1)
+DEF_TESTN(34,2)
+DEF_TESTN(34,4)
+DEF_TESTN(34,8)
+DEF_TESTN(34,16)
+DEF_TESTN(35,1)
+DEF_TESTN(35,2)
+DEF_TESTN(35,4)
+DEF_TESTN(35,8)
+DEF_TESTN(35,16)
+DEF_TESTN(36,1)
+DEF_TESTN(36,2)
+DEF_TESTN(36,4)
+DEF_TESTN(36,8)
+DEF_TESTN(36,16)
+DEF_TESTN(37,1)
+DEF_TESTN(37,2)
+DEF_TESTN(37,4)
+DEF_TESTN(37,8)
+DEF_TESTN(37,16)
+DEF_TESTN(38,1)
+DEF_TESTN(38,2)
+DEF_TESTN(38,4)
+DEF_TESTN(38,8)
+DEF_TESTN(38,16)
+DEF_TESTN(39,1)
+DEF_TESTN(39,2)
+DEF_TESTN(39,4)
+DEF_TESTN(39,8)
+DEF_TESTN(39,16)
+DEF_TESTN(40,1)
+DEF_TESTN(40,2)
+DEF_TESTN(40,4)
+DEF_TESTN(40,8)
+DEF_TESTN(40,16)
+DEF_TESTN(41,1)
+DEF_TESTN(41,2)
+DEF_TESTN(41,4)
+DEF_TESTN(41,8)
+DEF_TESTN(41,16)
+DEF_TESTN(42,1)
+DEF_TESTN(42,2)
+DEF_TESTN(42,4)
+DEF_TESTN(42,8)
+DEF_TESTN(42,16)
+DEF_TESTN(43,1)
+DEF_TESTN(43,2)
+DEF_TESTN(43,4)
+DEF_TESTN(43,8)
+DEF_TESTN(43,16)
+DEF_TESTN(44,1)
+DEF_TESTN(44,2)
+DEF_TESTN(44,4)
+DEF_TESTN(44,8)
+DEF_TESTN(44,16)
+DEF_TESTN(45,1)
+DEF_TESTN(45,2)
+DEF_TESTN(45,4)
+DEF_TESTN(45,8)
+DEF_TESTN(45,16)
+DEF_TESTN(46,1)
+DEF_TESTN(46,2)
+DEF_TESTN(46,4)
+DEF_TESTN(46,8)
+DEF_TESTN(46,16)
+DEF_TESTN(47,1)
+DEF_TESTN(47,2)
+DEF_TESTN(47,4)
+DEF_TESTN(47,8)
+DEF_TESTN(47,16)
+DEF_TESTN(48,1)
+DEF_TESTN(48,2)
+DEF_TESTN(48,4)
+DEF_TESTN(48,8)
+DEF_TESTN(48,16)
+DEF_TESTN(49,1)
+DEF_TESTN(49,2)
+DEF_TESTN(49,4)
+DEF_TESTN(49,8)
+DEF_TESTN(49,16)
+DEF_TESTN(100,1)
+DEF_TESTN(100,2)
+DEF_TESTN(100,4)
+DEF_TESTN(100,8)
+DEF_TESTN(100,16)
+DEF_TEST(1)
+DEF_TEST(2)
+DEF_TEST(4)
+DEF_TEST(8)
+DEF_TEST(16)
+#else
+DEF_TESTN(3,1)
+DEF_TESTN(4,1)
+DEF_TESTN(4,2)
+DEF_TESTN(4,4)
+DEF_TESTN(5,1)
+DEF_TESTN(6,1)
+DEF_TESTN(7,1)
+DEF_TESTN(8,1)
+DEF_TESTN(8,2)
+DEF_TESTN(8,4)
+DEF_TESTN(8,8)
+DEF_TESTN(9,1)
+DEF_TESTN(16,1)
+DEF_TESTN(16,2)
+DEF_TESTN(16,4)
+DEF_TESTN(16,8)
+DEF_TESTN(16,16)
+DEF_TESTN(32,1)
+DEF_TESTN(32,2)
+DEF_TESTN(32,4)
+DEF_TESTN(32,8)
+DEF_TESTN(32,16)
+DEF_TESTN(100,1)
+DEF_TESTN(100,2)
+DEF_TESTN(100,4)
+DEF_TESTN(100,8)
+DEF_TESTN(100,16)
+DEF_TESTN(SIZE_MAX,1)
+DEF_TEST(1)
+DEF_TEST(2)
+DEF_TEST(4)
+DEF_TEST(8)
+DEF_TEST(16)
+#endif
+
+int
+main(int argc, char **argv)
+{
+#ifdef TEST_ALL
+RUN_TESTN(1,1)
+RUN_TESTN(1,2)
+RUN_TESTN(1,4)
+RUN_TESTN(1,8)
+RUN_TESTN(1,16)
+RUN_TESTN(2,1)
+RUN_TESTN(2,2)
+RUN_TESTN(2,4)
+RUN_TESTN(2,8)
+RUN_TESTN(2,16)
+RUN_TESTN(3,1)
+RUN_TESTN(3,2)
+RUN_TESTN(3,4)
+RUN_TESTN(3,8)
+RUN_TESTN(3,16)
+RUN_TESTN(4,1)
+RUN_TESTN(4,2)
+RUN_TESTN(4,4)
+RUN_TESTN(4,8)
+RUN_TESTN(4,16)
+RUN_TESTN(5,1)
+RUN_TESTN(5,2)
+RUN_TESTN(5,4)
+RUN_TESTN(5,8)
+RUN_TESTN(5,16)
+RUN_TESTN(6,1)
+RUN_TESTN(6,2)
+RUN_TESTN(6,4)
+RUN_TESTN(6,8)
+RUN_TESTN(6,16)
+RUN_TESTN(7,1)
+RUN_TESTN(7,2)
+RUN_TESTN(7,4)
+RUN_TESTN(7,8)
+RUN_TESTN(7,16)
+RUN_TESTN(8,1)
+RUN_TESTN(8,2)
+RUN_TESTN(8,4)
+RUN_TESTN(8,8)
+RUN_TESTN(8,16)
+RUN_TESTN(9,1)
+RUN_TESTN(9,2)
+RUN_TESTN(9,4)
+RUN_TESTN(9,8)
+RUN_TESTN(9,16)
+RUN_TESTN(10,1)
+RUN_TESTN(10,2)
+RUN_TESTN(10,4)
+RUN_TESTN(10,8)
+RUN_TESTN(10,16)
+RUN_TESTN(11,1)
+RUN_TESTN(11,2)
+RUN_TESTN(11,4)
+RUN_TESTN(11,8)
+RUN_TESTN(11,16)
+RUN_TESTN(12,1)
+RUN_TESTN(12,2)
+RUN_TESTN(12,4)
+RUN_TESTN(12,8)
+RUN_TESTN(12,16)
+RUN_TESTN(13,1)
+RUN_TESTN(13,2)
+RUN_TESTN(13,4)
+RUN_TESTN(13,8)
+RUN_TESTN(13,16)
+RUN_TESTN(14,1)
+RUN_TESTN(14,2)
+RUN_TESTN(14,4)
+RUN_TESTN(14,8)
+RUN_TESTN(14,16)
+RUN_TESTN(15,1)
+RUN_TESTN(15,2)
+RUN_TESTN(15,4)
+RUN_TESTN(15,8)
+RUN_TESTN(15,16)
+RUN_TESTN(16,1)
+RUN_TESTN(16,2)
+RUN_TESTN(16,4)
+RUN_TESTN(16,8)
+RUN_TESTN(16,16)
+RUN_TESTN(17,1)
+RUN_TESTN(17,2)
+RUN_TESTN(17,4)
+RUN_TESTN(17,8)
+RUN_TESTN(17,16)
+RUN_TESTN(18,1)
+RUN_TESTN(18,2)
+RUN_TESTN(18,4)
+RUN_TESTN(18,8)
+RUN_TESTN(18,16)
+RUN_TESTN(19,1)
+RUN_TESTN(19,2)
+RUN_TESTN(19,4)
+RUN_TESTN(19,8)
+RUN_TESTN(19,16)
+RUN_TESTN(20,1)
+RUN_TESTN(20,2)
+RUN_TESTN(20,4)
+RUN_TESTN(20,8)
+RUN_TESTN(20,16)
+RUN_TESTN(21,1)
+RUN_TESTN(21,2)
+RUN_TESTN(21,4)
+RUN_TESTN(21,8)
+RUN_TESTN(21,16)
+RUN_TESTN(22,1)
+RUN_TESTN(22,2)
+RUN_TESTN(22,4)
+RUN_TESTN(22,8)
+RUN_TESTN(22,16)
+RUN_TESTN(23,1)
+RUN_TESTN(23,2)
+RUN_TESTN(23,4)
+RUN_TESTN(23,8)
+RUN_TESTN(23,16)
+RUN_TESTN(24,1)
+RUN_TESTN(24,2)
+RUN_TESTN(24,4)
+RUN_TESTN(24,8)
+RUN_TESTN(24,16)
+RUN_TESTN(25,1)
+RUN_TESTN(25,2)
+RUN_TESTN(25,4)
+RUN_TESTN(25,8)
+RUN_TESTN(25,16)
+RUN_TESTN(26,1)
+RUN_TESTN(26,2)
+RUN_TESTN(26,4)
+RUN_TESTN(26,8)
+RUN_TESTN(26,16)
+RUN_TESTN(27,1)
+RUN_TESTN(27,2)
+RUN_TESTN(27,4)
+RUN_TESTN(27,8)
+RUN_TESTN(27,16)
+RUN_TESTN(28,1)
+RUN_TESTN(28,2)
+RUN_TESTN(28,4)
+RUN_TESTN(28,8)
+RUN_TESTN(28,16)
+RUN_TESTN(29,1)
+RUN_TESTN(29,2)
+RUN_TESTN(29,4)
+RUN_TESTN(29,8)
+RUN_TESTN(29,16)
+RUN_TESTN(30,1)
+RUN_TESTN(30,2)
+RUN_TESTN(30,4)
+RUN_TESTN(30,8)
+RUN_TESTN(30,16)
+RUN_TESTN(31,1)
+RUN_TESTN(31,2)
+RUN_TESTN(31,4)
+RUN_TESTN(31,8)
+RUN_TESTN(31,16)
+RUN_TESTN(32,1)
+RUN_TESTN(32,2)
+RUN_TESTN(32,4)
+RUN_TESTN(32,8)
+RUN_TESTN(32,16)
+RUN_TESTN(33,1)
+RUN_TESTN(33,2)
+RUN_TESTN(33,4)
+RUN_TESTN(33,8)
+RUN_TESTN(33,16)
+RUN_TESTN(34,1)
+RUN_TESTN(34,2)
+RUN_TESTN(34,4)
+RUN_TESTN(34,8)
+RUN_TESTN(34,16)
+RUN_TESTN(35,1)
+RUN_TESTN(35,2)
+RUN_TESTN(35,4)
+RUN_TESTN(35,8)
+RUN_TESTN(35,16)
+RUN_TESTN(36,1)
+RUN_TESTN(36,2)
+RUN_TESTN(36,4)
+RUN_TESTN(36,8)
+RUN_TESTN(36,16)
+RUN_TESTN(37,1)
+RUN_TESTN(37,2)
+RUN_TESTN(37,4)
+RUN_TESTN(37,8)
+RUN_TESTN(37,16)
+RUN_TESTN(38,1)
+RUN_TESTN(38,2)
+RUN_TESTN(38,4)
+RUN_TESTN(38,8)
+RUN_TESTN(38,16)
+RUN_TESTN(39,1)
+RUN_TESTN(39,2)
+RUN_TESTN(39,4)
+RUN_TESTN(39,8)
+RUN_TESTN(39,16)
+RUN_TESTN(40,1)
+RUN_TESTN(40,2)
+RUN_TESTN(40,4)
+RUN_TESTN(40,8)
+RUN_TESTN(40,16)
+RUN_TESTN(41,1)
+RUN_TESTN(41,2)
+RUN_TESTN(41,4)
+RUN_TESTN(41,8)
+RUN_TESTN(41,16)
+RUN_TESTN(42,1)
+RUN_TESTN(42,2)
+RUN_TESTN(42,4)
+RUN_TESTN(42,8)
+RUN_TESTN(42,16)
+RUN_TESTN(43,1)
+RUN_TESTN(43,2)
+RUN_TESTN(43,4)
+RUN_TESTN(43,8)
+RUN_TESTN(43,16)
+RUN_TESTN(44,1)
+RUN_TESTN(44,2)
+RUN_TESTN(44,4)
+RUN_TESTN(44,8)
+RUN_TESTN(44,16)
+RUN_TESTN(45,1)
+RUN_TESTN(45,2)
+RUN_TESTN(45,4)
+RUN_TESTN(45,8)
+RUN_TESTN(45,16)
+RUN_TESTN(46,1)
+RUN_TESTN(46,2)
+RUN_TESTN(46,4)
+RUN_TESTN(46,8)
+RUN_TESTN(46,16)
+RUN_TESTN(47,1)
+RUN_TESTN(47,2)
+RUN_TESTN(47,4)
+RUN_TESTN(47,8)
+RUN_TESTN(47,16)
+RUN_TESTN(48,1)
+RUN_TESTN(48,2)
+RUN_TESTN(48,4)
+RUN_TESTN(48,8)
+RUN_TESTN(48,16)
+RUN_TESTN(49,1)
+RUN_TESTN(49,2)
+RUN_TESTN(49,4)
+RUN_TESTN(49,8)
+RUN_TESTN(49,16)
+RUN_TESTN(100,1)
+RUN_TESTN(100,2)
+RUN_TESTN(100,4)
+RUN_TESTN(100,8)
+RUN_TESTN(100,16)
+RUN_TEST(1)
+RUN_TEST(2)
+RUN_TEST(4)
+RUN_TEST(8)
+RUN_TEST(16)
+#else
+RUN_TESTN(3,1)
+RUN_TESTN(4,1)
+RUN_TESTN(4,2)
+RUN_TESTN(4,4)
+RUN_TESTN(5,1)
+RUN_TESTN(6,1)
+RUN_TESTN(7,1)
+RUN_TESTN(8,1)
+RUN_TESTN(8,2)
+RUN_TESTN(8,4)
+RUN_TESTN(8,8)
+RUN_TESTN(9,1)
+RUN_TESTN(16,1)
+RUN_TESTN(16,2)
+RUN_TESTN(16,4)
+RUN_TESTN(16,8)
+RUN_TESTN(16,16)
+RUN_TESTN(32,1)
+RUN_TESTN(32,2)
+RUN_TESTN(32,4)
+RUN_TESTN(32,8)
+RUN_TESTN(32,16)
+RUN_TESTN(100,1)
+RUN_TESTN(100,2)
+RUN_TESTN(100,4)
+RUN_TESTN(100,8)
+RUN_TESTN(100,16)
+RUN_TESTN(SIZE_MAX,1)
+RUN_TEST(1)
+RUN_TEST(2)
+RUN_TEST(4)
+RUN_TEST(8)
+RUN_TEST(16)
+#endif
+
+}
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2017-01-18 1:28 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-01-18 1:50 [PATCH] testcase for builtin expansion of strncmp and strcmp Aaron Sawdey
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).