← Back to branch summary

~ubuntu-branches/ubuntu/utopic/coreutils/utopic-proposed

« back to all changes in this revision

Viewing changes to gnulib-tests/test-strtoll.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-11-28 03:03:42 UTC
  • mfrom: (8.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20121128030342-21zanj8354gas5gr
Tags: 8.20-3ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - Make 'uname -i -p' return the real processor/hardware, instead of
    unknown.
  - Build-depend on gettext:any instead of on gettext, so that apt-get can
    properly resolve build-dependencies on the tool when cross-building.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib-tests/test-strtoll.c
 
1
/*
 
2
 * Copyright (C) 2011-2012 Free Software Foundation, Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 3 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
16
 
 
17
#include <config.h>
 
18
 
 
19
#include <stdlib.h>
 
20
 
 
21
#include "signature.h"
 
22
#ifndef strtoll
 
23
SIGNATURE_CHECK (strtoll, long long, (const char *, char **, int));
 
24
#endif
 
25
 
 
26
#include <errno.h>
 
27
 
 
28
#include "macros.h"
 
29
 
 
30
int
 
31
main (void)
 
32
{
 
33
  /* Subject sequence empty or invalid.  */
 
34
  {
 
35
    const char input[] = "";
 
36
    char *ptr;
 
37
    long long result;
 
38
    errno = 0;
 
39
    result = strtoll (input, &ptr, 10);
 
40
    ASSERT (result == 0);
 
41
    ASSERT (ptr == input);
 
42
    ASSERT (errno == 0 || errno == EINVAL);
 
43
  }
 
44
  {
 
45
    const char input[] = " ";
 
46
    char *ptr;
 
47
    long long result;
 
48
    errno = 0;
 
49
    result = strtoll (input, &ptr, 10);
 
50
    ASSERT (result == 0);
 
51
    ASSERT (ptr == input);
 
52
    ASSERT (errno == 0 || errno == EINVAL);
 
53
  }
 
54
  {
 
55
    const char input[] = " +";
 
56
    char *ptr;
 
57
    long long result;
 
58
    errno = 0;
 
59
    result = strtoll (input, &ptr, 10);
 
60
    ASSERT (result == 0);
 
61
    ASSERT (ptr == input);
 
62
    ASSERT (errno == 0 || errno == EINVAL);
 
63
  }
 
64
  {
 
65
    const char input[] = " -";
 
66
    char *ptr;
 
67
    long long result;
 
68
    errno = 0;
 
69
    result = strtoll (input, &ptr, 10);
 
70
    ASSERT (result == 0);
 
71
    ASSERT (ptr == input);
 
72
    ASSERT (errno == 0 || errno == EINVAL);
 
73
  }
 
74
 
 
75
  /* Simple integer values.  */
 
76
  {
 
77
    const char input[] = "0";
 
78
    char *ptr;
 
79
    long long result;
 
80
    errno = 0;
 
81
    result = strtoll (input, &ptr, 10);
 
82
    ASSERT (result == 0);
 
83
    ASSERT (ptr == input + 1);
 
84
    ASSERT (errno == 0);
 
85
  }
 
86
  {
 
87
    const char input[] = "+0";
 
88
    char *ptr;
 
89
    long long result;
 
90
    errno = 0;
 
91
    result = strtoll (input, &ptr, 10);
 
92
    ASSERT (result == 0);
 
93
    ASSERT (ptr == input + 2);
 
94
    ASSERT (errno == 0);
 
95
  }
 
96
  {
 
97
    const char input[] = "-0";
 
98
    char *ptr;
 
99
    long long result;
 
100
    errno = 0;
 
101
    result = strtoll (input, &ptr, 10);
 
102
    ASSERT (result == 0);
 
103
    ASSERT (ptr == input + 2);
 
104
    ASSERT (errno == 0);
 
105
  }
 
106
  {
 
107
    const char input[] = "23";
 
108
    char *ptr;
 
109
    long long result;
 
110
    errno = 0;
 
111
    result = strtoll (input, &ptr, 10);
 
112
    ASSERT (result == 23);
 
113
    ASSERT (ptr == input + 2);
 
114
    ASSERT (errno == 0);
 
115
  }
 
116
  {
 
117
    const char input[] = " 23";
 
118
    char *ptr;
 
119
    long long result;
 
120
    errno = 0;
 
121
    result = strtoll (input, &ptr, 10);
 
122
    ASSERT (result == 23);
 
123
    ASSERT (ptr == input + 3);
 
124
    ASSERT (errno == 0);
 
125
  }
 
126
  {
 
127
    const char input[] = "+23";
 
128
    char *ptr;
 
129
    long long result;
 
130
    errno = 0;
 
131
    result = strtoll (input, &ptr, 10);
 
132
    ASSERT (result == 23);
 
133
    ASSERT (ptr == input + 3);
 
134
    ASSERT (errno == 0);
 
135
  }
 
136
  {
 
137
    const char input[] = "-23";
 
138
    char *ptr;
 
139
    long long result;
 
140
    errno = 0;
 
141
    result = strtoll (input, &ptr, 10);
 
142
    ASSERT (result == -23);
 
143
    ASSERT (ptr == input + 3);
 
144
    ASSERT (errno == 0);
 
145
  }
 
146
 
 
147
  /* Large integer values.  */
 
148
  {
 
149
    const char input[] = "2147483647";
 
150
    char *ptr;
 
151
    long long result;
 
152
    errno = 0;
 
153
    result = strtoll (input, &ptr, 10);
 
154
    ASSERT (result == 2147483647);
 
155
    ASSERT (ptr == input + 10);
 
156
    ASSERT (errno == 0);
 
157
  }
 
158
  {
 
159
    const char input[] = "-2147483648";
 
160
    char *ptr;
 
161
    long long result;
 
162
    errno = 0;
 
163
    result = strtoll (input, &ptr, 10);
 
164
    ASSERT (result == -2147483647 - 1);
 
165
    ASSERT (ptr == input + 11);
 
166
    ASSERT (errno == 0);
 
167
  }
 
168
  if (sizeof (long long) > sizeof (int))
 
169
    {
 
170
      const char input[] = "4294967295";
 
171
      char *ptr;
 
172
      long long result;
 
173
      errno = 0;
 
174
      result = strtoll (input, &ptr, 10);
 
175
      ASSERT (result == 65535LL * 65537LL);
 
176
      ASSERT (ptr == input + 10);
 
177
      ASSERT (errno == 0);
 
178
    }
 
179
 
 
180
  return 0;
 
181
}