+2026-03-01 Bruno Haible <bruno@clisp.org>
+
+ tests: Use memeq, part 1.
+ Done through
+ sed -e 's/memcmp \([(][^()]*[)]\) == 0/memeq \1/g' \
+ -e 's/memcmp \([(][^()]*[(][^()]*[)][^()]*[)]\) == 0/memeq \1/g'
+ * tests/**/*.[hc]: Use memeq instead of memcmp ... == 0.
+ * modules/*-tests (Dependencies): Add memeq.
+
2026-03-01 Bruno Haible <bruno@clisp.org>
tests: Use streq, part 4.
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
setlocale
strerror
streq
+memeq
configure.ac:
gt_LOCALE_FR
setlocale
localcharset
streq
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
Depends-on:
setlocale
mbstoc32s
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
Depends-on:
setlocale
mbstoc32s
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
Depends-on:
setlocale
mbstoc32s
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
mbrtoc32
c32rtomb
setlocale
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
mbrtoc32
c32rtomb
setlocale
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
thrd
gettimeofday
streq
+memeq
configure.ac:
AC_CHECK_DECLS_ONCE([alarm])
gettimeofday
sleep
streq
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
float-h
+memeq
configure.ac:
c99
getrusage
gettimeofday
+memeq
configure.ac:
error
test-framework-sh
streq
+memeq
configure.ac:
stdint-h
unistd-h
streq
+memeq
configure.ac:
dnl Test for Linux system call close_range(), declared in <unistd.h>.
Depends-on:
stdint-h
vma-iter
+memeq
configure.ac:
Depends-on:
fflush
ftell
+memeq
configure.ac:
Depends-on:
lseek
unistd-h
+memeq
configure.ac:
Depends-on:
unistd-h
+memeq
configure.ac:
fsync
ftruncate
write
+memeq
configure.ac:
Depends-on:
binary-io
+memeq
configure.ac:
gl_FUNC_UNGETC_WORKS
binary-io
fdopen
ftello-extra-tests
+memeq
configure.ac:
gl_FUNC_UNGETC_WORKS
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
iconv_open
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
stdint-h
vma-iter
+memeq
configure.ac:
usleep
read
write
+memeq
configure.ac:
usleep
read
write
+memeq
configure.ac:
setlocale
strerror
streq
+memeq
configure.ac:
gt_LOCALE_FR
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
nan
+memeq
configure.ac:
tests/signature.h
Depends-on:
+memeq
configure.ac:
full-write
usleep
streq
+memeq
configure.ac:
read-file
full-write
streq
+memeq
configure.ac:
freopen
waitpid
streq
+memeq
configure.ac:
posix_spawn_file_actions_destroy
posix_spawnp-tests
findprog
+memeq
configure.ac:
sh-filename
sigprocmask
waitpid
+memeq
configure.ac:
nanosleep
sched_yield
streq
+memeq
configure.ac:
AC_CHECK_DECLS_ONCE([alarm])
pthread-thread
test-xfail
streq
+memeq
configure.ac:
Depends-on:
same-inode
streq
+memeq
configure.ac:
AC_CHECK_DECLS_ONCE([alarm])
Depends-on:
same-inode
streq
+memeq
configure.ac:
AC_CHECK_DECLS_ONCE([alarm])
c99
stdint-h
streq
+memeq
configure.ac:
dnl Check for prerequisites for memory fence checks.
setlocale
localcharset
streq
+memeq
configure.ac:
gt_LOCALE_FR
Depends-on:
binary-io
open
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
sleep
test-xfail
streq
+memeq
configure.ac:
nan
snan
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
nan
streq
+memeq
configure.ac:
msvc-inval
bool
stdint-h
+memeq
configure.ac:
nan
snan
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
close
test-framework-sh
+memeq
configure.ac:
unlink
rmdir
symlink
+memeq
configure.ac:
unistd-h
popen
pclose
+memeq
configure.ac:
Depends-on:
nan
streq
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
unistr/u8-strlen
+memeq
configure.ac:
Depends-on:
unistdio/ulc-asnprintf-extra-tests
streq
+memeq
configure.ac:
Depends-on:
setlocale
streq
+memeq
configure.ac:
gt_LOCALE_FR
unistr/u16-set
unistr/u32-set
unistr/u32-to-u16
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
unistr/u16-set
unistr/u32-set
unistr/u32-to-u16
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
c99
extensions
unistr/u32-set
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
Depends-on:
extensions
unistr/u32-set
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
unistr/u8-set
unistr/u32-set
unistr/u32-to-u8
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
unistr/u8-set
unistr/u32-set
unistr/u32-to-u8
+memeq
configure.ac:
gl_FUNC_MMAP_ANON
setlocale
localeconv
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
vasnprintf-extra-tests
streq
+memeq
configure.ac:
nan
snan
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
nan
streq
+memeq
configure.ac:
nan
snan
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
streq
+memeq
configure.ac:
Depends-on:
nan
streq
+memeq
configure.ac:
nan
snan
streq
+memeq
configure.ac:
AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
Depends-on:
nan
streq
+memeq
configure.ac:
setlocale
localcharset
streq
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
Depends-on:
setlocale
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
Depends-on:
setlocale
+memeq
configure.ac:
gt_LOCALE_EN_UTF8
tests/macros.h
Depends-on:
+memeq
configure.ac:
Depends-on:
binary-io
open
+memeq
configure.ac:
Depends-on:
streq
+memeq
configure.ac:
tests/macros.h
Depends-on:
+memeq
configure.ac:
memset (out, 0x42, sizeof (out));
base32_encode (in, 1, out, 10);
- ASSERT (memcmp (out, "ME======", 1) == 0);
+ ASSERT (memeq (out, "ME======", 1));
memset (out, 0x42, sizeof (out));
base32_encode (in, 1, out, 2);
- ASSERT (memcmp (out, "ME======", 2) == 0);
+ ASSERT (memeq (out, "ME======", 2));
memset (out, 0x42, sizeof (out));
base32_encode (in, 1, out, 3);
- ASSERT (memcmp (out, "ME======", 3) == 0);
+ ASSERT (memeq (out, "ME======", 3));
memset (out, 0x42, sizeof (out));
base32_encode (in, 1, out, 4);
- ASSERT (memcmp (out, "ME======", 4) == 0);
+ ASSERT (memeq (out, "ME======", 4));
memset (out, 0x42, sizeof (out));
base32_encode (in, 1, out, 8);
- ASSERT (memcmp (out, "ME======", 8) == 0);
+ ASSERT (memeq (out, "ME======", 8));
memset (out, 0x42, sizeof (out));
base32_encode (in, 2, out, 8);
- ASSERT (memcmp (out, "MFRA====", 8) == 0);
+ ASSERT (memeq (out, "MFRA====", 8));
memset (out, 0x42, sizeof (out));
base32_encode (in, 3, out, 8);
- ASSERT (memcmp (out, "MFRGG===", 8) == 0);
+ ASSERT (memeq (out, "MFRGG===", 8));
memset (out, 0x42, sizeof (out));
base32_encode (in, 4, out, 8);
- ASSERT (memcmp (out, "MFRGGZA=", 8) == 0);
+ ASSERT (memeq (out, "MFRGGZA=", 8));
memset (out, 0x42, sizeof (out));
base32_encode (in, 5, out, 8);
- ASSERT (memcmp (out, "MFRGGZDF", 8) == 0);
+ ASSERT (memeq (out, "MFRGGZDF", 8));
memset (out, 0x42, sizeof (out));
base32_encode (in, 6, out, 16);
- ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
+ ASSERT (memeq (out, "MFRGGZDFMY======", 16));
memset (out, 0x42, sizeof (out));
base32_encode (in, 6, out, 100);
- ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
+ ASSERT (memeq (out, "MFRGGZDFMY======", 16));
/* Decode. */
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 1);
- ASSERT (memcmp (out, "abcdefghijklmnop", 1) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 1));
memset (out, 0x42, sizeof (out));
len = 2;
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 2);
- ASSERT (memcmp (out, "abcdefghijklmnop", 2) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 2));
memset (out, 0x42, sizeof (out));
len = 3;
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 3);
- ASSERT (memcmp (out, "abcdefghijklmnop", 3) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 3));
memset (out, 0x42, sizeof (out));
len = 4;
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 4);
- ASSERT (memcmp (out, "abcdefghijklmnop", 4) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 4));
memset (out, 0x42, sizeof (out));
len = 5;
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 5);
- ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 5));
memset (out, 0x42, sizeof (out));
len = 6;
ok = base32_decode (b32in, 8, out, &len);
ASSERT (ok);
ASSERT (len == 5);
- ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 5));
memset (out, 0x42, sizeof (out));
len = 100;
ok = base32_decode (b32in, strlen (b32in), out, &len);
ASSERT (ok);
ASSERT (len == 16);
- ASSERT (memcmp (out, "abcdefghijklmnop", 16) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", 16));
/* Allocating encode */
ok = base32_decode_ctx (&ctx, b32in, strlen (b32in), out, &len);
ASSERT (ok);
ASSERT (len == 16);
- ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", len));
}
/* Allocating decode context function */
ok = base32_decode_alloc_ctx (NULL, b32in, strlen (b32in), &p, &len);
ASSERT (ok);
ASSERT (len == 16);
- ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
+ ASSERT (memeq (out, "abcdefghijklmnop", len));
free (p);
{
ok = base32_decode_alloc_ctx (&ctx, newlineb32, strlen (newlineb32), &p, &len);
ASSERT (ok);
ASSERT (len == strlen (in));
- ASSERT (memcmp (p, in, len) == 0);
+ ASSERT (memeq (p, in, len));
free (p);
}
ok = base32_decode_alloc_ctx (&ctx, "MFRGGZDFM\nZTWQ2LK", 17, &p, &len);
ASSERT (ok);
ASSERT (len == 10);
- ASSERT (memcmp (p, "abcdefghij", len) == 0);
+ ASSERT (memeq (p, "abcdefghij", len));
free (p);
base32_decode_ctx_init (&ctx);
ok = base32_decode_alloc_ctx (&ctx, "RGGZDFMZ", 8, &p, &len);
ASSERT (ok);
ASSERT (len == 5);
- ASSERT (memcmp (p, "abcde", len) == 0);
+ ASSERT (memeq (p, "abcde", len));
free (p);
ok = base32_decode_alloc_ctx (&ctx, "TWQ2LK", 6, &p, &len);
ASSERT (ok);
ASSERT (len == 5);
- ASSERT (memcmp (p, "fghij", len) == 0);
+ ASSERT (memeq (p, "fghij", len));
free (p);
ok = base32_decode_alloc_ctx (&ctx, "", 0, &p, &len);
memset (out, 0x42, sizeof (out));
base64_encode (in, 1, out, 1);
- ASSERT (memcmp (out, "YQ==", 1) == 0);
+ ASSERT (memeq (out, "YQ==", 1));
memset (out, 0x42, sizeof (out));
base64_encode (in, 1, out, 2);
- ASSERT (memcmp (out, "YQ==", 2) == 0);
+ ASSERT (memeq (out, "YQ==", 2));
memset (out, 0x42, sizeof (out));
base64_encode (in, 1, out, 3);
- ASSERT (memcmp (out, "YQ==", 3) == 0);
+ ASSERT (memeq (out, "YQ==", 3));
memset (out, 0x42, sizeof (out));
base64_encode (in, 1, out, 4);
- ASSERT (memcmp (out, "YQ==", 4) == 0);
+ ASSERT (memeq (out, "YQ==", 4));
memset (out, 0x42, sizeof (out));
base64_encode (in, 1, out, 8);
- ASSERT (memcmp (out, "YQ==", 4) == 0);
+ ASSERT (memeq (out, "YQ==", 4));
memset (out, 0x42, sizeof (out));
base64_encode (in, 2, out, 4);
- ASSERT (memcmp (out, "YWI=", 4) == 0);
+ ASSERT (memeq (out, "YWI=", 4));
memset (out, 0x42, sizeof (out));
base64_encode (in, 3, out, 4);
- ASSERT (memcmp (out, "YWJj", 4) == 0);
+ ASSERT (memeq (out, "YWJj", 4));
memset (out, 0x42, sizeof (out));
base64_encode (in, 4, out, 5);
- ASSERT (memcmp (out, "YWJjZA==", 5) == 0);
+ ASSERT (memeq (out, "YWJjZA==", 5));
memset (out, 0x42, sizeof (out));
base64_encode (in, 4, out, 100);
- ASSERT (memcmp (out, "YWJjZA==", 6) == 0);
+ ASSERT (memeq (out, "YWJjZA==", 6));
/* Decode. */
ok = base64_decode (b64in, 4, out, &len);
ASSERT (ok);
ASSERT (len == 1);
- ASSERT (memcmp (out, "abcdefg", 1) == 0);
+ ASSERT (memeq (out, "abcdefg", 1));
memset (out, 0x42, sizeof (out));
len = 2;
ok = base64_decode (b64in, 4, out, &len);
ASSERT (ok);
ASSERT (len == 2);
- ASSERT (memcmp (out, "abcdefg", 2) == 0);
+ ASSERT (memeq (out, "abcdefg", 2));
memset (out, 0x42, sizeof (out));
len = 3;
ok = base64_decode (b64in, 4, out, &len);
ASSERT (ok);
ASSERT (len == 3);
- ASSERT (memcmp (out, "abcdefg", 3) == 0);
+ ASSERT (memeq (out, "abcdefg", 3));
memset (out, 0x42, sizeof (out));
len = 4;
ok = base64_decode (b64in, 4, out, &len);
ASSERT (ok);
ASSERT (len == 3);
- ASSERT (memcmp (out, "abcdefg", 3) == 0);
+ ASSERT (memeq (out, "abcdefg", 3));
memset (out, 0x42, sizeof (out));
len = 100;
ok = base64_decode (b64in, strlen (b64in), out, &len);
ASSERT (ok);
ASSERT (len == 7);
- ASSERT (memcmp (out, "abcdefg", 7) == 0);
+ ASSERT (memeq (out, "abcdefg", 7));
/* Allocating encode */
ok = base64_decode_ctx (&ctx, b64in, strlen (b64in), out, &len);
ASSERT (ok);
ASSERT (len == 7);
- ASSERT (memcmp (out, "abcdefg", len) == 0);
+ ASSERT (memeq (out, "abcdefg", len));
}
/* Allocating decode context function */
ok = base64_decode_alloc_ctx (NULL, b64in, strlen (b64in), &p, &len);
ASSERT (ok);
ASSERT (len == 7);
- ASSERT (memcmp (out, "abcdefg", len) == 0);
+ ASSERT (memeq (out, "abcdefg", len));
free (p);
{
ok = base64_decode_alloc_ctx (&ctx, newlineb64, strlen (newlineb64), &p, &len);
ASSERT (ok);
ASSERT (len == strlen (in));
- ASSERT (memcmp (p, in, len) == 0);
+ ASSERT (memeq (p, in, len));
free (p);
}
ok = base64_decode_alloc_ctx (&ctx, "YW\nJjZGVmZ2hp", 13, &p, &len);
ASSERT (ok);
ASSERT (len == 9);
- ASSERT (memcmp (p, "abcdefghi", len) == 0);
+ ASSERT (memeq (p, "abcdefghi", len));
free (p);
base64_decode_ctx_init (&ctx);
ok = base64_decode_alloc_ctx (&ctx, "JjZGVmZ2", 8, &p, &len);
ASSERT (ok);
ASSERT (len == 6);
- ASSERT (memcmp (p, "abcdef", len) == 0);
+ ASSERT (memeq (p, "abcdef", len));
free (p);
ok = base64_decode_alloc_ctx (&ctx, "hp", 2, &p, &len);
ASSERT (ok);
ASSERT (len == 3);
- ASSERT (memcmp (p, "ghi", len) == 0);
+ ASSERT (memeq (p, "ghi", len));
free (p);
ok = base64_decode_alloc_ctx (&ctx, "", 0, &p, &len);
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00FC, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\374", 1) == 0);
+ ASSERT (memeq (buf, "\374", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00DF, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\337", 1) == 0);
+ ASSERT (memeq (buf, "\337", 1));
ASSERT (buf[1] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x0622, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\302", 1) == 0);
+ ASSERT (memeq (buf, "\302", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x0644, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\341", 1) == 0);
+ ASSERT (memeq (buf, "\341", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x0648, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\346", 1) == 0);
+ ASSERT (memeq (buf, "\346", 1));
ASSERT (buf[1] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00FC, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\303\274", 2) == 0);
+ ASSERT (memeq (buf, "\303\274", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00DF, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\303\237", 2) == 0);
+ ASSERT (memeq (buf, "\303\237", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x1F60B, NULL);
ASSERT (ret == 4);
- ASSERT (memcmp (buf, "\360\237\230\213", 4) == 0);
+ ASSERT (memeq (buf, "\360\237\230\213", 4));
ASSERT (buf[4] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\223\372", 2) == 0);
+ ASSERT (memeq (buf, "\223\372", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\226\173", 2) == 0);
+ ASSERT (memeq (buf, "\226\173", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\214\352", 2) == 0);
+ ASSERT (memeq (buf, "\214\352", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\244\351", 2) == 0);
+ ASSERT (memeq (buf, "\244\351", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\245\273", 2) == 0);
+ ASSERT (memeq (buf, "\245\273", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\273\171", 2) == 0);
+ ASSERT (memeq (buf, "\273\171", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\310\325", 2) == 0);
+ ASSERT (memeq (buf, "\310\325", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\261\276", 2) == 0);
+ ASSERT (memeq (buf, "\261\276", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\325\132", 2) == 0);
+ ASSERT (memeq (buf, "\325\132", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00FC, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\250\271", 2) == 0);
+ ASSERT (memeq (buf, "\250\271", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x00DF, NULL);
ASSERT (ret == 4);
- ASSERT (memcmp (buf, "\201\060\211\070", 4) == 0);
+ ASSERT (memeq (buf, "\201\060\211\070", 4));
ASSERT (buf[4] == 'x');
memset (buf, 'x', 8);
ret = c32rtomb (buf, 0x1F60B, NULL);
ASSERT (ret == 4);
- ASSERT (memcmp (buf, "\224\071\375\067", 4) == 0);
+ ASSERT (memeq (buf, "\224\071\375\067", 4));
ASSERT (buf[4] == 'x');
}
return 0;
ret = c32rtomb (buf, wc, NULL);
ASSERT (ret == n);
- ASSERT (memcmp (buf, s, n) == 0);
+ ASSERT (memeq (buf, s, n));
/* Test special calling convention, passing a NULL pointer. */
ret = c32rtomb (NULL, wc, NULL);
ret = c32snrtombs (buf, &src, 6, n, NULL);
ASSERT (ret == (n <= 5 ? n : 5));
ASSERT (src == (n <= 5 ? input + n : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 9 ? input + 3 :
n <= 10 ? input + (n - 5) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 7 ? input + 3 :
n <= 8 ? input + (n - 3) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 7 ? input + 2 :
n < 11 ? input + 3 :
n <= 12 ? input + (n - 7) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ret = c32srtombs (buf, &src, n, NULL);
ASSERT (ret == (n <= 5 ? n : 5));
ASSERT (src == (n <= 5 ? input + n : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 9 ? input + 3 :
n <= 10 ? input + (n - 5) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 7 ? input + 3 :
n <= 8 ? input + (n - 3) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 7 ? input + 2 :
n < 11 ? input + 3 :
n <= 12 ? input + (n - 7) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ret = c32stombs (buf, input, n);
ASSERT (ret == (n <= 5 ? n : 5));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (n > 5)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (n > 5) + 0] == '_');
n < 5 ? 3 :
n < 9 ? 5 :
n <= 10 ? n : 10));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (n > 10)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (n > 10) + 0] == '_');
n < 5 ? 3 :
n < 7 ? 5 :
n <= 8 ? n : 8));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (n > 8)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (n > 8) + 0] == '_');
n < 7 ? 3 :
n < 11 ? 7 :
n <= 12 ? n : 12));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (n > 12)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (n > 12) + 0] == '_');
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\262", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\262", 1) == 0);
+ ASSERT (memeq (mb.buf, "\262", 1));
/* U+00B5 MICRO SIGN */
mb = for_character ("\265", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\265", 1) == 0);
+ ASSERT (memeq (mb.buf, "\265", 1));
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\311", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\351", 1) == 0);
+ ASSERT (memeq (mb.buf, "\351", 1));
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\337", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\337", 1) == 0);
+ ASSERT (memeq (mb.buf, "\337", 1));
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\351", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\351", 1) == 0);
+ ASSERT (memeq (mb.buf, "\351", 1));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\377", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\377", 1) == 0);
+ ASSERT (memeq (mb.buf, "\377", 1));
}
return test_exit_status;
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\217\252\261", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\253\261", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\253\261", 3));
#endif
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\217\251\316", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\316", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\316", 3));
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\217\253\261", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\253\261", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\253\261", 3));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\217\253\363", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\253\363", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\253\363", 3));
#if !((defined __APPLE__ && defined __MACH__) || defined __DragonFly__)
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\217\251\250", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\310", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\310", 3));
#endif
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\217\251\310", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\310", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\310", 3));
#if !defined __DragonFly__
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\247\273", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\353", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\353", 2));
#endif
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\247\353", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\353", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\353", 2));
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\244\323", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\244\323", 2) == 0);
+ ASSERT (memeq (mb.buf, "\244\323", 2));
#if !defined __DragonFly__
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\243\307", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\347", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\347", 2));
#endif
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\243\347", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\347", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\347", 2));
}
return test_exit_status;
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\302\262", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\302\262", 2) == 0);
+ ASSERT (memeq (mb.buf, "\302\262", 2));
/* U+00B5 MICRO SIGN */
mb = for_character ("\302\265", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\302\265", 2) == 0);
+ ASSERT (memeq (mb.buf, "\302\265", 2));
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\303\211", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\251", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\251", 2));
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\303\237", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\237", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\237", 2));
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\303\251", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\251", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\251", 2));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\303\277", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\277", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\277", 2));
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\305\201", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\305\202", 2) == 0);
+ ASSERT (memeq (mb.buf, "\305\202", 2));
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\305\202", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\305\202", 2) == 0);
+ ASSERT (memeq (mb.buf, "\305\202", 2));
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\320\251", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\321\211", 2) == 0);
+ ASSERT (memeq (mb.buf, "\321\211", 2));
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\321\211", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\321\211", 2) == 0);
+ ASSERT (memeq (mb.buf, "\321\211", 2));
/* U+05D5 HEBREW LETTER VAV */
mb = for_character ("\327\225", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\327\225", 2) == 0);
+ ASSERT (memeq (mb.buf, "\327\225", 2));
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\343\201\263", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\343\201\263", 3) == 0);
+ ASSERT (memeq (mb.buf, "\343\201\263", 3));
/* U+3162 HANGUL LETTER YI */
mb = for_character ("\343\205\242", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\343\205\242", 3) == 0);
+ ASSERT (memeq (mb.buf, "\343\205\242", 3));
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\357\274\247", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\275\207", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\275\207", 3));
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\357\275\207", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\275\207", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\275\207", 3));
/* U+FFDB HALFWIDTH HANGUL LETTER YI */
mb = for_character ("\357\277\233", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\277\233", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\277\233", 3));
#if !(defined __DragonFly__ || defined __sun)
/* U+10419 DESERET CAPITAL LETTER EF */
mb = for_character ("\360\220\220\231", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\360\220\221\201", 4) == 0);
+ ASSERT (memeq (mb.buf, "\360\220\221\201", 4));
#endif
/* U+10441 DESERET SMALL LETTER EF */
mb = for_character ("\360\220\221\201", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\360\220\221\201", 4) == 0);
+ ASSERT (memeq (mb.buf, "\360\220\221\201", 4));
/* U+E0041 TAG LATIN CAPITAL LETTER A */
mb = for_character ("\363\240\201\201", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\363\240\201\201", 4) == 0);
+ ASSERT (memeq (mb.buf, "\363\240\201\201", 4));
/* U+E0061 TAG LATIN SMALL LETTER A */
mb = for_character ("\363\240\201\241", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\363\240\201\241", 4) == 0);
+ ASSERT (memeq (mb.buf, "\363\240\201\241", 4));
}
return test_exit_status;
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\201\060\205\065", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\205\065", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\205\065", 4));
/* U+00B5 MICRO SIGN */
mb = for_character ("\201\060\205\070", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\205\070", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\205\070", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __sun)
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\201\060\207\067", 4);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\250\246", 2) == 0);
+ ASSERT (memeq (mb.buf, "\250\246", 2));
#endif
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\201\060\211\070", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\211\070", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\211\070", 4));
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\250\246", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\250\246", 2) == 0);
+ ASSERT (memeq (mb.buf, "\250\246", 2));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\201\060\213\067", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\213\067", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\213\067", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __sun)
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\201\060\221\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\222\060", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\222\060", 4));
#endif
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\201\060\222\060", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\222\060", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\222\060", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__)
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\247\273", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\353", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\353", 2));
#endif
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\247\353", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\353", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\353", 2));
/* U+05D5 HEBREW LETTER VAV */
mb = for_character ("\201\060\371\067", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\371\067", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\371\067", 4));
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\244\323", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\244\323", 2) == 0);
+ ASSERT (memeq (mb.buf, "\244\323", 2));
/* U+3162 HANGUL LETTER YI */
mb = for_character ("\201\071\256\062", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\071\256\062", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\071\256\062", 4));
#if !defined __DragonFly__
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\243\307", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\347", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\347", 2));
#endif
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\243\347", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\347", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\347", 2));
/* U+FFDB HALFWIDTH HANGUL LETTER YI */
mb = for_character ("\204\061\241\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\204\061\241\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\204\061\241\071", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __sun)
/* U+10419 DESERET CAPITAL LETTER EF */
mb = for_character ("\220\060\351\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\220\060\355\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\220\060\355\071", 4));
#endif
/* U+10441 DESERET SMALL LETTER EF */
mb = for_character ("\220\060\355\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\220\060\355\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\220\060\355\071", 4));
/* U+E0041 TAG LATIN CAPITAL LETTER A */
mb = for_character ("\323\066\234\063", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\323\066\234\063", 4) == 0);
+ ASSERT (memeq (mb.buf, "\323\066\234\063", 4));
/* U+E0061 TAG LATIN SMALL LETTER A */
mb = for_character ("\323\066\237\065", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\323\066\237\065", 4) == 0);
+ ASSERT (memeq (mb.buf, "\323\066\237\065", 4));
}
return test_exit_status;
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\262", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\262", 1) == 0);
+ ASSERT (memeq (mb.buf, "\262", 1));
#if !(defined __GLIBC__ || (defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __NetBSD__ || defined __sun || defined __CYGWIN__ || (defined _WIN32 && !defined __CYGWIN__))
/* U+00B5 MICRO SIGN */
mb = for_character ("\265", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\265", 1) == 0);
+ ASSERT (memeq (mb.buf, "\265", 1));
#endif
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\311", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\311", 1) == 0);
+ ASSERT (memeq (mb.buf, "\311", 1));
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\337", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\337", 1) == 0);
+ ASSERT (memeq (mb.buf, "\337", 1));
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\351", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\311", 1) == 0);
+ ASSERT (memeq (mb.buf, "\311", 1));
#if !(defined __GLIBC__ || (defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __sun || defined __CYGWIN__ || (defined _WIN32 && !defined __CYGWIN__))
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\377", 1);
ASSERT (mb.nbytes == 1);
- ASSERT (memcmp (mb.buf, "\377", 1) == 0);
+ ASSERT (memeq (mb.buf, "\377", 1));
#endif
}
return test_exit_status;
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\217\252\261", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\252\261", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\252\261", 3));
#if !defined __NetBSD__
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\217\251\316", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\316", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\316", 3));
#endif
#if !((defined __APPLE__ && defined __MACH__) || defined __DragonFly__)
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\217\253\261", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\252\261", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\252\261", 3));
#endif
#if !((defined __APPLE__ && defined __MACH__) || defined __DragonFly__ || defined __NetBSD__)
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\217\253\363", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\252\363", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\252\363", 3));
#endif
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\217\251\250", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\250", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\250", 3));
#if !((defined __APPLE__ && defined __MACH__) || defined __DragonFly__)
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\217\251\310", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\217\251\250", 3) == 0);
+ ASSERT (memeq (mb.buf, "\217\251\250", 3));
#endif
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\247\273", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\273", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\273", 2));
#if !defined __DragonFly__
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\247\353", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\273", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\273", 2));
#endif
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\244\323", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\244\323", 2) == 0);
+ ASSERT (memeq (mb.buf, "\244\323", 2));
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\243\307", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\307", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\307", 2));
#if !defined __DragonFly__
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\243\347", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\307", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\307", 2));
#endif
}
return test_exit_status;
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\302\262", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\302\262", 2) == 0);
+ ASSERT (memeq (mb.buf, "\302\262", 2));
#if !(defined __GLIBC__ || defined MUSL_LIBC || (defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __OpenBSD__ || defined _AIX || defined __sun || defined __CYGWIN__ || (defined _WIN32 && !defined __CYGWIN__) || defined __ANDROID__ || defined __HAIKU__)
/* U+00B5 MICRO SIGN */
mb = for_character ("\302\265", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\302\265", 2) == 0);
+ ASSERT (memeq (mb.buf, "\302\265", 2));
#endif
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\303\211", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\211", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\211", 2));
#if !defined MUSL_LIBC
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\303\237", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\237", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\237", 2));
#endif
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\303\251", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\303\211", 2) == 0);
+ ASSERT (memeq (mb.buf, "\303\211", 2));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\303\277", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\305\270", 2) == 0);
+ ASSERT (memeq (mb.buf, "\305\270", 2));
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\305\201", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\305\201", 2) == 0);
+ ASSERT (memeq (mb.buf, "\305\201", 2));
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\305\202", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\305\201", 2) == 0);
+ ASSERT (memeq (mb.buf, "\305\201", 2));
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\320\251", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\320\251", 2) == 0);
+ ASSERT (memeq (mb.buf, "\320\251", 2));
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\321\211", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\320\251", 2) == 0);
+ ASSERT (memeq (mb.buf, "\320\251", 2));
/* U+05D5 HEBREW LETTER VAV */
mb = for_character ("\327\225", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\327\225", 2) == 0);
+ ASSERT (memeq (mb.buf, "\327\225", 2));
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\343\201\263", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\343\201\263", 3) == 0);
+ ASSERT (memeq (mb.buf, "\343\201\263", 3));
/* U+3162 HANGUL LETTER YI */
mb = for_character ("\343\205\242", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\343\205\242", 3) == 0);
+ ASSERT (memeq (mb.buf, "\343\205\242", 3));
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\357\274\247", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\274\247", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\274\247", 3));
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\357\275\207", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\274\247", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\274\247", 3));
/* U+FFDB HALFWIDTH HANGUL LETTER YI */
mb = for_character ("\357\277\233", 3);
ASSERT (mb.nbytes == 3);
- ASSERT (memcmp (mb.buf, "\357\277\233", 3) == 0);
+ ASSERT (memeq (mb.buf, "\357\277\233", 3));
/* U+10419 DESERET CAPITAL LETTER EF */
mb = for_character ("\360\220\220\231", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\360\220\220\231", 4) == 0);
+ ASSERT (memeq (mb.buf, "\360\220\220\231", 4));
#if !(defined __DragonFly__ || defined __sun)
/* U+10441 DESERET SMALL LETTER EF */
mb = for_character ("\360\220\221\201", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\360\220\220\231", 4) == 0);
+ ASSERT (memeq (mb.buf, "\360\220\220\231", 4));
#endif
/* U+E0041 TAG LATIN CAPITAL LETTER A */
mb = for_character ("\363\240\201\201", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\363\240\201\201", 4) == 0);
+ ASSERT (memeq (mb.buf, "\363\240\201\201", 4));
/* U+E0061 TAG LATIN SMALL LETTER A */
mb = for_character ("\363\240\201\241", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\363\240\201\241", 4) == 0);
+ ASSERT (memeq (mb.buf, "\363\240\201\241", 4));
}
return test_exit_status;
/* U+00B2 SUPERSCRIPT TWO */
mb = for_character ("\201\060\205\065", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\205\065", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\205\065", 4));
#if !(defined __GLIBC__ || defined __FreeBSD__ || (defined __APPLE__ && defined __MACH__) || defined __NetBSD__ || defined __CYGWIN__)
/* U+00B5 MICRO SIGN */
mb = for_character ("\201\060\205\070", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\205\070", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\205\070", 4));
#endif
/* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
mb = for_character ("\201\060\207\067", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\207\067", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\207\067", 4));
/* U+00DF LATIN SMALL LETTER SHARP S */
mb = for_character ("\201\060\211\070", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\211\070", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\211\070", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __sun)
/* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
mb = for_character ("\250\246", 2);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\207\067", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\207\067", 4));
/* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
mb = for_character ("\201\060\213\067", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\227\060", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\227\060", 4));
#endif
/* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
mb = for_character ("\201\060\221\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\221\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\221\071", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __sun)
/* U+0142 LATIN SMALL LETTER L WITH STROKE */
mb = for_character ("\201\060\222\060", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\221\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\221\071", 4));
#endif
/* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
mb = for_character ("\247\273", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\273", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\273", 2));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__)
/* U+0449 CYRILLIC SMALL LETTER SHCHA */
mb = for_character ("\247\353", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\247\273", 2) == 0);
+ ASSERT (memeq (mb.buf, "\247\273", 2));
#endif
/* U+05D5 HEBREW LETTER VAV */
mb = for_character ("\201\060\371\067", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\060\371\067", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\060\371\067", 4));
/* U+3073 HIRAGANA LETTER BI */
mb = for_character ("\244\323", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\244\323", 2) == 0);
+ ASSERT (memeq (mb.buf, "\244\323", 2));
/* U+3162 HANGUL LETTER YI */
mb = for_character ("\201\071\256\062", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\201\071\256\062", 4) == 0);
+ ASSERT (memeq (mb.buf, "\201\071\256\062", 4));
/* U+FF27 FULLWIDTH LATIN CAPITAL LETTER G */
mb = for_character ("\243\307", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\307", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\307", 2));
#if !defined __DragonFly__
/* U+FF47 FULLWIDTH LATIN SMALL LETTER G */
mb = for_character ("\243\347", 2);
ASSERT (mb.nbytes == 2);
- ASSERT (memcmp (mb.buf, "\243\307", 2) == 0);
+ ASSERT (memeq (mb.buf, "\243\307", 2));
#endif
/* U+FFDB HALFWIDTH HANGUL LETTER YI */
mb = for_character ("\204\061\241\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\204\061\241\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\204\061\241\071", 4));
/* U+10419 DESERET CAPITAL LETTER EF */
mb = for_character ("\220\060\351\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\220\060\351\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\220\060\351\071", 4));
#if !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __sun)
/* U+10441 DESERET SMALL LETTER EF */
mb = for_character ("\220\060\355\071", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\220\060\351\071", 4) == 0);
+ ASSERT (memeq (mb.buf, "\220\060\351\071", 4));
#endif
/* U+E0041 TAG LATIN CAPITAL LETTER A */
mb = for_character ("\323\066\234\063", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\323\066\234\063", 4) == 0);
+ ASSERT (memeq (mb.buf, "\323\066\234\063", 4));
/* U+E0061 TAG LATIN SMALL LETTER A */
mb = for_character ("\323\066\237\065", 4);
ASSERT (mb.nbytes == 4);
- ASSERT (memcmp (mb.buf, "\323\066\237\065", 4) == 0);
+ ASSERT (memeq (mb.buf, "\323\066\237\065", 4));
}
return test_exit_status;
y = 1.0;
z = copysign (x, y);
ASSERT (z == 0.0);
- ASSERT (memcmp (&z, &zero, sizeof z) == 0);
+ ASSERT (memeq (&z, &zero, sizeof z));
x = 0.0;
y = -1.0;
y = 1.0;
z = copysign (x, y);
ASSERT (z == 0.0);
- ASSERT (memcmp (&z, &zero, sizeof z) == 0);
+ ASSERT (memeq (&z, &zero, sizeof z));
x = minus_zerod;
y = -1.0;
y = 1.0f;
z = copysignf (x, y);
ASSERT (z == 0.0f);
- ASSERT (memcmp (&z, &zero, sizeof z) == 0);
+ ASSERT (memeq (&z, &zero, sizeof z));
x = 0.0f;
y = -1.0f;
y = 1.0f;
z = copysignf (x, y);
ASSERT (z == 0.0f);
- ASSERT (memcmp (&z, &zero, sizeof z) == 0);
+ ASSERT (memeq (&z, &zero, sizeof z));
x = minus_zerof;
y = -1.0f;
y = 1.0L;
z = copysignl (x, y);
ASSERT (z == 0.0L);
- ASSERT (memcmp (&z, &zero, LDBL_BYTES) == 0);
+ ASSERT (memeq (&z, &zero, LDBL_BYTES));
x = 0.0L;
y = -1.0L;
y = 1.0L;
z = copysignl (x, y);
ASSERT (z == 0.0L);
- ASSERT (memcmp (&z, &zero, LDBL_BYTES) == 0);
+ ASSERT (memeq (&z, &zero, LDBL_BYTES));
x = minus_zerol;
y = -1.0L;
argc--;
break;
}
- if (strlen (s) > 3 && memcmp (s, "no-", 3) == 0)
+ if (strlen (s) > 3 && memeq (s, "no-", 3))
{
neg = 1;
s += 3;
size_t length;
char *contents = read_file (BASE ".tmp", 0, &length);
- ASSERT (length == 3 && memcmp (contents, "bar", 3) == 0);
+ ASSERT (length == 3 && memeq (contents, "bar", 3));
ASSERT (remove (BASE ".tmp") == 0);
}
size_t length;
char *contents = read_file (BASE ".tmp", 0, &length);
- ASSERT (length == 3 && memcmp (contents, "bar", 3) == 0);
+ ASSERT (length == 3 && memeq (contents, "bar", 3));
ASSERT (remove (BASE ".tmp") == 0);
}
size_t length;
char *contents = read_file (BASE ".tmp", 0, &length);
- ASSERT (length == 6 && memcmp (contents, "Foobar", 6) == 0);
+ ASSERT (length == 6 && memeq (contents, "Foobar", 6));
ASSERT (remove (BASE ".tmp") == 0);
}
size_t length;
char *contents = read_file (DATA_FILENAME, 0, &length);
- ASSERT (length == 11 && memcmp (contents, "Halle Potta", 11) == 0);
+ ASSERT (length == 11 && memeq (contents, "Halle Potta", 11));
}
ASSERT (unlink (DATA_FILENAME) == 0);
{
memcpy (stbuf, SECRET, SECRET_SIZE);
explicit_bzero (stbuf, SECRET_SIZE);
- ASSERT (memcmp (zero, stbuf, SECRET_SIZE) == 0);
+ ASSERT (memeq (zero, stbuf, SECRET_SIZE));
}
/* =============== Verify operation on heap-allocated memory =============== */
char buf[8];
if (fread (buf, 1, 7, fp) < 7)
goto skip;
- ASSERT (memcmp (buf, "foogars", 7) == 0);
+ ASSERT (memeq (buf, "foogars", 7));
}
/* Discard the buffered 'h'. */
if (check_filepos)
{
char buf[10];
ASSERT (fread (buf, 1, 10, fp) == 9);
- ASSERT (memcmp (buf, "foogarsh!", 9) == 0);
+ ASSERT (memeq (buf, "foogarsh!", 9));
}
ASSERT (fclose (fp) == 0);
ASSERT (ptr != NULL);
ASSERT (available1 != 0);
ASSERT (available1 <= strlen (expected));
- ASSERT (memcmp (ptr, expected, available1) == 0);
+ ASSERT (memeq (ptr, expected, available1));
}
/* Test behaviour after normal ungetc. */
if (ptr != NULL)
{
ASSERT (available2 == available1);
- ASSERT (memcmp (ptr, expected, available2) == 0);
+ ASSERT (memeq (ptr, expected, available2));
}
}
ASSERT (ptr[0] == '@');
if (available3 > 1)
{
- ASSERT (memcmp (ptr + 1, expected + 1, available3 - 1) == 0);
+ ASSERT (memeq (ptr + 1, expected + 1, available3 - 1));
}
}
}
size_t position = 0;
ASSERT (fread (buf1, 1, nbytes1, stdin) == nbytes1);
- ASSERT (memcmp (buf1, stdin_contents + position, nbytes1) == 0);
+ ASSERT (memeq (buf1, stdin_contents + position, nbytes1));
position += nbytes1;
/* Test normal behaviour. */
position += nbytes2;
ASSERT (fread (buf3, 1, nbytes3, stdin) == nbytes3);
- ASSERT (memcmp (buf3, stdin_contents + position, nbytes3) == 0);
+ ASSERT (memeq (buf3, stdin_contents + position, nbytes3));
position += nbytes3;
/* Test behaviour after normal ungetc. */
position += nbytes4;
ASSERT (fread (buf5, 1, nbytes5, stdin) == nbytes5);
- ASSERT (memcmp (buf5, stdin_contents + position, nbytes5) == 0);
+ ASSERT (memeq (buf5, stdin_contents + position, nbytes5));
position += nbytes5;
/* Test behaviour after arbitrary ungetc. */
position += nbytes6;
ASSERT (fread (buf7, 1, nbytes7, stdin) == nbytes7);
- ASSERT (memcmp (buf7, stdin_contents + position, nbytes7) == 0);
+ ASSERT (memeq (buf7, stdin_contents + position, nbytes7));
position += nbytes7;
/* Test move to end of file. */
char buf[TESTFILE_DATA_LEN];
ASSERT (fread (buf, 1, TESTFILE_DATA_LEN, fp) == TESTFILE_DATA_LEN);
- ASSERT (memcmp (buf, TESTFILE_DATA, TESTFILE_DATA_LEN) == 0);
+ ASSERT (memeq (buf, TESTFILE_DATA, TESTFILE_DATA_LEN));
ret = fclose (fp);
ASSERT (ret == 0);
{
char buf[10];
ASSERT (fread (buf, 1, 10, fp) == 9);
- ASSERT (memcmp (buf, "foogarsh!", 9) == 0);
+ ASSERT (memeq (buf, "foogarsh!", 9));
}
ASSERT (fclose (fp) == 0);
{
char buf[10];
ASSERT (fread (buf, 1, 10, fp) == 9);
- ASSERT (memcmp (buf, "foogarsh!", 9) == 0);
+ ASSERT (memeq (buf, "foogarsh!", 9));
}
ASSERT (fclose (fp) == 0);
/* Test embedded NULs and EOF behavior. */
result = getdelim (&line, &len, 'n', f);
ASSERT (result == 3);
- ASSERT (memcmp (line, "d\0f", 4) == 0);
+ ASSERT (memeq (line, "d\0f", 4));
ASSERT (3 < len);
result = getdelim (&line, &len, 'n', f);
/* Test embedded NULs and EOF behavior. */
result = getline (&line, &len, f);
ASSERT (result == 3);
- ASSERT (memcmp (line, "d\0f", 4) == 0);
+ ASSERT (memeq (line, "d\0f", 4));
ASSERT (3 < len);
result = getline (&line, &len, f);
/* Test embedded NULs and EOF behavior. */
result = getndelim2 (&line, &len, 0, GETNLINE_NO_LIMIT, '\n', EOF, f);
ASSERT (result == 3);
- ASSERT (memcmp (line, "d\0f", 4) == 0);
+ ASSERT (memeq (line, "d\0f", 4));
ASSERT (3 < len);
result = getndelim2 (&line, &len, 0, GETNLINE_NO_LIMIT, '\n', EOF, f);
result = getndelim2 (&line, &len, 0, GETNLINE_NO_LIMIT, EOF, EOF, f);
ASSERT (result == 2);
ASSERT (10 == len);
- ASSERT (memcmp (line, "\0f\0eeea\nb", 10) == 0);
+ ASSERT (memeq (line, "\0f\0eeea\nb", 10));
result = getndelim2 (&line, &len, 0, GETNLINE_NO_LIMIT, '\n', '\r', f);
ASSERT (result == -1);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + (sizeof (expected) - 1));
- ASSERT (memcmp (buf, expected, sizeof (expected) - 1) == 0);
+ ASSERT (memeq (buf, expected, sizeof (expected) - 1));
ASSERT (iconv_close (cd) == 0);
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + strlen (expected));
- ASSERT (memcmp (buf, expected, strlen (expected)) == 0);
+ ASSERT (memeq (buf, expected, strlen (expected)));
}
/* Test conversion from ISO-8859-1 to UTF-8 with E2BIG. */
&outptr, &outbytesleft);
ASSERT (res == 0 && inbytesleft == 0);
ASSERT (outptr == buf + strlen (expected));
- ASSERT (memcmp (buf, expected, strlen (expected)) == 0);
+ ASSERT (memeq (buf, expected, strlen (expected)));
}
/* Test conversion from UTF-8 to ISO-8859-1 with EILSEQ. */
{
memcpy (stbuf, SECRET, SECRET_SIZE);
memset_explicit (stbuf, 0, SECRET_SIZE);
- ASSERT (memcmp (zero, stbuf, SECRET_SIZE) == 0);
+ ASSERT (memeq (zero, stbuf, SECRET_SIZE));
for (int i = 1; i <= UCHAR_MAX; i++)
{
char checkbuf[SECRET_SIZE];
memset (checkbuf, i, SECRET_SIZE);
memcpy (stbuf, SECRET, SECRET_SIZE);
memset_explicit (stbuf, i, SECRET_SIZE);
- ASSERT (memcmp (checkbuf, stbuf, SECRET_SIZE) == 0);
+ ASSERT (memeq (checkbuf, stbuf, SECRET_SIZE));
}
}
ret = full_read (fd, data, data_block_size);
END_TIMING
ASSERT (ret == data_block_size);
- ASSERT (memcmp (data, expected, data_block_size) == 0);
+ ASSERT (memeq (data, expected, data_block_size));
ASSERT (spent_time > 0.5);
/* This assertion fails if data_block_size is very large and
ENABLE_DEBUGGING is 1. */
ret = full_read (fd, data, data_block_size);
END_TIMING
ASSERT (ret == data_block_size);
- ASSERT (memcmp (data, expected + data_block_size, data_block_size) == 0);
+ ASSERT (memeq (data, expected + data_block_size, data_block_size));
/* This assertion fails if data_block_size is much larger than needed
and SMALL_DELAY is too large. */
ASSERT (spent_time < 0.5);
ret = full_read_from_nonblocking_fd (fd, data, data_block_size);
END_TIMING
ASSERT (ret == data_block_size);
- ASSERT (memcmp (data, expected, data_block_size) == 0);
+ ASSERT (memeq (data, expected, data_block_size));
ASSERT (spent_time > 0.5);
/* This assertion fails if data_block_size is much larger than needed
and SMALL_DELAY is too large, or if data_block_size is very large and
ret = full_read_from_nonblocking_fd (fd, data, data_block_size);
END_TIMING
ASSERT (ret == data_block_size);
- ASSERT (memcmp (data, expected + data_block_size, data_block_size) == 0);
+ ASSERT (memeq (data, expected + data_block_size, data_block_size));
/* This assertion fails if data_block_size is much larger than needed
and SMALL_DELAY is too large. */
ASSERT (spent_time < 0.5);
if (! (streq (buf, LT[i].exp)
|| (!tz && n == strlen (LT[i].exp)
- && memcmp (buf, LT[i].exp, n - sizeof "(GMT)" + 1) == 0
+ && memeq (buf, LT[i].exp, n - sizeof "(GMT)" + 1)
&& streq (buf + n - sizeof "(GMT)" + 1, "(GMT)"))
#if defined _WIN32 && !defined __CYGWIN__
/* On native Windows, the time zone is printed differently. */
obstack_init (&obs);
#define RESULT_EQ(expected) \
- (len == strlen (expected) && memcmp (result, expected, len) == 0)
+ (len == strlen (expected) && memeq (result, expected, len))
/* Test the support of the 'B' conversion specifier for binary output of
integers. */
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
obstack_init (&obs);
#define RESULT_EQ(expected) \
- (len == strlen (expected) && memcmp (result, expected, len) == 0)
+ (len == strlen (expected) && memeq (result, expected, len))
/* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
output of floating-point numbers. */
char *result = obstack_finish (&obs);
ASSERT (len >= 3 + 3
&& strisnan (result, 0, len - 3, 0)
- && memcmp (result + len - 3, " 33", 3) == 0);
+ && memeq (result + len - 3, " 33", 3));
obstack_free (&obs, result);
}
char *result = obstack_finish (&obs);
ASSERT (len >= 3 + 3
&& strisnan (result, 0, len - 3, 0)
- && memcmp (result + len - 3, " 33", 3) == 0);
+ && memeq (result + len - 3, " 33", 3));
obstack_free (&obs, result);
}
char *result = obstack_finish (&obs);
ASSERT (len >= 3 + 3
&& strisnan (result, 0, len - 3, 0)
- && memcmp (result + len - 3, " 33", 3) == 0);
+ && memeq (result + len - 3, " 33", 3));
obstack_free (&obs, result);
}
ASSERT (len == 4000 + 3);
for (size_t i = 0; i < 4000 - 7; i++)
ASSERT (result[i] == '0');
- ASSERT (memcmp (result + 4000 - 7, "1234567 99", 7 + 3) == 0);
+ ASSERT (memeq (result + 4000 - 7, "1234567 99", 7 + 3));
obstack_free (&obs, result);
}
return 1;
}
if (!(res == strlen (expected)
- && memcmp (buf, expected, strlen (expected)) == 0))
+ && memeq (buf, expected, strlen (expected))))
{
fprintf (stderr, "read result unexpected\n");
return 1;
fprintf (stderr, "could not read expected output\n");
exit (1);
}
- if (!(line_len == 2 && memcmp (line, "/\n", 2) == 0))
+ if (!(line_len == 2 && memeq (line, "/\n", 2)))
#if defined _WIN32 && !defined __CYGWIN__
/* If the pwd program is Cygwin's pwd, its output in the root directory is
"/cygdrive/N", where N is a lowercase letter.
And if the pwd program is MSYS2 pwd, its output in the root directory is
"/N", where N is a lowercase letter. */
if (!((line_len > 11
- && memcmp (line, "/cygdrive/", 10) == 0
+ && memeq (line, "/cygdrive/", 10)
&& line[10] >= 'a' && line[10] <= 'z'
&& ((line_len == 12 && line[11] == '\n')
|| (line_len == 13 && line[11] == '\r' && line[12] == '\n')))
/* Read from STDIN_FILENO. */
char buf[1024];
int nread = fread (buf, 1, sizeof (buf), stdin);
- if (!(nread == 5 && memcmp (buf, "Potta", 5) == 0))
+ if (!(nread == 5 && memeq (buf, "Potta", 5)))
{
fprintf (stderr, "child: read %d bytes, expected %d bytes\n", nread, 5);
return 1;
}
char buf[1024];
int nread = fread (buf, 1, sizeof (buf), fp);
- if (!(nread == 11 && memcmp (buf, "Halle Potta", 11) == 0))
+ if (!(nread == 11 && memeq (buf, "Halle Potta", 11)))
{
fprintf (stderr, "data file wrong: has %d bytes, expected %d bytes\n", nread, 11);
return 1;
/* See if reading from STDIN_FILENO yields the expected contents. */
if (fread (buf, 1, sizeof (buf), stdin) == 11
- && memcmp (buf, "Halle Potta", 11) == 0)
+ && memeq (buf, "Halle Potta", 11))
return 0;
else
return 2;
}
char buf[1024];
int nread = fread (buf, 1, sizeof (buf), fp);
- if (!(nread == 11 && memcmp (buf, "Halle Potta", 11) == 0))
+ if (!(nread == 11 && memeq (buf, "Halle Potta", 11)))
{
fprintf (stderr, "data file wrong: has %d bytes, expected %d bytes\n", nread, 11);
return 1;
}
char buf[1024];
int nread = fread (buf, 1, sizeof (buf), fp);
- if (!(nread == 11 && memcmp (buf, "Halle Potta", 11) == 0))
+ if (!(nread == 11 && memeq (buf, "Halle Potta", 11)))
{
fprintf (stderr, "data file wrong: has %d bytes, expected %d bytes\n", nread, 11);
return 1;
}
char buf[1024];
int nread = fread (buf, 1, sizeof (buf), fp);
- if (!(nread == 11 && memcmp (buf, "Halle Potta", 11) == 0))
+ if (!(nread == 11 && memeq (buf, "Halle Potta", 11)))
{
fprintf (stderr, "data file wrong: has %d bytes, expected %d bytes\n", nread, 11);
return 1;
master. */
if (result != NULL)
{
- ASSERT (memcmp (result, "/dev/", 5) == 0);
+ ASSERT (memeq (result, "/dev/", 5));
}
close (fd);
result = ptsname (fd);
ASSERT (result != NULL);
- ASSERT (memcmp (result, "/dev/pts/", 9) == 0);
+ ASSERT (memeq (result, "/dev/pts/", 9));
close (fd);
}
result = ptsname (fd);
ASSERT (result != NULL);
- ASSERT (memcmp (result, "/dev/pts/", 9) == 0);
+ ASSERT (memeq (result, "/dev/pts/", 9));
/* This close (fd) call takes 15 seconds. It would be interruptible by the
SIGALRM timer, but then this test would report failure. */
master. */
if (result == 0)
{
- ASSERT (memcmp (buffer, "/dev/", 5) == 0);
+ ASSERT (memeq (buffer, "/dev/", 5));
}
close (fd);
result = ptsname_r (fd, buffer, sizeof buffer);
ASSERT (result == 0);
- ASSERT (memcmp (buffer, "/dev/pts/", 9) == 0);
+ ASSERT (memeq (buffer, "/dev/pts/", 9));
test_errors (fd, buffer);
result = ptsname_r (fd, buffer, sizeof buffer);
ASSERT (result == 0);
- ASSERT (memcmp (buffer, "/dev/pts/", 9) == 0);
+ ASSERT (memeq (buffer, "/dev/pts/", 9));
test_errors (fd, buffer);
a-time, and from left to right (no SEGV) or some other way. */
size_t n = quotearg_buffer (buf, sizeof buf, z, SIZE_MAX, NULL);
ASSERT (n == s_len + 2 * q_len);
- ASSERT (memcmp (buf, q, sizeof buf) == 0);
+ ASSERT (memeq (buf, q, sizeof buf));
free (q);
}
}
compare (char const *a, size_t la, char const *b, size_t lb)
{
ASSERT (la == lb);
- ASSERT (memcmp (a, b, la) == 0);
+ ASSERT (memeq (a, b, la));
ASSERT (b[lb] == '\0');
}
char buf[10];
ssize_t ret = read (fd, buf, 10);
ASSERT (ret == 5);
- ASSERT (memcmp (buf, "World", 5) == 0);
+ ASSERT (memeq (buf, "World", 5));
}
ASSERT (close (fd) == 0);
buf[output_len + 1] = '%';
bufend = shell_quote_copy (buf, input);
ASSERT (bufend == buf + output_len);
- ASSERT (memcmp (buf, output, output_len + 1) == 0);
+ ASSERT (memeq (buf, output, output_len + 1));
ASSERT (buf[output_len + 1] == '%');
ASSERT (streq (output, expected));
mismatch (char const expect[SHA3_224_DIGEST_SIZE],
char const buf[SHA3_224_DIGEST_SIZE])
{
- if (memcmp (expect, buf, SHA3_224_DIGEST_SIZE) == 0)
+ if (memeq (expect, buf, SHA3_224_DIGEST_SIZE))
return 0;
printf ("expected:\n");
for (size_t i = 0; i < SHA3_224_DIGEST_SIZE; i++)
mismatch (char const expect[SHA3_256_DIGEST_SIZE],
char const buf[SHA3_256_DIGEST_SIZE])
{
- if (memcmp (expect, buf, SHA3_256_DIGEST_SIZE) == 0)
+ if (memeq (expect, buf, SHA3_256_DIGEST_SIZE))
return 0;
printf ("expected:\n");
for (size_t i = 0; i < SHA3_256_DIGEST_SIZE; i++)
mismatch (char const expect[SHA3_384_DIGEST_SIZE],
char const buf[SHA3_384_DIGEST_SIZE])
{
- if (memcmp (expect, buf, SHA3_384_DIGEST_SIZE) == 0)
+ if (memeq (expect, buf, SHA3_384_DIGEST_SIZE))
return 0;
printf ("expected:\n");
for (size_t i = 0; i < SHA3_384_DIGEST_SIZE; i++)
mismatch (char const expect[SHA3_512_DIGEST_SIZE],
char const buf[SHA3_512_DIGEST_SIZE])
{
- if (memcmp (expect, buf, SHA3_512_DIGEST_SIZE) == 0)
+ if (memeq (expect, buf, SHA3_512_DIGEST_SIZE))
return 0;
printf ("expected:\n");
for (size_t i = 0; i < SHA3_512_DIGEST_SIZE; i++)
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
{
if (size > 0)
{
- ASSERT (memcmp (buf, "12345", size - 1) == 0);
+ ASSERT (memeq (buf, "12345", size - 1));
ASSERT (buf[size - 1] == '\0');
}
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
}
else
{
- ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
+ ASSERT (memeq (buf, "12345\0EF", 8));
}
}
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
input[i] = 'a' + ((1000000 / (i + 1)) % 26);
input[i] = '\0';
retval = my_snprintf (result, sizeof (result), "%.4000s %d", input, 99);
- ASSERT (memcmp (result, input, 4000) == 0);
+ ASSERT (memeq (result, input, 4000));
ASSERT (streq (result + 4000, " 99"));
ASSERT (retval == strlen (result));
}
block = (char *) malloc (i);
memcpy (block, "abcdefgh", i);
retval = my_snprintf (result, sizeof (result), "%.*s", (int) i, block);
- ASSERT (memcmp (result, block, i) == 0);
+ ASSERT (memeq (result, block, i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (block);
for (size_t j = 0; j < i; j++)
block[j] = "abcdefgh"[j];
retval = my_snprintf (result, sizeof (result), "%.*ls", (int) i, block);
- ASSERT (memcmp (result, "abcdefgh", i) == 0);
+ ASSERT (memeq (result, "abcdefgh", i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (block);
int retval =
my_snprintf (result, sizeof (result),
"a%cz %d", '\0', 33, 44, 55);
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
}
as if by a call to the wcrtomb function with a pointer to storage of
at least MB_CUR_MAX bytes, the wint_t argument converted to wchar_t,
and an initial shift state." */
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
}
{
if (size > 0)
{
- ASSERT (memcmp (buf, "12345", size - 1) == 0);
+ ASSERT (memeq (buf, "12345", size - 1));
ASSERT (buf[size - 1] == '\0' || buf[size - 1] == '0' + size);
}
#if !CHECK_SNPRINTF_POSIX
if (size > 0)
#endif
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
}
else
{
- ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
+ ASSERT (memeq (buf, "12345\0EF", 8));
}
}
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
ASSERT (fread (buffer, 1, sizeof (buffer), fp) == 11);
/* Check the result. */
- ASSERT (memcmp (buffer, "Halle Potta", 11) == 0);
+ ASSERT (memeq (buffer, "Halle Potta", 11));
/* Wait for child. */
ASSERT (wait_subprocess (pid, progname, true, false, true, true, NULL) == 0);
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
memcpy (buf, "DEADBEEF", 8);
retval = my_sprintf (buf, "%d", 12345);
ASSERT (retval == 5);
- ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
+ ASSERT (memeq (buf, "12345\0EF", 8));
}
/* Test support of size specifiers as in C99. */
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
input[i] = 'a' + ((1000000 / (i + 1)) % 26);
input[i] = '\0';
retval = my_sprintf (result, "%.4000s %d", input, 99);
- ASSERT (memcmp (result, input, 4000) == 0);
+ ASSERT (memeq (result, input, 4000));
ASSERT (streq (result + 4000, " 99"));
ASSERT (retval == strlen (result));
}
block = (char *) malloc (i);
memcpy (block, "abcdefgh", i);
retval = my_sprintf (result, "%.*s", (int) i, block);
- ASSERT (memcmp (result, block, i) == 0);
+ ASSERT (memeq (result, block, i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (block);
for (size_t j = 0; j < i; j++)
block[j] = "abcdefgh"[j];
retval = my_sprintf (result, "%.*ls", (int) i, block);
- ASSERT (memcmp (result, "abcdefgh", i) == 0);
+ ASSERT (memeq (result, "abcdefgh", i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (block);
{ /* NUL character. */
int retval =
my_sprintf (result, "a%cz %d", '\0', 33, 44, 55);
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
}
- on musl libc,
- with GCC 14.1, 13.2, 12.3, and 11.4
<https://gcc.gnu.org/PR114876> */
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
}
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
free (result);
}
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
free (result);
}
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 41; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\357\277\275 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\2041\2447 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
ASSERT (length == strlen (expected1) || length == strlen (expected2));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2)));
free (result);
}
ASSERT (length == strlen (expected1) || length == strlen (expected2));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2)));
free (result);
}
# endif
|| length == strlen (expected3));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else if (length == strlen (expected2))
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2)));
else
- ASSERT (memcmp (result, expected3, strlen (expected3)) == 0);
+ ASSERT (memeq (result, expected3, strlen (expected3)));
free (result);
}
break;
|| length == strlen (expected3));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else if (length == strlen (expected2))
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2)));
else
- ASSERT (memcmp (result, expected3, strlen (expected3)) == 0);
+ ASSERT (memeq (result, expected3, strlen (expected3)));
free (result);
}
}
|| length == strlen (expected3));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else if (length == strlen (expected2))
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0
- || memcmp (result, expected3, strlen (expected3)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2))
+ || memeq (result, expected3, strlen (expected3)));
free (result);
}
break;
|| length == strlen (expected3));
ASSERT (result != NULL);
if (length == strlen (expected1))
- ASSERT (memcmp (result, expected1, strlen (expected1)) == 0);
+ ASSERT (memeq (result, expected1, strlen (expected1)));
else if (length == strlen (expected2))
- ASSERT (memcmp (result, expected2, strlen (expected2)) == 0
- || memcmp (result, expected3, strlen (expected3)) == 0);
+ ASSERT (memeq (result, expected2, strlen (expected2))
+ || memeq (result, expected3, strlen (expected3)));
free (result);
}
}
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 41; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 37; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 41; i++)
static const char expected[] = "Rafa? Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 17; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 10; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 10; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 16; i++)
&result, &length);
ASSERT (retval == 0);
ASSERT (length == strlen (expected));
- ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
+ ASSERT (result != NULL && memeq (result, expected, strlen (expected)));
if (o)
{
for (size_t i = 0; i < 13; i++)
ASSERT (sd_char_at (sd, 3) == '\377');
}
char *s = sbr_dupfree_c (&buffer);
- ASSERT (s != NULL && memcmp (s, "z\0x\377\0", 5) == 0);
+ ASSERT (s != NULL && memeq (s, "z\0x\377\0", 5));
free (s);
}
sbr_prepend_desc (&buffer, sd_new_addr (5, "de\0fg"));
sbr_prepend_c (&buffer, "abc");
char *s = sbr_dupfree_c (&buffer);
- ASSERT (s != NULL && memcmp (s, "abcde\0fghij", 12) == 0);
+ ASSERT (s != NULL && memeq (s, "abcde\0fghij", 12));
free (s);
}
ASSERT (sd_char_at (sd, 3) == 'z');
}
char *s = sb_dupfree_c (&buffer);
- ASSERT (s != NULL && memcmp (s, "x\377\0z\0", 5) == 0);
+ ASSERT (s != NULL && memeq (s, "x\377\0z\0", 5));
free (s);
}
sb_append_desc (&buffer, sd_new_addr (5, "de\0fg"));
sb_append_c (&buffer, "hij");
char *s = sb_dupfree_c (&buffer);
- ASSERT (s != NULL && memcmp (s, "abcde\0fghij", 12) == 0);
+ ASSERT (s != NULL && memeq (s, "abcde\0fghij", 12));
free (s);
}
char buf[80];
size_t n = sd_quotearg_buffer (buf, sizeof (buf), s2, NULL);
ASSERT (n == 21);
- ASSERT (memcmp (buf, "The\0quick\0brown\0\0fox", n) == 0);
+ ASSERT (memeq (buf, "The\0quick\0brown\0\0fox", n));
}
/* Test sd_quotearg_alloc. */
size_t n;
char *ret = sd_quotearg_alloc (s2, &n, NULL);
ASSERT (n == 21);
- ASSERT (memcmp (ret, "The\0quick\0brown\0\0fox", n) == 0);
+ ASSERT (memeq (ret, "The\0quick\0brown\0\0fox", n));
free (ret);
}
/* Test sd_quotearg_n. */
{
char *ret = sd_quotearg_n (1, s2);
- ASSERT (memcmp (ret, "Thequickbrownfox", 16 + 1) == 0);
+ ASSERT (memeq (ret, "Thequickbrownfox", 16 + 1));
}
/* Test sd_quotearg. */
{
char *ret = sd_quotearg (s2);
- ASSERT (memcmp (ret, "Thequickbrownfox", 16 + 1) == 0);
+ ASSERT (memeq (ret, "Thequickbrownfox", 16 + 1));
}
/* Test sd_quotearg_n_style. */
{
char *ret = sd_quotearg_n_style (1, clocale_quoting_style, s2);
- ASSERT (memcmp (ret, "\"The\\0quick\\0brown\\0\\0fox\\0\"", 28 + 1) == 0
+ ASSERT (memeq (ret, "\"The\\0quick\\0brown\\0\\0fox\\0\"", 28 + 1)
|| /* if the locale has UTF-8 encoding */
- memcmp (ret, "\342\200\230The\\0quick\\0brown\\0\\0fox\\0\342\200\231", 32 + 1) == 0);
+ memeq (ret, "\342\200\230The\\0quick\\0brown\\0\\0fox\\0\342\200\231", 32 + 1));
}
/* Test sd_quotearg_style. */
{
char *ret = sd_quotearg_style (clocale_quoting_style, s2);
- ASSERT (memcmp (ret, "\"The\\0quick\\0brown\\0\\0fox\\0\"", 28 + 1) == 0
+ ASSERT (memeq (ret, "\"The\\0quick\\0brown\\0\\0fox\\0\"", 28 + 1)
|| /* if the locale has UTF-8 encoding */
- memcmp (ret, "\342\200\230The\\0quick\\0brown\\0\\0fox\\0\342\200\231", 32 + 1) == 0);
+ memeq (ret, "\342\200\230The\\0quick\\0brown\\0\\0fox\\0\342\200\231", 32 + 1));
}
/* Test sd_quotearg_char. */
{
char *ret = sd_quotearg_char (s1, ' ');
- ASSERT (memcmp (ret, "Hello world!", 12 + 1) == 0); /* ' ' not quoted?! */
+ ASSERT (memeq (ret, "Hello world!", 12 + 1)); /* ' ' not quoted?! */
}
/* Test sd_quotearg_colon. */
{
char *ret = sd_quotearg_colon (sd_from_c ("a:b"));
- ASSERT (memcmp (ret, "a:b", 3 + 1) == 0); /* ':' not quoted?! */
+ ASSERT (memeq (ret, "a:b", 3 + 1)); /* ':' not quoted?! */
}
/* Test sd_quotearg_n_custom. */
{
char *ret = sd_quotearg_n_custom (2, "<", ">", s1);
- ASSERT (memcmp (ret, "<Hello world!>", 14 + 1) == 0);
+ ASSERT (memeq (ret, "<Hello world!>", 14 + 1));
}
/* Test sd_quotearg_n_custom. */
{
char *ret = sd_quotearg_custom ("[[", "]]", s1);
- ASSERT (memcmp (ret, "[[Hello world!]]", 16 + 1) == 0);
+ ASSERT (memeq (ret, "[[Hello world!]]", 16 + 1));
}
return test_exit_status;
/* Test sd_data. */
(void) sd_data (s0);
- ASSERT (memcmp (sd_data (s1), "Hello world!", 12) == 0);
- ASSERT (memcmp (sd_data (s2), "The\0quick\0brown\0\0fox", 21) == 0);
+ ASSERT (memeq (sd_data (s1), "Hello world!", 12));
+ ASSERT (memeq (sd_data (s2), "The\0quick\0brown\0\0fox", 21));
/* Test sd_is_empty. */
ASSERT (sd_is_empty (s0));
{
char *ptr = sd_c (s2);
ASSERT (ptr != NULL);
- ASSERT (memcmp (ptr, "The\0quick\0brown\0\0fox\0", 22) == 0);
+ ASSERT (memeq (ptr, "The\0quick\0brown\0\0fox\0", 22));
free (ptr);
}
size_t file_size;
char *file_contents = read_file (filename, RF_BINARY, &file_size);
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
}
/* Test the case that the file exists and is a regular file. */
if (supersede_if_exists)
{
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
}
else
{
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
}
}
ASSERT (fclose_supersede (fp, &action) == 0);
size_t file_size;
char *file_contents = read_file (filename, RF_BINARY, &file_size);
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
if (supersede_if_exists)
{
#if !(defined _WIN32 && !defined __CYGWIN__)
/* Note: On Linux/mips, statbuf.st_dev is smaller than a dev_t! */
dev_t new_dev = statbuf.st_dev;
- ASSERT (memcmp (&orig_dev, &new_dev, sizeof (dev_t)) == 0);
+ ASSERT (memeq (&orig_dev, &new_dev, sizeof (dev_t)));
ASSERT (memcmp (&orig_ino, &statbuf.st_ino, sizeof (ino_t)) != 0);
#endif
}
if (supersede_if_exists)
{
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
}
else
{
ASSERT (file_size == 4);
- ASSERT (memcmp (file_contents, "New\n", 4) == 0);
+ ASSERT (memeq (file_contents, "New\n", 4));
}
}
ASSERT (fclose_supersede (fp, &action) == 0);
size_t file_size;
char *file_contents = read_file (linkname, RF_BINARY, &file_size);
ASSERT (file_size == 4);
- ASSERT (memcmp (file_contents, "New\n", 4) == 0);
+ ASSERT (memeq (file_contents, "New\n", 4));
if (supersede_if_exists)
{
#if !(defined _WIN32 && !defined __CYGWIN__)
/* Note: On Linux/mips, statbuf.st_dev is smaller than a dev_t! */
dev_t new_dev = statbuf.st_dev;
- ASSERT (memcmp (&orig_dev, &new_dev, sizeof (dev_t)) == 0);
+ ASSERT (memeq (&orig_dev, &new_dev, sizeof (dev_t)));
ASSERT (memcmp (&orig_ino, &statbuf.st_ino, sizeof (ino_t)) != 0);
#endif
}
size_t file_size;
char *file_contents = read_file (linkname, RF_BINARY, &file_size);
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
/* Clean up. */
unlink (linkname);
size_t file_size;
char *file_contents = read_file (filename, RF_BINARY, &file_size);
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
}
/* Test the case that the file exists and is a regular file. */
if (supersede_if_exists)
{
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
}
else
{
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
}
}
ASSERT (close_supersede (fd, &action) == 0);
size_t file_size;
char *file_contents = read_file (filename, RF_BINARY, &file_size);
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
if (supersede_if_exists)
{
#if !(defined _WIN32 && !defined __CYGWIN__)
/* Note: On Linux/mips, statbuf.st_dev is smaller than a dev_t! */
dev_t new_dev = statbuf.st_dev;
- ASSERT (memcmp (&orig_dev, &new_dev, sizeof (dev_t)) == 0);
+ ASSERT (memeq (&orig_dev, &new_dev, sizeof (dev_t)));
ASSERT (memcmp (&orig_ino, &statbuf.st_ino, sizeof (ino_t)) != 0);
#endif
}
if (supersede_if_exists)
{
ASSERT (file_size == 7);
- ASSERT (memcmp (file_contents, "Foobar\n", 7) == 0);
+ ASSERT (memeq (file_contents, "Foobar\n", 7));
}
else
{
ASSERT (file_size == 4);
- ASSERT (memcmp (file_contents, "New\n", 4) == 0);
+ ASSERT (memeq (file_contents, "New\n", 4));
}
}
ASSERT (close_supersede (fd, &action) == 0);
size_t file_size;
char *file_contents = read_file (linkname, RF_BINARY, &file_size);
ASSERT (file_size == 4);
- ASSERT (memcmp (file_contents, "New\n", 4) == 0);
+ ASSERT (memeq (file_contents, "New\n", 4));
if (supersede_if_exists)
{
#if !(defined _WIN32 && !defined __CYGWIN__)
/* Note: On Linux/mips, statbuf.st_dev is smaller than a dev_t! */
dev_t new_dev = statbuf.st_dev;
- ASSERT (memcmp (&orig_dev, &new_dev, sizeof (dev_t)) == 0);
+ ASSERT (memeq (&orig_dev, &new_dev, sizeof (dev_t)));
ASSERT (memcmp (&orig_ino, &statbuf.st_ino, sizeof (ino_t)) != 0);
#endif
}
size_t file_size;
char *file_contents = read_file (linkname, RF_BINARY, &file_size);
ASSERT (file_size == 12);
- ASSERT (memcmp (file_contents, "Hello world\n", 12) == 0);
+ ASSERT (memeq (file_contents, "Hello world\n", 12));
/* Clean up. */
unlink (linkname);
buf[output_len + 1] = '%';
bufend = system_quote_copy (buf, interpreter, input);
ASSERT (bufend == buf + output_len);
- ASSERT (memcmp (buf, output, output_len + 1) == 0);
+ ASSERT (memeq (buf, output, output_len + 1));
ASSERT (buf[output_len + 1] == '%');
/* Store INPUT in EXPECTED_DATA_FILE, for verification by the child
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
ASSERT (ttyname_r (fd, buf, 1) == ERANGE);
ASSERT (ttyname_r (fd, buf, sizeof (buf)) == 0);
- ASSERT (memcmp (buf, "/dev/", 5) == 0);
+ ASSERT (memeq (buf, "/dev/", 5));
/* Test behaviour for invalid file descriptors. */
{
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
ASSERT (length == 5);
if (size < 6)
ASSERT (result != buf);
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
if (result != buf)
free (result);
}
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
input[i] = '\0';
result = my_asnprintf (NULL, &length, "%.4000s %d", input, 99);
ASSERT (result != NULL);
- ASSERT (memcmp (result, input, 4000) == 0);
+ ASSERT (memeq (result, input, 4000));
ASSERT (streq (result + 4000, " 99"));
ASSERT (length == strlen (result));
free (result);
memcpy (block, "abcdefgh", i);
result = my_asnprintf (NULL, &length, "%.*s", (int) i, block);
ASSERT (result != NULL);
- ASSERT (memcmp (result, block, i) == 0);
+ ASSERT (memeq (result, block, i));
ASSERT (result[i] == '\0');
ASSERT (length == strlen (result));
free (result);
block[j] = "abcdefgh"[j];
result = my_asnprintf (NULL, &length, "%.*ls", (int) i, block);
ASSERT (result != NULL);
- ASSERT (memcmp (result, "abcdefgh", i) == 0);
+ ASSERT (memeq (result, "abcdefgh", i));
ASSERT (result[i] == '\0');
ASSERT (length == strlen (result));
free (result);
char *result =
my_asnprintf (NULL, &length,
"a%cz %d", '\0', 33, 44, 55);
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (length == 6);
free (result);
}
as if by a call to the wcrtomb function with a pointer to storage of
at least MB_CUR_MAX bytes, the wint_t argument converted to wchar_t,
and an initial shift state." */
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (length == 6);
free (result);
}
char *result = asnprintf (NULL, &length, "%'d", 1000);
ASSERT (result != NULL);
ASSERT (length == 4 + separator_len);
- ASSERT (memcmp (result, "1", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
+ ASSERT (memeq (result, "1", 1)
+ && memeq (result + 1, separator, separator_len)
&& streq (result + 1 + separator_len, "000"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'d", -1000);
ASSERT (result != NULL);
ASSERT (length == 5 + separator_len);
- ASSERT (memcmp (result, "-1", 2) == 0
- && memcmp (result + 2, separator, separator_len) == 0
+ ASSERT (memeq (result, "-1", 2)
+ && memeq (result + 2, separator, separator_len)
&& streq (result + 2 + separator_len, "000"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'d", -142857);
ASSERT (result != NULL);
ASSERT (length == 7 + separator_len);
- ASSERT (memcmp (result, "-142", 4) == 0
- && memcmp (result + 4, separator, separator_len) == 0
+ ASSERT (memeq (result, "-142", 4)
+ && memeq (result + 4, separator, separator_len)
&& streq (result + 4 + separator_len, "857"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'d", 2147483647);
ASSERT (result != NULL);
ASSERT (length == 10 + 3 * separator_len);
- ASSERT (memcmp (result, "2", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
- && memcmp (result + 1 + separator_len, "147", 3) == 0
- && memcmp (result + 4 + separator_len, separator, separator_len) == 0
- && memcmp (result + 4 + 2 * separator_len, "483", 3) == 0
- && memcmp (result + 7 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "2", 1)
+ && memeq (result + 1, separator, separator_len)
+ && memeq (result + 1 + separator_len, "147", 3)
+ && memeq (result + 4 + separator_len, separator, separator_len)
+ && memeq (result + 4 + 2 * separator_len, "483", 3)
+ && memeq (result + 7 + 2 * separator_len, separator, separator_len)
&& streq (result + 7 + 3 * separator_len, "647"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'d", -2147483647);
ASSERT (result != NULL);
ASSERT (length == 11 + 3 * separator_len);
- ASSERT (memcmp (result, "-2", 2) == 0
- && memcmp (result + 2, separator, separator_len) == 0
- && memcmp (result + 2 + separator_len, "147", 3) == 0
- && memcmp (result + 5 + separator_len, separator, separator_len) == 0
- && memcmp (result + 5 + 2 * separator_len, "483", 3) == 0
- && memcmp (result + 8 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "-2", 2)
+ && memeq (result + 2, separator, separator_len)
+ && memeq (result + 2 + separator_len, "147", 3)
+ && memeq (result + 5 + separator_len, separator, separator_len)
+ && memeq (result + 5 + 2 * separator_len, "483", 3)
+ && memeq (result + 8 + 2 * separator_len, separator, separator_len)
&& streq (result + 8 + 3 * separator_len, "647"));
free (result);
}
/* Most implementations don't add the grouping character within the
leading zeroes. */
ASSERT (length == 10 + separator_len);
- ASSERT (memcmp (result, "0000001", 7) == 0
- && memcmp (result + 7, separator, separator_len) == 0
+ ASSERT (memeq (result, "0000001", 7)
+ && memeq (result + 7, separator, separator_len)
&& streq (result + 7 + separator_len, "000"));
}
else
within the leading zeroes.
<https://sourceware.org/PR23432> */
ASSERT (length == 10 + 3 * separator_len);
- ASSERT (memcmp (result, "0", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
- && memcmp (result + 1 + separator_len, "000", 3) == 0
- && memcmp (result + 4 + separator_len, separator, separator_len) == 0
- && memcmp (result + 4 + 2 * separator_len, "001", 3) == 0
- && memcmp (result + 7 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "0", 1)
+ && memeq (result + 1, separator, separator_len)
+ && memeq (result + 1 + separator_len, "000", 3)
+ && memeq (result + 4 + separator_len, separator, separator_len)
+ && memeq (result + 4 + 2 * separator_len, "001", 3)
+ && memeq (result + 7 + 2 * separator_len, separator, separator_len)
&& streq (result + 7 + 3 * separator_len, "000"));
}
free (result);
/* Most implementations don't add the grouping character within the
leading zeroes. */
ASSERT (length == 11 + separator_len);
- ASSERT (memcmp (result, "-0000001", 8) == 0
- && memcmp (result + 8, separator, separator_len) == 0
+ ASSERT (memeq (result, "-0000001", 8)
+ && memeq (result + 8, separator, separator_len)
&& streq (result + 8 + separator_len, "000"));
}
else
within the leading zeroes.
<https://sourceware.org/PR23432> */
ASSERT (length == 11 + 3 * separator_len);
- ASSERT (memcmp (result, "-0", 2) == 0
- && memcmp (result + 2, separator, separator_len) == 0
- && memcmp (result + 2 + separator_len, "000", 3) == 0
- && memcmp (result + 5 + separator_len, separator, separator_len) == 0
- && memcmp (result + 5 + 2 * separator_len, "001", 3) == 0
- && memcmp (result + 8 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "-0", 2)
+ && memeq (result + 2, separator, separator_len)
+ && memeq (result + 2 + separator_len, "000", 3)
+ && memeq (result + 5 + separator_len, separator, separator_len)
+ && memeq (result + 5 + 2 * separator_len, "001", 3)
+ && memeq (result + 8 + 2 * separator_len, separator, separator_len)
&& streq (result + 8 + 3 * separator_len, "000"));
}
free (result);
<https://pubs.opengroup.org/onlinepubs/9799919799/functions/fprintf.html>
<https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap05.html#tag_05> */
ASSERT (length == 10);
- ASSERT (memcmp (result, " 1" + separator_len, 7 - separator_len) == 0
- && memcmp (result + 7 - separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, " 1" + separator_len, 7 - separator_len)
+ && memeq (result + 7 - separator_len, separator, separator_len)
&& streq (result + 7, "000"));
}
else
<https://sourceware.org/PR30883>
<https://sourceware.org/PR31542> */
ASSERT (length == 9 + separator_len);
- ASSERT (memcmp (result, " 1", 6) == 0
- && memcmp (result + 6, separator, separator_len) == 0
+ ASSERT (memeq (result, " 1", 6)
+ && memeq (result + 6, separator, separator_len)
&& streq (result + 6 + separator_len, "000"));
}
}
<https://pubs.opengroup.org/onlinepubs/9799919799/functions/fprintf.html>
<https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap05.html#tag_05> */
ASSERT (length == 10);
- ASSERT (memcmp (result, " -1" + separator_len, 7 - separator_len) == 0
- && memcmp (result + 7 - separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, " -1" + separator_len, 7 - separator_len)
+ && memeq (result + 7 - separator_len, separator, separator_len)
&& streq (result + 7, "000"));
}
else
<https://sourceware.org/PR30883>
<https://sourceware.org/PR31542> */
ASSERT (length == 9 + separator_len);
- ASSERT (memcmp (result, " -1", 6) == 0
- && memcmp (result + 6, separator, separator_len) == 0
+ ASSERT (memeq (result, " -1", 6)
+ && memeq (result + 6, separator, separator_len)
&& streq (result + 6 + separator_len, "000"));
}
}
char *result = asnprintf (NULL, &length, "%'.0f", 1000.0);
ASSERT (result != NULL);
ASSERT (length == 4 + separator_len);
- ASSERT (memcmp (result, "1", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
+ ASSERT (memeq (result, "1", 1)
+ && memeq (result + 1, separator, separator_len)
&& streq (result + 1 + separator_len, "000"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'.5f", 3141592653.5897932386);
ASSERT (result != NULL);
ASSERT (length == 16 + 3 * separator_len);
- ASSERT (memcmp (result, "3", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
- && memcmp (result + 1 + separator_len, "141", 3) == 0
- && memcmp (result + 4 + separator_len, separator, separator_len) == 0
- && memcmp (result + 4 + 2 * separator_len, "592", 3) == 0
- && memcmp (result + 7 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "3", 1)
+ && memeq (result + 1, separator, separator_len)
+ && memeq (result + 1 + separator_len, "141", 3)
+ && memeq (result + 4 + separator_len, separator, separator_len)
+ && memeq (result + 4 + 2 * separator_len, "592", 3)
+ && memeq (result + 7 + 2 * separator_len, separator, separator_len)
&& streq (result + 7 + 3 * separator_len, "653,58979"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'.5f", -3141592653.5897932386);
ASSERT (result != NULL);
ASSERT (length == 17 + 3 * separator_len);
- ASSERT (memcmp (result, "-3", 2) == 0
- && memcmp (result + 2, separator, separator_len) == 0
- && memcmp (result + 2 + separator_len, "141", 3) == 0
- && memcmp (result + 5 + separator_len, separator, separator_len) == 0
- && memcmp (result + 5 + 2 * separator_len, "592", 3) == 0
- && memcmp (result + 8 + 2 * separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "-3", 2)
+ && memeq (result + 2, separator, separator_len)
+ && memeq (result + 2 + separator_len, "141", 3)
+ && memeq (result + 5 + separator_len, separator, separator_len)
+ && memeq (result + 5 + 2 * separator_len, "592", 3)
+ && memeq (result + 8 + 2 * separator_len, separator, separator_len)
&& streq (result + 8 + 3 * separator_len, "653,58979"));
free (result);
}
<https://pubs.opengroup.org/onlinepubs/9799919799/functions/fprintf.html>
<https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap05.html#tag_05> */
ASSERT (length == 10);
- ASSERT (memcmp (result, "0000001" + separator_len, 7 - separator_len) == 0
- && memcmp (result + 7 - separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "0000001" + separator_len, 7 - separator_len)
+ && memeq (result + 7 - separator_len, separator, separator_len)
&& streq (result + 7, "000"));
}
else
<https://sourceware.org/PR30883>
<https://sourceware.org/PR31542> */
ASSERT (length == 9 + separator_len);
- ASSERT (memcmp (result, "000001", 6) == 0
- && memcmp (result + 6, separator, separator_len) == 0
+ ASSERT (memeq (result, "000001", 6)
+ && memeq (result + 6, separator, separator_len)
&& streq (result + 6 + separator_len, "000"));
}
}
char *result = asnprintf (NULL, &length, "%'g", 1000.0);
ASSERT (result != NULL);
ASSERT (length == 4 + separator_len);
- ASSERT (memcmp (result, "1", 1) == 0
- && memcmp (result + 1, separator, separator_len) == 0
+ ASSERT (memeq (result, "1", 1)
+ && memeq (result + 1, separator, separator_len)
&& streq (result + 1 + separator_len, "000"));
free (result);
}
char *result = asnprintf (NULL, &length, "%'g", -142857.0);
ASSERT (result != NULL);
ASSERT (length == 7 + separator_len);
- ASSERT (memcmp (result, "-142", 4) == 0
- && memcmp (result + 4, separator, separator_len) == 0
+ ASSERT (memeq (result, "-142", 4)
+ && memeq (result + 4, separator, separator_len)
&& streq (result + 4 + separator_len, "857"));
free (result);
}
42351647362715016953416125033982098102569580078125.0);
ASSERT (result != NULL);
ASSERT (length == 50 + 16 * separator_len);
- ASSERT (memcmp (result, "42", 2) == 0
- && memcmp (result + 2, separator, separator_len) == 0
- && memcmp (result + 2 + separator_len, "351", 3) == 0
- && memcmp (result + 5 + separator_len, separator, separator_len) == 0
- && memcmp (result + 5 + 2 * separator_len, "647", 3) == 0
- && memcmp (result + 8 + 2 * separator_len, separator, separator_len) == 0
- && memcmp (result + 8 + 3 * separator_len, "362", 3) == 0
- && memcmp (result + 11 + 3 * separator_len, separator, separator_len) == 0
- && memcmp (result + 11 + 4 * separator_len, "715", 3) == 0
- && memcmp (result + 14 + 4 * separator_len, separator, separator_len) == 0);
+ ASSERT (memeq (result, "42", 2)
+ && memeq (result + 2, separator, separator_len)
+ && memeq (result + 2 + separator_len, "351", 3)
+ && memeq (result + 5 + separator_len, separator, separator_len)
+ && memeq (result + 5 + 2 * separator_len, "647", 3)
+ && memeq (result + 8 + 2 * separator_len, separator, separator_len)
+ && memeq (result + 8 + 3 * separator_len, "362", 3)
+ && memeq (result + 11 + 3 * separator_len, separator, separator_len)
+ && memeq (result + 11 + 4 * separator_len, "715", 3)
+ && memeq (result + 14 + 4 * separator_len, separator, separator_len));
free (result);
}
{
<https://pubs.opengroup.org/onlinepubs/9799919799/functions/fprintf.html>
<https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap05.html#tag_05> */
ASSERT (length == 10);
- ASSERT (memcmp (result, "0000001" + separator_len, 7 - separator_len) == 0
- && memcmp (result + 7 - separator_len, separator, separator_len) == 0
+ ASSERT (memeq (result, "0000001" + separator_len, 7 - separator_len)
+ && memeq (result + 7 - separator_len, separator, separator_len)
&& streq (result + 7, "000"));
}
else
<https://sourceware.org/PR30883>
<https://sourceware.org/PR31542> */
ASSERT (length == 9 + separator_len);
- ASSERT (memcmp (result, "000001", 6) == 0
- && memcmp (result + 6, separator, separator_len) == 0
+ ASSERT (memeq (result, "000001", 6)
+ && memeq (result + 6, separator, separator_len)
&& streq (result + 6 + separator_len, "000"));
}
}
ASSERT (length == 5);
if (size < 5 + 1)
ASSERT (result != buf);
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
if (result != buf)
free (result);
}
163141592653589790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
*/
ASSERT (strlen (result) == 126);
- ASSERT (memcmp (result, "163141592653589790", 18) == 0);
+ ASSERT (memeq (result, "163141592653589790", 18));
ASSERT (length == 126);
if (size < 126 + 1)
ASSERT (result != buf);
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
if (result != buf)
free (result);
}
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
ASSERT (streq (result, expected)
/* Some implementations produce exponents with 3 digits. */
|| (strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
/* Some implementations produce exponents with 3 digits. */
|| (expected[strlen (expected) - 4] == 'e'
&& strlen (result) == strlen (expected) + 1
- && memcmp (result, expected, strlen (expected) - 2) == 0
+ && memeq (result, expected, strlen (expected) - 2)
&& result[strlen (expected) - 2] == '0'
&& streq (result + strlen (expected) - 1,
expected + strlen (expected) - 2)));
input[i] = '\0';
retval = my_asprintf (&result, "%.4000s %d", input, 99);
ASSERT (result != NULL);
- ASSERT (memcmp (result, input, 4000) == 0);
+ ASSERT (memeq (result, input, 4000));
ASSERT (streq (result + 4000, " 99"));
ASSERT (retval == strlen (result));
free (result);
memcpy (block, "abcdefgh", i);
retval = my_asprintf (&result, "%.*s", (int) i, block);
ASSERT (result != NULL);
- ASSERT (memcmp (result, block, i) == 0);
+ ASSERT (memeq (result, block, i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (result);
block[j] = "abcdefgh"[j];
retval = my_asprintf (&result, "%.*ls", (int) i, block);
ASSERT (result != NULL);
- ASSERT (memcmp (result, "abcdefgh", i) == 0);
+ ASSERT (memeq (result, "abcdefgh", i));
ASSERT (result[i] == '\0');
ASSERT (retval == strlen (result));
free (result);
char *result;
int retval =
my_asprintf (&result, "a%cz %d", '\0', 33, 44, 55);
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
free (result);
}
as if by a call to the wcrtomb function with a pointer to storage of
at least MB_CUR_MAX bytes, the wint_t argument converted to wchar_t,
and an initial shift state." */
- ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
+ ASSERT (memeq (result, "a\0z 33\0", 6 + 1));
ASSERT (retval == 6);
free (result);
}
if (string[start_index] == '-')
start_index++;
if (start_index + 3 <= end_index
- && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+ && memeq (string + start_index, uppercase ? "NAN" : "nan", 3))
{
start_index += 3;
if (start_index == end_index
{
if (size > 0)
{
- ASSERT (memcmp (buf, "12345", size - 1) == 0);
+ ASSERT (memeq (buf, "12345", size - 1));
ASSERT (buf[size - 1] == '\0' || buf[size - 1] == '0' + size);
}
#if !CHECK_VSNPRINTF_POSIX
if (size > 0)
#endif
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
}
else
{
- ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
+ ASSERT (memeq (buf, "12345\0EF", 8));
}
}
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00FC, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\374", 1) == 0);
+ ASSERT (memeq (buf, "\374", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00DF, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\337", 1) == 0);
+ ASSERT (memeq (buf, "\337", 1));
ASSERT (buf[1] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x0622, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\302", 1) == 0);
+ ASSERT (memeq (buf, "\302", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x0644, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\341", 1) == 0);
+ ASSERT (memeq (buf, "\341", 1));
ASSERT (buf[1] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x0648, NULL);
ASSERT (ret == 1);
- ASSERT (memcmp (buf, "\346", 1) == 0);
+ ASSERT (memeq (buf, "\346", 1));
ASSERT (buf[1] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00FC, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\303\274", 2) == 0);
+ ASSERT (memeq (buf, "\303\274", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00DF, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\303\237", 2) == 0);
+ ASSERT (memeq (buf, "\303\237", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\223\372", 2) == 0);
+ ASSERT (memeq (buf, "\223\372", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\226\173", 2) == 0);
+ ASSERT (memeq (buf, "\226\173", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\214\352", 2) == 0);
+ ASSERT (memeq (buf, "\214\352", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\244\351", 2) == 0);
+ ASSERT (memeq (buf, "\244\351", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\245\273", 2) == 0);
+ ASSERT (memeq (buf, "\245\273", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\273\171", 2) == 0);
+ ASSERT (memeq (buf, "\273\171", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x65E5, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\310\325", 2) == 0);
+ ASSERT (memeq (buf, "\310\325", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x672C, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\261\276", 2) == 0);
+ ASSERT (memeq (buf, "\261\276", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x8A9E, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\325\132", 2) == 0);
+ ASSERT (memeq (buf, "\325\132", 2));
ASSERT (buf[2] == 'x');
}
return 0;
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00FC, NULL);
ASSERT (ret == 2);
- ASSERT (memcmp (buf, "\250\271", 2) == 0);
+ ASSERT (memeq (buf, "\250\271", 2));
ASSERT (buf[2] == 'x');
memset (buf, 'x', 8);
ret = wcrtomb (buf, 0x00DF, NULL);
ASSERT (ret == 4);
- ASSERT (memcmp (buf, "\201\060\211\070", 4) == 0);
+ ASSERT (memeq (buf, "\201\060\211\070", 4));
ASSERT (buf[4] == 'x');
}
return 0;
ret = wcrtomb (buf, wc, NULL);
ASSERT (ret == n);
- ASSERT (memcmp (buf, s, n) == 0);
+ ASSERT (memeq (buf, s, n));
/* Test special calling convention, passing a NULL pointer. */
ret = wcrtomb (NULL, wc, NULL);
ret = wcsnrtombs (buf, &src, 6, n, NULL);
ASSERT (ret == (n <= 5 ? n : 5));
ASSERT (src == (n <= 5 ? input + n : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 3 ? input + 1 :
n < 5 ? input + 2 :
n <= 7 ? input + (n - 2) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 7 ? input + 3 :
n <= 8 ? input + (n - 3) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 3 ? input + 1 :
n < 7 ? input + 2 :
n <= 9 ? input + (n - 4) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ret = wcsrtombs (buf, &src, n, NULL);
ASSERT (ret == (n <= 5 ? n : 5));
ASSERT (src == (n <= 5 ? input + n : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 3 ? input + 1 :
n < 5 ? input + 2 :
n <= 7 ? input + (n - 2) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 5 ? input + 2 :
n < 7 ? input + 3 :
n <= 8 ? input + (n - 3) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
n < 3 ? input + 1 :
n < 7 ? input + 2 :
n <= 9 ? input + (n - 4) : NULL));
- ASSERT (memcmp (buf, original, ret) == 0);
+ ASSERT (memeq (buf, original, ret));
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ret = wcstok (string, delim, &ptr);
ASSERT (ret == string);
- ASSERT (memcmp (string, L"hello\0 world!", 14 * sizeof (wchar_t)) == 0);
+ ASSERT (memeq (string, L"hello\0 world!", 14 * sizeof (wchar_t)));
ASSERT (ptr == string + 6);
ret = wcstok (NULL, delim, &ptr);
ASSERT (ret == string + 7);
- ASSERT (memcmp (string, L"hello\0 world!", 14 * sizeof (wchar_t)) == 0);
+ ASSERT (memeq (string, L"hello\0 world!", 14 * sizeof (wchar_t)));
ASSERT (ptr == NULL || *ptr == L'\0');
ret = wcstok (NULL, delim, &ptr);
ASSERT (rfd >= 0);
ASSERT (read (rfd, buf, sizeof (buf)) == 17);
ASSERT (close (rfd) == 0);
- ASSERT (memcmp (buf, "Hello fascination", 17) == 0);
+ ASSERT (memeq (buf, "Hello fascination", 17));
}
ASSERT (close (fd) == 0);
{
char *result = xmemdup0 (buffer, 9);
ASSERT (result);
- ASSERT (memcmp (result, buffer, 9) == 0);
+ ASSERT (memeq (result, buffer, 9));
ASSERT (result[9] == '\0');
free (result);
}
{
char *result = xmemdup0 (buffer, 10);
ASSERT (result);
- ASSERT (memcmp (result, buffer, 10) == 0);
+ ASSERT (memeq (result, buffer, 10));
ASSERT (result[10] == '\0');
free (result);
}
{
char *ptr = xsd_c (s2);
ASSERT (ptr != NULL);
- ASSERT (memcmp (ptr, "The\0quick\0brown\0\0fox\0", 22) == 0);
+ ASSERT (memeq (ptr, "The\0quick\0brown\0\0fox\0", 22));
free (ptr);
}
NULL, &length);
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 37; i++)
static const char expected_translit[] = "Rafal Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0
- || memcmp (result, expected_translit, length) == 0);
+ ASSERT (memeq (result, expected, length)
+ || memeq (result, expected_translit, length));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 16; i++)
NULL, &length);
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 37; i++)
static const char expected_translit[] = "Rafal Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0
- || memcmp (result, expected_translit, length) == 0);
+ ASSERT (memeq (result, expected, length)
+ || memeq (result, expected_translit, length));
if (o)
{
for (size_t i = 0; i < 16; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 16; i++)
NULL, &length);
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 41; i++)
static const char expected_translit[] = "Rafal Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0
- || memcmp (result, expected_translit, length) == 0);
+ ASSERT (memeq (result, expected, length)
+ || memeq (result, expected_translit, length));
if (o)
{
for (size_t i = 0; i < 17; i++)
static const char expected[] = "Rafa\\u0142 Maszkowski";
ASSERT (result != NULL);
ASSERT (length == strlen (expected));
- ASSERT (memcmp (result, expected, length) == 0);
+ ASSERT (memeq (result, expected, length));
if (o)
{
for (size_t i = 0; i < 17; i++)
ASSERT (length == 5);
if (size < 6)
ASSERT (result != buf);
- ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
+ ASSERT (memeq (buf + size, &"DEADBEEF"[size], 8 - size));
if (result != buf)
free (result);
}
n = U_UCTOMB (c, uc, 6);
ASSERT (exp < input + length - 1);
ASSERT (U_CHR (prev, (length - 1) - (prev - input), uc) == exp);
- ASSERT (memcmp (exp, c, n * sizeof (UNIT)) == 0);
+ ASSERT (memeq (exp, c, n * sizeof (UNIT)));
prev = exp;
exp += n * 63;
}
n = U_UCTOMB (c, uc, 6);
ASSERT (exp < input + length - 2);
ASSERT (U_STRCHR (prev, uc) == exp);
- ASSERT (memcmp (exp, c, n * sizeof (UNIT)) == 0);
+ ASSERT (memeq (exp, c, n * sizeof (UNIT)));
prev = exp;
exp += n * 63;
}
{
int n = read (fd, buf, sizeof (buf));
close (fd);
- if (n == 10 + 1 && memcmp (buf, "VirtualBox\n", 10 + 1) == 0)
+ if (n == 10 + 1 && memeq (buf, "VirtualBox\n", 10 + 1))
return true;
}
#endif
projects / thirdparty / gnulib.git / commitdiff
