← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/test-memchr.c

  • Committer: Michael Hope
  • Date: 2010-09-02 02:26:33 UTC
  • Revision ID: michael.hope@linaro.org-20100902022633-xbddfwagsup43ykn
Added a README.  Re-factored the build into a top level Makefile.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-memchr.c
1
 
/* Test and measure memchr functions.
2
 
   Copyright (C) 1999, 2002, 2003, 2005, 2009 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, size_t);
25
 
char *simple_memchr (const char *, int, size_t);
26
 
 
27
 
IMPL (simple_memchr, 0)
28
 
IMPL (memchr, 1)
29
 
 
30
 
char *
31
 
simple_memchr (const char *s, int c, size_t n)
32
 
{
33
 
  while (n--)
34
 
    if (*s++ == (char) c)
35
 
      return (char *) s - 1;
36
 
  return NULL;
37
 
}
38
 
 
39
 
static void
40
 
do_one_test (impl_t *impl, const char *s, int c, size_t n, char *exp_res)
41
 
{
42
 
  char *res = CALL (impl, s, c, n);
43
 
  if (res != exp_res)
44
 
    {
45
 
      error (0, 0, "Wrong result in function %s %p %p", impl->name,
46
 
             res, exp_res);
47
 
      ret = 1;
48
 
      return;
49
 
    }
50
 
 
51
 
  if (HP_TIMING_AVAIL)
52
 
    {
53
 
      hp_timing_t start __attribute ((unused));
54
 
      hp_timing_t stop __attribute ((unused));
55
 
      hp_timing_t best_time = ~ (hp_timing_t) 0;
56
 
      size_t i;
57
 
 
58
 
      for (i = 0; i < 32; ++i)
59
 
        {
60
 
          HP_TIMING_NOW (start);
61
 
          CALL (impl, s, c, n);
62
 
          HP_TIMING_NOW (stop);
63
 
          HP_TIMING_BEST (best_time, start, stop);
64
 
        }
65
 
 
66
 
      printf ("\t%zd", (size_t) best_time);
67
 
    }
68
 
}
69
 
 
70
 
static void
71
 
do_test (size_t align, size_t pos, size_t len, int seek_char)
72
 
{
73
 
  size_t i;
74
 
  char *result;
75
 
 
76
 
  align &= 7;
77
 
  if (align + len >= page_size)
78
 
    return;
79
 
 
80
 
  for (i = 0; i < len; ++i)
81
 
    {
82
 
      buf1[align + i] = 1 + 23 * i % 127;
83
 
      if (buf1[align + i] == seek_char)
84
 
        buf1[align + i] = seek_char + 1;
85
 
    }
86
 
  buf1[align + len] = 0;
87
 
 
88
 
  if (pos < len)
89
 
    {
90
 
      buf1[align + pos] = seek_char;
91
 
      buf1[align + len] = -seek_char;
92
 
      result = (char *) (buf1 + align + pos);
93
 
    }
94
 
  else
95
 
    {
96
 
      result = NULL;
97
 
      buf1[align + len] = seek_char;
98
 
    }
99
 
 
100
 
  if (HP_TIMING_AVAIL)
101
 
    printf ("Length %4zd, alignment %2zd:", pos, align);
102
 
 
103
 
  FOR_EACH_IMPL (impl, 0)
104
 
    do_one_test (impl, (char *) (buf1 + align), seek_char, len, result);
105
 
 
106
 
  if (HP_TIMING_AVAIL)
107
 
    putchar ('\n');
108
 
}
109
 
 
110
 
static void
111
 
do_random_tests (void)
112
 
{
113
 
  size_t i, j, n, align, pos, len;
114
 
  int seek_char;
115
 
  char *result;
116
 
  unsigned char *p = buf1 + page_size - 512;
117
 
 
118
 
  for (n = 0; n < ITERATIONS; n++)
119
 
    {
120
 
      align = random () & 15;
121
 
      pos = random () & 511;
122
 
      if (pos + align >= 512)
123
 
        pos = 511 - align - (random () & 7);
124
 
      len = random () & 511;
125
 
      if (pos >= len)
126
 
        len = pos + (random () & 7);
127
 
      if (len + align >= 512)
128
 
        len = 512 - align - (random () & 7);
129
 
      seek_char = random () & 255;
130
 
      j = len + align + 64;
131
 
      if (j > 512)
132
 
        j = 512;
133
 
 
134
 
      for (i = 0; i < j; i++)
135
 
        {
136
 
          if (i == pos + align)
137
 
            p[i] = seek_char;
138
 
          else
139
 
            {
140
 
              p[i] = random () & 255;
141
 
              if (i < pos + align && p[i] == seek_char)
142
 
                p[i] = seek_char + 13;
143
 
            }
144
 
        }
145
 
 
146
 
      if (pos < len)
147
 
        {
148
 
          size_t r = random ();
149
 
          if ((r & 31) == 0)
150
 
            len = ~(uintptr_t) (p + align) - ((r >> 5) & 31);
151
 
          result = (char *) (p + pos + align);
152
 
        }
153
 
      else
154
 
        result = NULL;
155
 
 
156
 
      FOR_EACH_IMPL (impl, 1)
157
 
        if (CALL (impl, (char *) (p + align), seek_char, len) != result)
158
 
          {
159
 
            error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %d, %zd, %zd) %p != %p, p %p",
160
 
                   n, impl->name, align, seek_char, len, pos,
161
 
                   CALL (impl, (char *) (p + align), seek_char, len),
162
 
                   result, p);
163
 
            ret = 1;
164
 
          }
165
 
    }
166
 
}
167
 
 
168
 
int
169
 
test_main (void)
170
 
{
171
 
  size_t i;
172
 
 
173
 
  test_init ();
174
 
 
175
 
  printf ("%20s", "");
176
 
  FOR_EACH_IMPL (impl, 0)
177
 
    printf ("\t%s", impl->name);
178
 
  putchar ('\n');
179
 
 
180
 
  for (i = 1; i < 8; ++i)
181
 
    {
182
 
      do_test (0, 16 << i, 2048, 23);
183
 
      do_test (i, 64, 256, 23);
184
 
      do_test (0, 16 << i, 2048, 0);
185
 
      do_test (i, 64, 256, 0);
186
 
    }
187
 
  for (i = 1; i < 32; ++i)
188
 
    {
189
 
      do_test (0, i, i + 1, 23);
190
 
      do_test (0, i, i + 1, 0);
191
 
    }
192
 
 
193
 
  do_random_tests ();
194
 
  return ret;
195
 
}
196
 
 
197
 
#include "test-skeleton.c"