Merge "Reimplement the <ctype.h> is* functions."
This commit is contained in:
Elliott Hughes
Gerrit Code Review
commit
e9ff762789
6 changed files with 345 additions and 281 deletions
|
|
@ -19,6 +19,63 @@
|
|||
#include <benchmark/benchmark.h>
|
||||
#include "util.h"
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalnum_y1, isalnum('A'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalnum_y2, isalnum('a'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalnum_y3, isalnum('0'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalnum_n, isalnum('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalpha_y1, isalpha('A'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalpha_y2, isalpha('a'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isalpha_n, isalpha('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isascii_y, isascii('x'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isascii_n, isascii(0x88));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isblank_y1, isblank(' '));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isblank_y2, isblank('\t'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isblank_n, isblank('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_iscntrl_y1, iscntrl('\b'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_iscntrl_y2, iscntrl('\x7f'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_iscntrl_n, iscntrl('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isdigit_y, iscntrl('0'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isdigit_n, iscntrl('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isgraph_y1, isgraph('A'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isgraph_y2, isgraph('a'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isgraph_y3, isgraph('0'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isgraph_y4, isgraph('_'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isgraph_n, isgraph(' '));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_islower_y, islower('x'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_islower_n, islower('X'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_y1, isprint('A'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_y2, isprint('a'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_y3, isprint('0'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_y4, isprint('_'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_y5, isprint(' '));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isprint_n, isprint('\b'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_ispunct_y, ispunct('_'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_ispunct_n, ispunct('A'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isspace_y1, isspace(' '));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isspace_y2, isspace('\t'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isspace_n, isspace('A'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isupper_y, isupper('X'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isupper_n, isupper('x'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isxdigit_y1, isxdigit('0'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isxdigit_y2, isxdigit('a'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isxdigit_y3, isxdigit('A'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_isxdigit_n, isxdigit('_'));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_toascii_y, isascii('x'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_toascii_n, isascii(0x88));
|
||||
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_tolower_y, tolower('X'));
|
||||
BIONIC_TRIVIAL_BENCHMARK(BM_ctype_tolower_n, tolower('x'));
|
||||
|
||||
|
|
|
|||
|
|
@ -438,7 +438,6 @@ cc_library_static {
|
|||
"upstream-openbsd/lib/libc/gen/fnmatch.c",
|
||||
"upstream-openbsd/lib/libc/gen/ftok.c",
|
||||
"upstream-openbsd/lib/libc/gen/getprogname.c",
|
||||
"upstream-openbsd/lib/libc/gen/isctype.c",
|
||||
"upstream-openbsd/lib/libc/gen/setprogname.c",
|
||||
"upstream-openbsd/lib/libc/gen/verr.c",
|
||||
"upstream-openbsd/lib/libc/gen/verrx.c",
|
||||
|
|
|
|||
|
|
@ -28,70 +28,146 @@
|
|||
|
||||
#include <ctype.h>
|
||||
|
||||
static inline int __in_range(int c, char lo, char hi) {
|
||||
return c >= lo && c <= hi;
|
||||
}
|
||||
|
||||
int isalnum(int c) {
|
||||
// `isalnum(c)` is `isalpha(c) || isdigit(c)`, but there's no obvious way
|
||||
// to simplify that, and the table lookup is just slightly faster...
|
||||
// Note that this is unsafe for inputs less than -1 (EOF) or greater than
|
||||
// 0xff. This is true of other C libraries too.
|
||||
return (_ctype_[c + 1] & (_CTYPE_U|_CTYPE_L|_CTYPE_N));
|
||||
}
|
||||
|
||||
int isalnum_l(int c, locale_t) {
|
||||
return isalnum(c);
|
||||
}
|
||||
|
||||
int isalpha(int c) {
|
||||
return __in_range(c, 'A', 'Z') || __in_range(c, 'a', 'z');
|
||||
}
|
||||
|
||||
int isalpha_l(int c, locale_t) {
|
||||
return isalpha(c);
|
||||
}
|
||||
|
||||
int isascii(int c) {
|
||||
return static_cast<unsigned>(c) < 0x80;
|
||||
}
|
||||
|
||||
int isblank(int c) {
|
||||
return c == ' ' || c == '\t';
|
||||
}
|
||||
|
||||
int isblank_l(int c, locale_t) {
|
||||
return isblank(c);
|
||||
}
|
||||
|
||||
int iscntrl(int c) {
|
||||
return (static_cast<unsigned>(c) < ' ') || c == 0x7f;
|
||||
}
|
||||
|
||||
int iscntrl_l(int c, locale_t) {
|
||||
return iscntrl(c);
|
||||
}
|
||||
|
||||
int isdigit(int c) {
|
||||
return __in_range(c, '0', '9');
|
||||
}
|
||||
|
||||
int isdigit_l(int c, locale_t) {
|
||||
return isdigit(c);
|
||||
}
|
||||
|
||||
int isgraph(int c) {
|
||||
return __in_range(c, '!', '~');
|
||||
}
|
||||
|
||||
int isgraph_l(int c, locale_t) {
|
||||
return isgraph(c);
|
||||
}
|
||||
|
||||
int islower(int c) {
|
||||
return __in_range(c, 'a', 'z');
|
||||
}
|
||||
|
||||
int islower_l(int c, locale_t) {
|
||||
return islower(c);
|
||||
}
|
||||
|
||||
int isprint(int c) {
|
||||
return __in_range(c, ' ', '~');
|
||||
}
|
||||
|
||||
int isprint_l(int c, locale_t) {
|
||||
return isprint(c);
|
||||
}
|
||||
|
||||
int ispunct(int c) {
|
||||
// `ispunct(c)` is `isgraph(c) && !isalnum(c)`, but there's no obvious way
|
||||
// to simplify that, and the table lookup is just slightly faster...
|
||||
// Note that this is unsafe for inputs less than -1 (EOF) or greater than
|
||||
// 0xff. This is true of other C libraries too.
|
||||
return (_ctype_[c + 1] & _CTYPE_P);
|
||||
}
|
||||
|
||||
int ispunct_l(int c, locale_t) {
|
||||
return ispunct(c);
|
||||
}
|
||||
|
||||
int isspace(int c) {
|
||||
return c == ' ' || __in_range(c, '\t', '\r');
|
||||
}
|
||||
|
||||
int isspace_l(int c, locale_t) {
|
||||
return isspace(c);
|
||||
}
|
||||
|
||||
int isupper(int c) {
|
||||
return __in_range(c, 'A', 'Z');
|
||||
}
|
||||
|
||||
int isupper_l(int c, locale_t) {
|
||||
return isupper(c);
|
||||
}
|
||||
|
||||
int isxdigit(int c) {
|
||||
return __in_range(c, '0', '9') || __in_range(c, 'a', 'f') || __in_range(c, 'A', 'F');
|
||||
}
|
||||
|
||||
int isxdigit_l(int c, locale_t) {
|
||||
return isxdigit(c);
|
||||
}
|
||||
|
||||
int toascii(int c) {
|
||||
return c & 0x7f;
|
||||
}
|
||||
|
||||
int _toupper(int c) {
|
||||
// Using EOR rather than AND makes no difference on arm, but saves an
|
||||
// instruction on arm64.
|
||||
return c ^ 0x20;
|
||||
}
|
||||
|
||||
int toupper(int c) {
|
||||
if (c >= 'a' && c <= 'z') return _toupper(c);
|
||||
return c;
|
||||
}
|
||||
|
||||
int toupper_l(int c, locale_t) {
|
||||
return toupper(c);
|
||||
}
|
||||
|
||||
int _tolower(int c) {
|
||||
return c | 0x20;
|
||||
}
|
||||
|
||||
int tolower(int c) {
|
||||
if (c >= 'A' && c <= 'Z') return _tolower(c);
|
||||
return c;
|
||||
}
|
||||
|
||||
int tolower_l(int c, locale_t) {
|
||||
return tolower(c);
|
||||
}
|
||||
|
||||
int tolower(int c) {
|
||||
if (c >= 'A' && c <= 'Z') return c | 0x20;
|
||||
return c;
|
||||
}
|
||||
|
||||
int toupper(int c) {
|
||||
// Using EOR rather than AND makes no difference on arm, but saves an
|
||||
// instruction on arm64.
|
||||
if (c >= 'a' && c <= 'z') return c ^ 0x20;
|
||||
return c;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ int ispunct(int __ch);
|
|||
int isspace(int __ch);
|
||||
/** Returns true if `ch` is in `[A-Z]`. */
|
||||
int isupper(int __ch);
|
||||
/** Returns true if `ch` is in `[0-9a-f]`. */
|
||||
/** Returns true if `ch` is in `[0-9A-Fa-f]`. */
|
||||
int isxdigit(int __ch);
|
||||
|
||||
/** Returns the corresponding lower-case character if `ch` is upper-case, or `ch` otherwise. */
|
||||
|
|
|
|||
|
|
@ -1,163 +0,0 @@
|
|||
/* $OpenBSD: isctype.c,v 1.12 2015/09/13 11:38:08 guenther Exp $ */
|
||||
/*
|
||||
* Copyright (c) 1989 The Regents of the University of California.
|
||||
* All rights reserved.
|
||||
* (c) UNIX System Laboratories, Inc.
|
||||
* All or some portions of this file are derived from material licensed
|
||||
* to the University of California by American Telephone and Telegraph
|
||||
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
||||
* the permission of UNIX System Laboratories, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#define _ANSI_LIBRARY
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#undef isalnum
|
||||
int
|
||||
isalnum(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & (_U|_L|_N)));
|
||||
}
|
||||
DEF_STRONG(isalnum);
|
||||
|
||||
#undef isalpha
|
||||
int
|
||||
isalpha(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & (_U|_L)));
|
||||
}
|
||||
DEF_STRONG(isalpha);
|
||||
|
||||
#undef isblank
|
||||
int
|
||||
isblank(int c)
|
||||
{
|
||||
return (c == ' ' || c == '\t');
|
||||
}
|
||||
DEF_STRONG(isblank);
|
||||
|
||||
#undef iscntrl
|
||||
int
|
||||
iscntrl(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _C));
|
||||
}
|
||||
DEF_STRONG(iscntrl);
|
||||
|
||||
#undef isdigit
|
||||
int
|
||||
isdigit(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _N));
|
||||
}
|
||||
DEF_STRONG(isdigit);
|
||||
|
||||
#undef isgraph
|
||||
int
|
||||
isgraph(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & (_P|_U|_L|_N)));
|
||||
}
|
||||
DEF_STRONG(isgraph);
|
||||
|
||||
#undef islower
|
||||
int
|
||||
islower(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _L));
|
||||
}
|
||||
DEF_STRONG(islower);
|
||||
|
||||
#undef isprint
|
||||
int
|
||||
isprint(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & (_P|_U|_L|_N|_B)));
|
||||
}
|
||||
DEF_STRONG(isprint);
|
||||
|
||||
#undef ispunct
|
||||
int
|
||||
ispunct(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _P));
|
||||
}
|
||||
DEF_STRONG(ispunct);
|
||||
|
||||
#undef isspace
|
||||
int
|
||||
isspace(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _S));
|
||||
}
|
||||
DEF_STRONG(isspace);
|
||||
|
||||
#undef isupper
|
||||
int
|
||||
isupper(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & _U));
|
||||
}
|
||||
DEF_STRONG(isupper);
|
||||
|
||||
#undef isxdigit
|
||||
int
|
||||
isxdigit(int c)
|
||||
{
|
||||
return (c == EOF ? 0 : ((_ctype_ + 1)[(unsigned char)c] & (_N|_X)));
|
||||
}
|
||||
DEF_STRONG(isxdigit);
|
||||
|
||||
#undef isascii
|
||||
int
|
||||
isascii(int c)
|
||||
{
|
||||
return ((unsigned int)c <= 0177);
|
||||
}
|
||||
DEF_WEAK(isascii);
|
||||
|
||||
#undef toascii
|
||||
int
|
||||
toascii(int c)
|
||||
{
|
||||
return (c & 0177);
|
||||
}
|
||||
|
||||
#undef _toupper
|
||||
int
|
||||
_toupper(int c)
|
||||
{
|
||||
return (c - 'a' + 'A');
|
||||
}
|
||||
|
||||
#undef _tolower
|
||||
int
|
||||
_tolower(int c)
|
||||
{
|
||||
return (c - 'A' + 'a');
|
||||
}
|
||||
|
|
@ -18,183 +18,278 @@
|
|||
|
||||
#include <ctype.h>
|
||||
|
||||
// We test from -1 (EOF) to 0xff, because that's the range for which behavior
|
||||
// is actually defined. (It's explicitly undefined below or above that.) Most
|
||||
// of our routines are no longer table-based and behave correctly for the
|
||||
// entire int range, but that's not true of other C libraries that we might
|
||||
// want to compare against, nor of our isalnum(3) and ispunt(3).
|
||||
static constexpr int kMin = -1;
|
||||
static constexpr int kMax = 256;
|
||||
|
||||
TEST(ctype, isalnum) {
|
||||
EXPECT_TRUE(isalnum('1'));
|
||||
EXPECT_TRUE(isalnum('a'));
|
||||
EXPECT_TRUE(isalnum('A'));
|
||||
EXPECT_FALSE(isalnum('!'));
|
||||
EXPECT_FALSE(isalnum(' '));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '0' && i <= '9') ||
|
||||
(i >= 'A' && i <= 'Z') ||
|
||||
(i >= 'a' && i <= 'z')) {
|
||||
EXPECT_TRUE(isalnum(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isalnum(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isalnum_l) {
|
||||
EXPECT_TRUE(isalnum_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isalnum_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isalnum_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isalnum_l('!', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isalnum_l(' ', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '0' && i <= '9') ||
|
||||
(i >= 'A' && i <= 'Z') ||
|
||||
(i >= 'a' && i <= 'z')) {
|
||||
EXPECT_TRUE(isalnum_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isalnum_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isalpha) {
|
||||
EXPECT_FALSE(isalpha('1'));
|
||||
EXPECT_TRUE(isalpha('a'));
|
||||
EXPECT_TRUE(isalpha('A'));
|
||||
EXPECT_FALSE(isalpha('!'));
|
||||
EXPECT_FALSE(isalpha(' '));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= 'A' && i <= 'Z') ||
|
||||
(i >= 'a' && i <= 'z')) {
|
||||
EXPECT_TRUE(isalpha(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isalpha(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isalpha_l) {
|
||||
EXPECT_FALSE(isalpha_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isalpha_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isalpha_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isalpha_l('!', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isalpha_l(' ', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= 'A' && i <= 'Z') ||
|
||||
(i >= 'a' && i <= 'z')) {
|
||||
EXPECT_TRUE(isalpha_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isalpha_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isascii) {
|
||||
EXPECT_TRUE(isascii('\x7f'));
|
||||
EXPECT_FALSE(isascii('\x80'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= 0 && i <= 0x7f) {
|
||||
EXPECT_TRUE(isascii(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isascii(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isblank) {
|
||||
EXPECT_FALSE(isblank('1'));
|
||||
EXPECT_TRUE(isblank(' '));
|
||||
EXPECT_TRUE(isblank('\t'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i == '\t' || i == ' ') {
|
||||
EXPECT_TRUE(isblank(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isblank(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isblank_l) {
|
||||
EXPECT_FALSE(isblank_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isblank_l(' ', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isblank_l('\t', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i == '\t' || i == ' ') {
|
||||
EXPECT_TRUE(isblank_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isblank_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, iscntrl) {
|
||||
EXPECT_FALSE(iscntrl('1'));
|
||||
EXPECT_TRUE(iscntrl('\b'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= 0 && i < ' ') || i == 0x7f) {
|
||||
EXPECT_TRUE(iscntrl(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(iscntrl(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, iscntrl_l) {
|
||||
EXPECT_FALSE(iscntrl_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(iscntrl_l('\b', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= 0 && i < ' ') || i == 0x7f) {
|
||||
EXPECT_TRUE(iscntrl_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(iscntrl_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isdigit) {
|
||||
EXPECT_TRUE(isdigit('1'));
|
||||
EXPECT_FALSE(isdigit('a'));
|
||||
EXPECT_FALSE(isdigit('x'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= '0' && i <= '9') {
|
||||
EXPECT_TRUE(isdigit(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isdigit(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isdigit_l) {
|
||||
EXPECT_TRUE(isdigit_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isdigit_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isdigit_l('x', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= '0' && i <= '9') {
|
||||
EXPECT_TRUE(isdigit_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isdigit_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isgraph) {
|
||||
EXPECT_TRUE(isgraph('a'));
|
||||
EXPECT_TRUE(isgraph('A'));
|
||||
EXPECT_TRUE(isgraph('1'));
|
||||
EXPECT_TRUE(isgraph('!'));
|
||||
EXPECT_FALSE(isgraph(' '));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= '!' && i <= '~') {
|
||||
EXPECT_TRUE(isgraph(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isgraph(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isgraph_l) {
|
||||
EXPECT_TRUE(isgraph_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isgraph_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isgraph_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isgraph_l('!', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isgraph_l(' ', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= '!' && i <= '~') {
|
||||
EXPECT_TRUE(isgraph_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isgraph_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, islower) {
|
||||
EXPECT_TRUE(islower('a'));
|
||||
EXPECT_FALSE(islower('A'));
|
||||
EXPECT_FALSE(islower('!'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= 'a' && i <= 'z') {
|
||||
EXPECT_TRUE(islower(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(islower(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, islower_l) {
|
||||
EXPECT_TRUE(islower_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(islower_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(islower_l('!', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= 'a' && i <= 'z') {
|
||||
EXPECT_TRUE(islower_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(islower_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isprint) {
|
||||
EXPECT_TRUE(isprint('a'));
|
||||
EXPECT_TRUE(isprint(' '));
|
||||
EXPECT_FALSE(isprint('\b'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= ' ' && i <= '~') {
|
||||
EXPECT_TRUE(isprint(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isprint(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isprint_l) {
|
||||
EXPECT_TRUE(isprint_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isprint_l(' ', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isprint_l('\b', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= ' ' && i <= '~') {
|
||||
EXPECT_TRUE(isprint_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isprint_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, ispunct) {
|
||||
EXPECT_TRUE(ispunct('!'));
|
||||
EXPECT_FALSE(ispunct('a'));
|
||||
EXPECT_FALSE(ispunct(' '));
|
||||
EXPECT_FALSE(ispunct('\b'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '!' && i <= '/') ||
|
||||
(i >= ':' && i <= '@') ||
|
||||
(i >= '[' && i <= '`') ||
|
||||
(i >= '{' && i <= '~')) {
|
||||
EXPECT_TRUE(ispunct(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(ispunct(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, ispunct_l) {
|
||||
EXPECT_TRUE(ispunct_l('!', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(ispunct_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(ispunct_l(' ', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(ispunct_l('\b', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '!' && i <= '/') ||
|
||||
(i >= ':' && i <= '@') ||
|
||||
(i >= '[' && i <= '`') ||
|
||||
(i >= '{' && i <= '~')) {
|
||||
EXPECT_TRUE(ispunct_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(ispunct_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isspace) {
|
||||
EXPECT_TRUE(isspace(' '));
|
||||
EXPECT_TRUE(isspace('\f'));
|
||||
EXPECT_TRUE(isspace('\n'));
|
||||
EXPECT_TRUE(isspace('\r'));
|
||||
EXPECT_TRUE(isspace('\t'));
|
||||
EXPECT_TRUE(isspace('\v'));
|
||||
EXPECT_FALSE(isspace('a'));
|
||||
EXPECT_FALSE(isspace('!'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '\t' && i <= '\r') || i == ' ') {
|
||||
EXPECT_TRUE(isspace(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isspace(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isspace_l) {
|
||||
EXPECT_TRUE(isspace_l(' ', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isspace_l('\f', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isspace_l('\n', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isspace_l('\r', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isspace_l('\t', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isspace_l('\v', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isspace_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isspace_l('!', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '\t' && i <= '\r') || i == ' ') {
|
||||
EXPECT_TRUE(isspace_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isspace_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isupper) {
|
||||
EXPECT_TRUE(isupper('A'));
|
||||
EXPECT_FALSE(isupper('a'));
|
||||
EXPECT_FALSE(isupper('!'));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= 'A' && i <= 'Z') {
|
||||
EXPECT_TRUE(isupper(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isupper(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isupper_l) {
|
||||
EXPECT_TRUE(isupper_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isupper_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isupper_l('!', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if (i >= 'A' && i <= 'Z') {
|
||||
EXPECT_TRUE(isupper_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isupper_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isxdigit) {
|
||||
EXPECT_TRUE(isxdigit('0'));
|
||||
EXPECT_FALSE(isxdigit('x'));
|
||||
EXPECT_TRUE(isxdigit('1'));
|
||||
EXPECT_TRUE(isxdigit('a'));
|
||||
EXPECT_TRUE(isxdigit('A'));
|
||||
EXPECT_FALSE(isxdigit('g'));
|
||||
EXPECT_FALSE(isxdigit(' '));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '0' && i <= '9') ||
|
||||
(i >= 'A' && i <= 'F') ||
|
||||
(i >= 'a' && i <= 'f')) {
|
||||
EXPECT_TRUE(isxdigit(i)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isxdigit(i)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, isxdigit_l) {
|
||||
EXPECT_TRUE(isxdigit_l('0', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isxdigit_l('x', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isxdigit_l('1', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isxdigit_l('a', LC_GLOBAL_LOCALE));
|
||||
EXPECT_TRUE(isxdigit_l('A', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isxdigit_l('g', LC_GLOBAL_LOCALE));
|
||||
EXPECT_FALSE(isxdigit_l(' ', LC_GLOBAL_LOCALE));
|
||||
for (int i = kMin; i < kMax; ++i) {
|
||||
if ((i >= '0' && i <= '9') ||
|
||||
(i >= 'A' && i <= 'F') ||
|
||||
(i >= 'a' && i <= 'f')) {
|
||||
EXPECT_TRUE(isxdigit_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
} else {
|
||||
EXPECT_FALSE(isxdigit_l(i, LC_GLOBAL_LOCALE)) << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ctype, toascii) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue