diff --git a/tests/buffer_tests.cpp b/tests/buffer_tests.cpp
index 9e6318b..4967382 100644
--- a/tests/buffer_tests.cpp
+++ b/tests/buffer_tests.cpp
@@ -21,6 +21,10 @@
 #include <gtest/gtest.h>
 #include "buffer_tests.h"
 
+// For the comparison buffer tests, the maximum length to test for the
+// miscompare checks.
+#define MISCMP_MAX_LENGTH 512
+
 #define FENCEPOST_LENGTH 8
 
 static int g_single_aligns[][2] = {
@@ -248,9 +252,7 @@
 
       test_func(buf_align, len);
 
-      if (buf_align != buf) {
-        VerifyFencepost(&buf_align[-FENCEPOST_LENGTH]);
-      }
+      VerifyFencepost(&buf_align[-FENCEPOST_LENGTH]);
       VerifyFencepost(&buf_align[len]);
     }
   }
@@ -286,9 +288,7 @@
 
       test_func(src_align, dst_align, len);
 
-      if (dst_align != dst) {
-        VerifyFencepost(&dst_align[-FENCEPOST_LENGTH]);
-      }
+      VerifyFencepost(&dst_align[-FENCEPOST_LENGTH]);
       VerifyFencepost(&dst_align[len]);
     }
   }
@@ -296,6 +296,58 @@
   delete dst;
 }
 
+void RunCmpBufferAlignTest(
+    size_t max_test_size, void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
+    void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t),
+    size_t (*set_incr)(size_t)) {
+  if (!set_incr) {
+    set_incr = SetIncrement;
+  }
+
+  // Allocate two large buffers for all of the testing.
+  uint8_t* buf1 = new uint8_t[3*max_test_size];
+  uint8_t* buf2 = new uint8_t[3*max_test_size];
+
+  uint8_t* buf1_align;
+  uint8_t* buf2_align;
+  for (size_t i = 0; i < g_double_aligns_len; i++) {
+    size_t incr = 1;
+    for (size_t len = 0; len <= max_test_size; len += incr) {
+      incr = set_incr(len);
+
+      buf1_align =
+          reinterpret_cast<uint8_t*>(GetAlignedPtr(
+              buf1, g_double_aligns[i][0], g_double_aligns[i][1]));
+      buf2_align =
+          reinterpret_cast<uint8_t*>(GetAlignedPtr(
+              buf2, g_double_aligns[i][2], g_double_aligns[i][3]));
+
+      // Check by putting all zeroes after both buffers.
+      memset(buf1_align+len, 0, 32);
+      memset(buf2_align+len, 0, 32);
+      test_cmp_func(buf1_align, buf2_align, len);
+
+      // Check by putting different values after both buffers.
+      for (size_t j = 0; j < 32; j++) {
+        buf1_align[len+j] = j;
+        buf2_align[len+j] = j+1;
+      }
+      test_cmp_func(buf1_align, buf2_align, len);
+
+      if (len > 0) {
+        // Change the lengths of the buffers and verify that there are
+        // miscompares.
+        for (size_t len2 = len+1; len2 < len+32; len2++) {
+          test_miscmp_func(buf1_align, buf2_align, len, len2);
+          test_miscmp_func(buf1_align, buf2_align, len2, len);
+        }
+      }
+    }
+  }
+  delete buf1;
+  delete buf2;
+}
+
 void RunSingleBufferOverreadTest(void (*test_func)(uint8_t*, size_t)) {
   // In order to verify that functions are not reading past the end of the
   // src, create data that ends exactly at an unreadable memory boundary.
@@ -339,3 +391,58 @@
   free(memory);
   delete dst;
 }
