diff --git a/benchmarks/ctype_benchmark.cpp b/benchmarks/ctype_benchmark.cpp
index 3c7f48d..eab0133 100644
--- a/benchmarks/ctype_benchmark.cpp
+++ b/benchmarks/ctype_benchmark.cpp
@@ -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'));
 
diff --git a/libc/Android.bp b/libc/Android.bp
index 3653f45..37e0f09 100644
--- a/libc/Android.bp
+++ b/libc/Android.bp
@@ -438,7 +438,6 @@
         "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",
diff --git a/libc/bionic/ctype.cpp b/libc/bionic/ctype.cpp
index b72935b..ba8afca 100644
--- a/libc/bionic/ctype.cpp
+++ b/libc/bionic/ctype.cpp
@@ -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_l(int c, locale_t) {
-  return tolower(c);
+int _tolower(int c) {
+  return c | 0x20;
 }
 
 int tolower(int c) {
-  if (c >= 'A' && c <= 'Z') return c | 0x20;
+  if (c >= 'A' && c <= 'Z') return _tolower(c);
   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;
+int tolower_l(int c, locale_t) {
+  return tolower(c);
 }
diff --git a/libc/include/android/api-level.h b/libc/include/android/api-level.h
index af7cde1..4a3d052 100644
--- a/libc/include/android/api-level.h
+++ b/libc/include/android/api-level.h
@@ -37,70 +37,89 @@
 
 __BEGIN_DECLS
 
-#ifndef __ANDROID_API_FUTURE__
 /**
  * Magic version number for an Android OS build which has
  * not yet turned into an official release,
- * for comparisons against __ANDROID_API__.
+ * for comparison against `__ANDROID_API__`.
  */
 #define __ANDROID_API_FUTURE__ 10000
-#endif
 
+/* This #ifndef should never be true except when doxygen is generating docs. */
 #ifndef __ANDROID_API__
 /**
  * `__ANDROID_API__` is the API level being targeted. For the OS,
  * this is `__ANDROID_API_FUTURE__`. For the NDK, this is set by the
- * compiler/build system based on the API level you claimed to target.
+ * compiler system based on the API level you claimed to target.
  */
 #define __ANDROID_API__ __ANDROID_API_FUTURE__
 #endif
 
-/** Names the Gingerbread API level (9), for comparisons against __ANDROID_API__. */
+#if __ANDROID_API__ != __ANDROID_API_FUTURE__
+/**
+ * `__ANDROID_NDK__` is defined for code that's built by the NDK
+ * rather than as part of the OS. "Built by the NDK" is an ambiguous idea,
+ * so you might prefer to check `__ANDROID__`, `__BIONIC__`, `__linux__`,
+ * or `__NDK_MAJOR__` instead, depending on exactly what you're trying to say.
+ *
+ * `__ANDROID_NDK__` is intended to capture "this code is being built for
+ * Android, but targeting a specific API level". This is true for all code built
+ * by the NDK proper, but also for OS code that sets `sdk_version` in its build
+ * file. This distinction might matter to you if, for example, your code could
+ * be built as part of an app *or* as part of the OS.
+ */
+#define __ANDROID_NDK__ 1
+#endif
+
+/** Names the Gingerbread API level (9), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_G__ 9
 
-/** Names the Ice-Cream Sandwich API level (14), for comparisons against __ANDROID_API__. */
+/** Names the Ice-Cream Sandwich API level (14), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_I__ 14
 
-/** Names the Jellybean API level (16), for comparisons against __ANDROID_API__. */
+/** Names the Jellybean API level (16), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_J__ 16
 
-/** Names the Jellybean MR1 API level (17), for comparisons against __ANDROID_API__. */
+/** Names the Jellybean MR1 API level (17), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_J_MR1__ 17
 
-/** Names the Jellybean MR2 API level (18), for comparisons against __ANDROID_API__. */
+/** Names the Jellybean MR2 API level (18), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_J_MR2__ 18
 
-/** Names the KitKat API level (19), for comparisons against __ANDROID_API__. */
+/** Names the KitKat API level (19), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_K__ 19
 
-/** Names the Lollipop API level (21), for comparisons against __ANDROID_API__. */
+/** Names the Lollipop API level (21), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_L__ 21
 
-/** Names the Lollipop MR1 API level (22), for comparisons against __ANDROID_API__. */
+/** Names the Lollipop MR1 API level (22), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_L_MR1__ 22
 
-/** Names the Marshmallow API level (23), for comparisons against __ANDROID_API__. */
+/** Names the Marshmallow API level (23), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_M__ 23
 
-/** Names the Nougat API level (24), for comparisons against __ANDROID_API__. */
+/** Names the Nougat API level (24), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_N__ 24
 
-/** Names the Nougat MR1 API level (25), for comparisons against __ANDROID_API__. */
+/** Names the Nougat MR1 API level (25), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_N_MR1__ 25
 
-/** Names the Oreo API level (26), for comparisons against __ANDROID_API__. */
+/** Names the Oreo API level (26), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_O__ 26
 
-/** Names the Oreo MR1 API level (27), for comparisons against __ANDROID_API__. */
+/** Names the Oreo MR1 API level (27), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_O_MR1__ 27
 
-/** Names the Pie API level (28), for comparisons against __ANDROID_API__. */
+/** Names the Pie API level (28), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_P__ 28
 
-/** Names the "Q" API level (29), for comparisons against __ANDROID_API__. */
+/**
+ * Names the "Q" API level (29), for comparison against `__ANDROID_API__`.
+ * This release was called Android 10 publicly, not to be (but sure to be)
+ * confused with API level 10.
+ */
 #define __ANDROID_API_Q__ 29
 
-/** Names the "R" API level (30), for comparisons against __ANDROID_API__. */
+/** Names the "R" API level (30), for comparison against `__ANDROID_API__`. */
 #define __ANDROID_API_R__ 30
 
 /**
diff --git a/libc/include/ctype.h b/libc/include/ctype.h
index e91b0e2..e7df299 100644
--- a/libc/include/ctype.h
+++ b/libc/include/ctype.h
@@ -97,7 +97,7 @@
 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. */
diff --git a/libc/upstream-openbsd/lib/libc/gen/isctype.c b/libc/upstream-openbsd/lib/libc/gen/isctype.c
deleted file mode 100644
index a4e944c..0000000
--- a/libc/upstream-openbsd/lib/libc/gen/isctype.c
+++ /dev/null
@@ -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');
-}
diff --git a/libm/Android.bp b/libm/Android.bp
index b7bae54..bf05b17 100644
--- a/libm/Android.bp
+++ b/libm/Android.bp
@@ -463,7 +463,6 @@
 
     cflags: [
         "-D__BIONIC_LP32_USE_LONG_DOUBLE",
-        "-D__BIONIC_NO_MATH_INLINES",
         "-D_BSD_SOURCE",
         "-DFLT_EVAL_METHOD=0",
         "-include freebsd-compat.h",
diff --git a/tests/ctype_test.cpp b/tests/ctype_test.cpp
index c12518b..826d39a 100644
--- a/tests/ctype_test.cpp
+++ b/tests/ctype_test.cpp
@@ -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) {