← Back to branch summary

~linaro-toolchain-dev/cortex-strings/trunk

« back to all changes in this revision

Viewing changes to tests/test-strchr.c

  • Committer: Michael Hope
  • Date: 2010-09-10 01:34:33 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: michael.hope@linaro.org-20100910013433-3ehxlbloizs3pqwg
Fixed up the Makefile so a 'make dist' includes everything required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-strchr.c
1
 
/* Test and measure strchr functions.
2
 
   Copyright (C) 1999, 2002, 2003 Free Software Foundation, Inc.
3
 
   This file is part of the GNU C Library.
4
 
   Written by Jakub Jelinek <jakub@redhat.com>, 1999.
5
 
 
6
 
   The GNU C Library is free software; you can redistribute it and/or
7
 
   modify it under the terms of the GNU Lesser General Public
8
 
   License as published by the Free Software Foundation; either
9
 
   version 2.1 of the License, or (at your option) any later version.
10
 
 
11
 
   The GNU C Library is distributed in the hope that it will be useful,
12
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 
   Lesser General Public License for more details.
15
 
 
16
 
   You should have received a copy of the GNU Lesser General Public
17
 
   License along with the GNU C Library; if not, write to the Free
18
 
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19
 
   02111-1307 USA.  */
20
 
 
21
 
#define TEST_MAIN
22
 
#include "test-string.h"
23
 
 
24
 
typedef char *(*proto_t) (const char *, int);
25
 
char *simple_strchr (const char *, int);
26
 
char *stupid_strchr (const char *, int);
27
 
 
28
 
IMPL (stupid_strchr, 0)
29
 
IMPL (simple_strchr, 0)
30
 
IMPL (strchr, 1)
31
 
 
32
 
char *
33
 
simple_strchr (const char *s, int c)
34
 
{
35
 
  for (; *s != (char) c; ++s)
36
 
    if (*s == '\0')
37
 
      return NULL;
38
 
  return (char *) s;
39
 
}
40
 
 
41
 
char *
42
 
stupid_strchr (const char *s, int c)
43
 
{
44
 
  size_t n = strlen (s) + 1;
45
 
 
46
 
  while (n--)
47
 
    if (*s++ == (char) c)
48
 
      return (char *) s - 1;
49
 
  return NULL;
50
 
}
51
 
 
52
 
static void
53
 
do_one_test (impl_t *impl, const char *s, int c, char *exp_res)
54
 
{
55
 
  char *res = CALL (impl, s, c);
56
 
  if (res != exp_res)
57
 
    {
58
 
      error (0, 0, "Wrong result in function %s %p %p", impl->name,
59
 
             res, exp_res);
60
 
      ret = 1;
61
 
      return;
62
 
    }
63
 
 
64
 
  if (HP_TIMING_AVAIL)
65
 
    {
66
 
      hp_timing_t start __attribute ((unused));
67
 
      hp_timing_t stop __attribute ((unused));
68
 
      hp_timing_t best_time = ~ (hp_timing_t) 0;
69
 
      size_t i;
70
 
 
71
 
      for (i = 0; i < 32; ++i)
72
 
        {
73
 
          HP_TIMING_NOW (start);
74
 
          CALL (impl, s, c);
75
 
          HP_TIMING_NOW (stop);
76
 
          HP_TIMING_BEST (best_time, start, stop);
77
 
        }
78
 
 
79
 
      printf ("\t%zd", (size_t) best_time);
80
 
    }
81
 
}
82
 
 
83
 
static void
84
 
do_test (size_t align, size_t pos, size_t len, int seek_char, int max_char)
85
 
{
86
 
  size_t i;
87
 
  char *result;
88
 
 
89
 
  align &= 7;
90
 
  if (align + len >= page_size)
91
 
    return;
92
 
 
93
 
  for (i = 0; i < len; ++i)
94
 
    {
95
 
      buf1[align + i] = 32 + 23 * i % (max_char - 32);
96
 
      if (buf1[align + i] == seek_char)
97
 
        buf1[align + i] = seek_char + 1;
98
 
    }
99
 
  buf1[align + len] = 0;
100
 
 
101
 
  if (pos < len)
102
 
    {
103
 
      buf1[align + pos] = seek_char;
104
 
      result = (char *) (buf1 + align + pos);
105
 
    }
106
 
  else if (seek_char == 0)
107
 
    result = (char *) (buf1 + align + len);
108
 
  else
109
 
    result = NULL;
110
 
 
111
 
  if (HP_TIMING_AVAIL)
112
 
    printf ("Length %4zd, alignment %2zd:", pos, align);
113
 
 
114
 
  FOR_EACH_IMPL (impl, 0)
115
 
    do_one_test (impl, (char *) (buf1 + align), seek_char, result);
116
 
 
117
 
  if (HP_TIMING_AVAIL)
118
 
    putchar ('\n');
119
 
}
120
 
 
121
 
static void
122
 
do_random_tests (void)
123
 
{
124
 
  size_t i, j, n, align, pos, len;
125
 
  int seek_char;
126
 
  char *result;
127
 
  unsigned char *p = buf1 + page_size - 512;
128
 
 
129
 
  for (n = 0; n < ITERATIONS; n++)
130
 
    {
131
 
      align = random () & 15;
132
 
      pos = random () & 511;
133
 
      seek_char = random () & 255;
134
 
      if (pos + align >= 511)
135
 
        pos = 510 - align - (random () & 7);
136
 
      len = random () & 511;
137
 
      if ((pos == len && seek_char)
138
 
          || (pos > len && (random () & 1)))
139
 
        len = pos + 1 + (random () & 7);
140
 
      if (len + align >= 512)
141
 
        len = 511 - align - (random () & 7);
142
 
      if (pos == len && seek_char)
143
 
        len = pos + 1;
144
 
      j = (pos > len ? pos : len) + align + 64;
145
 
      if (j > 512)
146
 
        j = 512;
147
 
 
148
 
      for (i = 0; i < j; i++)
149
 
        {
150
 
          if (i == pos + align)
151
 
            p[i] = seek_char;
152
 
          else if (i == len + align)
153
 
            p[i] = 0;
154
 
          else
155
 
            {
156
 
              p[i] = random () & 255;
157
 
              if (i < pos + align && p[i] == seek_char)
158
 
                p[i] = seek_char + 13;
159
 
              if (i < len + align && !p[i])
160
 
                {
161
 
                  p[i] = seek_char - 13;
162
 
                  if (!p[i])
163
 
                    p[i] = 140;
164
 
                }
165
 
            }
166
 
        }
167
 
 
168
 
      if (pos <= len)
169
 
        result = (char *) (p + pos + align);
170
 
      else if (seek_char == 0)
171
 
        result = (char *) (p + len + align);
172
 
      else
173
 
        result = NULL;
174
 
 
175
 
      FOR_EACH_IMPL (impl, 1)
176
 
        if (CALL (impl, (char *) (p + align), seek_char) != result)
177
 
          {
178
 
            error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %d, %zd, %zd) %p != %p, p %p",
179
 
                   n, impl->name, align, seek_char, len, pos,
180
 
                   CALL (impl, (char *) (p + align), seek_char), result, p);
181
 
            ret = 1;
182
 
          }
183
 
    }
184
 
}
185
 
 
186
 
int
187
 
test_main (void)
188
 
{
189
 
  size_t i;
190
 
 
191
 
  test_init ();
192
 
 
193
 
  printf ("%20s", "");
194
 
  FOR_EACH_IMPL (impl, 0)
195
 
    printf ("\t%s", impl->name);
196
 
  putchar ('\n');
197
 
 
198
 
  for (i = 1; i < 8; ++i)
199
 
    {
200
 
      do_test (0, 16 << i, 2048, 23, 127);
201
 
      do_test (i, 16 << i, 2048, 23, 127);
202
 
    }
203
 
 
204
 
  for (i = 1; i < 8; ++i)
205
 
    {
206
 
      do_test (i, 64, 256, 23, 127);
207
 
      do_test (i, 64, 256, 23, 255);
208
 
    }
209
 
 
210
 
  for (i = 0; i < 32; ++i)
211
 
    {
212
 
      do_test (0, i, i + 1, 23, 127);
213
 
      do_test (0, i, i + 1, 23, 255);
214
 
    }
215
 
 
216
 
  for (i = 1; i < 8; ++i)
217
 
    {
218
 
      do_test (0, 16 << i, 2048, 0, 127);
219
 
      do_test (i, 16 << i, 2048, 0, 127);
220
 
    }
221
 
 
222
 
  for (i = 1; i < 8; ++i)
223
 
    {
224
 
      do_test (i, 64, 256, 0, 127);
225
 
      do_test (i, 64, 256, 0, 255);
226
 
    }
227
 
 
228
 
  for (i = 0; i < 32; ++i)
229
 
    {
230
 
      do_test (0, i, i + 1, 0, 127);
231
 
      do_test (0, i, i + 1, 0, 255);
232
 
    }
233
 
 
234
 
  do_random_tests ();
235
 
  return ret;
236
 
}
237
 
 
238
 
#include "test-skeleton.c"