← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnutls26/trusty-security

« back to all changes in this revision

Viewing changes to gl/tests/test-memchr.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Metzler
  • Date: 2010-04-22 19:29:52 UTC
  • mto: (12.4.3 experimental) (1.5.1)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: james.westby@ubuntu.com-20100422192952-gbj6cvaan8e4ejck
Tags: upstream-2.9.10
Import upstream version 2.9.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
gl/tests/test-memchr.c
1
1
/*
2
 
 * Copyright (C) 2008-2009 Free Software Foundation
 
2
 * Copyright (C) 2008-2010 Free Software Foundation, Inc.
3
3
 * Written by Eric Blake and Bruno Haible
4
4
 *
5
5
 * This program is free software: you can redistribute it and/or modify
19
19
 
20
20
#include <string.h>
21
21
 
22
 
#include <stdio.h>
 
22
#include "signature.h"
 
23
SIGNATURE_CHECK (memchr, void *, (void const *, int, size_t));
 
24
 
23
25
#include <stdlib.h>
24
26
 
25
27
#include "zerosize-ptr.h"
26
 
 
27
 
#define ASSERT(expr) \
28
 
  do                                                                         \
29
 
    {                                                                        \
30
 
      if (!(expr))                                                           \
31
 
        {                                                                    \
32
 
          fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
33
 
          fflush (stderr);                                                   \
34
 
          abort ();                                                          \
35
 
        }                                                                    \
36
 
    }                                                                        \
37
 
  while (0)
 
28
#include "macros.h"
38
29
 
39
30
/* Calculating void * + int is not portable, so this wrapper converts
40
31
   to char * to make the tests easier to write.  */
76
67
    size_t repeat = 10000;
77
68
    for (; repeat > 0; repeat--)
78
69
      {
79
 
        ASSERT (MEMCHR (input, 'c', n) == input + 2);
 
70
        ASSERT (MEMCHR (input, 'c', n) == input + 2);
80
71
      }
81
72
  }
82
73
 
85
76
    int i, j;
86
77
    for (i = 0; i < 32; i++)
87
78
      {
88
 
        for (j = 0; j < 256; j++)
89
 
          input[i + j] = j;
90
 
        for (j = 0; j < 256; j++)
91
 
          {
92
 
            ASSERT (MEMCHR (input + i, j, 256) == input + i + j);
93
 
          }
 
79
        for (j = 0; j < 256; j++)
 
80
          input[i + j] = j;
 
81
        for (j = 0; j < 256; j++)
 
82
          {
 
83
            ASSERT (MEMCHR (input + i, j, 256) == input + i + j);
 
84
          }
94
85
      }
95
86
  }
96
87
 
102
93
 
103
94
    if (page_boundary != NULL)
104
95
      {
105
 
        for (n = 1; n <= 500; n++)
106
 
          {
107
 
            char *mem = page_boundary - n;
108
 
            memset (mem, 'X', n);
109
 
            ASSERT (MEMCHR (mem, 'U', n) == NULL);
110
 
 
111
 
            {
112
 
              size_t i;
113
 
 
114
 
              for (i = 0; i < n; i++)
115
 
                {
116
 
                  mem[i] = 'U';
117
 
                  ASSERT (MEMCHR (mem, 'U', 4000) == mem + i);
118
 
                  mem[i] = 'X';
119
 
                }
120
 
            }
121
 
          }
 
96
        for (n = 1; n <= 500; n++)
 
97
          {
 
98
            char *mem = page_boundary - n;
 
99
            memset (mem, 'X', n);
 
100
            ASSERT (MEMCHR (mem, 'U', n) == NULL);
 
101
 
 
102
            {
 
103
              size_t i;
 
104
 
 
105
              for (i = 0; i < n; i++)
 
106
                {
 
107
                  mem[i] = 'U';
 
108
                  ASSERT (MEMCHR (mem, 'U', 4000) == mem + i);
 
109
                  mem[i] = 'X';
 
110
                }
 
111
            }
 
112
          }
122
113
      }
123
114
  }
124
115