+
+void RunCmpBufferOverreadTest(
+    void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
+    void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t)) {
+  // In order to verify that functions are not reading past the end of either
+  // of the bufs, create both buffers that end exactly at an unreadable memory
+  // boundary.
+  size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
+  uint8_t* memory1;
+  ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory1), pagesize,
+                             2*pagesize) == 0);
+  memset(memory1, 0x23, 2*pagesize);
+
+  // Make the second page unreadable and unwritable.
+  ASSERT_TRUE(mprotect(&memory1[pagesize], pagesize, PROT_NONE) == 0);
+
+  uint8_t* memory2;
+  ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory2), pagesize,
+                             2*pagesize) == 0);
+  memset(memory2, 0x23, 2*pagesize);
+
+  // Make the second page unreadable and unwritable.
+  ASSERT_TRUE(mprotect(&memory2[pagesize], pagesize, PROT_NONE) == 0);
+
+  for (size_t i = 0; i < pagesize; i++) {
+    uint8_t* buf1 = &memory1[pagesize-i];
+    uint8_t* buf2 = &memory2[pagesize-i];
+
+    test_cmp_func(buf1, buf2, i);
+  }
+
+  // Don't cycle through pagesize, MISCMP_MAX_LENGTH bytes should be good.
+  size_t miscmp_len;
+  if (pagesize > MISCMP_MAX_LENGTH) {
+    miscmp_len = MISCMP_MAX_LENGTH;
+  } else {
+    miscmp_len = pagesize;
+  }
+  for (size_t i = 1; i < miscmp_len; i++) {
+    uint8_t* buf1 = &memory1[pagesize-i];
+    for (size_t j = 1; j < miscmp_len; j++) {
+      if (j == i)
+        continue;
+
+      uint8_t* buf2 = &memory2[pagesize-j];
+
+      test_miscmp_func(buf1, buf2, i, j);
+    }
+  }
+
+  ASSERT_TRUE(mprotect(&memory1[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
+  ASSERT_TRUE(mprotect(&memory2[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
+  free(memory1);
+  free(memory2);
+}
diff --git a/tests/buffer_tests.h b/tests/buffer_tests.h
index f8685a2..315083b 100644
--- a/tests/buffer_tests.h
+++ b/tests/buffer_tests.h
@@ -28,8 +28,17 @@
     size_t max_test_size, void (*test_func)(uint8_t*, uint8_t*, size_t),
     size_t (*set_incr)(size_t) = NULL);
 
+void RunCmpBufferAlignTest(
+    size_t max_test_size, void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
+    void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t),
+    size_t (*set_incr)(size_t) = NULL);
+
 void RunSingleBufferOverreadTest(void (*test_func)(uint8_t*, size_t));
 
 void RunSrcDstBufferOverreadTest(void (*test_func)(uint8_t*, uint8_t*, size_t));
 
+void RunCmpBufferOverreadTest(
+    void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
+    void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t));
+
 #endif // _BIONIC_TESTS_BUFFER_TESTS_H
diff --git a/tests/string_test.cpp b/tests/string_test.cpp
index be46dc9..1a7e27d 100644
--- a/tests/string_test.cpp
+++ b/tests/string_test.cpp
@@ -956,7 +956,7 @@
 }
 
 // Use our own incrementer to cut down on the total number of calls.
-static size_t StrcatSetIncrement(size_t len) {
+static size_t LargeSetIncrement(size_t len) {
   if (len >= 4096) {
     return 4096;
   } else if (len >= 1024) {
@@ -1001,9 +1001,94 @@
 }
 
 TEST(string, strcat_align) {
-  RunSrcDstBufferAlignTest(MEDIUM, DoStrcatTest, StrcatSetIncrement);
+  RunSrcDstBufferAlignTest(MEDIUM, DoStrcatTest, LargeSetIncrement);
 }
 
 TEST(string, strcat_overread) {
   RunSrcDstBufferOverreadTest(DoStrcatTest);
 }
+
+static void DoStrcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
+  if (len >= 1) {
+    memset(buf1, (32 + (len % 96)), len - 1);
+    buf1[len-1] = '\0';
+    memset(buf2, (32 + (len % 96)), len - 1);
+    buf2[len-1] = '\0';
+    ASSERT_EQ(0, strcmp(reinterpret_cast<char*>(buf1),
+                        reinterpret_cast<char*>(buf2)));
+  }
+}
+
+static void DoStrcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
+  // Do string length differences.
+  int c = (32 + (len1 % 96));
+  memset(buf1, c, len1 - 1);
+  buf1[len1-1] = '\0';
+  memset(buf2, c, len2 - 1);
+  buf2[len2-1] = '\0';
+  ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
+                      reinterpret_cast<char*>(buf2)));
+
+  // Do single character differences.
+  size_t len;
+  if (len1 > len2) {
+    len = len2;
+  } else {
+    len = len1;
+  }
+  // Need at least a two character buffer to do this test.
+  if (len > 1) {
+    buf1[len-1] = '\0';
+    buf2[len-1] = '\0';
+    int diff_c = (c + 1) % 96;
+
+    buf1[len-2] = diff_c;
+    ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
+                        reinterpret_cast<char*>(buf2)));
+
+    buf1[len-2] = c;
+    buf2[len-2] = diff_c;
+    ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
+                        reinterpret_cast<char*>(buf2)));
+  }
+}
+
+TEST(string, strcmp_align) {
+  RunCmpBufferAlignTest(MEDIUM, DoStrcmpTest, DoStrcmpFailTest, LargeSetIncrement);
+}
+
+TEST(string, strcmp_overread) {
+  RunCmpBufferOverreadTest(DoStrcmpTest, DoStrcmpFailTest);
+}
+
+static void DoMemcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
+  memset(buf1, len+1, len);
+  memset(buf2, len+1, len);
+  ASSERT_EQ(0, memcmp(buf1, buf2, len));
+}
+
+static void DoMemcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
+  size_t len;
+  if (len1 > len2) {
+    len = len2;
+  } else {
+    len = len1;
+  }
+
+  memset(buf1, len2+1, len);
+  buf1[len-1] = len2;
+  memset(buf2, len2+1, len);
+  ASSERT_NE(0, memcmp(buf1, buf2, len));
+
+  buf1[len-1] = len2+1;
+  buf2[len-1] = len2;
+  ASSERT_NE(0, memcmp(buf1, buf2, len));
+}
+
+TEST(string, memcmp_align) {
+  RunCmpBufferAlignTest(MEDIUM, DoMemcmpTest, DoMemcmpFailTest, LargeSetIncrement);
+}
+
+TEST(string, memcmp_overread) {
+  RunCmpBufferOverreadTest(DoMemcmpTest, DoMemcmpFailTest);
+}