path
stringlengths 14
112
| content
stringlengths 0
6.32M
| size
int64 0
6.32M
| max_lines
int64 1
100k
| repo_name
stringclasses 2
values | autogenerated
bool 1
class |
|---|---|---|---|---|---|
cosmopolitan/test/libc/intrin/memrchr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/stdio/rand.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(memrchr, testNotFoundSse) {
char buf[16] = {0};
ASSERT_EQ(NULL, memrchr(buf, 1, 16));
}
TEST(memrchr, testNotFoundPure) {
char buf[15] = {0};
ASSERT_EQ(NULL, memrchr(buf, 1, 15));
}
TEST(memrchr, testSse) {
char buf[16];
rngset(buf, sizeof(buf), lemur64, -1);
ASSERT_EQ(buf + 0, memrchr(buf, buf[0], 16));
ASSERT_EQ(buf + 15, memrchr(buf, buf[15], 16));
}
TEST(memrchr, testPure) {
char buf[15];
rngset(buf, sizeof(buf), lemur64, -1);
ASSERT_EQ(buf + 0, memrchr(buf, buf[0], 15));
ASSERT_EQ(buf + 14, memrchr(buf, buf[14], 15));
}
TEST(memrchr, testSse2) {
char buf[32];
rngset(buf, sizeof(buf), lemur64, -1);
ASSERT_EQ(buf + 0, memrchr(buf, buf[0], 32));
ASSERT_EQ(buf + 15, memrchr(buf, buf[15], 32));
ASSERT_EQ(buf + 16, memrchr(buf, buf[16], 32));
ASSERT_EQ(buf + 31, memrchr(buf, buf[31], 32));
}
TEST(memrchr, testSsePure) {
char buf[20];
rngset(buf, sizeof(buf), lemur64, -1);
ASSERT_EQ(buf + 0, memrchr(buf, buf[0], 20));
ASSERT_EQ(buf + 15, memrchr(buf, buf[15], 20));
ASSERT_EQ(buf + 16, memrchr(buf, buf[16], 20));
ASSERT_EQ(buf + 19, memrchr(buf, buf[19], 20));
}
BENCH(memrchr, bench) {
void *memrchr_(const void *, int, size_t) asm("memrchr");
EZBENCH2("memrchr", donothing, memrchr_(kHyperion, 255, kHyperionSize));
}
| 3,291 | 71 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/pthread_once_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/atomic.h"
#include "libc/dce.h"
#include "libc/intrin/atomic.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/spawn.h"
#include "libc/thread/thread.h"
int i, n;
struct spawn *t;
atomic_int x, y;
pthread_barrier_t b;
static pthread_once_t once = PTHREAD_ONCE_INIT;
void InitFactory(void) {
ASSERT_EQ(0, atomic_load(&x));
atomic_fetch_add(&y, 1);
}
int Worker(void *arg, int tid) {
pthread_barrier_wait(&b);
ASSERT_EQ(0, pthread_once(&once, InitFactory));
ASSERT_EQ(1, atomic_load(&y));
atomic_fetch_add(&x, 1);
return 0;
}
TEST(pthread_once, test) {
n = 32;
x = y = 0;
ASSERT_EQ(0, pthread_barrier_init(&b, 0, n));
t = gc(malloc(sizeof(struct spawn) * n));
for (i = 0; i < n; ++i) ASSERT_SYS(0, 0, _spawn(Worker, 0, t + i));
for (i = 0; i < n; ++i) EXPECT_SYS(0, 0, _join(t + i));
ASSERT_EQ(n, atomic_load(&x));
ASSERT_EQ(1, atomic_load(&y));
ASSERT_EQ(0, pthread_barrier_destroy(&b));
}
__attribute__((__constructor__)) static void init(void) {
// try to test both the nsync and non-nsync versions with regular builds
if (!IsTiny()) {
pthread_cond_t c = {0};
pthread_cond_broadcast(&c);
}
}
| 3,063 | 66 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/strcmp_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/assert.h"
#include "libc/dce.h"
#include "libc/intrin/bits.h"
#include "libc/macros.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/cachesize.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
int (*memcmpi)(const void *, const void *, size_t) = memcmp;
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § emptiness ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(strcmp, emptyString) {
EXPECT_EQ(0, strcmp("", ""));
EXPECT_NE(0, strcmp("", "a"));
}
TEST(strcasecmp, emptyString) {
EXPECT_EQ(0, strcasecmp("", ""));
EXPECT_NE(0, strcasecmp("", "a"));
}
TEST(strcmp16, emptyString) {
EXPECT_EQ(0, strcmp16(u"", u""));
EXPECT_NE(0, strcmp16(u"", u"a"));
}
TEST(strcasecmp16, emptyString) {
EXPECT_EQ(0, strcasecmp16(u"", u""));
EXPECT_NE(0, strcasecmp16(u"", u"a"));
}
TEST(wcscmp, emptyString) {
EXPECT_EQ(0, wcscmp(L"", L""));
EXPECT_NE(0, wcscmp(L"", L"a"));
}
TEST(wcscasecmp, emptyString) {
EXPECT_EQ(0, wcscasecmp(L"", L""));
EXPECT_NE(0, wcscasecmp(L"", L"a"));
}
TEST(strncmp, nullString) {
char *s1 = malloc(0);
char *s2 = malloc(0);
ASSERT_NE(s1, s2);
ASSERT_EQ(0, strncmp(s1, s2, 0));
free(s2);
free(s1);
}
TEST(strncmp, emptyString) {
char *s1 = strcpy(malloc(1), "");
char *s2 = strcpy(malloc(1), "");
ASSERT_EQ(0, strncmp(s1, s2, 0));
ASSERT_EQ(0, strncmp(s1, s2, 1));
ASSERT_EQ(0, strncmp(s1, s2, -1));
ASSERT_EQ(0, strncmp(s1, s1, -1));
ASSERT_EQ(0, strncmp(s2, s2, -1));
free(s2);
free(s1);
}
TEST(strncasecmp, emptyString) {
char *s1 = strcpy(malloc(1), "");
char *s2 = strcpy(malloc(1), "");
ASSERT_EQ(0, strncasecmp(s1, s2, 0));
ASSERT_EQ(0, strncasecmp(s1, s2, 1));
ASSERT_EQ(0, strncasecmp(s1, s2, -1));
ASSERT_EQ(0, strncasecmp(s1, s1, -1));
ASSERT_EQ(0, strncasecmp(s2, s2, -1));
free(s2);
free(s1);
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § inequality ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(strncmp, testInequality) {
char *s1 = strcpy(malloc(2), "1");
char *s2 = strcpy(malloc(1), "");
ASSERT_EQ(0, strncmp(s1, s2, 0));
ASSERT_GT(strncmp(s1, s2, 1), 0);
ASSERT_LT(strncmp(s2, s1, 1), 0);
free(s2);
free(s1);
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § does it work? ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(memcmp, test) {
EXPECT_EQ(memcmpi("\200", "\200", 1), 0);
EXPECT_LT(memcmpi("\177", "\200", 1), 0);
EXPECT_GT(memcmpi("\200", "\177", 1), 0);
EXPECT_EQ(memcmpi("", "", 0), 0);
EXPECT_EQ(memcmpi("a", "a", 1), 0);
EXPECT_GT(memcmpi("a", "A", 1), 0);
EXPECT_LT(memcmpi("A", "a", 1), 0);
EXPECT_LT(memcmpi("\001", "\377", 1), 0);
EXPECT_GT(memcmpi("\377", "\001", 1), 0);
EXPECT_EQ(memcmpi("a", "aa", 1), 0);
EXPECT_EQ(memcmpi("aa", "a", 1), 0);
EXPECT_LT(memcmpi("a", "aa", 2), 0);
EXPECT_GT(memcmpi("aa", "a", 2), 0);
EXPECT_LT(memcmpi("aaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaa\377", 16), 0);
EXPECT_GT(memcmpi("aaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaa\001", 16), 0);
EXPECT_LT(memcmpi("aaaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaaa\377", 17), 0);
EXPECT_GT(memcmpi("aaaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaaa\001", 17), 0);
EXPECT_LT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377", 32),
0);
EXPECT_GT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001", 32),
0);
EXPECT_LT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377", 33),
0);
EXPECT_GT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001", 33),
0);
EXPECT_LT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377", 34),
0);
EXPECT_GT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001", 34),
0);
}
TEST(strcmp, testItWorks) {
EXPECT_EQ(strcmp("", ""), 0);
EXPECT_EQ(strcmp("a", "a"), 0);
EXPECT_GT(strcmp("a", "A"), 0);
EXPECT_LT(strcmp("A", "a"), 0);
EXPECT_LT(strcmp("\001", "\377"), 0);
EXPECT_GT(strcmp("\377", "\001"), 0);
EXPECT_LT(strcmp("a", "aa"), 0);
EXPECT_GT(strcmp("aa", "a"), 0);
EXPECT_LT(strcmp("a\000", "aa\000"), 0);
EXPECT_GT(strcmp("aa\000", "a\000"), 0);
EXPECT_LT(strcmp("aaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcmp("aaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcmp("aaaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcmp("aaaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
}
TEST(strcasecmp, testItWorks) {
EXPECT_EQ(strcasecmp("", ""), 0);
EXPECT_EQ(strcasecmp("a", "a"), 0);
EXPECT_EQ(strcasecmp("a", "A"), 0);
EXPECT_EQ(strcasecmp("A", "a"), 0);
EXPECT_LT(strcasecmp("a", "z"), 0);
EXPECT_GT(strcasecmp("z", "a"), 0);
EXPECT_LT(strcasecmp("\001", "\377"), 0);
EXPECT_GT(strcasecmp("\377", "\001"), 0);
EXPECT_LT(strcasecmp("a", "aa"), 0);
EXPECT_GT(strcasecmp("aa", "a"), 0);
EXPECT_LT(strcasecmp("a\000", "aa\000"), 0);
EXPECT_GT(strcasecmp("aa\000", "a\000"), 0);
EXPECT_LT(strcasecmp("aaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcasecmp("aaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcasecmp("aaaaaaaaaaaaaaaa\001", "aaaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcasecmp("aaaaaaaaaaaaaaaa\377", "aaaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcasecmp("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
}
TEST(strcmp16, testItWorks) {
EXPECT_EQ(strcmp16(u"", u""), 0);
EXPECT_EQ(strcmp16(u"a", u"a"), 0);
EXPECT_GT(strcmp16(u"a", u"A"), 0);
EXPECT_LT(strcmp16(u"A", u"a"), 0);
EXPECT_LT(strcmp16(u"\001", u"\377"), 0);
EXPECT_GT(strcmp16(u"\377", u"\001"), 0);
EXPECT_LT(strcmp16(u"a", u"aa"), 0);
EXPECT_GT(strcmp16(u"aa", u"a"), 0);
EXPECT_LT(strcmp16(u"a\000", u"aa\000"), 0);
EXPECT_GT(strcmp16(u"aa\000", u"a\000"), 0);
EXPECT_LT(strcmp16(u"aaaaaaaaaaaaaaa\001", u"aaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcmp16(u"aaaaaaaaaaaaaaa\377", u"aaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcmp16(u"aaaaaaaaaaaaaaaa\001", u"aaaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(strcmp16(u"aaaaaaaaaaaaaaaa\377", u"aaaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(strcmp16(u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377",
u"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
}
TEST(wcscmp, testItWorks) {
EXPECT_EQ(wcscmp(L"", L""), 0);
EXPECT_EQ(wcscmp(L"a", L"a"), 0);
EXPECT_GT(wcscmp(L"a", L"A"), 0);
EXPECT_LT(wcscmp(L"A", L"a"), 0);
EXPECT_LT(wcscmp(L"\001", L"\377"), 0);
EXPECT_GT(wcscmp(L"\377", L"\001"), 0);
EXPECT_LT(wcscmp(L"a", L"aa"), 0);
EXPECT_GT(wcscmp(L"aa", L"a"), 0);
EXPECT_LT(wcscmp(L"a", L"aa"), 0);
EXPECT_GT(wcscmp(L"aa", L"a"), 0);
EXPECT_LT(wcscmp(L"aaaaaaaaaaaaaaa\001", L"aaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(wcscmp(L"aaaaaaaaaaaaaaa\377", L"aaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(wcscmp(L"aaaaaaaaaaaaaaaa\001", L"aaaaaaaaaaaaaaaa\377"), 0);
EXPECT_GT(wcscmp(L"aaaaaaaaaaaaaaaa\377", L"aaaaaaaaaaaaaaaa\001"), 0);
EXPECT_LT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\377",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\377",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
EXPECT_LT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377"),
0);
EXPECT_GT(wcscmp(L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\377",
L"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\001"),
0);
}
TEST(strcasecmp, testItWorksCase) {
EXPECT_EQ(0, strcasecmp("hello", "HELLO"));
EXPECT_EQ(0, strcasecmp("hello", "Hello"));
EXPECT_EQ(0, strcasecmp("hello", "hello"));
EXPECT_NE(0, strcasecmp("hello", "yello"));
}
TEST(strcasecmp16, testItWorksCase) {
EXPECT_EQ(0, strcasecmp16(u"hello", u"HELLO"));
EXPECT_EQ(0, strcasecmp16(u"hello", u"Hello"));
EXPECT_EQ(0, strcasecmp16(u"hello", u"hello"));
EXPECT_NE(0, strcasecmp16(u"hello", u"yello"));
}
TEST(wcscasecmp, testItWorksCase) {
EXPECT_EQ(0, wcscasecmp(L"hello", L"HELLO"));
EXPECT_EQ(0, wcscasecmp(L"hello", L"Hello"));
EXPECT_EQ(0, wcscasecmp(L"hello", L"hello"));
EXPECT_NE(0, wcscasecmp(L"hello", L"yello"));
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § nontrivial length ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(strncmp, testEqualManyNs) {
char *s1 = malloc(PAGESIZE);
char *s2 = malloc(PAGESIZE);
memset(s1, 7, PAGESIZE);
memset(s2, 7, PAGESIZE);
s1[PAGESIZE - 1] = '\0';
s2[PAGESIZE - 1] = '\0';
for (unsigned i = 1; i <= 128; ++i) {
ASSERT_EQ(0, strncmp(s1 + PAGESIZE - i, s2 + PAGESIZE - i, i + 0));
ASSERT_EQ(0, strncmp(s1 + PAGESIZE - i, s2 + PAGESIZE - i, i + 1));
}
free(s2);
free(s1);
}
TEST(strncmp, testNotEqualManyNs) {
char *s1 = malloc(PAGESIZE);
char *s2 = malloc(PAGESIZE);
for (unsigned i = 1; i <= 128; ++i) {
memset(s1, 7, PAGESIZE);
memset(s2, 7, PAGESIZE);
s1[PAGESIZE - 1] = (unsigned char)0;
s2[PAGESIZE - 1] = (unsigned char)255;
ASSERT_EQ(-255, strncmp(s1 + PAGESIZE - i, s2 + PAGESIZE - i, i + 0));
ASSERT_EQ(-255, strncmp(s1 + PAGESIZE - i, s2 + PAGESIZE - i, i + 1));
}
free(s2);
free(s1);
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § nul termination vs. explicit length ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(strncmp, testStringNulTerminatesBeforeExplicitLength) {
const char kRdi[] = "";
const char kRsi[] = "TZ=America/Los_Angeles";
char *rdi = memcpy(malloc(sizeof(kRdi)), kRdi, sizeof(kRdi));
char *rsi = memcpy(malloc(sizeof(kRsi)), kRsi, sizeof(kRsi));
size_t rdx = 3;
EXPECT_EQ(strncmp(rdi, rdi, rdx), 0);
EXPECT_LT(strncmp(rdi, rsi, rdx), 0);
EXPECT_GT(strncmp(rsi, rdi, rdx), 0);
free(rsi);
free(rdi);
}
TEST(strncasecmp, testStringNulTerminatesBeforeExplicitLength) {
const char kRdi[] = "";
const char kRsi[] = "TZ=America/Los_Angeles";
char *rdi = memcpy(malloc(sizeof(kRdi)), kRdi, sizeof(kRdi));
char *rsi = memcpy(malloc(sizeof(kRsi)), kRsi, sizeof(kRsi));
size_t rdx = 3;
EXPECT_EQ(strncasecmp(rdi, rdi, rdx), 0);
EXPECT_LT(strncasecmp(rdi, rsi, rdx), 0);
EXPECT_GT(strncasecmp(rsi, rdi, rdx), 0);
free(rsi);
free(rdi);
}
TEST(strncmp16, testStringNulTerminatesBeforeExplicitLength) {
const char16_t kRdi[] = u"";
const char16_t kRsi[] = u"TZ=America/Los_Angeles";
char16_t *rdi = memcpy(malloc(sizeof(kRdi)), kRdi, sizeof(kRdi));
char16_t *rsi = memcpy(malloc(sizeof(kRsi)), kRsi, sizeof(kRsi));
size_t rdx = 3;
EXPECT_EQ(strncmp16(rdi, rdi, rdx), 0);
EXPECT_LT(strncmp16(rdi, rsi, rdx), 0);
EXPECT_GT(strncmp16(rsi, rdi, rdx), 0);
free(rsi);
free(rdi);
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § two's complement bane ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
TEST(strcmp, testTwosComplementBane_hasUnsignedBehavior) {
EXPECT_EQ(strcmp("\200", "\200"), 0);
EXPECT_LT(strcmp("\x7f", "\x80"), 0);
EXPECT_GT(strcmp("\x80", "\x7f"), 0);
}
TEST(strcasecmp, testTwosComplementBane_hasUnsignedBehavior) {
EXPECT_EQ(strcasecmp("\200", "\200"), 0);
EXPECT_LT(strcasecmp("\x7f", "\x80"), 0);
EXPECT_GT(strcasecmp("\x80", "\x7f"), 0);
}
TEST(memcmp, testTwosComplementBane_unsignedBehavior) {
EXPECT_EQ(memcmpi("\200", "\200", 1), 0);
EXPECT_LT(memcmpi("\177", "\200", 1), 0);
EXPECT_GT(memcmpi("\200", "\177", 1), 0);
EXPECT_EQ(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\200",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\200", 34),
0);
EXPECT_LT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\177",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\200", 34),
0);
EXPECT_GT(memcmpi("aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\200",
"aaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaa\177", 34),
0);
}
TEST(strcmp16, testTwosComplementBane_hasUnsignedBehavior) {
char16_t *B1 = malloc(8);
char16_t *B2 = malloc(8);
B1[1] = L'\0';
B2[1] = L'\0';
EXPECT_EQ(strcmp16(memcpy(B1, "\x00\x80", 2), memcpy(B2, "\x00\x80", 2)), 0);
EXPECT_LT(strcmp16(memcpy(B1, "\xff\x7f", 2), memcpy(B2, "\x00\x80", 2)), 0);
EXPECT_GT(strcmp16(memcpy(B1, "\x00\x80", 2), memcpy(B2, "\xff\x7f", 2)), 0);
free(B2);
free(B1);
}
TEST(strncmp16, testTwosComplementBane_hasUnsignedBehavior) {
char16_t *B1 = malloc(4);
char16_t *B2 = malloc(4);
EXPECT_EQ(strncmp16(memcpy(B1, "\x00\x80", 2), memcpy(B2, "\x00\x80", 2), 1),
0);
EXPECT_LT(strncmp16(memcpy(B1, "\xff\x7f", 2), memcpy(B2, "\x00\x80", 2), 1),
0);
EXPECT_GT(strncmp16(memcpy(B1, "\x00\x80", 2), memcpy(B2, "\xff\x7f", 2), 1),
0);
free(B2);
free(B1);
}
TEST(wcscmp, testTwosComplementBane) {
wchar_t *B1 = malloc(8);
wchar_t *B2 = malloc(8);
B1[1] = L'\0';
B2[1] = L'\0';
EXPECT_EQ(wcscmp(memcpy(B1, "\x00\x00\x00\x80", 4),
memcpy(B2, "\x00\x00\x00\x80", 4)),
0);
EXPECT_LT(0, wcscmp(memcpy(B1, "\xff\xff\xff\x7f", 4),
memcpy(B2, "\x00\x00\x00\x80", 4)));
EXPECT_LT(wcscmp(memcpy(B1, "\x00\x00\x00\x80", 4),
memcpy(B2, "\xff\xff\xff\x7f", 4)),
0);
free(B2);
free(B1);
}
TEST(wcsncmp, testTwosComplementBane) {
wchar_t *B1 = malloc(4);
wchar_t *B2 = malloc(4);
EXPECT_EQ(wcsncmp(memcpy(B1, "\x00\x00\x00\x80", 4),
memcpy(B2, "\x00\x00\x00\x80", 4), 1),
0);
EXPECT_GT(wcsncmp(memcpy(B1, "\xff\xff\xff\x7f", 4),
memcpy(B2, "\x00\x00\x00\x80", 4), 1),
0);
EXPECT_LT(wcsncmp(memcpy(B1, "\x00\x00\x00\x80", 4),
memcpy(B2, "\xff\xff\xff\x7f", 4), 1),
0);
free(B2);
free(B1);
}
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â test/libc/str/strcmp_test.c § benchmarks ââ¬âââ¼
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
dontinline int strcmp_pure(const char *a, const char *b) {
for (; *a == *b; a++, b++) {
if (!*a) break;
}
return (*a & 0xff) - (*b & 0xff);
}
dontinline int strcasecmp_pure(const char *a, const char *b) {
for (; *a && *b; a++, b++) {
if (!(*a == *b || tolower(*a & 0xff) == tolower(*b & 0xff))) {
break;
}
}
return tolower(*a & 0xff) - tolower(*b & 0xff);
}
char *randomize_buf2str(size_t size, char data[size]) {
rngset(data, size, _rand64, -1);
data[size - 1] = '\0';
return data;
}
char *longstringislong(size_t size, char data[size]) {
unsigned i;
randomize_buf2str(size, data);
for (i = 0; i < size; ++i) {
data[i] |= 1u << (i & 5);
}
data[size - 1] = '\0';
return data;
}
void randomize_buf2str_dupe(size_t size, char data[size], char dupe[size]) {
randomize_buf2str(size, data);
memcpy(dupe, data, size);
}
void longstringislong_dupe(size_t size, char data[size], char dupe[size]) {
longstringislong(size, data);
memcpy(dupe, data, size);
}
BENCH(bench_00_strcmp, bench) {
size_t size;
char *dupe, *data;
size = 14139;
data = gc(malloc(size));
dupe = gc(malloc(size));
EZBENCH2("strcmp [identity]", longstringislong(size, data),
EXPROPRIATE(strcmp(VEIL("r", data), data)));
EZBENCH2("strcmp [2 diff]", donothing,
EXPROPRIATE(strcmp(VEIL("r", "hi"), VEIL("r", "there"))));
EZBENCH2("scmppure [2 diff]", donothing,
EXPROPRIATE(strcmp_pure(VEIL("r", "hi"), VEIL("r", "there"))));
EZBENCH2("strcmp [2 dupe]", randomize_buf2str_dupe(2, data, dupe),
EXPROPRIATE(strcmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("scmp_pure [2 dupe]", randomize_buf2str_dupe(2, data, dupe),
EXPROPRIATE(strcmp_pure(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("strcmp [4 dupe]", randomize_buf2str_dupe(4, data, dupe),
EXPROPRIATE(strcmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("scmp_pure [4 dupe]", randomize_buf2str_dupe(4, data, dupe),
EXPROPRIATE(strcmp_pure(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("strcmp [8 dupe]", randomize_buf2str_dupe(8, data, dupe),
EXPROPRIATE(strcmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("scmp_pure [8 dupe]", randomize_buf2str_dupe(8, data, dupe),
EXPROPRIATE(strcmp_pure(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("strcmp [sdupe]", randomize_buf2str_dupe(size, data, dupe),
EXPROPRIATE(strcmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("scmp_pure [sdupe]", randomize_buf2str_dupe(size, data, dupe),
EXPROPRIATE(strcmp_pure(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("strcmp [ldupe]", longstringislong_dupe(size, data, dupe),
EXPROPRIATE(strcmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("scmp_pure [ldupe]", longstringislong_dupe(size, data, dupe),
EXPROPRIATE(strcmp_pure(VEIL("r", data), VEIL("r", dupe))));
}
BENCH(bench_01_strcasecmp, bench) {
size_t size;
char *dupe, *data;
size = 141393;
data = gc(malloc(size));
dupe = gc(malloc(size));
EZBENCH2("strcasecmp [iden]", longstringislong(size, data),
EXPROPRIATE(strcasecmp(VEIL("r", data), data)));
EZBENCH2("strcasecmp [sdupe]", randomize_buf2str_dupe(size, data, dupe),
EXPROPRIATE(strcasecmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("sccmp_pure [sdupe]", randomize_buf2str_dupe(size, data, dupe),
EXPROPRIATE(strcasecmp_pure(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("strcasecmp [ldupe]", longstringislong_dupe(size, data, dupe),
EXPROPRIATE(strcasecmp(VEIL("r", data), VEIL("r", dupe))));
EZBENCH2("sccmp_pure [ldupe]", longstringislong_dupe(size, data, dupe),
EXPROPRIATE(strcasecmp_pure(VEIL("r", data), VEIL("r", dupe))));
}
BENCH(memcmp, bench) {
volatile char *copy = gc(strdup(kHyperion));
EZBENCH2("memcmp big", donothing,
EXPROPRIATE(memcmp(kHyperion, copy, kHyperionSize)));
copy = gc(strdup("tough little ship"));
EZBENCH2("memcmp 18", donothing,
EXPROPRIATE(memcmp("tough little ship", copy, 18)));
}
/* jart
* strcmp [identity] l: 3c 1ns m: 30c 10ns
* strcmp [2 diff] l: 4c 1ns m: 30c 10ns
* scmppure [2 diff] l: 3c 1ns m: 31c 10ns
* strcmp [2 dupe] l: 8c 3ns m: 39c 13ns
* scmp_pure [2 dupe] l: 6c 2ns m: 34c 11ns
* strcmp [4 dupe] l: 9c 3ns m: 40c 13ns
* scmp_pure [4 dupe] l: 9c 3ns m: 38c 12ns
* strcmp [8 dupe] l: 10c 3ns m: 40c 13ns
* scmp_pure [8 dupe] l: 11c 4ns m: 41c 13ns
* strcmp [sdupe] l: 87c 28ns m: 121c 39ns
* scmp_pure [sdupe] l: 188c 61ns m: 294c 95ns
* strcmp [ldupe] l: 3,458c 1,117ns m: 3,486c 1,126ns
* scmp_pure [ldupe] l: 11,441c 3,695ns m: 11,520c 3,721ns
* strcasecmp [iden] l: 3c 1ns m: 30c 10ns
* strcasecmp [sdupe] l: 105c 34ns m: 156c 50ns
* sccmp_pure [sdupe] l: 644c 208ns m: 963c 311ns
* strcasecmp [ldupe] l: 36,527c 11,798ns m: 36,582c 11,816ns
* sccmp_pure [ldupe] l: 365,880c 118,177ns m: 365,721c 118,125ns
* memcmp big l: 2,050c 662ns m: 2,093c 676ns
* memcmp 18 l: 6c 2ns m: 35c 11ns
*/
/* jart+intel
* strcmp [identity] l: 1c 0ns m: 28c 9ns
* strcmp [2 diff] l: 2c 1ns m: 29c 9ns
* scmppure [2 diff] l: 2c 1ns m: 29c 9ns
* strcmp [2 dupe] l: 8c 3ns m: 40c 13ns
* scmp_pure [2 dupe] l: 5c 2ns m: 32c 10ns
* strcmp [4 dupe] l: 9c 3ns m: 41c 13ns
* scmp_pure [4 dupe] l: 7c 2ns m: 34c 11ns
* strcmp [8 dupe] l: 10c 3ns m: 40c 13ns
* scmp_pure [8 dupe] l: 10c 3ns m: 39c 13ns
* strcmp [sdupe] l: 57c 18ns m: 87c 28ns
* scmp_pure [sdupe] l: 191c 62ns m: 224c 72ns
* strcmp [ldupe] l: 1,667c 538ns m: 1,708c 552ns
* scmp_pure [ldupe] l: 10,988c 3,549ns m: 11,055c 3,571ns
* strcasecmp [iden] l: 2c 1ns m: 31c 10ns
* strcasecmp [sdupe] l: 121c 39ns m: 160c 52ns
* sccmp_pure [sdupe] l: 684c 221ns m: 702c 227ns
* strcasecmp [ldupe] l: 34,325c 11,087ns m: 35,954c 11,613ns
* sccmp_pure [ldupe] l: 361,449c 116,746ns m: 366,022c 118,223ns
* memcmp big l: 2,040c 659ns m: 2,083c 673ns
* memcmp 18 l: 5c 2ns m: 35c 11ns
*/
| 29,139 | 651 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/morton_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/morton.h"
#include "libc/calls/calls.h"
#include "libc/errno.h"
#include "libc/nexgen32e/kcpuids.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
TEST(morton, test) {
EXPECT_EQ(0, morton(0, 0));
EXPECT_EQ(1, morton(0, 1));
EXPECT_EQ(2, morton(1, 0));
EXPECT_EQ(3, morton(1, 1));
EXPECT_EQ(4, morton(0, 2));
EXPECT_EQ(~0ul, morton(~0ul, ~0ul));
EXPECT_EQ(0x7ffffffffffffffdul, morton(0x7ffffffeul, 0xfffffffful));
EXPECT_EQ(0b1010101000010101010, morton(0b0000001111, 0b1111000000));
}
TEST(unmorton, test) {
EXPECT_EQ(0, unmorton(0).ax);
EXPECT_EQ(0, unmorton(0).dx);
EXPECT_EQ(0, unmorton(1).ax);
EXPECT_EQ(1, unmorton(1).dx);
EXPECT_EQ(1, unmorton(2).ax);
EXPECT_EQ(0, unmorton(2).dx);
EXPECT_EQ(1, unmorton(3).ax);
EXPECT_EQ(1, unmorton(3).dx);
EXPECT_EQ(0, unmorton(4).ax);
EXPECT_EQ(2, unmorton(4).dx);
EXPECT_EQ(0xffffffffu, unmorton(~0ul).ax);
EXPECT_EQ(0xffffffffu, unmorton(~0ul).dx);
EXPECT_EQ(0x7ffffffeul, unmorton(0x7ffffffffffffffdul).ax);
EXPECT_EQ(0xfffffffful, unmorton(0x7ffffffffffffffdul).dx);
EXPECT_EQ(0b0000001111000000, unmorton(0b010101010000001010101).ax);
EXPECT_EQ(0b0000000000001111, unmorton(0b010101010000001010101).dx);
}
BENCH(morton, bench) {
EZBENCH2("morton", donothing,
EXPROPRIATE(morton(CONCEAL("r", 123), CONCEAL("r", 123))));
EZBENCH2("unmorton", donothing, EXPROPRIATE(unmorton(CONCEAL("r", 123))));
}
| 3,388 | 66 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/memcmp_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/fastrandomstring.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
int golden(const void *p, const void *q, size_t n) {
int c;
size_t i;
for (i = 0; i < n; ++i) {
if ((c = ((const unsigned char *)p)[i] - ((const unsigned char *)q)[i])) {
return c;
}
}
return 0;
}
TEST(memcmp, test) {
EXPECT_EQ(0, memcmp("hi", "hi", 2));
EXPECT_NE(0, memcmp("hi", "HI", 2));
EXPECT_EQ(-1, memcmp("a", "b", 1));
EXPECT_EQ(+1, memcmp("b", "a", 1));
}
TEST(memcmp, hug) {
int i, j, g;
char a[128] = {0};
char b[128] = {0};
for (j = 0; j < 128; ++j) {
for (i = 0; i < j; ++i) {
a[i] = 1;
g = golden(a, b, j);
ASSERT_EQ(g, memcmp(a, b, j), "i=%d j=%d", i, j);
ASSERT_EQ(!!g, !!bcmp(a, b, j), "i=%d j=%d", i, j);
ASSERT_EQ(!!g, !!timingsafe_bcmp(a, b, j), "i=%d", i);
ASSERT_EQ(MAX(-1, MIN(1, g)), timingsafe_memcmp(a, b, j), "i=%d", i);
a[i] = 0;
}
}
}
static int coerce(int result) {
#ifdef __aarch64__
// arm's strcmp assembly is nuts and unpredictable, but it's legal
if (result < 0) return -1;
if (result > 0) return +1;
return 0;
#else
return result;
#endif
}
TEST(memcmp, fuzz) {
int i, o, n, g;
char a[256], b[256];
for (i = 0; i < 100000; ++i) {
rngset(a, sizeof(a), _rand64, -1);
memcpy(b, a, sizeof(a));
if (rand() & 1) {
a[rand() % sizeof(a)] += rand();
} else {
b[rand() % sizeof(a)] += rand();
}
if (rand() & 1) {
a[rand() % sizeof(a)] += rand();
} else {
b[rand() % sizeof(a)] += rand();
}
o = rand() & 31;
n = rand() % (sizeof(a) - o);
g = coerce(golden(a + o, b + o, n));
#if 0
if (memcmp(a + o, b + o, n) != g) {
kprintf("const size_t g = %d;\n", g);
kprintf("const size_t n = %d;\n", n);
kprintf("const char a[] = unbingstr(%#.*hhhs); /* %p */\n", n, a + o,
a + o);
kprintf("const char b[] = unbingstr(%#.*hhhs); /* %p */\n", n, b + o,
b + o);
}
#endif
ASSERT_EQ(g, coerce(memcmp(a + o, b + o, n)), "n=%d o=%d", n, o);
ASSERT_EQ(!!g, !!bcmp(a + o, b + o, n), "n=%d o=%d", n, o);
ASSERT_EQ(!!g, !!timingsafe_bcmp(a + o, b + o, n), "n=%d o=%d", n, o);
ASSERT_EQ(MAX(-1, MIN(1, g)), timingsafe_memcmp(a + o, b + o, n),
"n=%d o=%d", n, o);
}
}
int buncmp(const void *, const void *, size_t) asm("bcmp");
int funcmp(const void *, const void *, size_t) asm("memcmp");
#if 0
BENCH(bcmp, bench) {
volatile int v;
const char *volatile a;
const char *volatile b;
b = a = "123456789123456789123456789123456789123456789123456789";
b = gc(strdup(b));
EZBENCH_N("bcmp", 0, v = buncmp(a, b, 0));
EZBENCH_N("bcmp", 1, v = buncmp(a, b, 1));
EZBENCH_N("bcmp", 2, v = buncmp(a, b, 2));
EZBENCH_N("bcmp", 3, v = buncmp(a, b, 3));
EZBENCH_N("ð¯ð°ðºð½", 4, v = buncmp(a, b, 4));
EZBENCH_N("bcmp", 5, v = buncmp(a, b, 5));
EZBENCH_N("bcmp", 6, v = buncmp(a, b, 6));
EZBENCH_N("bcmp", 7, v = buncmp(a, b, 7));
EZBENCH_N("ð¯ð°ðºð½", 8, v = buncmp(a, b, 8));
EZBENCH_N("bcmp", 9, v = buncmp(a, b, 9));
EZBENCH_N("bcmp", 15, v = buncmp(a, b, 15));
EZBENCH_N("ð¯ð°ðºð½", 16, v = buncmp(a, b, 16));
EZBENCH_N("bcmp", 17, v = buncmp(a, b, 17));
EZBENCH_N("bcmp", 31, v = buncmp(a, b, 31));
EZBENCH_N("bcmp", 32, v = buncmp(a, b, 32));
a = kHyperion;
b = gc(strdup(kHyperion));
EZBENCH_N("bcmp", 33, v = buncmp(a, b, 33));
EZBENCH_N("bcmp", 79, v = buncmp(a, b, 79));
EZBENCH_N("ð¯ð°ðºð½", 80, v = buncmp(a, b, 80));
EZBENCH_N("bcmp", 128, v = buncmp(a, b, 128));
EZBENCH_N("bcmp", 256, v = buncmp(a, b, 256));
a = gc(malloc(16 * 1024));
b = gc(malloc(16 * 1024));
rngset(a, 16 * 1024, lemur64, -1);
memcpy(b, a, 16 * 1024);
EZBENCH_N("bcmp", 16384, v = buncmp(a, b, 16384));
a = gc(malloc(32 * 1024));
b = gc(malloc(32 * 1024));
rngset(a, 32 * 1024, lemur64, -1);
memcpy(b, a, 32 * 1024);
EZBENCH_N("bcmp", 32768, v = buncmp(a, b, 32768));
a = gc(malloc(128 * 1024));
b = gc(malloc(128 * 1024));
rngset(a, 128 * 1024, lemur64, -1);
memcpy(b, a, 128 * 1024);
EZBENCH_N("bcmp", 131072, v = buncmp(a, b, 131072));
}
#endif
#if 0
BENCH(memcmp, bench) {
volatile int v;
const char *volatile a;
const char *volatile b;
b = a = "123456789123456789123456789123456789123456789123456789";
b = gc(strdup(b));
EZBENCH_N("memcmp", 0, v = funcmp(a, b, 0));
EZBENCH_N("memcmp", 1, v = funcmp(a, b, 1));
EZBENCH_N("memcmp", 2, v = funcmp(a, b, 2));
EZBENCH_N("memcmp", 3, v = funcmp(a, b, 3));
EZBENCH_N("ðºð²ðºð°ðºð½", 4, v = funcmp(a, b, 4));
EZBENCH_N("memcmp", 5, v = funcmp(a, b, 5));
EZBENCH_N("memcmp", 6, v = funcmp(a, b, 6));
EZBENCH_N("memcmp", 7, v = funcmp(a, b, 7));
EZBENCH_N("ðºð²ðºð°ðºð½", 8, v = funcmp(a, b, 8));
EZBENCH_N("memcmp", 9, v = funcmp(a, b, 9));
EZBENCH_N("memcmp", 15, v = funcmp(a, b, 15));
EZBENCH_N("ðºð²ðºð°ðºð½", 16, v = funcmp(a, b, 16));
EZBENCH_N("memcmp", 17, v = funcmp(a, b, 17));
EZBENCH_N("memcmp", 31, v = funcmp(a, b, 31));
EZBENCH_N("memcmp", 32, v = funcmp(a, b, 32));
a = kHyperion;
b = gc(strdup(kHyperion));
EZBENCH_N("memcmp", 33, v = funcmp(a, b, 33));
EZBENCH_N("memcmp", 79, v = funcmp(a, b, 79));
EZBENCH_N("ðºð²ðºð°ðºð½", 80, v = funcmp(a, b, 80));
EZBENCH_N("memcmp", 128, v = funcmp(a, b, 128));
EZBENCH_N("memcmp", 256, v = funcmp(a, b, 256));
a = gc(malloc(16 * 1024));
b = gc(malloc(16 * 1024));
rngset(a, 16 * 1024, lemur64, -1);
memcpy(b, a, 16 * 1024);
EZBENCH_N("memcmp", 16384, v = funcmp(a, b, 16384));
a = gc(malloc(32 * 1024));
b = gc(malloc(32 * 1024));
rngset(a, 32 * 1024, lemur64, -1);
memcpy(b, a, 32 * 1024);
EZBENCH_N("memcmp", 32768, v = funcmp(a, b, 32768));
a = gc(malloc(128 * 1024));
b = gc(malloc(128 * 1024));
rngset(a, 128 * 1024, lemur64, -1);
memcpy(b, a, 128 * 1024);
EZBENCH_N("memcmp", 131072, v = funcmp(a, b, 131072));
}
#endif
#if 0
BENCH(timingsafe_memcmp, bench) {
volatile int v;
const char *volatile a;
const char *volatile b;
b = a = "123456789123456789123456789123456789123456789123456789";
b = gc(strdup(b));
EZBENCH_N("timingsafe_memcmp", 0, v = timingsafe_memcmp(a, b, 0));
EZBENCH_N("timingsafe_memcmp", 1, v = timingsafe_memcmp(a, b, 1));
EZBENCH_N("timingsafe_memcmp", 2, v = timingsafe_memcmp(a, b, 2));
EZBENCH_N("timingsafe_memcmp", 3, v = timingsafe_memcmp(a, b, 3));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ðºð²ðºð°ðºð½", 4, v = timingsafe_memcmp(a, b, 4));
EZBENCH_N("timingsafe_memcmp", 5, v = timingsafe_memcmp(a, b, 5));
EZBENCH_N("timingsafe_memcmp", 6, v = timingsafe_memcmp(a, b, 6));
EZBENCH_N("timingsafe_memcmp", 7, v = timingsafe_memcmp(a, b, 7));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ðºð²ðºð°ðºð½", 8, v = timingsafe_memcmp(a, b, 8));
EZBENCH_N("timingsafe_memcmp", 9, v = timingsafe_memcmp(a, b, 9));
EZBENCH_N("timingsafe_memcmp", 15, v = timingsafe_memcmp(a, b, 15));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ðºð²ðºð°ðºð½", 16, v = timingsafe_memcmp(a, b, 16));
EZBENCH_N("timingsafe_memcmp", 17, v = timingsafe_memcmp(a, b, 17));
EZBENCH_N("timingsafe_memcmp", 31, v = timingsafe_memcmp(a, b, 31));
EZBENCH_N("timingsafe_memcmp", 32, v = timingsafe_memcmp(a, b, 32));
a = kHyperion;
b = gc(strdup(kHyperion));
EZBENCH_N("timingsafe_memcmp", 33, v = timingsafe_memcmp(a, b, 33));
EZBENCH_N("timingsafe_memcmp", 79, v = timingsafe_memcmp(a, b, 79));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ðºð²ðºð°ðºð½", 80, v = timingsafe_memcmp(a, b, 80));
EZBENCH_N("timingsafe_memcmp", 128, v = timingsafe_memcmp(a, b, 128));
EZBENCH_N("timingsafe_memcmp", 256, v = timingsafe_memcmp(a, b, 256));
a = gc(malloc(16 * 1024));
b = gc(malloc(16 * 1024));
rngset(a, 16 * 1024, lemur64, -1);
memcpy(b, a, 16 * 1024);
EZBENCH_N("timingsafe_memcmp", 16384, v = timingsafe_memcmp(a, b, 16384));
a = gc(malloc(32 * 1024));
b = gc(malloc(32 * 1024));
rngset(a, 32 * 1024, lemur64, -1);
memcpy(b, a, 32 * 1024);
EZBENCH_N("timingsafe_memcmp", 32768, v = timingsafe_memcmp(a, b, 32768));
a = gc(malloc(128 * 1024));
b = gc(malloc(128 * 1024));
rngset(a, 128 * 1024, lemur64, -1);
memcpy(b, a, 128 * 1024);
EZBENCH_N("timingsafe_memcmp", 131072, v = timingsafe_memcmp(a, b, 131072));
}
#endif
#if 0
BENCH(timingsafe_bcmp, bench) {
volatile int v;
const char *volatile a;
const char *volatile b;
b = a = "123456789123456789123456789123456789123456789123456789";
b = gc(strdup(b));
EZBENCH_N("timingsafe_bcmp", 0, v = timingsafe_bcmp(a, b, 0));
EZBENCH_N("timingsafe_bcmp", 1, v = timingsafe_bcmp(a, b, 1));
EZBENCH_N("timingsafe_bcmp", 2, v = timingsafe_bcmp(a, b, 2));
EZBENCH_N("timingsafe_bcmp", 3, v = timingsafe_bcmp(a, b, 3));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ð¯ð°ðºð½", 4, v = timingsafe_bcmp(a, b, 4));
EZBENCH_N("timingsafe_bcmp", 5, v = timingsafe_bcmp(a, b, 5));
EZBENCH_N("timingsafe_bcmp", 6, v = timingsafe_bcmp(a, b, 6));
EZBENCH_N("timingsafe_bcmp", 7, v = timingsafe_bcmp(a, b, 7));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ð¯ð°ðºð½", 8, v = timingsafe_bcmp(a, b, 8));
EZBENCH_N("timingsafe_bcmp", 9, v = timingsafe_bcmp(a, b, 9));
EZBENCH_N("timingsafe_bcmp", 15, v = timingsafe_bcmp(a, b, 15));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ð¯ð°ðºð½", 16, v = timingsafe_bcmp(a, b, 16));
EZBENCH_N("timingsafe_bcmp", 17, v = timingsafe_bcmp(a, b, 17));
EZBENCH_N("timingsafe_bcmp", 31, v = timingsafe_bcmp(a, b, 31));
EZBENCH_N("timingsafe_bcmp", 32, v = timingsafe_bcmp(a, b, 32));
a = kHyperion;
b = gc(strdup(kHyperion));
EZBENCH_N("timingsafe_bcmp", 33, v = timingsafe_bcmp(a, b, 33));
EZBENCH_N("timingsafe_bcmp", 79, v = timingsafe_bcmp(a, b, 79));
EZBENCH_N("ðð¶ðºð¶ð»ð´ðð®ð³ð²_ð¯ð°ðºð½", 80, v = timingsafe_bcmp(a, b, 80));
EZBENCH_N("timingsafe_bcmp", 128, v = timingsafe_bcmp(a, b, 128));
EZBENCH_N("timingsafe_bcmp", 256, v = timingsafe_bcmp(a, b, 256));
a = gc(malloc(16 * 1024));
b = gc(malloc(16 * 1024));
rngset(a, 16 * 1024, lemur64, -1);
memcpy(b, a, 16 * 1024);
EZBENCH_N("timingsafe_bcmp", 16384, v = timingsafe_bcmp(a, b, 16384));
a = gc(malloc(32 * 1024));
b = gc(malloc(32 * 1024));
rngset(a, 32 * 1024, lemur64, -1);
memcpy(b, a, 32 * 1024);
EZBENCH_N("timingsafe_bcmp", 32768, v = timingsafe_bcmp(a, b, 32768));
a = gc(malloc(128 * 1024));
b = gc(malloc(128 * 1024));
rngset(a, 128 * 1024, lemur64, -1);
memcpy(b, a, 128 * 1024);
EZBENCH_N("timingsafe_bcmp", 131072, v = timingsafe_bcmp(a, b, 131072));
}
#endif
#if 0
BENCH(memcasecmp, bench) {
volatile int v;
const char *volatile a;
const char *volatile b;
b = a = "123456789123456789123456789123456789123456789123456789";
b = gc(strdup(b));
EZBENCH_N("memcasecmp", 0, v = memcasecmp(a, b, 0));
EZBENCH_N("memcasecmp", 1, v = memcasecmp(a, b, 1));
EZBENCH_N("memcasecmp", 2, v = memcasecmp(a, b, 2));
EZBENCH_N("memcasecmp", 3, v = memcasecmp(a, b, 3));
EZBENCH_N("ðºð²ðºð°ð®ðð²ð°ðºð½", 4, v = memcasecmp(a, b, 4));
EZBENCH_N("memcasecmp", 5, v = memcasecmp(a, b, 5));
EZBENCH_N("memcasecmp", 6, v = memcasecmp(a, b, 6));
EZBENCH_N("memcasecmp", 7, v = memcasecmp(a, b, 7));
EZBENCH_N("ðºð²ðºð°ð®ðð²ð°ðºð½", 8, v = memcasecmp(a, b, 8));
EZBENCH_N("memcasecmp", 9, v = memcasecmp(a, b, 9));
EZBENCH_N("memcasecmp", 15, v = memcasecmp(a, b, 15));
EZBENCH_N("ðºð²ðºð°ð®ðð²ð°ðºð½", 16, v = memcasecmp(a, b, 16));
EZBENCH_N("memcasecmp", 17, v = memcasecmp(a, b, 17));
EZBENCH_N("memcasecmp", 31, v = memcasecmp(a, b, 31));
EZBENCH_N("memcasecmp", 32, v = memcasecmp(a, b, 32));
a = kHyperion;
b = gc(strdup(kHyperion));
EZBENCH_N("memcasecmp", 33, v = memcasecmp(a, b, 33));
EZBENCH_N("memcasecmp", 79, v = memcasecmp(a, b, 79));
EZBENCH_N("ðºð²ðºð°ð®ðð²ð°ðºð½", 80, v = memcasecmp(a, b, 80));
EZBENCH_N("memcasecmp", 128, v = memcasecmp(a, b, 128));
EZBENCH_N("memcasecmp", 256, v = memcasecmp(a, b, 256));
a = gc(malloc(16 * 1024));
b = gc(malloc(16 * 1024));
rngset(a, 16 * 1024, lemur64, -1);
memcpy(b, a, 16 * 1024);
EZBENCH_N("memcasecmp", 16384, v = memcasecmp(a, b, 16384));
a = gc(malloc(32 * 1024));
b = gc(malloc(32 * 1024));
rngset(a, 32 * 1024, lemur64, -1);
memcpy(b, a, 32 * 1024);
EZBENCH_N("memcasecmp", 32768, v = memcasecmp(a, b, 32768));
a = gc(malloc(128 * 1024));
b = gc(malloc(128 * 1024));
rngset(a, 128 * 1024, lemur64, -1);
memcpy(b, a, 128 * 1024);
EZBENCH_N("memcasecmp", 131072, v = memcasecmp(a, b, 131072));
}
#endif
#if 0
BENCH(timingsafe_memcmp, demonstration) {
int bcmp_(const void *, const void *, size_t) asm("bcmp");
int memcmp_(const void *, const void *, size_t) asm("memcmp");
char a[256], b[256];
rngset(a, 256, lemur64, -1);
memcpy(b, a, 256);
++a[0];
EZBENCH_N("bcmp ne", 256, bcmp_(a, b, 256));
a[0] = b[0];
EZBENCH_N("bcmp eq", 256, bcmp_(a, b, 256));
++a[0];
EZBENCH_N("memcmp ne", 256, memcmp_(a, b, 256));
a[0] = b[0];
EZBENCH_N("memcmp eq", 256, memcmp_(a, b, 256));
++a[0];
EZBENCH_N("timingsafe_bcmp ne", 256, timingsafe_bcmp(a, b, 256));
a[0] = b[0];
EZBENCH_N("timingsafe_bcmp eq", 256, timingsafe_bcmp(a, b, 256));
++a[0];
EZBENCH_N("timingsafe_memcmp ne", 256, timingsafe_memcmp(a, b, 256));
a[0] = b[0];
EZBENCH_N("timingsafe_memcmp eq", 256, timingsafe_memcmp(a, b, 256));
}
#endif
| 15,733 | 375 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/pthread_spin_lock_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/atomic.h"
#include "libc/calls/struct/timespec.h"
#include "libc/intrin/atomic.h"
#include "libc/intrin/kprintf.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/thread.h"
#include "third_party/zip/zip.h"
#define THREADS 8
#define ITERATIONS 20000
atomic_int number;
pthread_t th[THREADS];
pthread_spinlock_t lock;
void *SpinWorker(void *arg) {
for (int i = 0; i < ITERATIONS; ++i) {
ASSERT_EQ(0, pthread_spin_lock(&lock));
atomic_store_explicit(
&number, atomic_load_explicit(&number, memory_order_relaxed) + 1,
memory_order_relaxed);
ASSERT_EQ(0, pthread_spin_unlock(&lock));
}
return 0;
}
TEST(pthread_spin_lock, torture) {
int i;
number = 0;
ASSERT_EQ(0, pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE));
for (i = 0; i < THREADS; ++i) {
ASSERT_EQ(0, pthread_create(th + i, 0, SpinWorker, 0));
}
for (i = 0; i < THREADS; ++i) {
ASSERT_EQ(0, pthread_join(th[i], 0));
}
ASSERT_EQ(0, pthread_spin_destroy(&lock));
ASSERT_EQ(THREADS * ITERATIONS, number);
}
TEST(pthread_spin_lock, macros) {
ASSERT_EQ(0, pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE));
ASSERT_EQ(0, pthread_spin_lock(&lock));
ASSERT_EQ(0, pthread_spin_unlock(&lock));
ASSERT_EQ(0, pthread_spin_destroy(&lock));
}
TEST(pthread_spin_lock, linked) {
ASSERT_EQ(0, (pthread_spin_init)(&lock, PTHREAD_PROCESS_PRIVATE));
ASSERT_EQ(0, (pthread_spin_lock)(&lock));
ASSERT_EQ(0, (pthread_spin_unlock)(&lock));
ASSERT_EQ(0, (pthread_spin_destroy)(&lock));
}
| 3,364 | 72 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/strsignal_r_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/testlib.h"
TEST(strsignal, test) {
EXPECT_STREQ("0", strsignal(0));
EXPECT_STREQ("SIGINT", strsignal(SIGINT));
EXPECT_STREQ("SIGQUIT", strsignal(SIGQUIT));
EXPECT_STREQ("SIGALRM", strsignal(SIGALRM));
EXPECT_STREQ("SIGUSR1", strsignal(SIGUSR1));
EXPECT_STREQ("SIGSTOP", strsignal(SIGSTOP));
EXPECT_STREQ("666", strsignal(666));
EXPECT_STREQ("-1", strsignal(-1));
EXPECT_STREQ("9001", strsignal(9001));
}
TEST(strsignal, realtime) {
if (!SIGRTMIN) return;
EXPECT_STREQ("SIGTHR", strsignal(SIGTHR));
ASSERT_STREQ("SIGRTMIN+1", strsignal(SIGRTMIN + 1));
}
| 2,498 | 40 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/memset_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/dce.h"
#include "libc/intrin/asan.internal.h"
#include "libc/mem/mem.h"
#include "libc/mem/gc.internal.h"
#include "libc/stdio/rand.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
static noasan void *golden(void *p, int c, size_t n) {
size_t i;
if (IsAsan()) __asan_verify(p, n);
for (i = 0; i < n; ++i) ((char *)p)[i] = c;
return p;
}
TEST(memset, hug) {
char *a, *b;
int i, j, c;
a = gc(malloc(1025 * 2));
b = gc(malloc(1025 * 2));
for (i = 0; i < 1025; ++i) {
for (j = 0; j < 1025 - i; ++j) {
c = lemur64();
rngset(a, i + j, 0, 0);
memcpy(b, a, i + j);
ASSERT_EQ(a + i, golden(a + i, c, j));
ASSERT_EQ(b + i, memset(b + i, c, j));
ASSERT_EQ(0, timingsafe_bcmp(a, b, i + j));
}
}
}
TEST(bzero, hug) {
char *a, *b;
int i, j;
a = gc(malloc(1025 * 2));
b = gc(malloc(1025 * 2));
for (i = 0; i < 1025; ++i) {
for (j = 0; j < 1025 - i; ++j) {
rngset(a, i + j, 0, 0);
memcpy(b, a, i + j);
golden(a + i, 0, j);
bzero(b + i, j);
ASSERT_EQ(0, timingsafe_bcmp(a, b, i + j));
}
}
}
BENCH(memset, bench) {
int n, max = 8 * 1024 * 1024;
char *volatile p = gc(malloc(max));
EZBENCH_N("memset", 0, memset(p, -1, 0));
for (n = 2; n <= max; n *= 2) {
EZBENCH_N("memset", n - 1, memset(p, -1, n - 1));
EZBENCH_N("memset", n, memset(p, -1, n));
}
EZBENCH_N("memset16", 0, memset16((char16_t *)p, -1, 0));
for (n = 2; n <= max; n *= 2) {
EZBENCH_N("memset16", n, memset16((char16_t *)p, -1, n / 2));
}
EZBENCH_N("bzero", 0, bzero(p, 0));
for (n = 2; n <= max; n *= 2) {
EZBENCH_N("bzero", n - 1, bzero(p, n - 1));
EZBENCH_N("bzero", n, bzero(p, n));
}
}
BENCH(strlen, bench) {
volatile size_t r;
int n, max = 8 * 1024 * 1024;
char *volatile p = gc(calloc(max + 1, 1));
EZBENCH_N("strlen", 0, strlen(p));
for (n = 2; n <= max; n *= 2) {
memset(p, -1, n - 1);
EZBENCH_N("strlen", n - 1, r = strlen(p));
p[n - 1] = -1;
EZBENCH_N("strlen", n, r = strlen(p));
}
}
| 3,933 | 102 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/kprintf_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/kprintf.h"
#include "libc/calls/calls.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/bits.h"
#include "libc/limits.h"
#include "libc/log/libfatal.internal.h"
#include "libc/macros.internal.h"
#include "libc/runtime/memtrack.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/runtime/symbols.internal.h"
#include "libc/stdio/rand.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/prot.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#define S(x) ((uintptr_t)(x))
/**
* returns random bytes that don't have exclamation mark
* since that would disable memory safety in the fuzzing
*/
static uint64_t Rando(void) {
uint64_t x;
do x = lemur64();
while (((x ^ READ64LE("!!!!!!!!")) - 0x0101010101010101) &
~(x ^ READ64LE("!!!!!!!!")) & 0x8080808080808080);
return x;
}
static const struct {
const char *want;
const char *fmt;
uintptr_t arg1;
uintptr_t arg2;
} V[] = {
{"!!WONTFMT", (const char *)31337, 123}, //
{"!!31337", "%s", 0x31337}, //
{"!!1", "%#s", 1}, //
{"!!feff800000031337", "%s", 0xfeff800000031337ull}, //
{"!!ffff800000031337", "%s", 0xffff800000031337ull}, //
{"123", "%d", 123}, //
{"2147483647", "%d", INT_MAX}, //
{"-2147483648", "%d", INT_MIN}, //
{"9223372036854775807", "%ld", LONG_MAX}, //
{"-9223372036854775808", "%ld", LONG_MIN}, //
{"9'223'372'036'854'775'807", "%'ld", LONG_MAX}, //
{"-9'223'372'036'854'775'808", "%'ld", LONG_MIN}, //
{"9,223,372,036,854,775,807", "%,ld", LONG_MAX}, //
{"-9,223,372,036,854,775,808", "%,ld", LONG_MIN}, //
{"9_223_372_036_854_775_807", "%_ld", LONG_MAX}, //
{"-9_223_372_036_854_775_808", "%_ld", LONG_MIN}, //
{"true", "%hhhd", 0xffff}, //
{"true", "%hhhd", 0xff00}, //
{"false", "%hhhd"}, //
{"fa", "%hhh.2d"}, //
{" 0x001337", "%#010.6x", 0x1337}, //
{"0x001337 ", "%#-010.6x", 0x1337}, //
{"0x1337 ", "%#-010.2x", 0x1337}, //
{" 0x1337", "%#010.2x", 0x1337}, //
{"0000001337", "%010d", 1337}, //
{"+000001337", "%+010d", 1337}, //
{" 001337", "%010.6d", 1337}, //
{" +001337", "%+010.6d", 1337}, //
{" 001337", "%010.6x", 0x1337}, //
{" 1337", "%010.2x", 0x1337}, //
{"1337 ", "%-010d", 1337}, //
{"001337 ", "%-010.6d", 1337}, //
{"+1337 ", "%+-010d", 1337}, //
{"+001337 ", "%+-010.6d", 1337}, //
{"001337 ", "%-010.6x", 0x1337}, //
{"1337 ", "%-010.2x", 0x1337}, //
{"000001'337", "%'010d", 1337}, //
{" 1337", "%*d", 10, 1337}, //
{"1337 ", "%*d", -10, 1337}, //
{"0", "%#x"}, //
{"0", "%#o"}, //
{"0", "%#b"}, //
{"0", "%#d"}, //
{"0", "%p"}, //
{"-1", "%p", S(MAP_FAILED)}, //
{"00000000", "%#.8x"}, //
{"00000000", "%#.8b"}, //
{"00000000", "%#.8o"}, //
{" 123", "%5d", 123}, //
{" -123", "%5d", -123}, //
{" 123", "%*d", 5, 123}, //
{" -123", "%*d", 5, -123}, //
{"123 ", "%-5d", 123}, //
{"-123 ", "%-5d", -123}, //
{" +123", "%+5d", 123}, //
{"00123", "%05d", 123}, //
{"-0123", "%05d", -123}, //
{" 0", "%5d"}, //
{" +0", "%+5d"}, //
{"00000", "%05d"}, //
{" deadbeef", "%20x", 0xdeadbeef}, //
{" 0xdeadbeef", "%20p", 0xdeadbeef}, //
{"101", "%b", 0b101}, //
{"123", "%x", 0x123}, //
{"deadbeef", "%x", 0xdeadbeef}, //
{"DEADBEEF", "%X", 0xdeadbeef}, //
{"0", "%hd", INT_MIN}, //
{"123", "%o", 0123}, //
{"+0", "%+d"}, //
{"+123", "%+d", 123}, //
{"-123", "%+d", -123}, //
{" 0", "% d"}, //
{" 123", "% d", 123}, //
{"-123", "% d", -123}, //
{"x", "%c", 'x'}, //
{"âº", "%hc", u'âº'}, //
{"âº", "%lc", L'âº'}, //
{"âº", "%C", L'âº'}, //
{"0x31337", "%p", 0x31337}, //
{"0xffff800000031337", "%p", 0xffff800000031337ull}, //
{"0xfeff800000031337", "%p", 0xfeff800000031337ull}, //
{"65535", "%hu", 0xffffffffu}, //
{"0", "%hu", 0x80000000u}, //
{"123", "%hd", 123}, //
{"32767", "%hd", SHRT_MAX}, //
{"-32768", "%hd", SHRT_MIN}, //
{"-1", "%hhd", 0xffff}, //
{"-128", "%hhd", 0xff80}, //
{"255", "%hhu", 0xffffffffu}, //
{"'x'", "%#c", 'x'}, //
{"u'âº'", "%#hc", u'âº'}, //
{"L'âº'", "%#lc", L'âº'}, //
{"L'âº'", "%#C", L'âº'}, //
{"L'\\''", "%#C", L'\''}, //
{"hello world\n", "%s", S("hello world\n")}, //
{"âºâ»â¥â¦â£â !\n", "%s", S("âºâ»â¥â¦â£â !\n")}, //
{"â", "%s", S("\1")}, //
{"\1", "%.*s", 1, S("\1")}, //
{"\\001", "%'s", S("\1")}, //
{"\"\\001\"", "%#s", S("\1")}, //
{"", "%.*s", 0}, //
{"âºâ»â¥â¦â£â !", "%hhs", S("\1\2\3\4\5\6!")}, //
{"âºâ»", "%.*hhs", 2, S("\1\2\3\4\5\6!")}, //
{"u\"âºâ»\"", "%#.*hhs", 2, S("\1\2\3\4\5\6!")}, //
{"u\"Â â»\"", "%#.*hhs", 2, S("\0\2\3\4\5\6!")}, //
{"", "% s", S("")}, //
{" a", "% s", S("a")}, //
{"", "% .*s", 0, S("a")}, //
{"", "% s"}, //
{"ð°ð±ð²ð³ð´ðµð¶ð·", "%hs", S(u"ð°ð±ð²ð³ð´ðµð¶ð·")}, //
{"âºâ»â¥â¦â£â !", "%ls", S(L"âºâ»â¥â¦â£â !")}, //
{"HELLO", "%^s", S("hello")}, //
{"eeeeeee ", "%10s", S("eeeeeee")}, //
{"hello", "%.*s", 5, S("hello world")}, //
{"þell", "%.*s", 5, S("þello world")}, //
{"þello", "%.*hs", 5, S(u"þello world")}, //
{"þeeeeee ", "%10s", S("þeeeeee")}, //
{"âºâ»â¥â¦â£â ! ", "%10s", S("âºâ»â¥â¦â£â !")}, //
{"âºâ»â¥â¦â£â ", "%10hs", S(u"âºâ»â¥â¦â£â ")}, //
{"ð°ð±ð²ð³ð´ðµð¶ð· ", "%10hs", S(u"ð°ð±ð²ð³ð´ðµð¶ð·")}, //
{"âºâ»â¥â¦â£â ! ", "%10ls", S(L"âºâ»â¥â¦â£â !")}, //
{"\"xx\"", "%#s", S("xx")}, //
{"u\"âºâº\"", "%#hs", S(u"âºâº")}, //
{"L\"âºâº\"", "%#ls", S(L"âºâº")}, //
{"\"\\\\\\\"\\177\"", "%#s", S("\\\"\177")}, //
{"%%", "%%%%"}, //
{"%", "%.%"}, //
{"=", "%="}, //
};
TEST(ksnprintf, test) {
char b[48], g[48];
size_t i, j, n, rc;
rngset(g, sizeof(g), 0, 0);
for (i = 0; i < ARRAYLEN(V); ++i) {
bzero(b, 48);
n = strlen(V[i].want);
rc = ksnprintf(b, 48, V[i].fmt, V[i].arg1, V[i].arg2);
EXPECT_EQ(n, rc, "ksnprintf(\"%s\", %#lx, %#lx) â %zu â %zu", V[i].fmt,
V[i].arg1, V[i].arg2, rc, n);
EXPECT_STREQ(V[i].want, b);
memcpy(b, g, 48);
for (j = 0; j < 40; ++j) {
rc = ksnprintf(b, 0, V[i].fmt, V[i].arg1, V[i].arg2);
ASSERT_EQ(n, rc, "ksnprintf(b, %zu, \"%s\", %#lx, %#lx) â %zu â %zu", j,
V[i].fmt, V[i].arg1, V[i].arg2, rc, n);
ASSERT_EQ(READ64LE(g + j), READ64LE(b + j),
"ksnprintf(b, %zu, \"%s\", %#lx, %#lx) â buffer overrun", j,
V[i].fmt, V[i].arg1, V[i].arg2);
}
}
}
TEST(ksnprintf, testSymbols) {
char b[2][32];
bool hassymbols;
hassymbols = GetSymbolTable();
ksnprintf(b[0], 32, "%t", strlen);
if (hassymbols) {
ASSERT_STREQ("&strlen", b[0]);
} else {
ksnprintf(b[1], 32, "&%x", strlen);
ASSERT_STREQ(b[1], b[0]);
}
}
TEST(ksnprintf, fuzzTheUnbreakable) {
int e;
size_t i;
uint64_t x;
char *f, b[32];
_Alignas(FRAMESIZE) static const char weasel[FRAMESIZE];
f = VEIL("r", weasel);
EXPECT_SYS(0, 0, mprotect(f, FRAMESIZE, PROT_READ | PROT_WRITE));
strcpy(f, "hello %s\n");
EXPECT_EQ(12, ksnprintf(b, sizeof(b), f, "world"));
EXPECT_STREQ("hello world\n", b);
for (i = 0; i < 30000; ++i) {
x = Rando();
memcpy(f, &x, sizeof(x));
x = Rando();
memcpy(f + 8, &x, sizeof(x));
f[Rando() & 15] = '%';
ksnprintf(b, sizeof(b), f, lemur64(), lemur64(), lemur64());
}
EXPECT_SYS(0, 0, mprotect(f, FRAMESIZE, PROT_READ));
}
TEST(kprintf, testFailure_wontClobberErrnoAndBypassesSystemCallSupport) {
int n;
const char *s = 0;
ASSERT_EQ(0, errno);
EXPECT_SYS(0, 3, dup(2));
// <LIMBO>
if (close(2)) _Exit(200);
n = __syscount;
if (__syscount != n) _Exit(201);
if (errno != 0) _Exit(202);
if (dup2(3, 2) != 2) _Exit(203);
// </LIMBO>
EXPECT_SYS(0, 0, close(3));
}
TEST(ksnprintf, testy) {
char b[32];
EXPECT_EQ(3, ksnprintf(b, 32, "%#s", 1));
EXPECT_STREQ("!!1", b);
}
TEST(ksnprintf, testNonTextFmt_wontFormat) {
char b[32];
char variable_format_string[16] = "%s";
EXPECT_EQ(9, ksnprintf(b, 32, variable_format_string, NULL));
EXPECT_STREQ("!!WONTFMT", b);
}
TEST(ksnprintf, testMisalignedPointer_wontFormat) {
char b[32];
const char16_t *s = u"hello";
ksnprintf(b, 32, "%hs", (char *)s + 1);
EXPECT_STARTSWITH("!!", b);
}
TEST(ksnprintf, testUnterminatedOverrun_truncatesAtPageBoundary) {
char *m;
char b[32];
m = memset(_mapanon(FRAMESIZE * 2), 1, FRAMESIZE);
EXPECT_SYS(0, 0, munmap(m + FRAMESIZE, FRAMESIZE));
EXPECT_EQ(12, ksnprintf(b, 32, "%'s", m + FRAMESIZE - 3));
EXPECT_STREQ("\\001\\001\\001", b);
EXPECT_SYS(0, 0, munmap(m, FRAMESIZE));
}
TEST(ksnprintf, testEmptyBuffer_determinesTrueLength) {
EXPECT_EQ(5, ksnprintf(0, 0, "hello"));
}
TEST(ksnprintf, testFormatOnly_copiesString) {
char b[6];
EXPECT_EQ(5, ksnprintf(b, 6, "hello"));
EXPECT_STREQ("hello", b);
}
TEST(ksnprintf, testOneChar_justNulTerminates) {
char b[2] = {1, 2};
EXPECT_EQ(3, ksnprintf(b, 1, "%d", 123));
EXPECT_EQ(0, b[0]);
EXPECT_EQ(2, b[1]);
}
TEST(kprintf, testStringUcs2) {
char b[32];
EXPECT_EQ(21, ksnprintf(b, 32, "%hs", u"þâºâ»â¥â¦â£â !"));
EXPECT_EQ(0xc3, b[0] & 255);
EXPECT_EQ(0xbe, b[1] & 255);
EXPECT_EQ(0xe2, b[2] & 255);
EXPECT_EQ(0x98, b[3] & 255);
EXPECT_EQ(0xba, b[4] & 255);
EXPECT_STREQ("þâºâ»â¥â¦â£â !", b);
}
TEST(kprintf, testTruncate_addsDotsAndReturnsTrueLength) {
char b[15];
EXPECT_EQ(10, ksnprintf(b, 15, "%p", 0xdeadbeef));
EXPECT_STREQ("0xdeadbeef", b);
EXPECT_EQ(10, ksnprintf(b, 10, "%p", 0xdeadbeef));
EXPECT_STREQ("0xdead...", b);
}
TEST(kprintf, testTruncate_preservesNewlineFromEndOfFormatString) {
char b[14];
EXPECT_EQ(11, ksnprintf(b, 10, "%p\n", 0xdeadbeef));
EXPECT_STREQ("0xdea...\n", b);
}
TEST(ksnprintf, testTruncate_doesntBreakApartCharacters) {
char b[5];
ASSERT_EQ(6, ksnprintf(b, 5, "â»â»"));
ASSERT_STREQ("....", b);
}
TEST(ksnprintf, badUtf16) {
size_t i;
char b[16];
static const struct {
const char *want;
const char *fmt;
char16_t arg[16];
} V[] = {
{"� ", "%10hs", {0xd800}},
{"� ", "%10hs", {0xdc00}},
{"�� ", "%10hs", {0xd800, 0xd800}},
{"�� ", "%10hs", {0xdc00, 0xdc00}},
};
for (i = 0; i < ARRAYLEN(V); ++i) {
EXPECT_EQ(strlen(V[i].want), ksnprintf(b, 16, V[i].fmt, V[i].arg));
EXPECT_STREQ(V[i].want, b);
}
}
TEST(ksnprintf, negativeOverflowIdiom_isSafe) {
int i, n;
char golden[11];
struct {
char underflow[11];
char buf[11];
char overflow[11];
} u;
memset(golden, -1, 11);
memset(u.underflow, -1, 11);
memset(u.overflow, -1, 11);
i = 0;
n = 11;
i += ksnprintf(u.buf + i, n - i, "hello");
ASSERT_STREQ("hello", u.buf);
i += ksnprintf(u.buf + i, n - i, " world");
ASSERT_STREQ("hello w...", u.buf);
i += ksnprintf(u.buf + i, n - i, " i love you");
ASSERT_STREQ("hello w...", u.buf);
ASSERT_EQ(i, 5 + 6 + 11);
ASSERT_EQ(0, memcmp(golden, u.underflow, 11));
ASSERT_EQ(0, memcmp(golden, u.overflow, 11));
}
TEST(ksnprintf, truncation) {
char buf[16] = {0};
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(0, 0, "%s", "xxxxx");
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 1, "%s", "xxxxx");
EXPECT_STREQ("", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 2, "%s", "xxxxx");
EXPECT_STREQ(".", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 3, "%s", "xxxxx");
EXPECT_STREQ("..", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 4, "%s", "xxxxx");
EXPECT_STREQ("...", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 5, "%s", "xxxxx");
EXPECT_STREQ("x...", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 6, "%s", "xxxxxxxxxxx");
EXPECT_STREQ("xx...", buf);
rngset(buf, sizeof(buf) - 1, lemur64, -1);
ksnprintf(buf, 7, "%s", "xxxxxxxxx");
EXPECT_STREQ("xxx...", buf);
}
BENCH(printf, bench) {
char b[128];
int snprintf_(char *, size_t, const char *, ...) asm("snprintf");
EZBENCH2("ksnprintf fmt", donothing, ksnprintf(b, 128, "."));
EZBENCH2("snprintf fmt", donothing, snprintf_(b, 128, "."));
EZBENCH2("ksnprintf str", donothing,
ksnprintf(b, 128, "%s\n", "hello world"));
EZBENCH2("snprintf str", donothing,
snprintf_(b, 128, "%s\n", "hello world"));
EZBENCH2("ksnprintf utf8", donothing,
ksnprintf(b, 128, "%s\n", "天å°çé»å®å®æ´ªè天å°çé»å®å®æ´ªè"));
EZBENCH2("snprintf utf8", donothing,
snprintf_(b, 128, "%s\n", "天å°çé»å®å®æ´ªè天å°çé»å®å®æ´ªè"));
EZBENCH2("ksnprintf chinese", donothing,
ksnprintf(b, 128, "%hs\n", u"天å°çé»å®å®æ´ªè"));
EZBENCH2("snprintf chinese", donothing,
snprintf_(b, 128, "%hs\n", u"天å°çé»å®å®æ´ªè"));
EZBENCH2("ksnprintf astral", donothing,
ksnprintf(b, 128, "%hs\n", u"ð°ð±ð²ð³ð´ðµð¶ð·"));
EZBENCH2("snprintf astral", donothing,
snprintf_(b, 128, "%hs\n", u"ð°ð±ð²ð³ð´ðµð¶ð·"));
EZBENCH2("ksnprintf octal", donothing, ksnprintf(b, 128, "%#lo", ULONG_MAX));
EZBENCH2("snprintf octal", donothing, snprintf(b, 128, "%#lo", ULONG_MAX));
EZBENCH2("ksnprintf long", donothing, ksnprintf(b, 128, "%ld", LONG_MAX));
EZBENCH2("snprintf long", donothing, snprintf_(b, 128, "%ld", LONG_MAX));
EZBENCH2("ksnprintf thou", donothing, ksnprintf(b, 128, "%'ld", LONG_MAX));
EZBENCH2("snprintf thou", donothing, snprintf_(b, 128, "%'ld", LONG_MAX));
EZBENCH2(
"ksnprintf bin", donothing,
ksnprintf(b, 128, "%#.*hhs\n", 8, "\001\002\003\004\005\006\007\008"));
EZBENCH2(
"snprintf bin", donothing,
snprintf(b, 128, "%`'.*hhs\n", 8, "\001\002\003\004\005\006\007\008"));
}
| 19,115 | 443 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/bextra_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/intrin/bits.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
unsigned P[] = {
// 33333222222222111111111000000000
0b000011000000010000000001000000000, //
// 76666666665555555554444444443333
0b010000001100000001010000001000000, //
0b000101000000100100000100000000011, //
0b010000001101000001100000001011000, //
0b000100010000100000000011110000011, //
0b010100001010000001001100001001000, //
0b000011000000010111000010110000010, //
0b011000000110110000110100000110010, //
0b000001111100001111000001110100001, //
0b000011000100010000100001000100000, //
0b010001001100001001010001001000001, //
0b010101000010100100010100000010011, //
0b010000101101000101100000101011000, //
0b001100010001100000001011110001011, //
0b010100011010000011001100011001000, //
0b000111000000110111000110110000110, //
0b011000001110110001110100001110010, //
0b000011111100011111000011110100011, //
0b000011001000010001000001001000000, //
0b010010001100010001010010001000010, //
0b000101000100100100100100000100011, //
0b010001001101001001100001001011001, //
0b010100010010100000010011110010011, //
0b010100101010000101001100101001000, //
0b001011000001010111001010110001010, //
0b011000010110110010110100010110010, //
0b000101111100101111000101110100101, //
0b000011001100010001100001001100000, //
0b010011001100011001010011001000011, //
0b010101000110100100110100000110011, //
0b010001101101001101100001101011001, //
0b011100010011100000011011110011011, //
0b010100111010000111001100111001000, //
0b001111000001110111001110110001110, //
0b011000011110110011110100011110010, //
0b000111111100111111000111110100111, //
0b000011010000010010000001010000000, //
0b010100001100100001010100001000100, //
0b000101001000100101000100001000011, //
0b010010001101010001100010001011010, //
0b000100010100100000100011110100011, //
0b010101001010001001001101001001001, //
0b010011000010010111010010110010010, //
0b011000100110110100110100100110010, //
0b001001111101001111001001110101001, //
0b000011010100010010100001010100000, //
0b010101001100101001010101001000101, //
0b010101001010100101010100001010011, //
0b010010101101010101100010101011010, //
0b001100010101100000101011110101011, //
0b010101011010001011001101011001001, //
0b010111000010110111010110110010110, //
0b011000101110110101110100101110010, //
0b001011111101011111001011110101011, //
0b000011011000010011000001011000000, //
0b010110001100110001010110001000110, //
0b000101001100100101100100001100011, //
0b010011001101011001100011001011011, //
0b010100010110100000110011110110011, //
0b010101101010001101001101101001001, //
0b011011000011010111011010110011010, //
0b011000110110110110110100110110010, //
0b001101111101101111001101110101101, //
0b000011011100010011100001011100000, //
0b010111001100111001010111001000111, //
0b010101001110100101110100001110011, //
0b010011101101011101100011101011011, //
0b011100010111100000111011110111011, //
0b010101111010001111001101111001001, //
0b011111000011110111011110110011110, //
0b011000111110110111110100111110010, //
0b001111111101111111001111110101111, //
0b000000000000000000000000100000000, //
};
TEST(bextra, 9bit) {
int i;
for (i = 4; i < 257; ++i) {
ASSERT_EQ(i, _bextra(P, i, 9));
}
}
BENCH(bextra, bench) {
EZBENCH2("bextra 1/31", donothing, _bextra(P, 1, 31));
}
| 5,608 | 116 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/intrin_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/mpsadbw.h"
#include "libc/intrin/pabsb.h"
#include "libc/intrin/pabsd.h"
#include "libc/intrin/pabsw.h"
#include "libc/intrin/packssdw.h"
#include "libc/intrin/packsswb.h"
#include "libc/intrin/packusdw.h"
#include "libc/intrin/packuswb.h"
#include "libc/intrin/paddb.h"
#include "libc/intrin/paddd.h"
#include "libc/intrin/paddq.h"
#include "libc/intrin/paddsb.h"
#include "libc/intrin/paddsw.h"
#include "libc/intrin/paddusb.h"
#include "libc/intrin/paddusw.h"
#include "libc/intrin/paddw.h"
#include "libc/intrin/palignr.h"
#include "libc/intrin/pand.h"
#include "libc/intrin/pandn.h"
#include "libc/intrin/pavgb.h"
#include "libc/intrin/pavgw.h"
#include "libc/intrin/pcmpeqb.h"
#include "libc/intrin/pcmpeqd.h"
#include "libc/intrin/pcmpeqw.h"
#include "libc/intrin/pcmpgtb.h"
#include "libc/intrin/pcmpgtd.h"
#include "libc/intrin/pcmpgtw.h"
#include "libc/intrin/pdep.h"
#include "libc/intrin/pext.h"
#include "libc/intrin/phaddd.h"
#include "libc/intrin/phaddsw.h"
#include "libc/intrin/phaddw.h"
#include "libc/intrin/phsubd.h"
#include "libc/intrin/phsubsw.h"
#include "libc/intrin/phsubw.h"
#include "libc/intrin/pmaddubsw.h"
#include "libc/intrin/pmaddwd.h"
#include "libc/intrin/pmaxsw.h"
#include "libc/intrin/pmaxub.h"
#include "libc/intrin/pminsw.h"
#include "libc/intrin/pminub.h"
#include "libc/intrin/pmulhrsw.h"
#include "libc/intrin/pmulhuw.h"
#include "libc/intrin/pmulhw.h"
#include "libc/intrin/pmulld.h"
#include "libc/intrin/pmullw.h"
#include "libc/intrin/pmuludq.h"
#include "libc/intrin/por.h"
#include "libc/intrin/psadbw.h"
#include "libc/intrin/pshufb.h"
#include "libc/intrin/pshufd.h"
#include "libc/intrin/pshufhw.h"
#include "libc/intrin/pshuflw.h"
#include "libc/intrin/pshufw.h"
#include "libc/intrin/psignb.h"
#include "libc/intrin/psignd.h"
#include "libc/intrin/psignw.h"
#include "libc/intrin/pslld.h"
#include "libc/intrin/pslldq.h"
#include "libc/intrin/psllq.h"
#include "libc/intrin/psllw.h"
#include "libc/intrin/psrad.h"
#include "libc/intrin/psraw.h"
#include "libc/intrin/psrld.h"
#include "libc/intrin/psrldq.h"
#include "libc/intrin/psrlq.h"
#include "libc/intrin/psrlw.h"
#include "libc/intrin/psubb.h"
#include "libc/intrin/psubd.h"
#include "libc/intrin/psubq.h"
#include "libc/intrin/psubsb.h"
#include "libc/intrin/psubsw.h"
#include "libc/intrin/psubusb.h"
#include "libc/intrin/psubusw.h"
#include "libc/intrin/psubw.h"
#include "libc/intrin/punpckhbw.h"
#include "libc/intrin/punpckhdq.h"
#include "libc/intrin/punpckhqdq.h"
#include "libc/intrin/punpckhwd.h"
#include "libc/intrin/punpcklbw.h"
#include "libc/intrin/punpckldq.h"
#include "libc/intrin/punpcklqdq.h"
#include "libc/intrin/punpcklwd.h"
#include "libc/intrin/pxor.h"
#include "libc/intrin/shufpd.h"
#include "libc/intrin/shufps.h"
#include "libc/limits.h"
#include "libc/log/check.h"
#include "libc/mem/gc.internal.h"
#include "libc/nexgen32e/kcpuids.h"
#include "libc/stdio/lcg.internal.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "tool/viz/lib/formatstringtable-testlib.h"
uint64_t g_rando = 1;
forceinline uint64_t Rando(void) {
return KnuthLinearCongruentialGenerator(&g_rando) >> 32 << 32 |
KnuthLinearCongruentialGenerator(&g_rando) >> 32;
}
dontinline void RngSet(void *mem, size_t size) {
uint64_t coin;
DCHECK(size % 8 == 0);
for (size >>= 3; size--;) {
coin = Rando();
memcpy((char *)mem + size * 8, &coin, 8);
}
}
FIXTURE(intrin, disableHardwareExtensions) {
#ifdef __x86_64__
memset((/*unconst*/ void *)kCpuids, 0, sizeof(kCpuids));
#endif
}
TEST(punpcklwd, test) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
uint16_t c[8];
punpcklwd(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(9, c[1]);
ASSERT_EQ(2, c[2]);
ASSERT_EQ(10, c[3]);
ASSERT_EQ(3, c[4]);
ASSERT_EQ(11, c[5]);
ASSERT_EQ(4, c[6]);
ASSERT_EQ(12, c[7]);
}
TEST(punpcklwd, pure) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
uint16_t c[8];
punpcklwd(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(9, c[1]);
ASSERT_EQ(2, c[2]);
ASSERT_EQ(10, c[3]);
ASSERT_EQ(3, c[4]);
ASSERT_EQ(11, c[5]);
ASSERT_EQ(4, c[6]);
ASSERT_EQ(12, c[7]);
}
TEST(punpcklwd, testAlias) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
punpcklwd(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(9, a[1]);
ASSERT_EQ(2, a[2]);
ASSERT_EQ(10, a[3]);
ASSERT_EQ(3, a[4]);
ASSERT_EQ(11, a[5]);
ASSERT_EQ(4, a[6]);
ASSERT_EQ(12, a[7]);
}
TEST(punpcklwd, pureAlias) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
(punpcklwd)(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(9, a[1]);
ASSERT_EQ(2, a[2]);
ASSERT_EQ(10, a[3]);
ASSERT_EQ(3, a[4]);
ASSERT_EQ(11, a[5]);
ASSERT_EQ(4, a[6]);
ASSERT_EQ(12, a[7]);
}
TEST(punpcklwd, testAlias2) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
punpcklwd(b, a, b);
ASSERT_EQ(1, b[0]);
ASSERT_EQ(9, b[1]);
ASSERT_EQ(2, b[2]);
ASSERT_EQ(10, b[3]);
ASSERT_EQ(3, b[4]);
ASSERT_EQ(11, b[5]);
ASSERT_EQ(4, b[6]);
ASSERT_EQ(12, b[7]);
}
TEST(punpcklwd, pureAlias2) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
(punpcklwd)(b, a, b);
ASSERT_EQ(1, b[0]);
ASSERT_EQ(9, b[1]);
ASSERT_EQ(2, b[2]);
ASSERT_EQ(10, b[3]);
ASSERT_EQ(3, b[4]);
ASSERT_EQ(11, b[5]);
ASSERT_EQ(4, b[6]);
ASSERT_EQ(12, b[7]);
}
TEST(punpcklqdq, test) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
uint64_t c[2];
punpcklqdq(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(3, c[1]);
}
TEST(punpcklqdq, pure) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
uint64_t c[2];
(punpcklqdq)(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(3, c[1]);
}
TEST(punpcklqdq, testAlias) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
punpcklqdq(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(3, a[1]);
}
TEST(punpcklqdq, pureAlias) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
(punpcklqdq)(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(3, a[1]);
}
TEST(punpckldq, test) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
uint32_t c[4];
punpckldq(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(5, c[1]);
ASSERT_EQ(2, c[2]);
ASSERT_EQ(6, c[3]);
}
TEST(punpckldq, pure) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
uint32_t c[4];
punpckldq(c, a, b);
ASSERT_EQ(1, c[0]);
ASSERT_EQ(5, c[1]);
ASSERT_EQ(2, c[2]);
ASSERT_EQ(6, c[3]);
}
TEST(punpckldq, testAlias) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
punpckldq(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(5, a[1]);
ASSERT_EQ(2, a[2]);
ASSERT_EQ(6, a[3]);
}
TEST(punpckldq, pureAlias) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
(punpckldq)(a, a, b);
ASSERT_EQ(1, a[0]);
ASSERT_EQ(5, a[1]);
ASSERT_EQ(2, a[2]);
ASSERT_EQ(6, a[3]);
}
TEST(punpckldq, testAlias2) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
punpckldq(b, a, b);
ASSERT_EQ(1, b[0]);
ASSERT_EQ(5, b[1]);
ASSERT_EQ(2, b[2]);
ASSERT_EQ(6, b[3]);
}
TEST(punpckldq, pureAlias2) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
(punpckldq)(b, a, b);
ASSERT_EQ(1, b[0]);
ASSERT_EQ(5, b[1]);
ASSERT_EQ(2, b[2]);
ASSERT_EQ(6, b[3]);
}
TEST(punpcklqdq, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpcklqdq(a, x, y);
(punpcklqdq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpckldq, fuzz) {
int i, j;
uint32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpckldq(a, x, y);
(punpckldq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpcklbw, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpcklbw(a, x, y);
(punpcklbw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpckhwd, test) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
uint16_t c[8];
punpckhwd(c, a, b);
EXPECT_EQ(5, c[0]);
EXPECT_EQ(13, c[1]);
EXPECT_EQ(6, c[2]);
EXPECT_EQ(14, c[3]);
EXPECT_EQ(7, c[4]);
EXPECT_EQ(15, c[5]);
EXPECT_EQ(8, c[6]);
EXPECT_EQ(16, c[7]);
}
TEST(punpckhwd, pure) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
uint16_t c[8];
punpckhwd(c, a, b);
EXPECT_EQ(5, c[0]);
EXPECT_EQ(13, c[1]);
EXPECT_EQ(6, c[2]);
EXPECT_EQ(14, c[3]);
EXPECT_EQ(7, c[4]);
EXPECT_EQ(15, c[5]);
EXPECT_EQ(8, c[6]);
EXPECT_EQ(16, c[7]);
}
TEST(punpckhwd, testAlias) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
punpckhwd(a, a, b);
EXPECT_EQ(5, a[0]);
EXPECT_EQ(13, a[1]);
EXPECT_EQ(6, a[2]);
EXPECT_EQ(14, a[3]);
EXPECT_EQ(7, a[4]);
EXPECT_EQ(15, a[5]);
EXPECT_EQ(8, a[6]);
EXPECT_EQ(16, a[7]);
}
TEST(punpckhwd, pureAlias) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
(punpckhwd)(a, a, b);
EXPECT_EQ(5, a[0]);
EXPECT_EQ(13, a[1]);
EXPECT_EQ(6, a[2]);
EXPECT_EQ(14, a[3]);
EXPECT_EQ(7, a[4]);
EXPECT_EQ(15, a[5]);
EXPECT_EQ(8, a[6]);
EXPECT_EQ(16, a[7]);
}
TEST(punpckhwd, testAlias2) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
punpckhwd(b, a, b);
EXPECT_EQ(5, b[0]);
EXPECT_EQ(13, b[1]);
EXPECT_EQ(6, b[2]);
EXPECT_EQ(14, b[3]);
EXPECT_EQ(7, b[4]);
EXPECT_EQ(15, b[5]);
EXPECT_EQ(8, b[6]);
EXPECT_EQ(16, b[7]);
}
TEST(punpckhwd, pureAlias2) {
uint16_t a[8] = {1, 02, 03, 04, 05, 06, 07, 8};
uint16_t b[8] = {9, 10, 11, 12, 13, 14, 15, 16};
(punpckhwd)(b, a, b);
EXPECT_EQ(5, b[0]);
EXPECT_EQ(13, b[1]);
EXPECT_EQ(6, b[2]);
EXPECT_EQ(14, b[3]);
EXPECT_EQ(7, b[4]);
EXPECT_EQ(15, b[5]);
EXPECT_EQ(8, b[6]);
EXPECT_EQ(16, b[7]);
}
TEST(punpckhqdq, test) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
uint64_t c[2];
punpckhqdq(c, a, b);
EXPECT_EQ(2, c[0]);
EXPECT_EQ(4, c[1]);
}
TEST(punpckhqdq, pure) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
uint64_t c[2];
(punpckhqdq)(c, a, b);
EXPECT_EQ(2, c[0]);
EXPECT_EQ(4, c[1]);
}
TEST(punpckhqdq, testAlias) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
punpckhqdq(a, a, b);
EXPECT_EQ(2, a[0]);
EXPECT_EQ(4, a[1]);
}
TEST(punpckhqdq, pureAlias) {
uint64_t a[2] = {1, 2};
uint64_t b[2] = {3, 4};
(punpckhqdq)(a, a, b);
EXPECT_EQ(2, a[0]);
EXPECT_EQ(4, a[1]);
}
TEST(punpckhdq, test) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
uint32_t c[4];
punpckhdq(c, a, b);
EXPECT_EQ(3, c[0]);
EXPECT_EQ(7, c[1]);
EXPECT_EQ(4, c[2]);
EXPECT_EQ(8, c[3]);
}
TEST(punpckhdq, pure) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
uint32_t c[4];
punpckhdq(c, a, b);
EXPECT_EQ(3, c[0]);
EXPECT_EQ(7, c[1]);
EXPECT_EQ(4, c[2]);
EXPECT_EQ(8, c[3]);
}
TEST(punpckhdq, testAlias) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
punpckhdq(a, a, b);
EXPECT_EQ(3, a[0]);
EXPECT_EQ(7, a[1]);
EXPECT_EQ(4, a[2]);
EXPECT_EQ(8, a[3]);
}
TEST(punpckhdq, pureAlias) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
(punpckhdq)(a, a, b);
EXPECT_EQ(3, a[0]);
EXPECT_EQ(7, a[1]);
EXPECT_EQ(4, a[2]);
EXPECT_EQ(8, a[3]);
}
TEST(punpckhdq, testAlias2) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
punpckhdq(b, a, b);
EXPECT_EQ(3, b[0]);
EXPECT_EQ(7, b[1]);
EXPECT_EQ(4, b[2]);
EXPECT_EQ(8, b[3]);
}
TEST(punpckhdq, pureAlias2) {
uint32_t a[4] = {1, 2, 3, 4};
uint32_t b[4] = {5, 6, 7, 8};
(punpckhdq)(b, a, b);
EXPECT_EQ(3, b[0]);
EXPECT_EQ(7, b[1]);
EXPECT_EQ(4, b[2]);
EXPECT_EQ(8, b[3]);
}
TEST(punpckhwd, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpckhwd(a, x, y);
(punpckhwd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpckhqdq, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpckhqdq(a, x, y);
(punpckhqdq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpckhdq, fuzz) {
int i, j;
uint32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpckhdq(a, x, y);
(punpckhdq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpckhbw, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpckhbw(a, x, y);
(punpckhbw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubq, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubq(a, x, y);
(psubq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrawv, testSmallShift) {
int16_t A[8] = {-1, -2, SHRT_MIN, 2};
uint64_t B[2] = {1};
psrawv(A, A, B);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-16384, A[2]);
ASSERT_EQ(1, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psraw, testSmallShift) {
int16_t A[8] = {-1, -2, SHRT_MIN, 2};
psraw(A, A, 1);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-16384, A[2]);
ASSERT_EQ(1, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psraw, pureSmallShift) {
int16_t A[8] = {-1, -2, SHRT_MIN, 2};
(psraw)(A, A, 1);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-16384, A[2]);
ASSERT_EQ(1, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psraw, testBigShift_saturatesCount) {
int16_t A[8] = {-1, -2, SHRT_MIN, 2};
psraw(A, A, 77);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1, A[2]);
ASSERT_EQ(0, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psraw, pureBigShift_saturatesCount) {
int16_t A[8] = {-1, -2, SHRT_MIN, 2};
(psraw)(A, A, 77);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1, A[2]);
ASSERT_EQ(0, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psradv, testSmallShift) {
int32_t A[8] = {-1, -2, INT32_MIN, 2};
uint64_t B[2] = {1};
psradv(A, A, B);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1073741824, A[2]);
ASSERT_EQ(1, A[3]);
ASSERT_EQ(0, A[4]);
}
TEST(psradv, test) {
int i, j;
int32_t x[4], a[4], b[4];
uint64_t y[2];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
for (j = 0; j < 2; ++j) {
y[j] = Rando() % 70;
}
psradv(a, x, y);
(psradv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrad, testSmallShift) {
int32_t A[4] = {-1, -2, INT32_MIN, 2};
psrad(A, A, 1);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1073741824, A[2]);
ASSERT_EQ(1, A[3]);
}
TEST(psrad, pureSmallShift) {
int32_t A[4] = {-1, -2, INT32_MIN, 2};
(psrad)(A, A, 1);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1073741824, A[2]);
ASSERT_EQ(1, A[3]);
}
TEST(psrad, testBigShift_saturatesCount) {
int32_t A[4] = {-1, -2, INT32_MIN, 2};
psrad(A, A, 77);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1, A[2]);
ASSERT_EQ(0, A[3]);
}
TEST(psrad, pureBigShift_saturatesCount) {
int32_t A[4] = {-1, -2, INT32_MIN, 2};
(psrad)(A, A, 77);
ASSERT_EQ(-1, A[0]);
ASSERT_EQ(-1, A[1]);
ASSERT_EQ(-1, A[2]);
ASSERT_EQ(0, A[3]);
}
TEST(psllwv, test) {
int i, j;
uint16_t x[8], a[8], b[8];
uint64_t y[2];
for (i = 0; i < 32; ++i) {
RngSet(x, sizeof(x));
for (j = 0; j < 2; ++j) {
y[j] = Rando() % 300;
}
psllwv(a, x, y);
(psllwv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psllw, testSmallShift) {
uint16_t A[8] = {0, 1, 0xffff, 2};
psllw(A, A, 1);
ASSERT_EQ(0, A[0]);
ASSERT_EQ(2, A[1]);
ASSERT_EQ(0xfffe, A[2]);
ASSERT_EQ(4, A[3]);
}
TEST(psllwv, testSmallShift) {
uint16_t A[8] = {0, 1, 0xffff, 2};
uint64_t B[2] = {1};
psllwv(A, A, B);
ASSERT_EQ(0, A[0]);
ASSERT_EQ(2, A[1]);
ASSERT_EQ(0xfffe, A[2]);
ASSERT_EQ(4, A[3]);
}
TEST(pslldv, test) {
int i, j;
uint32_t x[4], a[4], b[4];
uint64_t y[2];
for (i = 0; i < 32; ++i) {
RngSet(x, sizeof(x));
for (j = 0; j < 2; ++j) {
y[j] = Rando() % 300;
}
pslldv(a, x, y);
(pslldv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pslld, testSmallShift) {
uint32_t A[8] = {0, 1, 0xffffffff, 2};
pslld(A, A, 1);
ASSERT_EQ(0, A[0]);
ASSERT_EQ(2, A[1]);
ASSERT_EQ(0xfffffffe, A[2]);
ASSERT_EQ(4, A[3]);
}
TEST(pslldv, testSmallShift) {
uint32_t A[8] = {0, 1, 0xffffffff, 2};
uint64_t B[2] = {1};
pslldv(A, A, B);
ASSERT_EQ(0, A[0]);
ASSERT_EQ(2, A[1]);
ASSERT_EQ(0xfffffffe, A[2]);
ASSERT_EQ(4, A[3]);
}
TEST(pmulhuw, test) {
uint16_t x[8] = {0, 0xffff, 0x0000, 0x0001, 0x8000};
uint16_t y[8] = {0, 0xffff, 0xffff, 0xffff, 0x8000};
uint16_t z[8];
pmulhuw(z, x, y);
ASSERT_EQ(0x0000 /*0000*/, z[0]);
ASSERT_EQ(0xfffe /*0001*/, z[1]);
ASSERT_EQ(0x0000 /*0000*/, z[2]);
ASSERT_EQ(0x0000 /*ffff*/, z[3]);
ASSERT_EQ(0x4000 /*0000*/, z[4]);
}
TEST(pmulhuw, pure) {
uint16_t x[8] = {0, 0xffff, 0x0000, 0x0001, 0x8000};
uint16_t y[8] = {0, 0xffff, 0xffff, 0xffff, 0x8000};
uint16_t z[8];
(pmulhuw)(z, x, y);
ASSERT_EQ(0x0000 /*0000*/, z[0]);
ASSERT_EQ(0xfffe /*0001*/, z[1]);
ASSERT_EQ(0x0000 /*0000*/, z[2]);
ASSERT_EQ(0x0000 /*ffff*/, z[3]);
ASSERT_EQ(0x4000 /*0000*/, z[4]);
}
TEST(pmulhuw, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmulhuw(a, x, y);
(pmulhuw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmulhuw(a, (void *)a, y);
(pmulhuw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmulhw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmulhw(a, x, y);
(pmulhw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmulhw(a, (void *)a, y);
(pmulhw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmullw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmullw(a, x, y);
(pmullw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmullw(a, (void *)a, y);
(pmullw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmulld, fuzz) {
int i, j;
uint32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmulld(a, x, y);
(pmulld)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmulld(a, (void *)a, y);
(pmulld)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmuludq, fuzz) {
int i, j;
uint32_t x[4], y[4];
uint64_t a[2], b[2];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmuludq(a, x, y);
(pmuludq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmuludq(a, (void *)a, y);
(pmuludq)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmaddwd, fuzz) {
int i, j;
int16_t x[8], y[8];
int32_t a[4], b[4];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmaddwd(a, x, y);
(pmaddwd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmaddwd(a, (void *)a, y);
(pmaddwd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phaddw, fuzz) {
int i, j;
int16_t x[8], y[8];
int16_t a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phaddw(a, x, y);
(phaddw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phaddw(a, (void *)a, y);
(phaddw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phaddd, fuzz) {
int i, j;
uint32_t x[4], y[4];
uint32_t a[4], b[4];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phaddd(a, x, y);
(phaddd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phaddd(a, (void *)a, y);
(phaddd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phsubw, fuzz) {
int i, j;
int16_t x[8], y[8];
int16_t a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phsubw(a, x, y);
(phsubw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phsubw(a, (void *)a, y);
(phsubw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phsubd, fuzz) {
int i, j;
uint32_t x[4], y[4];
uint32_t a[4], b[4];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phsubd(a, x, y);
(phsubd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phsubd(a, (void *)a, y);
(phsubd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubd, fuzz) {
int i, j;
uint32_t x[4], y[4];
uint32_t a[4], b[4];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubd(a, x, y);
(psubd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubd(a, (void *)a, y);
(psubd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phaddsw, fuzz) {
int i, j;
int16_t x[8], y[8];
int16_t a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phaddsw(a, x, y);
(phaddsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phaddsw(a, (void *)a, y);
(phaddsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phsubsw, fuzz) {
int i, j;
int16_t x[8], y[8];
int16_t a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
phsubsw(a, x, y);
(phsubsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
phsubsw(a, (void *)a, y);
(phsubsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(phaddw, testOverflow_wrapsAround) {
short M[2][8] = {
{0x7fff, 0, 0x7fff, 1, 13004, -30425, 20777, -16389},
{-28040, 13318, -1336, -24798, -13876, 3599, -7346, -23575},
};
phaddw(M[0], M[0], M[1]);
EXPECT_SHRTMATRIXEQ(2, 8, M, "\n\
32767 -32768 -17421 4388 -14722 -26134 -10277 -30921\n\
-28040 13318 -1336 -24798 -13876 3599 -7346 -23575");
}
TEST(phaddw, testAliasing_isOk) {
short M[1][8] = {
{0, 1, 2, 3, 4, 5, 6, 7},
};
phaddw(M[0], M[0], M[0]);
EXPECT_SHRTMATRIXEQ(1, 8, M, "\n\
1 5 9 13 1 5 9 13");
}
TEST(phaddsw, testOverflow_saturates) {
short M[2][8] = {
{0x7fff, 0, 0x7fff, 1, 0x7fff, 0x7fff, 20777, -16389},
{-28040, 13318, -1336, -24798, -13876, 3599, -7346, -23575},
};
phaddsw(M[0], M[0], M[1]);
EXPECT_SHRTMATRIXEQ(2, 8, M, "\n\
32767 32767 32767 4388 -14722 -26134 -10277 -30921\n\
-28040 13318 -1336 -24798 -13876 3599 -7346 -23575");
}
TEST(phaddsw, testAliasing_isOk) {
short M[1][8] = {{0, 1, 2, 3, 4, 5, 6, 7}};
phaddsw(M[0], M[0], M[0]);
EXPECT_SHRTMATRIXEQ(1, 8, M, "\n\
1 5 9 13 1 5 9 13");
}
TEST(pcmpgtb, test) {
int i, j;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
static int count;
pcmpgtb(a, x, y);
(pcmpgtb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pcmpeqb, test) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pcmpeqb(a, x, y);
(pcmpeqb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pcmpeqd, test) {
int i, j;
int32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pcmpeqd(a, x, y);
(pcmpeqd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pcmpgtd, test) {
int i, j;
int32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pcmpgtd(a, x, y);
(pcmpgtd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pcmpeqw, test) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pcmpeqw(a, x, y);
(pcmpeqw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pcmpgtw, test) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pcmpgtw(a, x, y);
(pcmpgtw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(por, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando();
por(a, x, y);
(por)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
por(a, (void *)a, y);
(por)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pxor, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando();
pxor(a, x, y);
(pxor)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pxor(a, (void *)a, y);
(pxor)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pand, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando();
pand(a, x, y);
(pand)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pand(a, (void *)a, y);
(pand)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pandn, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando();
pandn(a, x, y);
(pandn)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pandn(a, (void *)a, y);
(pandn)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddq, fuzz) {
int i, j;
uint64_t x[2], y[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando();
paddq(a, x, y);
(paddq)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddq(a, (void *)a, y);
(paddq)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pavgb, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pavgb(a, x, y);
(pavgb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pavgb(a, (void *)a, y);
(pavgb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pavgw, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pavgw(a, x, y);
(pavgw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pavgw(a, (void *)a, y);
(pavgw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(punpcklwd, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
punpcklwd(a, x, y);
(punpcklwd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
punpcklwd(a, a, y);
(punpcklwd)(b, b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
punpcklwd(a, y, a);
(punpcklwd)(b, y, b);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pminub, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pminub(a, x, y);
(pminub)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pminub(a, (void *)a, y);
(pminub)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pminsw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pminsw(a, x, y);
(pminsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pminsw(a, (void *)a, y);
(pminsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmaxub, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmaxub(a, x, y);
(pmaxub)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmaxub(a, (void *)a, y);
(pmaxub)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmaxsw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmaxsw(a, x, y);
(pmaxsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmaxsw(a, (void *)a, y);
(pmaxsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddw, test) {
int16_t A[8] = {7};
int16_t B[8] = {11};
int16_t C[8];
paddw(C, A, B);
ASSERT_EQ(18, C[0]);
}
TEST(paddw, testOverflow_wrapsAround) {
int16_t A[8] = {SHRT_MAX, SHRT_MIN};
int16_t B[8] = {1, -1};
paddw(A, A, B);
ASSERT_EQ(SHRT_MIN, A[0]);
ASSERT_EQ(SHRT_MAX, A[1]);
}
TEST(paddw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddw(a, x, y);
(paddw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddw(a, (void *)a, y);
(paddw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddsw, test) {
int16_t A[8] = {7};
int16_t B[8] = {11};
int16_t C[8];
paddsw(C, A, B);
ASSERT_EQ(18, C[0]);
}
TEST(paddsw, testOverflow_saturates) {
int16_t A[8] = {SHRT_MAX, SHRT_MIN};
int16_t B[8] = {1, -1};
paddsw(A, A, B);
ASSERT_EQ(SHRT_MAX, A[0]);
ASSERT_EQ(SHRT_MIN, A[1]);
}
TEST(paddusw, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddusw(a, x, y);
(paddusw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddusw(a, (void *)a, y);
(paddusw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubb, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubb(a, x, y);
(psubb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubb(a, (void *)a, y);
(psubb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubw(a, x, y);
(psubw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubw(a, (void *)a, y);
(psubw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubusw, fuzz) {
int i, j;
uint16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubusw(a, x, y);
(psubusw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubusw(a, (void *)a, y);
(psubusw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddusb, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddusb(a, x, y);
(paddusb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddusb(a, (void *)a, y);
(paddusb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubusb, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubusb(a, x, y);
(psubusb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubusb(a, (void *)a, y);
(psubusb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pabsb, fuzz) {
int i, j;
int8_t x[16];
uint8_t a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
pabsb(a, x);
(pabsb)(b, x);
ASSERT_EQ(0, memcmp(a, b, 16), "%d\n\t%#.16hhs\n\t%#.16hhs\n\t%#.16hhs", i,
x, a, b);
}
}
TEST(pabsw, fuzz) {
int i, j;
int16_t x[8];
uint16_t a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
pabsw(a, x);
(pabsw)(b, x);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pabsd, fuzz) {
int i, j;
int32_t x[4];
uint32_t a[4], b[4];
x[0] = INT_MIN;
pabsd((uint32_t *)x, x);
EXPECT_EQ(INT_MIN, x[0]);
x[0] = INT_MIN;
(pabsd)((uint32_t *)x, x);
EXPECT_EQ(INT_MIN, x[0]);
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
pabsd(a, x);
(pabsd)(b, x);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psignb, fuzz) {
int i, j;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psignb(a, x, y);
(psignb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psignb(a, (void *)a, y);
(psignb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psignw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psignw(a, x, y);
(psignw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psignw(a, (void *)a, y);
(psignw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psignd, fuzz) {
int i, j;
int32_t x[4], y[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psignd(a, x, y);
(psignd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psignd(a, (void *)a, y);
(psignd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psignd, testBane) {
int32_t x[4] = {INT_MIN, INT_MIN, INT_MIN, INT_MIN};
int32_t y[4] = {0, 1, -1, INT_MIN};
psignd(x, x, y);
EXPECT_EQ(0, x[0]);
EXPECT_EQ(INT_MIN, x[1]);
EXPECT_EQ(INT_MIN, x[2]);
EXPECT_EQ(INT_MIN, x[3]);
}
TEST(paddb, fuzz) {
int i, j;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddb(a, x, y);
(paddb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddb(a, (void *)a, y);
(paddb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddsb, fuzz) {
int i, j;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddsb(a, x, y);
(paddsb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddsb(a, (void *)a, y);
(paddsb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddsw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddsw(a, x, y);
(paddsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddsw(a, (void *)a, y);
(paddsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubsb, fuzz) {
int i, j;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubsb(a, x, y);
(psubsb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubsb(a, (void *)a, y);
(psubsb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psubsw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psubsw(a, x, y);
(psubsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psubsw(a, (void *)a, y);
(psubsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(paddd, fuzz) {
int i, j;
uint32_t x[4], y[4], a[4], b[4];
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
x[0] = 0x7fffffff;
y[0] = 0x7fffffff;
(paddd)(b, x, y);
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
paddd(a, x, y);
(paddd)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
paddd(a, (void *)a, y);
(paddd)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pshufb, fuzz) {
int i, j;
uint8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pshufb(a, x, y);
(pshufb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pshufb(a, (void *)a, y);
(pshufb)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pshufd, fuzz) {
int i, j;
int32_t x[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 4; ++j) x[j] = Rando();
#define T(IMM) \
pshufd(a, x, IMM); \
(pshufd)(b, x, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16)); \
pshufd(a, (void *)a, IMM); \
(pshufd)(b, (void *)b, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16))
T(0b00000011);
T(0b00000110);
T(0b00001100);
T(0b00011000);
T(0b00110000);
T(0b01100000);
T(0b11000000);
T(0b10000000);
#undef T
}
}
TEST(pshuflw, fuzz) {
int i, j;
int16_t x[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 8; ++j) x[j] = Rando();
#define T(IMM) \
pshuflw(a, x, IMM); \
(pshuflw)(b, x, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16)); \
pshuflw(a, (void *)a, IMM); \
(pshuflw)(b, (void *)b, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16))
T(0b00000011);
T(0b00000110);
T(0b00001100);
T(0b00011000);
T(0b00110000);
T(0b01100000);
T(0b11000000);
T(0b10000000);
#undef T
}
}
TEST(pshufhw, fuzz) {
int i, j;
int16_t x[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 8; ++j) x[j] = Rando();
#define T(IMM) \
pshufhw(a, x, IMM); \
(pshufhw)(b, x, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16)); \
pshufhw(a, (void *)a, IMM); \
(pshufhw)(b, (void *)b, IMM); \
ASSERT_EQ(0, memcmp(a, b, 16))
T(0b00000011);
T(0b00000110);
T(0b00001100);
T(0b00011000);
T(0b00110000);
T(0b01100000);
T(0b11000000);
T(0b10000000);
#undef T
}
}
TEST(packuswb, test) {
const short S[8] = {0, 128, -128, 255, SHRT_MAX, SHRT_MIN, 0, 0};
unsigned char B[16] = {0};
packuswb(B, S, S);
ASSERT_EQ(0, B[0]);
ASSERT_EQ(128, B[1]);
ASSERT_EQ(0, B[2]);
ASSERT_EQ(255, B[3]);
ASSERT_EQ(255, B[4]);
ASSERT_EQ(0, B[5]);
ASSERT_EQ(0, B[6]);
ASSERT_EQ(0, B[7]);
ASSERT_EQ(0, B[8]);
ASSERT_EQ(128, B[9]);
ASSERT_EQ(0, B[10]);
ASSERT_EQ(255, B[11]);
ASSERT_EQ(255, B[12]);
ASSERT_EQ(0, B[13]);
ASSERT_EQ(0, B[14]);
ASSERT_EQ(0, B[15]);
}
TEST(packsswb, test) {
const short S[8] = {0, 128, -128, 255, SHRT_MAX, SHRT_MIN, 0, 0};
signed char B[16] = {0};
packsswb(B, S, S);
ASSERT_EQ(0, B[0]);
ASSERT_EQ(127, B[1]);
ASSERT_EQ(-128, B[2]);
ASSERT_EQ(127, B[3]);
ASSERT_EQ(127, B[4]);
ASSERT_EQ(-128, B[5]);
ASSERT_EQ(0, B[6]);
ASSERT_EQ(0, B[7]);
ASSERT_EQ(0, B[8]);
ASSERT_EQ(127, B[9]);
ASSERT_EQ(-128, B[10]);
ASSERT_EQ(127, B[11]);
ASSERT_EQ(127, B[12]);
ASSERT_EQ(-128, B[13]);
ASSERT_EQ(0, B[14]);
ASSERT_EQ(0, B[15]);
}
TEST(packssdw, testAlias) {
int i, j;
union {
int16_t out[8];
int32_t in1[4];
} u;
int16_t a[8], b[8];
int32_t x[4], y[4];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
memcpy(u.in1, x, sizeof(x));
packssdw(u.out, u.in1, y);
memcpy(a, u.out, sizeof(u.out));
memcpy(u.in1, x, sizeof(x));
(packssdw)(u.out, u.in1, y);
memcpy(b, u.out, sizeof(u.out));
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(packusdw, test) {
int i, j;
int32_t x[4], y[4];
uint16_t a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
packusdw(a, x, y);
(packusdw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(packuswb, fuzz) {
int i, j;
int16_t x[8], y[8];
uint8_t a[16], b[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
packuswb(a, x, y);
(packuswb)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
packuswb(a, x, x);
(packuswb)(b, x, x);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(packssdw, test) {
int i, j;
int32_t x[4], y[4];
int16_t a[8], b[8];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
packssdw(a, x, y);
(packssdw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psllwv, fuzz) {
int i, j;
uint64_t y[2];
uint16_t x[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 8; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psllwv(a, x, y);
(psllwv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psllwv(a, (void *)a, y);
(psllwv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pslldv, fuzz) {
int i, j;
uint64_t y[2];
uint32_t x[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 4; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
pslldv(a, x, y);
(pslldv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pslldv(a, (void *)a, y);
(pslldv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psllqv, fuzz) {
int i, j;
uint64_t y[2];
uint64_t x[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psllqv(a, x, y);
(psllqv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psllqv(a, (void *)a, y);
(psllqv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrlwv, fuzz) {
int i, j;
uint64_t y[2];
uint16_t x[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 8; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psrlwv(a, x, y);
(psrlwv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psrlwv(a, (void *)a, y);
(psrlwv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrldv, fuzz) {
int i, j;
uint64_t y[2];
uint32_t x[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 4; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psrldv(a, x, y);
(psrldv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psrldv(a, (void *)a, y);
(psrldv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrlqv, fuzz) {
int i, j;
uint64_t y[2];
uint64_t x[2], a[2], b[2];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 2; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psrlqv(a, x, y);
(psrlqv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psrlqv(a, (void *)a, y);
(psrlqv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psrawv, fuzz) {
int i, j;
uint64_t y[2];
int16_t x[8], a[8], b[8];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 8; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psrawv(a, x, y);
(psrawv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psrawv(a, (void *)a, y);
(psrawv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(psradv, fuzz) {
int i, j;
uint64_t y[2];
int32_t x[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 4; ++j) x[j] = Rando();
for (j = 0; j < 2; ++j) y[j] = Rando() % 64;
psradv(a, x, y);
(psradv)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
psradv(a, (void *)a, y);
(psradv)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
// // TODO(jart): Fix me. on low power cpus.
// TEST(psrldq, fuzz) {
// int i, n;
// uint8_t x[16], a[16], b[16];
// for (i = 0; i < 100; ++i) {
// memset(a, -1, sizeof(a));
// memset(b, -1, sizeof(b));
// RngSet(x, sizeof(x));
// n = Rando() % 20;
// psrldq(a, x, n);
// (psrldq)(b, x, n);
// ASSERT_EQ(0, memcmp(a, b, 16), "%d\n\t%#.16hhs\n\t%#.16hhs\n\t%#.16hhs",
// n, x, a, b);
// n = Rando() % 20;
// psrldq(a, a, n);
// (psrldq)(b, b, n);
// ASSERT_EQ(0, memcmp(a, b, 16), "%d\n\t%#.16hhs\n\t%#.16hhs\n\t%#.16hhs",
// n, x, a, b);
// }
// }
TEST(pslldq, fuzz) {
int i, n;
uint8_t x[16], a[16], b[16];
for (i = 0; i < 100; ++i) {
memset(a, -1, sizeof(a));
memset(b, -1, sizeof(b));
RngSet(x, sizeof(x));
n = Rando() % 20;
pslldq(a, x, n);
(pslldq)(b, x, n);
ASSERT_EQ(0, memcmp(a, b, 16), "%d\n\t%#.16hhs\n\t%#.16hhs\n\t%#.16hhs", n,
x, a, b);
n = Rando() % 20;
pslldq(a, a, n);
(pslldq)(b, b, n);
ASSERT_EQ(0, memcmp(a, b, 16), "%d\n\t%#.16hhs\n\t%#.16hhs\n\t%#.16hhs", n,
x, a, b);
}
}
TEST(psadbw, test) {
int i, j;
uint64_t a[2], b[2];
uint8_t x[16], y[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
psadbw(a, x, y);
(psadbw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pmulhrsw, fuzz) {
int i, j;
int16_t x[8], y[8], a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmulhrsw(a, x, y);
(pmulhrsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmulhrsw(a, (void *)a, y);
(pmulhrsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(mpsadbw, fuzz) {
int i, j;
uint16_t a[8], b[8];
uint8_t x[16], y[16];
for (i = 0; i < 100; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
for (j = 0; j < 8; ++j) {
mpsadbw(a, x, y, j);
(mpsadbw)(b, x, y, j);
ASSERT_EQ(0, memcmp(a, b, 16), "%d %d", i, j);
}
}
}
TEST(pmaddubsw, fuzz) {
int i, j;
int8_t y[16];
uint8_t x[16];
int16_t a[8], b[8];
for (i = 0; i < 1000; ++i) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
pmaddubsw(a, x, y);
(pmaddubsw)(b, x, y);
ASSERT_EQ(0, memcmp(a, b, 16));
pmaddubsw(a, (void *)a, y);
(pmaddubsw)(b, (void *)b, y);
ASSERT_EQ(0, memcmp(a, b, 16));
}
}
TEST(pshufw, fuzz) {
int i, j;
uint8_t y;
int16_t x[4], a[4], b[4];
for (i = 0; i < 100; ++i) {
for (j = 0; j < 4; ++j) x[j] = Rando();
pshufw(a, x, 0b10111111);
(pshufw)(b, x, 0b10111111);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, (void *)a, 0b10111111);
(pshufw)(b, (void *)b, 0b10111111);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b00001000);
(pshufw)(b, x, 0b00001000);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b00010001);
(pshufw)(b, x, 0b00010001);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b01110100);
(pshufw)(b, x, 0b01110100);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b01101101);
(pshufw)(b, x, 0b01101101);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b10011011);
(pshufw)(b, x, 0b10011011);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b10111000);
(pshufw)(b, x, 0b10111000);
ASSERT_EQ(0, memcmp(a, b, 8));
pshufw(a, x, 0b11000111);
(pshufw)(b, x, 0b11000111);
ASSERT_EQ(0, memcmp(a, b, 8));
}
}
TEST(pcmpeqw, test2) {
int16_t kNumbers16[] = {0, 1, 2, 123, 0xffff, 0xfffe, 0x8000, 0x8001, 0x8080};
int i, j, k;
int16_t a[8], b[8], x[8], y[8];
for (i = 0; i < ARRAYLEN(kNumbers16); ++i) {
for (j = 0; j < ARRAYLEN(kNumbers16); ++j) {
for (k = 0; k < 8; ++k) {
x[k] = kNumbers16[(i + k) % ARRAYLEN(kNumbers16)];
y[k] = kNumbers16[(j + k) % ARRAYLEN(kNumbers16)];
}
pcmpeqw(a, x, y);
(pcmpeqw)(b, x, y);
EXPECT_EQ(0, memcmp(a, b, 16));
}
}
}
TEST(pdep, fuzz) {
int i;
uint64_t x, y;
for (i = 0; i < 1000; ++i) {
x = _rand64();
y = _rand64();
ASSERT_EQ(pdep(x, y), (pdep)(x, y));
}
}
TEST(pext, fuzz) {
int i;
uint64_t x, y;
for (i = 0; i < 1000; ++i) {
x = _rand64();
y = _rand64();
ASSERT_EQ(pext(x, y), (pext)(x, y));
}
}
TEST(palignr, fuzz) {
int i, imm;
int8_t x[16], y[16], a[16], b[16];
for (i = 0; i < 50; ++i) {
for (imm = 0; imm < 32; ++imm) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
memcpy(a, x, 16);
memcpy(b, y, 16);
palignr(a, a, b, imm);
(palignr)(x, x, y, imm);
ASSERT_EQ(0, memcmp(a, x, 16));
ASSERT_EQ(0, memcmp(b, y, 16));
}
}
}
TEST(shufps, fuzz) {
int i, imm;
char x[16], y[16], a[16], b[16];
for (i = 0; i < 20; ++i) {
for (imm = 0; imm < 256; ++imm) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
memcpy(a, x, 16);
memcpy(b, y, 16);
shufps((void *)a, (void *)a, (void *)b, imm);
(shufps)((void *)x, (void *)x, (void *)y, imm);
ASSERT_EQ(0, memcmp(a, x, 16));
ASSERT_EQ(0, memcmp(b, y, 16));
}
}
}
TEST(shufpd, fuzz) {
int i, imm;
char x[16], y[16], a[16], b[16];
for (i = 0; i < 20; ++i) {
for (imm = 0; imm < 256; ++imm) {
RngSet(x, sizeof(x));
RngSet(y, sizeof(y));
memcpy(a, x, 16);
memcpy(b, y, 16);
shufpd((void *)a, (void *)a, (void *)b, imm);
(shufpd)((void *)x, (void *)x, (void *)y, imm);
ASSERT_EQ(0, memcmp(a, x, 16),
"imm=%d\n\t"
"a=%.*hhs\n\t"
"x=%.*hhs",
imm, 16, a, 16, x);
ASSERT_EQ(0, memcmp(b, y, 16), "imm=%d", imm);
}
}
}
| 51,338 | 2,183 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/memmove_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/macros.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
static void *golden(void *a, const void *b, size_t n) {
size_t i;
char *d = a;
const char *s = b;
if (d > s) {
for (i = n; i--;) {
d[i] = s[i];
}
} else {
for (i = 0; i < n; ++i) {
d[i] = s[i];
}
}
return d;
}
TEST(memmove, hug) {
char *a, *b, *c;
int i, o1, o2;
int N[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 31, 32, 33, 63, 64, 65, 80, 81, 1000, 1024, 1025};
a = gc(malloc(1104));
b = gc(malloc(1104));
for (o1 = 0; o1 < 48; ++o1) {
for (o2 = 0; o2 < 48; ++o2) {
for (i = 0; i < ARRAYLEN(N); ++i) {
rngset(a, 1104, 0, 0);
memcpy(b, a, 1104);
ASSERT_EQ(a + o2, golden(a + o2, a + o1, N[i]));
ASSERT_EQ(b + o2, memmove(b + o2, b + o1, N[i]));
ASSERT_EQ(0, timingsafe_bcmp(a, b, 1104), "%d %d %d", o1, o2, i);
}
}
}
}
TEST(memmove, bighug) {
char *a, *b, *c;
int i, o1, o2;
int N[] = {5 * 1024 * 1024};
a = gc(malloc(6291456));
b = gc(malloc(6291456));
for (o1 = 0; o1 < 40; o1 += 20) {
for (o2 = 0; o2 < 40; o2 += 20) {
for (i = 0; i < ARRAYLEN(N); ++i) {
rngset(a, 6291456, 0, 0);
memcpy(b, a, 6291456);
ASSERT_EQ(a + o2, golden(a + o2, a + o1, N[i]));
ASSERT_EQ(b + o2, memmove(b + o2, b + o1, N[i]), "%d", N[i]);
ASSERT_EQ(0, timingsafe_bcmp(a, b, 6291456), "%d %d %d", o1, o2, i);
}
}
}
}
BENCH(memmove, bench) {
volatile char *r;
int n, max = 128 * 1024 * 1024;
char *volatile p = gc(calloc(max, 1));
char *volatile q = gc(calloc(max, 1));
EZBENCH_N("memmove", 0, memmove(p, q, 0));
for (n = 0; n < 127; ++n) {
EZBENCH_N("memmove", n, r = memmove(p, q, n));
}
for (n = 128; n <= max; n *= 2) {
EZBENCH_N("memmove", n - 1, r = memmove(p, q, n - 1));
EZBENCH_N("memmove", n, r = memmove(p, q, n));
}
for (n = 500; n <= 1000; n += 100) {
EZBENCH_N("memmove", n, r = memmove(p, q, n));
}
}
| 4,101 | 101 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/division_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#define L(x) ((int64_t)(x))
#define S(x) ((int128_t)(x))
#define U(x) ((uint128_t)(x))
TEST(division, testUnsigned) {
volatile uint128_t x;
x = U(1000000000123123123);
EXPECT_EQ(U(20769187431582143), (U(1125899906842624) << 64) / x);
x = U(42);
EXPECT_EQ((U(26807140639110) << 64) | U(1756832768924719201),
(U(1125899906842624) << 64) / x);
}
TEST(division, testSigned) {
volatile int128_t x;
x = S(1000000000123123123);
EXPECT_EQ(S(20769187431582143), (S(1125899906842624) << 64) / x);
x = S(42);
EXPECT_EQ(S(26807140639110) << 64 | S(1756832768924719201),
(S(1125899906842624) << 64) / x);
}
| 2,575 | 44 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/formatint32_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/fmt/itoa.h"
#include "libc/limits.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(FormatInt32, test) {
char b[12];
EXPECT_STREQ("", FormatInt32(b, 0));
EXPECT_STREQ("0", b);
EXPECT_STREQ("", FormatInt32(b, INT32_MAX));
EXPECT_STREQ("2147483647", b);
EXPECT_STREQ("", FormatInt32(b, INT32_MIN));
EXPECT_STREQ("-2147483648", b);
}
TEST(FormatInt64, test) {
char b[21];
EXPECT_STREQ("", FormatInt64(b, 0));
EXPECT_STREQ("0", b);
EXPECT_STREQ("", FormatInt64(b, INT64_MAX));
EXPECT_STREQ("9223372036854775807", b);
EXPECT_STREQ("", FormatInt64(b, INT64_MIN));
EXPECT_STREQ("-9223372036854775808", b);
}
BENCH(FormatInt, bench) {
char b[21];
EZBENCH2("FormatUint32 max32", donothing, FormatUint32(b, INT_MAX));
EZBENCH2("FormatUint64 max32", donothing, FormatUint64(b, INT_MAX));
EZBENCH2("FormatInt32 min32", donothing, FormatInt32(b, INT_MIN));
EZBENCH2("FormatInt64 min32", donothing, FormatInt64(b, INT_MIN));
EZBENCH2("FormatInt32 max32", donothing, FormatInt32(b, INT_MAX));
EZBENCH2("FormatInt64 max32", donothing, FormatInt64(b, INT_MAX));
}
| 2,969 | 53 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/strchr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(strchr, blank) {
const char *const blank = "";
EXPECT_EQ(NULL, strchr(blank, '#'));
EXPECT_EQ(blank, strchr(blank, '\0'));
}
TEST(strchr, text) {
char buf[] = "hellothere";
EXPECT_STREQ("there", strchr(buf, 't'));
}
TEST(strchr, testsse) {
char buf[] = "hellohellohellohellohellohellohellohello"
"theretheretheretheretheretheretherethere";
EXPECT_STREQ("theretheretheretheretheretheretherethere", strchr(buf, 't'));
}
TEST(rawmemchr, text) {
char buf[] = "hellothere";
EXPECT_STREQ("there", rawmemchr(buf, 't'));
}
TEST(strchrnul, text) {
char buf[] = "hellothere";
EXPECT_STREQ("there", strchrnul(buf, 't'));
}
TEST(strchr, nulTerminator) {
char buf[] = "hellothere";
EXPECT_STREQ("", strchr(buf, '\0'));
}
TEST(rawmemchr, nulTerminator) {
char buf[] = "hellothere";
EXPECT_STREQ("", rawmemchr(buf, '\0'));
}
TEST(strchrnul, nulTerminator) {
char buf[] = "hellothere";
EXPECT_STREQ("", strchrnul(buf, '\0'));
}
TEST(strchr, notFound_returnsNul) {
char buf[] = "hellothere";
EXPECT_EQ(NULL, strchr(buf, 'z'));
}
TEST(strchrnul, notFound_returnsPointerToNulByte) {
char buf[] = "hi";
EXPECT_STREQ("", strchrnul(buf, 'z'));
EXPECT_EQ(&buf[2], strchrnul(buf, 'z'));
}
char *strchr_pure(const char *s, int c) {
char *r;
for (c &= 0xff;; ++s) {
if ((*s & 0xff) == c) return (char *)s;
if (!*s) return NULL;
}
}
TEST(strchr, fuzz) {
char *p;
int i, j;
p = calloc(1, 64);
for (i = -2; i < 257; ++i) {
for (j = 0; j < 17; ++j) {
rngset(p, 63, rdseed, -1);
ASSERT_EQ(strchr_pure(p + j, i), strchr(p + j, i));
}
}
free(p);
}
BENCH(strchr, bench) {
EZBENCH2("strchr 0", donothing, EXPROPRIATE(strchr(VEIL("r", ""), 0)));
EZBENCH2("strchr 5", donothing, EXPROPRIATE(strchr(VEIL("r", "hello"), 'o')));
EZBENCH2("strchr 8", donothing,
EXPROPRIATE(strchr(VEIL("r", "hellzzzo"), 'o')));
EZBENCH2("strchr 17", donothing,
EXPROPRIATE(strchr(VEIL("r", "hellzzzhellzzzeeo"), 'o')));
EZBENCH2("strchr 34", donothing,
EXPROPRIATE(
strchr(VEIL("r", "hellzzzhellzzzeeAhellzzzhellzzzeeo"), 'o')));
}
char *memchr_pure(const char *m, int c, size_t n) {
const unsigned char *p, *pe;
for (c &= 0xff, p = (const unsigned char *)m, pe = p + n; p < pe; ++p) {
if (*p == c) return p;
}
return NULL;
}
TEST(memchr, fuzz) {
char *p;
int i, j;
p = malloc(64);
for (i = -2; i < 257; ++i) {
for (j = 0; j < 17; ++j) {
rngset(p, 64, _rand64, -1);
ASSERT_EQ(memchr(p + j, i, 64 - j), memchr_pure(p + j, i, 64 - j));
}
}
free(p);
}
char *strchrnul_pure(const char *s, int c) {
char *r;
for (c &= 0xff;; ++s) {
if ((*s & 0xff) == c) return (char *)s;
if (!*s) return s;
}
}
TEST(strchrnul, fuzz) {
char *p;
int i, j;
p = calloc(1, 64);
for (i = -2; i < 257; ++i) {
for (j = 0; j < 17; ++j) {
rngset(p, 63, _rand64, -1);
ASSERT_EQ(strchrnul(p + j, i), strchrnul_pure(p + j, i));
}
}
free(p);
}
void *rawmemchr_pure(const void *m, int c) {
const unsigned char *s;
for (c &= 255, s = m;; ++s) {
if (*s == c) return s;
}
}
TEST(rawmemchr, fuzz) {
char *p;
int i, j;
p = malloc(64);
for (i = -2; i < 257; ++i) {
for (j = 0; j < 17; ++j) {
rngset(p, 63, _rand64, -1);
p[63] = i;
ASSERT_EQ(rawmemchr(p + j, i), rawmemchr_pure(p + j, i));
}
}
free(p);
}
/*
* strchr 0 l: 10c 3ns m: 38c 12ns
* strchr 5 l: 13c 4ns m: 42c 14ns
* strchr 8 l: 14c 5ns m: 44c 14ns
* strchr 17 l: 13c 4ns m: 45c 15ns
* strchr 34 l: 16c 5ns m: 48c 16ns
* strchr z l: 369c 119ns m: 408c 132ns
* rawmemchr z l: 236c 76ns m: 391c 126ns
* memchr z l: 357c 115ns m: 423c 137ns
* strchr Z l: 1,872c 605ns m: 1,911c 617ns
* rawmemchr \0 l: 1,184c 382ns m: 1,880c 607ns
* strlen l: 1,174c 379ns m: 1,237c 400ns
* memchr Z l: 1,866c 603ns m: 1,945c 628ns
* strchrnul z l: 365c 118ns m: 408c 132ns
* strchrnul Z l: 1,871c 604ns m: 1,914c 618ns
*/
BENCH(strchr, bench2) {
char *strchr_(const char *, int) asm("strchr");
char *strchrnul_(const char *, int) asm("strchrnul");
char *memchr_(const char *, int, size_t) asm("memchr");
char *strlen_(const char *) asm("strlen");
char *rawmemchr_(const char *, int) asm("rawmemchr");
EZBENCH2("strchr z", donothing, strchr_(kHyperion, 'z'));
EZBENCH2("strchr Z", donothing, strchr_(kHyperion, 'Z'));
EZBENCH2("memchr z", donothing, memchr_(kHyperion, 'z', kHyperionSize));
EZBENCH2("memchr Z", donothing, memchr_(kHyperion, 'Z', kHyperionSize));
EZBENCH2("rawmemchr z", donothing, rawmemchr_(kHyperion, 'z'));
EZBENCH2("rawmemchr Z", donothing, rawmemchr_(kHyperion, 'z'));
EZBENCH2("rawmemchr \\0", donothing, rawmemchr_(kHyperion, 0));
EZBENCH2("strlen", donothing, strlen_(kHyperion));
EZBENCH2("memchr Z", donothing, memchr_(kHyperion, 'Z', kHyperionSize));
EZBENCH2("strchrnul z", donothing, strchrnul_(kHyperion, 'z'));
EZBENCH2("strchrnul Z", donothing, strchrnul_(kHyperion, 'Z'));
}
| 7,635 | 204 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/lock_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/atomic.h"
#include "libc/calls/calls.h"
#include "libc/calls/struct/timespec.h"
#include "libc/errno.h"
#include "libc/fmt/itoa.h"
#include "libc/intrin/atomic.h"
#include "libc/intrin/kprintf.h"
#include "libc/intrin/weaken.h"
#include "libc/runtime/clone.internal.h"
#include "libc/runtime/internal.h"
#include "libc/runtime/runtime.h"
#include "libc/runtime/stack.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/clone.h"
#include "libc/thread/thread.h"
#include "libc/thread/tls.h"
#include "third_party/nsync/mu.h"
/**
* @fileoverview Austere Mutex Test
*
* 1. Tests what happens when *NSYNC isn't linked.
* 2. Tests what happens when TLS isn't enabled.
*
* If either:
*
* 1. malloc() isn't linked, or
* 2. we're in MODE=tiny
*
* Then we use Cosmopolitan's hand-rolled tiny locks. They're not
* scalable. They use a lot of CPU if you have lots of threads. But
* they're wicked fast and free of bloat if your app is tiny.
*/
atomic_int ready;
atomic_int counter;
atomic_int success;
pthread_mutex_t mu;
#define ASSERT_EQ(WANT, GOT) \
do { \
long _want = WANT, _got = GOT; \
if (_want != _got) \
__assert_eq_fail(__FILE__, __LINE__, #WANT, #GOT, _want, _got); \
} while (0)
void __assert_eq_fail(const char *file, int line, const char *wantstr,
const char *gotstr, long want, long got) {
kprintf("%s:%d: %s vs. %s was %ld vs. %ld (%s)\n", file, line, wantstr,
gotstr, want, got, !(got & ~255) ? _strerrno(got) : "n/a");
_Exit(1);
}
double time2dbl(struct timespec t) {
return (((double)t.tv_sec) + ((double)t.tv_nsec * 1e-9));
}
char *time2str(double s) {
static char buf[32];
static const struct {
const char *suffix;
double multiplier;
} scale[] = {
{"ns", 1.0e-9}, //
{"us", 1e-6}, //
{"ms", 1e-3}, //
{"s", 1.0}, //
{"hr", 3600.0}, //
};
int i = 0;
while (i + 1 != sizeof(scale) / sizeof(scale[0]) &&
scale[i + 1].multiplier <= s) {
i++;
}
stpcpy(FormatInt32(buf, s / scale[i].multiplier), scale[i].suffix);
return buf;
}
int Worker(void *arg) {
int i, x;
atomic_store(&ready, 1);
for (i = 0; i < 10000; ++i) {
ASSERT_EQ(0, pthread_mutex_lock(&mu));
x = atomic_load_explicit(&counter, memory_order_relaxed);
atomic_store_explicit(&counter, x + 1, memory_order_relaxed);
ASSERT_EQ(x + 1, atomic_load_explicit(&counter, memory_order_relaxed));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
}
atomic_store(&success, 1);
return 0;
}
void TestContendedLock(const char *name, int kind) {
char *stk;
double ns;
errno_t rc;
struct timespec t1, t2;
pthread_mutexattr_t attr;
int tid, x, i, n = 10000;
struct CosmoTib tib = {.tib_self = &tib, .tib_self2 = &tib, .tib_tid = -1};
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, kind);
pthread_mutex_init(&mu, &attr);
pthread_mutexattr_destroy(&attr);
atomic_store(&ready, 0);
atomic_store(&success, 0);
stk = _mapstack();
rc = clone(Worker, stk, GetStackSize() - 16 /* openbsd:stackbound */,
CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
CLONE_SYSVSEM | CLONE_PARENT_SETTID | CLONE_CHILD_SETTID |
CLONE_CHILD_CLEARTID | CLONE_SETTLS,
0, &tid, &tib, &tib.tib_tid);
if (rc) {
kprintf("clone failed: %s\n", strerror(rc));
_Exit(1);
}
while (!atomic_load(&ready)) donothing;
t1 = timespec_real();
for (i = 0; i < n; ++i) {
ASSERT_EQ(0, pthread_mutex_lock(&mu));
x = atomic_load_explicit(&counter, memory_order_relaxed);
atomic_store_explicit(&counter, x - 1, memory_order_relaxed);
ASSERT_EQ(x - 1, atomic_load_explicit(&counter, memory_order_relaxed));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
}
t2 = timespec_real();
while (tib.tib_tid) donothing;
ASSERT_EQ(1, atomic_load(&success));
ASSERT_EQ(0, atomic_load(&counter));
_freestack(stk);
ASSERT_EQ(0, pthread_mutex_destroy(&mu));
ns = time2dbl(timespec_sub(t2, t1)) / n;
kprintf("%s contended took %s\n", name, time2str(ns));
}
void TestUncontendedLock(const char *name, int kind) {
double ns;
long i, n = 10000;
struct timespec t1, t2;
pthread_mutex_t lock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, kind);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
t1 = timespec_real();
for (i = 0; i < n; ++i) {
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);
}
t2 = timespec_real();
pthread_mutex_destroy(&lock);
ns = time2dbl(timespec_sub(t2, t1)) / n;
kprintf("%s took %s\n", name, time2str(ns));
}
int main(int argc, char *argv[]) {
pthread_mutexattr_t attr;
if (_weaken(nsync_mu_lock)) {
kprintf("*NSYNC should not be linked\n");
_Exit(1);
}
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL));
ASSERT_EQ(0, pthread_mutex_init(&mu, &attr));
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
ASSERT_EQ(0, pthread_mutex_lock(&mu));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
ASSERT_EQ(0, pthread_mutex_destroy(&mu));
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
ASSERT_EQ(0, pthread_mutex_init(&mu, &attr));
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
ASSERT_EQ(0, pthread_mutex_lock(&mu));
ASSERT_EQ(0, pthread_mutex_lock(&mu));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
ASSERT_EQ(0, pthread_mutex_destroy(&mu));
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK));
ASSERT_EQ(0, pthread_mutex_init(&mu, &attr));
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
ASSERT_EQ(0, pthread_mutex_lock(&mu));
ASSERT_EQ(EDEADLK, pthread_mutex_lock(&mu));
ASSERT_EQ(0, pthread_mutex_unlock(&mu));
ASSERT_EQ(0, pthread_mutex_destroy(&mu));
ASSERT_EQ(1, __tls_enabled);
TestUncontendedLock("PTHREAD_MUTEX_NORMAL RAW TLS", PTHREAD_MUTEX_NORMAL);
TestUncontendedLock("PTHREAD_MUTEX_RECURSIVE RAW TLS",
PTHREAD_MUTEX_RECURSIVE);
TestUncontendedLock("PTHREAD_MUTEX_ERRORCHECK RAW TLS",
PTHREAD_MUTEX_ERRORCHECK);
TestContendedLock("PTHREAD_MUTEX_NORMAL RAW TLS", PTHREAD_MUTEX_NORMAL);
TestContendedLock("PTHREAD_MUTEX_RECURSIVE RAW TLS", PTHREAD_MUTEX_RECURSIVE);
TestContendedLock("PTHREAD_MUTEX_ERRORCHECK RAW TLS",
PTHREAD_MUTEX_ERRORCHECK);
__tls_enabled_set(false);
TestUncontendedLock("PTHREAD_MUTEX_NORMAL RAW", PTHREAD_MUTEX_NORMAL);
TestUncontendedLock("PTHREAD_MUTEX_RECURSIVE RAW", PTHREAD_MUTEX_RECURSIVE);
TestUncontendedLock("PTHREAD_MUTEX_ERRORCHECK RAW", PTHREAD_MUTEX_ERRORCHECK);
TestContendedLock("PTHREAD_MUTEX_NORMAL RAW", PTHREAD_MUTEX_NORMAL);
TestContendedLock("PTHREAD_MUTEX_RECURSIVE RAW", PTHREAD_MUTEX_RECURSIVE);
TestContendedLock("PTHREAD_MUTEX_ERRORCHECK RAW", PTHREAD_MUTEX_ERRORCHECK);
//
}
| 9,137 | 235 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/bitreverse_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/intrin/bits.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
TEST(_bitreverse, test) {
EXPECT_EQ(0xde, _bitreverse8(123));
EXPECT_EQ(0xde00, _bitreverse16(123));
EXPECT_EQ(0xde000000u, _bitreverse32(123));
EXPECT_EQ(0xde00000000000000ul, _bitreverse64(123));
EXPECT_EQ(0x482d96c305f7c697ul, _bitreverse64(0xe963efa0c369b412));
}
BENCH(_bitreverse, bench) {
EZBENCH2("_bitreverse8", donothing,
EXPROPRIATE(_bitreverse8(CONCEAL("r", 123))));
EZBENCH2("_bitreverse32", donothing,
EXPROPRIATE(_bitreverse32(CONCEAL("r", 123))));
EZBENCH2("_bitreverse64", donothing,
EXPROPRIATE(_bitreverse64(CONCEAL("r", 123))));
}
| 2,638 | 44 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/palignr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/palignr.h"
#include "libc/stdio/rand.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(palignr, testLeftpad) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {0};
palignr(C, B, A, 12);
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignr, testLeftpad_variableImmediate) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {0};
palignr(C, B, A, VEIL("r", 12));
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignr, test0) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
palignr(C, B, A, 0);
ASSERT_EQ(1, C[0]);
ASSERT_EQ(2, C[1]);
ASSERT_EQ(3, C[2]);
ASSERT_EQ(4, C[3]);
}
TEST(palignr, test4) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
palignr(C, B, A, 4);
ASSERT_EQ(2, C[0]);
ASSERT_EQ(3, C[1]);
ASSERT_EQ(4, C[2]);
ASSERT_EQ(5, C[3]);
}
TEST(palignr, test12) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
palignr(C, B, A, 12);
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignr, test16) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
palignr(C, B, A, 16);
ASSERT_EQ(5, C[0]);
ASSERT_EQ(6, C[1]);
ASSERT_EQ(7, C[2]);
ASSERT_EQ(8, C[3]);
}
TEST(palignr, test20) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {-1, -1, -1, -1};
palignr(C, B, A, 20);
ASSERT_EQ(6, C[0]);
ASSERT_EQ(7, C[1]);
ASSERT_EQ(8, C[2]);
ASSERT_EQ(0, C[3]);
}
TEST(palignrc, testLeftpad) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {0};
(palignr)(C, B, A, 12);
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignrc, testLeftpad_variableImmediate) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {0};
(palignr)(C, B, A, VEIL("r", 12));
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignrc, test0) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
(palignr)(C, B, A, 0);
ASSERT_EQ(1, C[0]);
ASSERT_EQ(2, C[1]);
ASSERT_EQ(3, C[2]);
ASSERT_EQ(4, C[3]);
}
TEST(palignrc, test4) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
(palignr)(C, B, A, 4);
ASSERT_EQ(2, C[0]);
ASSERT_EQ(3, C[1]);
ASSERT_EQ(4, C[2]);
ASSERT_EQ(5, C[3]);
}
TEST(palignrc, test12) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
(palignr)(C, B, A, 12);
ASSERT_EQ(4, C[0]);
ASSERT_EQ(5, C[1]);
ASSERT_EQ(6, C[2]);
ASSERT_EQ(7, C[3]);
}
TEST(palignrc, test16) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4];
(palignr)(C, B, A, 16);
ASSERT_EQ(5, C[0]);
ASSERT_EQ(6, C[1]);
ASSERT_EQ(7, C[2]);
ASSERT_EQ(8, C[3]);
}
TEST(palignrc, test20) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {-1, -1, -1, -1};
(palignr)(C, B, A, 20);
ASSERT_EQ(6, C[0]);
ASSERT_EQ(7, C[1]);
ASSERT_EQ(8, C[2]);
ASSERT_EQ(0, C[3]);
}
TEST(palignr, test32orHigher_clearsOutput) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {-1, -1, -1, -1};
palignr(C, B, A, 32);
ASSERT_EQ(0, C[0]);
ASSERT_EQ(0, C[1]);
ASSERT_EQ(0, C[2]);
ASSERT_EQ(0, C[3]);
C[0] = 43;
palignr(C, B, A, 123);
ASSERT_EQ(0, C[0]);
ASSERT_EQ(0, C[1]);
ASSERT_EQ(0, C[2]);
ASSERT_EQ(0, C[3]);
}
TEST(palignrv, test32orHigher_clearsOutput) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {-1, -1, -1, -1};
palignr(C, B, A, VEIL("r", 32));
ASSERT_EQ(0, C[0]);
ASSERT_EQ(0, C[1]);
ASSERT_EQ(0, C[2]);
ASSERT_EQ(0, C[3]);
C[0] = 43;
palignr(C, B, A, VEIL("r", 123));
ASSERT_EQ(0, C[0]);
ASSERT_EQ(0, C[1]);
ASSERT_EQ(0, C[2]);
ASSERT_EQ(0, C[3]);
}
TEST(palignrc, test32orHigher_clearsOutput) {
const int A[4] = {1, 2, 3, 4};
const int B[4] = {5, 6, 7, 8};
int C[4] = {-1, -1, -1, -1};
(palignr)(C, B, A, 32);
ASSERT_EQ(0, C[0]);
ASSERT_EQ(0, C[1]);
ASSERT_EQ(0, C[2]);
ASSERT_EQ(0, C[3]);
}
| 6,206 | 222 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/describeflags_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/describeflags.internal.h"
#include "libc/macros.internal.h"
#include "libc/testlib/testlib.h"
static const struct DescribeFlags kFlags[] = {
{1, "hi"}, //
{2, "there"}, //
};
const char *DescribeIt(uint32_t x) {
static char s[64];
return DescribeFlags(s, ARRAYLEN(s), kFlags, ARRAYLEN(kFlags), "x", x);
}
TEST(describeflags, test) {
EXPECT_STREQ("0", DescribeIt(0));
EXPECT_STREQ("xhi", DescribeIt(1));
EXPECT_STREQ("xthere", DescribeIt(2));
EXPECT_STREQ("xhi|xthere", DescribeIt(3));
EXPECT_STREQ("xhi|xthere|0x14", DescribeIt(0x17));
}
| 2,426 | 40 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/putenv_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Gavin Arthur Hayes â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(putenv, test) {
EXPECT_EQ(0, clearenv());
EXPECT_EQ(0, putenv("hi=there"));
EXPECT_STREQ("there", getenv("hi"));
EXPECT_EQ(0, clearenv());
EXPECT_EQ(0, putenv("hi=theretwo"));
EXPECT_STREQ("theretwo", getenv("hi"));
EXPECT_EQ(0, clearenv());
EXPECT_EQ(0, setenv("hi", "therethree", 0));
EXPECT_STREQ("therethree", getenv("hi"));
}
TEST(putenv, usesProvidedMemory) {
char kv[32] = "hi=hello";
EXPECT_EQ(0, putenv(kv));
EXPECT_STREQ("hello", getenv("hi"));
strcpy(kv, "hi=there");
EXPECT_STREQ("there", getenv("hi"));
EXPECT_EQ(0, unsetenv("hi"));
EXPECT_EQ(0, unsetenv("hi"));
EXPECT_EQ(0, getenv("hi"));
EXPECT_EQ(0, clearenv());
}
TEST(putenv, keyonly) {
EXPECT_EQ(0, clearenv());
EXPECT_EQ(0, putenv("hi"));
EXPECT_STREQ("", getenv("hi"));
EXPECT_STREQ("hi", environ[0]);
EXPECT_EQ(0, environ[1]);
EXPECT_EQ(0, unsetenv("hi"));
EXPECT_EQ(0, getenv("hi"));
EXPECT_EQ(0, environ[0]);
EXPECT_EQ(0, environ[1]);
}
TEST(putenv, environ) {
char *s = strdup("hi=there");
EXPECT_EQ(0, clearenv());
EXPECT_EQ(0, putenv(s));
EXPECT_EQ(0, putenv(s));
EXPECT_EQ(s, environ[0]);
EXPECT_EQ(0, environ[1]);
EXPECT_EQ(0, clearenv());
free(s);
}
| 3,166 | 70 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/countbits_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/intrin/popcnt.h"
#include "libc/calls/calls.h"
#include "libc/mem/mem.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio", 0));
}
TEST(_countbits, testLow) {
int i;
char p[2];
for (i = 0; i < 65536; ++i) {
p[0] = i >> 0;
p[1] = i >> 8;
ASSERT_EQ(__builtin_popcount(i), _countbits(p, 2), "i=%d", i);
}
}
TEST(_countbits, test) {
int i;
char *p = gc(memset(malloc(256), 0x55, 256));
for (i = 0; i < 256; ++i) {
ASSERT_EQ(i * CHAR_BIT / 2, _countbits(p, i), "i=%d", i);
}
}
BENCH(countbits, bench) {
EZBENCH_N("_countbits", 7, _countbits(kHyperion, 7));
EZBENCH_N("_countbits", 8, _countbits(kHyperion, 8));
EZBENCH_N("_countbits", 16, _countbits(kHyperion, 16));
EZBENCH_N("_countbits", kHyperionSize, _countbits(kHyperion, kHyperionSize));
}
| 2,837 | 57 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/rounddown2pow_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/intrin/bits.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio", 0));
}
TEST(_rounddown2pow, test) {
EXPECT_EQ(0, _rounddown2pow(0));
EXPECT_EQ(1, _rounddown2pow(1));
EXPECT_EQ(2, _rounddown2pow(2));
EXPECT_EQ(2, _rounddown2pow(3));
EXPECT_EQ(4, _rounddown2pow(4));
EXPECT_EQ(PAGESIZE / 2, _rounddown2pow(PAGESIZE - 1));
EXPECT_EQ(PAGESIZE, _rounddown2pow(PAGESIZE));
EXPECT_EQ(PAGESIZE, _rounddown2pow(PAGESIZE + 1));
EXPECT_EQ(PAGESIZE / 2, _rounddown2pow(PAGESIZE - 1));
EXPECT_EQ(PAGESIZE, _rounddown2pow(PAGESIZE));
EXPECT_EQ(PAGESIZE, _rounddown2pow(PAGESIZE + 1));
}
| 2,521 | 40 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
PKGS += TEST_LIBC_INTRIN
TEST_LIBC_INTRIN_SRCS := $(wildcard test/libc/intrin/*.c)
TEST_LIBC_INTRIN_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_INTRIN_SRCS))
TEST_LIBC_INTRIN_OBJS = \
$(TEST_LIBC_INTRIN_SRCS:%.c=o/$(MODE)/%.o)
TEST_LIBC_INTRIN_COMS = \
$(TEST_LIBC_INTRIN_SRCS:%.c=o/$(MODE)/%.com)
TEST_LIBC_INTRIN_BINS = \
$(TEST_LIBC_INTRIN_COMS) \
$(TEST_LIBC_INTRIN_COMS:%=%.dbg)
TEST_LIBC_INTRIN_TESTS = \
$(TEST_LIBC_INTRIN_SRCS_TEST:%.c=o/$(MODE)/%.com.ok)
TEST_LIBC_INTRIN_CHECKS = \
$(TEST_LIBC_INTRIN_SRCS_TEST:%.c=o/$(MODE)/%.com.runs)
TEST_LIBC_INTRIN_DIRECTDEPS = \
LIBC_CALLS \
LIBC_FMT \
LIBC_INTRIN \
LIBC_LOG \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STDIO \
LIBC_STR \
LIBC_STUBS \
LIBC_SYSV \
LIBC_SYSV_CALLS \
LIBC_THREAD \
LIBC_TESTLIB \
LIBC_TINYMATH \
LIBC_X \
TOOL_VIZ_LIB \
THIRD_PARTY_COMPILER_RT \
THIRD_PARTY_NSYNC
TEST_LIBC_INTRIN_DEPS := \
$(call uniq,$(foreach x,$(TEST_LIBC_INTRIN_DIRECTDEPS),$($(x))))
o/$(MODE)/test/libc/intrin/intrin.pkg: \
$(TEST_LIBC_INTRIN_OBJS) \
$(foreach x,$(TEST_LIBC_INTRIN_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/libc/intrin/%.com.dbg: \
$(TEST_LIBC_INTRIN_DEPS) \
o/$(MODE)/test/libc/intrin/%.o \
o/$(MODE)/test/libc/intrin/intrin.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
# Test what happens when *NSYNC isn't linked.
o/$(MODE)/test/libc/intrin/lock_test.com.dbg: \
$(TEST_LIBC_INTRIN_DEPS) \
o/$(MODE)/test/libc/intrin/lock_test.o \
o/$(MODE)/test/libc/intrin/intrin.pkg \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
$(TEST_LIBC_INTRIN_OBJS): private \
OVERRIDE_CFLAGS += \
-fno-builtin
.PHONY: o/$(MODE)/test/libc/intrin
o/$(MODE)/test/libc/intrin: \
$(TEST_LIBC_INTRIN_BINS) \
$(TEST_LIBC_INTRIN_CHECKS)
| 2,105 | 79 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/roundup2pow_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/intrin/bits.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio", 0));
}
TEST(_roundup2pow, test) {
EXPECT_EQ(0, _roundup2pow(0));
EXPECT_EQ(1, _roundup2pow(1));
EXPECT_EQ(2, _roundup2pow(2));
EXPECT_EQ(4, _roundup2pow(3));
EXPECT_EQ(4, _roundup2pow(4));
EXPECT_EQ(PAGESIZE, _roundup2pow(PAGESIZE - 1));
EXPECT_EQ(PAGESIZE, _roundup2pow(PAGESIZE));
EXPECT_EQ(PAGESIZE * 2, _roundup2pow(PAGESIZE + 1));
EXPECT_EQ(PAGESIZE, _roundup2pow(PAGESIZE - 1));
EXPECT_EQ(PAGESIZE, _roundup2pow(PAGESIZE));
EXPECT_EQ(PAGESIZE * 2, _roundup2pow(PAGESIZE + 1));
}
| 2,497 | 40 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/fmax_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2023 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/testlib/testlib.h"
#include "third_party/libcxx/math.h"
TEST(fmax, test) {
EXPECT_TRUE(fmax(2., 3.) == 3.);
EXPECT_TRUE(fmax(3., 2.) == 3.);
EXPECT_TRUE(fmax(NAN, 3.) == 3.);
EXPECT_TRUE(fmax(NAN, -3.) == -3.);
EXPECT_TRUE(fmax(-NAN, 3.) == 3.);
EXPECT_TRUE(fmax(-NAN, -3.) == -3.);
EXPECT_TRUE(fmax(3., NAN) == 3.);
EXPECT_TRUE(fmax(-3., NAN) == -3.);
EXPECT_TRUE(fmax(3., -NAN) == 3.);
EXPECT_TRUE(fmax(-3., -NAN) == -3.);
EXPECT_TRUE(fmax(-0., +0.) == +0.);
EXPECT_TRUE(fmax(+0., -0.) == +0.);
}
| 2,375 | 36 | jart/cosmopolitan | false |
cosmopolitan/test/libc/intrin/lockipc_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/errno.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/kprintf.h"
#include "libc/macros.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/thread.h"
#define PROCESSES 8
#define ITERATIONS 100000
struct SharedMemory {
pthread_mutex_t mutex;
volatile long x;
} * shm;
void Worker(void) {
long t;
for (int i = 0; i < ITERATIONS; ++i) {
pthread_mutex_lock(&shm->mutex);
t = shm->x;
t += 1;
shm->x = t;
pthread_mutex_unlock(&shm->mutex);
}
}
TEST(lockipc, mutex) {
int e, rc, ws, pid;
// create shared memory
shm = _mapshared(FRAMESIZE);
// create shared mutex
pthread_mutexattr_t mattr;
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&shm->mutex, &mattr);
pthread_mutexattr_destroy(&mattr);
// create processes
for (int i = 0; i < PROCESSES; ++i) {
ASSERT_NE(-1, (rc = fork()));
if (!rc) {
Worker();
_Exit(0);
}
}
// wait for processes to finish
for (;;) {
e = errno;
if ((pid = waitpid(0, &ws, 0)) != -1) {
if (WIFSIGNALED(ws)) {
kprintf("process %d terminated with %G\n", pid, WTERMSIG(ws));
testlib_incrementfailed();
} else if (WEXITSTATUS(ws)) {
kprintf("process %d exited with %d\n", pid, WEXITSTATUS(ws));
testlib_incrementfailed();
}
} else {
ASSERT_EQ(ECHILD, errno);
errno = e;
break;
}
}
EXPECT_EQ(PROCESSES * ITERATIONS, shm->x);
ASSERT_EQ(0, pthread_mutex_destroy(&shm->mutex));
ASSERT_SYS(0, 0, munmap(shm, FRAMESIZE));
}
| 3,579 | 92 | jart/cosmopolitan | false |
cosmopolitan/test/libc/release/metal.sh | #!/bin/sh
# TODO(jart): Stack size increase probably broke this.
exit
if [ "$MODE" = dbg ]; then
exit # TODO
fi
if [ "$MODE" = opt ] || [ "$MODE" = optlinux ]; then
exit
fi
$MKDIR o/$MODE/test/libc/release/
# smoke test booting on bare metal and printing data to serial uart
CMD="o/$MODE/tool/build/blinkenlights.com.dbg -r o/$MODE/examples/hello.com"
if OUTPUT="$($CMD)"; then
if [ x"$OUTPUT" = x"hello world" ]; then
exit 0
else
printf '%s\n' "error: $CMD printed wrong output: $OUTPUT" >&2
exit 1
fi
else
RC=$?
printf '%s\n' "error: $CMD failed: $RC" >&2
exit $RC
fi
| 603 | 29 | jart/cosmopolitan | false |
cosmopolitan/test/libc/release/smoke.c | int main(int argc, char *argv[]) {
int rc;
char *s;
FILE *f;
ShowCrashReports();
s = strdup(argv[0]);
s[0] = 'Z';
f = fopen("/dev/null", "w");
fputs(_gc(xiso8601ts(NULL)), f);
fputs(_gc(xasprintf("hello world %d %s\n", argc, s)), f);
fclose(f);
free(s);
return 0;
}
| 290 | 15 | jart/cosmopolitan | false |
cosmopolitan/test/libc/release/emulate.sh | #!/bin/sh
if [ "$MODE" = dbg ]; then
exit # TODO
fi
if [ "$MODE" = opt ] || [ "$MODE" = optlinux ]; then
exit
fi
# smoke test userspace binary emulation
CMD="o/$MODE/tool/build/blinkenlights.com.dbg o/$MODE/examples/hello.com"
if OUTPUT="$($CMD)"; then
if [ x"$OUTPUT" = x"hello world" ]; then
exit 0
else
printf '%s\n' "error: $CMD printed wrong output: $OUTPUT" >&2
exit 1
fi
else
RC=$?
printf '%s\n' "error: $CMD failed: $RC" >&2
exit $RC
fi
| 477 | 25 | jart/cosmopolitan | false |
cosmopolitan/test/libc/release/smokecxx.cc | int main() {
int rc;
FILE *f;
int *x = new int[32];
x[0] = 2;
x[1] = 2;
x[2] = x[0] + x[1];
return x[2] - 4;
}
| 125 | 10 | jart/cosmopolitan | false |
cosmopolitan/test/libc/release/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
ifeq ($(ARCH), x86_64)
o/$(MODE)/test/libc/release/cosmopolitan.zip: private .UNSANDBOXED = 1
o/$(MODE)/test/libc/release/cosmopolitan.zip: \
o/cosmopolitan.h \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/ape/ape-copy-self.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a \
o/$(MODE)/third_party/zip/zip.com
@$(COMPILE) -AZIP -T$@ \
o/$(MODE)/third_party/zip/zip.com \
-b$(TMPDIR) -qj $@ \
o/cosmopolitan.h \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/ape/ape-copy-self.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a
o/$(MODE)/test/libc/release/smoke.o: \
test/libc/release/smoke.c \
o/cosmopolitan.h
@$(COMPILE) -ACC $(CC) \
-o $@ \
-c \
-Os \
-fno-pie \
-nostdinc \
-fno-omit-frame-pointer \
-include o/cosmopolitan.h \
$<
o/$(MODE)/test/libc/release/smoke.com.dbg: \
o/$(MODE)/test/libc/release/smoke.o \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/cosmopolitan.a
@$(COMPILE) -ALD $(LD) \
-static \
-no-pie \
-nostdlib \
-T o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/test/libc/release/smoke.o \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/cosmopolitan.a \
-o $@
o/$(MODE)/test/libc/release/smoke-nms.com.dbg: \
o/$(MODE)/test/libc/release/smoke.o \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a
@$(COMPILE) -ALD $(LD) \
-static \
-no-pie \
-nostdlib \
-T o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/test/libc/release/smoke.o \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a \
-o $@
o/$(MODE)/test/libc/release/smoke-chibicc.com.dbg: \
o/$(MODE)/test/libc/release/smoke-chibicc.o \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a \
o/$(MODE)/third_party/chibicc/chibicc.com
@$(COMPILE) -ALD $(LD) \
-static \
-no-pie \
-nostdlib \
-T o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/test/libc/release/smoke-chibicc.o \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape-no-modify-self.o \
o/$(MODE)/cosmopolitan.a \
-o $@
o/$(MODE)/test/libc/release/smoke-chibicc.o: \
test/libc/release/smoke.c \
o/cosmopolitan.h \
o/$(MODE)/third_party/chibicc/chibicc.com
@$(COMPILE) -wACHIBICC \
o/$(MODE)/third_party/chibicc/chibicc.com \
$(CHIBICC_FLAGS) \
-o $@ \
-c \
-Os \
-static \
-fno-pie \
-nostdlib \
-nostdinc \
-mno-red-zone \
-fno-omit-frame-pointer \
-include o/cosmopolitan.h \
$<
o/$(MODE)/test/libc/release/smokecxx.com.dbg: \
o/$(MODE)/test/libc/release/smokecxx.o \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/cosmopolitan.a \
o/$(MODE)/third_party/libcxx/libcxx.a
@$(COMPILE) -ALD $(LD) \
-static \
-no-pie \
-nostdlib \
-T o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/test/libc/release/smokecxx.o \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/third_party/libcxx/libcxx.a \
o/$(MODE)/cosmopolitan.a \
-o $@
o/$(MODE)/test/libc/release/smokecxx.o: \
test/libc/release/smokecxx.cc \
o/cosmopolitan.h
@$(COMPILE) -ACXX $(CXX) \
-o $@ \
-c \
-Os \
-fno-pie \
-nostdinc \
-fno-omit-frame-pointer \
-include o/cosmopolitan.h \
test/libc/release/smokecxx.cc
o/$(MODE)/test/libc/release/smokeansi.com.dbg: \
o/$(MODE)/test/libc/release/smokeansi.o \
o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/cosmopolitan.a
@$(COMPILE) -ALD $(LD) \
-static \
-no-pie \
-nostdlib \
-T o/$(MODE)/ape/public/ape.lds \
o/$(MODE)/test/libc/release/smokeansi.o \
o/$(MODE)/libc/crt/crt.o \
o/$(MODE)/ape/ape.o \
o/$(MODE)/cosmopolitan.a \
-o $@
o/$(MODE)/test/libc/release/smokeansi.o: \
test/libc/release/smoke.c \
o/cosmopolitan.h
@$(COMPILE) -AANSI $(CC) \
-o $@ \
-c \
-Os \
-ansi \
-static \
-fno-pie \
-nostdinc \
-fno-omit-frame-pointer \
-include o/cosmopolitan.h \
test/libc/release/smoke.c
# TODO(jart): Rewrite these shell scripts as C code.
# o/$(MODE)/test/libc/release/metal.ok: \
# test/libc/release/metal.sh \
# o/$(MODE)/examples/hello.com \
# o/$(MODE)/tool/build/blinkenlights.com.dbg
# @$(COMPILE) -ASHTEST -tT$@ $<
# o/$(MODE)/test/libc/release/emulate.ok: \
# test/libc/release/emulate.sh \
# o/$(MODE)/examples/hello.com \
# o/$(MODE)/tool/build/blinkenlights.com.dbg
# @$(COMPILE) -ASHTEST -tT$@ $<
.PHONY: o/$(MODE)/test/libc/release
o/$(MODE)/test/libc/release: \
o/$(MODE)/test/libc/release/smoke.com \
o/$(MODE)/test/libc/release/smoke.com.runs \
o/$(MODE)/test/libc/release/smoke-nms.com \
o/$(MODE)/test/libc/release/smoke-nms.com.runs \
o/$(MODE)/test/libc/release/smoke-chibicc.com \
o/$(MODE)/test/libc/release/smoke-chibicc.com.runs \
o/$(MODE)/test/libc/release/smokecxx.com \
o/$(MODE)/test/libc/release/smokecxx.com.runs \
o/$(MODE)/test/libc/release/smokeansi.com \
o/$(MODE)/test/libc/release/smokeansi.com.runs
endif
.PHONY: o/$(MODE)/test/libc/release
o/$(MODE)/test/libc/release:
| 6,048 | 204 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/mprotect_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/log/log.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/prot.h"
#include "libc/sysv/consts/sa.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "third_party/xed/x86.h"
#ifdef __x86_64__
volatile bool gotsegv;
volatile bool gotbusted;
struct sigaction old[2];
char testlib_enable_tmp_setup_teardown;
void SkipOverFaultingInstruction(struct ucontext *ctx) {
struct XedDecodedInst xedd;
xed_decoded_inst_zero_set_mode(&xedd, XED_MACHINE_MODE_LONG_64);
xed_instruction_length_decode(&xedd, (void *)ctx->uc_mcontext.rip, 15);
ctx->uc_mcontext.rip += xedd.length;
}
void OnSigSegv(int sig, struct siginfo *si, void *vctx) {
struct ucontext *ctx = vctx;
gotsegv = true;
SkipOverFaultingInstruction(ctx);
}
void OnSigBus(int sig, struct siginfo *si, void *vctx) {
struct ucontext *ctx = vctx;
gotbusted = true;
SkipOverFaultingInstruction(ctx);
#if 0
kprintf("SIGBUS%n");
kprintf("si->si_signo = %G%n", si->si_signo);
kprintf("si->si_errno = %s (%d)%n", _strerrno(si->si_errno),
si->si_errno);
kprintf("si->si_code = %s (%d)%n", GetSiCodeName(sig, si->si_code),
si->si_code);
kprintf("âsi->si_addr = %p%n", si->si_addr);
kprintf("â¼âââââââââââââââââ%n");
kprintf("âsi->si_pid = %d (note: getpid() is %d)%n", si->si_pid, getpid());
kprintf("âsi->si_uid = %d%n", si->si_uid);
kprintf("â¼âââââââââââââââââ%n");
kprintf("âsi->si_timerid = %d%n", si->si_timerid);
kprintf("âsi->si_overrun = %d%n", si->si_overrun);
kprintf("si->si_value.sival_int = %d%n", si->si_value.sival_int);
kprintf("si->si_value.sival_ptr = %p%n", si->si_value.sival_ptr);
system(xasprintf("cat /proc/%d/map", getpid()));
#endif
}
void SetUp(void) {
struct sigaction sabus = {.sa_sigaction = OnSigBus,
.sa_flags = SA_SIGINFO | SA_RESETHAND};
struct sigaction sasegv = {.sa_sigaction = OnSigSegv,
.sa_flags = SA_SIGINFO | SA_RESETHAND};
sigaction(SIGBUS, &sabus, old + 0);
sigaction(SIGSEGV, &sasegv, old + 1);
gotbusted = false;
gotsegv = false;
}
void TearDown(void) {
sigaction(SIGBUS, old + 0, 0);
sigaction(SIGSEGV, old + 1, 0);
}
TEST(mprotect, testOkMemory) {
char *p = gc(memalign(GUARDSIZE, GUARDSIZE));
p[0] = 0;
ASSERT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE));
p[0] = 1;
EXPECT_EQ(1, p[0]);
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
}
TEST(mprotect, testSegfault_writeToReadOnlyAnonymous) {
volatile char *p;
p = gc(memalign(GUARDSIZE, GUARDSIZE));
EXPECT_FALSE(gotsegv);
p[0] = 1;
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ));
_missingno(p[0]);
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
p[0] = 2;
EXPECT_TRUE(gotsegv | gotbusted);
EXPECT_EQ(1, p[0]);
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE));
}
TEST(mprotect, testExecOnly_canExecute) {
char *p = _mapanon(FRAMESIZE);
void (*f)(void) = (void *)p;
p[0] = 0xC3; // RET
ASSERT_SYS(0, 0, mprotect(p, FRAMESIZE, PROT_EXEC | PROT_READ));
f();
// On all supported platforms, PROT_EXEC implies PROT_READ. There is
// one exception to this rule: Chromebook's fork of the Linux kernel
// which has been reported, to have the ability to prevent a program
// from reading its own code.
ASSERT_SYS(0, 0, mprotect(p, FRAMESIZE, PROT_EXEC));
f();
munmap(p, FRAMESIZE);
}
TEST(mprotect, testProtNone_cantEvenRead) {
volatile char *p;
p = gc(memalign(GUARDSIZE, GUARDSIZE));
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_NONE));
_missingno(p[0]);
EXPECT_TRUE(gotsegv | gotbusted);
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE));
}
static const char kRet31337[] = {
0xb8, 0x69, 0x7a, 0x00, 0x00, // mov $31337,%eax
0xc3, // ret
};
TEST(mprotect, testExecJit_actuallyWorks) {
int (*p)(void) = gc(memalign(GUARDSIZE, GUARDSIZE));
memcpy(p, kRet31337, sizeof(kRet31337));
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_EXEC));
EXPECT_EQ(31337, p());
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE));
}
TEST(mprotect, testRwxMap_vonNeumannRules) {
if (IsOpenbsd()) return; // boo
int (*p)(void) = gc(memalign(GUARDSIZE, GUARDSIZE));
memcpy(p, kRet31337, sizeof(kRet31337));
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE | PROT_EXEC));
EXPECT_EQ(31337, p());
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
EXPECT_NE(-1, mprotect(p, GUARDSIZE, PROT_READ | PROT_WRITE));
}
TEST(mprotect, testExecuteFlatFileMapOpenedAsReadonly) {
int (*p)(void);
size_t n = sizeof(kRet31337);
ASSERT_SYS(0, 3, creat("return31337", 0755));
ASSERT_SYS(0, n, write(3, kRet31337, n));
ASSERT_SYS(0, 0, close(3));
ASSERT_SYS(0, 3, open("return31337", O_RDONLY));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, n, PROT_READ | PROT_EXEC, MAP_PRIVATE, 3, 0)));
EXPECT_EQ(31337, p());
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
ASSERT_SYS(0, 0, close(3));
ASSERT_SYS(0, 0, munmap(p, n));
}
TEST(mprotect, testFileMap_canChangeToExecWhileOpenInRdwrMode) {
int (*p)(void);
size_t n = sizeof(kRet31337);
ASSERT_SYS(0, 3, open("return31337", O_CREAT | O_TRUNC | O_RDWR, 0755));
ASSERT_SYS(0, n, write(3, kRet31337, n));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, n, PROT_READ | PROT_WRITE, MAP_PRIVATE, 3, 0)));
EXPECT_NE(-1, mprotect(p, n, PROT_READ | PROT_EXEC));
EXPECT_EQ(31337, p());
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
ASSERT_SYS(0, 0, close(3));
ASSERT_SYS(0, 0, munmap(p, n));
}
TEST(mprotect, testBadProt_failsEinval) {
volatile char *p = gc(memalign(GUARDSIZE, GUARDSIZE));
EXPECT_EQ(-1, mprotect(p, 9999, -1));
EXPECT_EQ(EINVAL, errno);
}
TEST(mprotect, testZeroSize_doesNothing) {
volatile char *p = gc(memalign(GUARDSIZE, GUARDSIZE));
EXPECT_NE(-1, mprotect(p, 0, PROT_READ));
p[0] = 1;
EXPECT_FALSE(gotsegv);
EXPECT_FALSE(gotbusted);
}
#endif /* __x86_64__ */
| 8,305 | 221 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/exit_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/runtime/runtime.h"
#include "libc/testlib/subprocess.h"
#include "libc/testlib/testlib.h"
int i, *p;
void SetUp(void) {
p = _mapshared(FRAMESIZE);
}
void TearDown(void) {
munmap(p, FRAMESIZE);
}
void AtExit3(void) {
p[i++] = 3;
}
void AtExit2(void) {
p[i++] = 2;
exit(2);
}
void AtExit1(void) {
p[i++] = 1;
atexit(AtExit2);
exit(1);
}
// consistent with glibc, musl, freebsd, openbsd & netbsd
// please note posix says recursion is undefined behavior
// however, fifo ordering of atexit handlers is specified
TEST(exit, test) {
SPAWN(fork);
atexit(AtExit3);
atexit(AtExit3);
atexit(AtExit1);
exit(0);
EXITS(2);
ASSERT_EQ(1, p[0]);
ASSERT_EQ(2, p[1]);
ASSERT_EQ(3, p[2]);
ASSERT_EQ(3, p[3]);
}
| 2,587 | 63 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/getdosenviron_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/runtime/internal.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(GetDosEnviron, testOneVariable) {
#define kEnv u"a=Und wird die Welt auch in Flammen stehen\0"
size_t max = 2;
size_t size = sizeof(kEnv) >> 1;
char *block = calloc(1, size);
char16_t *env = memcpy(calloc(1, sizeof(kEnv)), kEnv, sizeof(kEnv));
char **envp = calloc(1, max * sizeof(char *));
EXPECT_EQ(1, GetDosEnviron(env, block, size, envp, max));
EXPECT_STREQ("A=Und wird die Welt auch in Flammen stehen", envp[0]);
EXPECT_EQ(NULL, envp[1]);
ASSERT_BINEQ(u"A=Und wird die Welt auch in Flammen stehen  ", block);
free(envp);
free(env);
free(block);
#undef kEnv
}
TEST(GetDosEnviron, testTwoVariables) {
#define kEnv \
(u"ð°ð±ð²ð³=Und wird die Welt auch in Flammen stehen\0" \
u"ð´ðµð¶ð·=Wir werden wieder auferstehen\0")
size_t max = 3;
size_t size = 1024;
char *block = calloc(1, size);
char16_t *env = memcpy(calloc(1, sizeof(kEnv)), kEnv, sizeof(kEnv));
char **envp = calloc(1, max * sizeof(char *));
EXPECT_EQ(2, GetDosEnviron(env, block, size, envp, max));
EXPECT_STREQ("ð°ð±ð²ð³=Und wird die Welt auch in Flammen stehen", envp[0]);
EXPECT_STREQ("ð´ðµð¶ð·=Wir werden wieder auferstehen", envp[1]);
EXPECT_EQ(NULL, envp[2]);
free(envp);
free(env);
free(block);
#undef kEnv
}
TEST(GetDosEnviron, testOverrun_truncatesWithGrace) {
#define kEnv u"A=Und wird die Welt auch in Flammen stehen\0"
size_t max = 2;
size_t size = sizeof(kEnv) >> 2;
char *block = calloc(1, size);
char16_t *env = memcpy(calloc(1, sizeof(kEnv)), kEnv, sizeof(kEnv));
char **envp = calloc(1, max * sizeof(char *));
EXPECT_EQ(1, GetDosEnviron(env, block, size, envp, max));
EXPECT_STREQ("A=Und wird die Welt ", envp[0]);
EXPECT_EQ(NULL, envp[1]);
ASSERT_BINEQ(u"A=Und wird die Welt   ", block);
free(envp);
free(env);
free(block);
#undef kEnv
}
TEST(GetDosEnviron, testEmpty_doesntTouchMemory) {
EXPECT_EQ(0, GetDosEnviron(u"", NULL, 0, NULL, 0));
}
TEST(GetDosEnviron, testEmpty_zeroTerminatesWheneverPossible_1) {
size_t max = 1;
char **envp = calloc(1, max * sizeof(char *));
EXPECT_EQ(0, GetDosEnviron(u"", NULL, 0, envp, max));
EXPECT_EQ(NULL, envp[0]);
free(envp);
}
TEST(GetDosEnviron, testEmpty_zeroTerminatesWheneverPossible_2) {
size_t size = 1;
char *block = calloc(1, size);
EXPECT_EQ(0, GetDosEnviron(u"", block, size, NULL, 0));
EXPECT_BINEQ(u"Â ", block);
free(block);
}
TEST(GetDosEnviron, testEmpty_zeroTerminatesWheneverPossible_3) {
size_t size = 2;
char *block = calloc(1, size);
EXPECT_EQ(0, GetDosEnviron(u"", block, size, NULL, 0));
EXPECT_BINEQ(u"Â ", block);
free(block);
}
| 4,641 | 104 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/abort_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/calls/struct/sigset.h"
#include "libc/dce.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/subprocess.h"
#include "libc/testlib/testlib.h"
TEST(abort, sysv) {
if (IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_DFL));
abort();
TERMS(SIGABRT);
}
TEST(abort, windows) {
if (!IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_DFL));
abort();
EXITS(128 + SIGABRT);
}
////////////////////////////////////////////////////////////////////////////////
TEST(abort, blocked_stillTerminates_sysv) {
sigset_t ss;
if (IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_DFL));
sigfillset(&ss);
sigprocmask(SIG_SETMASK, &ss, 0);
abort();
TERMS(SIGABRT);
}
TEST(abort, blocked_stillTerminates_windows) {
sigset_t ss;
if (!IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_DFL));
sigfillset(&ss);
sigprocmask(SIG_SETMASK, &ss, 0);
abort();
EXITS(128 + SIGABRT);
}
////////////////////////////////////////////////////////////////////////////////
TEST(abort, ign_stillTerminates_sysv) {
if (IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_IGN));
abort();
TERMS(SIGABRT);
}
TEST(abort, ign_stillTerminates_windows) {
if (!IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, SIG_IGN));
abort();
EXITS(128 + SIGABRT);
}
////////////////////////////////////////////////////////////////////////////////
void Ignore(int sig) {
}
TEST(abort, handled_stillTerminates_sysv) {
if (IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, Ignore));
abort();
TERMS(SIGABRT);
}
TEST(abort, handled_stillTerminates_windows) {
if (!IsWindows()) return;
SPAWN(fork);
ASSERT_NE(SIG_ERR, signal(SIGABRT, Ignore));
abort();
EXITS(128 + SIGABRT);
}
| 3,828 | 106 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/daemon_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigset.h"
#include "libc/dce.h"
#include "libc/intrin/kprintf.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/o.h"
#include "libc/testlib/subprocess.h"
#include "libc/testlib/testlib.h"
#include "libc/time/time.h"
#include "libc/x/x.h"
char testlib_enable_tmp_setup_teardown;
TEST(daemon, test) {
int dirfd;
char buf[512];
SPAWN(fork);
ASSERT_SYS(0, 3, open(".", O_RDONLY | O_DIRECTORY));
ASSERT_SYS(0, 0, daemon(false, false));
ASSERT_SYS(0, 4, openat(3, "ok", O_WRONLY | O_CREAT | O_TRUNC, 0644));
ASSERT_NE(NULL, getcwd(buf, sizeof(buf)));
ASSERT_SYS(0, 0, write(4, buf, strlen(buf)));
ASSERT_SYS(0, 0, close(4));
ASSERT_SYS(0, 0, close(3));
EXITS(0);
for (int i = 0; i < 13; ++i) {
bzero(buf, 512);
open("ok", O_RDONLY);
read(3, buf, 511);
close(3);
if (!strcmp(IsWindows() ? "/C/" : "/", buf)) {
return;
}
usleep(1000L << i);
}
ASSERT_TRUE(false);
}
| 2,855 | 57 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/mmap_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/linux/mmap.h"
#include "ape/sections.internal.h"
#include "libc/calls/calls.h"
#include "libc/calls/ucontext.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/atomic.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/kprintf.h"
#include "libc/intrin/safemacros.internal.h"
#include "libc/intrin/xchg.internal.h"
#include "libc/linux/munmap.h"
#include "libc/log/log.h"
#include "libc/mem/gc.h"
#include "libc/mem/mem.h"
#include "libc/runtime/memtrack.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/msync.h"
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/prot.h"
#include "libc/sysv/consts/sa.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/xspawn.h"
#include "third_party/xed/x86.h"
STATIC_YOINK("zip_uri_support");
char testlib_enable_tmp_setup_teardown;
void SetUpOnce(void) {
// ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath proc", 0));
}
TEST(mmap, zeroSize) {
ASSERT_SYS(EINVAL, MAP_FAILED,
mmap(NULL, 0, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
}
TEST(mmap, overflow) {
ASSERT_SYS(EINVAL, MAP_FAILED,
mmap(NULL, 0x800000000000, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0));
ASSERT_SYS(EINVAL, MAP_FAILED,
mmap(NULL, 0x7fffffffffff, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0));
}
TEST(mmap, outOfAutomapRange) {
ASSERT_SYS(
ENOMEM, MAP_FAILED,
mmap(NULL, kAutomapSize, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
}
TEST(mmap, noreplaceImage) {
ASSERT_SYS(EEXIST, MAP_FAILED,
mmap(__executable_start, FRAMESIZE, PROT_READ,
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
}
TEST(mmap, noreplaceExistingMap) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
ASSERT_SYS(EEXIST, MAP_FAILED,
mmap(p, FRAMESIZE, PROT_READ,
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
}
TEST(mmap, testMapFile) {
int fd;
char *p;
char path[PATH_MAX];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
EXPECT_EQ(5, write(fd, "hello", 5));
EXPECT_NE(-1, fdatasync(fd));
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("hello", p, 5);
EXPECT_NE(-1, munmap(p, 5));
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, unlink(path));
}
TEST(mmap, testMapFile_fdGetsClosed_makesNoDifference) {
int fd;
char *p, buf[16], path[PATH_MAX];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
EXPECT_EQ(5, write(fd, "hello", 5));
EXPECT_NE(-1, fdatasync(fd));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, 5, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
EXPECT_NE(-1, close(fd));
EXPECT_STREQN("hello", p, 5);
p[1] = 'a';
EXPECT_NE(-1, msync(p, PAGESIZE, MS_SYNC));
ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
EXPECT_EQ(5, read(fd, buf, 5));
EXPECT_STREQN("hallo", buf, 5);
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, munmap(p, 5));
EXPECT_NE(-1, unlink(path));
}
TEST(mmap, testMapFixed_destroysEverythingInItsPath) {
unsigned m1 = _mmi.i;
EXPECT_NE(MAP_FAILED, mmap((void *)(kFixedmapStart + FRAMESIZE * 0),
FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
EXPECT_NE(MAP_FAILED, mmap((void *)(kFixedmapStart + FRAMESIZE * 1),
FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
EXPECT_NE(MAP_FAILED, mmap((void *)(kFixedmapStart + FRAMESIZE * 2),
FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
EXPECT_NE(MAP_FAILED, mmap((void *)(kFixedmapStart + FRAMESIZE * 0),
FRAMESIZE * 3, PROT_READ | PROT_WRITE,
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
ASSERT_GT(_mmi.i, m1);
EXPECT_NE(-1, munmap((void *)kFixedmapStart, FRAMESIZE * 3));
}
#ifdef __x86_64__
TEST(mmap, customStackMemory_isAuthorized) {
char *stack;
uintptr_t w, r;
ASSERT_NE(MAP_FAILED, (stack = mmap(NULL, STACKSIZE, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_STACK, -1, 0)));
asm("mov\t%%rsp,%0\n\t"
"mov\t%2,%%rsp\n\t"
"push\t%3\n\t"
"pop\t%1\n\t"
"mov\t%0,%%rsp"
: "=&r"(w), "=&r"(r)
: "rm"(stack + STACKSIZE - 8), "i"(123));
ASSERT_EQ(123, r);
EXPECT_SYS(0, 0, munmap(stack, STACKSIZE));
}
#endif /* __x86_64__ */
TEST(mmap, fileOffset) {
int fd;
char *map;
ASSERT_NE(-1, (fd = open("foo", O_CREAT | O_RDWR, 0644)));
EXPECT_NE(-1, ftruncate(fd, FRAMESIZE * 2));
EXPECT_NE(-1, pwrite(fd, "hello", 5, FRAMESIZE * 0));
EXPECT_NE(-1, pwrite(fd, "there", 5, FRAMESIZE * 1));
EXPECT_NE(-1, fdatasync(fd));
ASSERT_NE(MAP_FAILED, (map = mmap(NULL, FRAMESIZE, PROT_READ, MAP_PRIVATE, fd,
FRAMESIZE)));
EXPECT_EQ(0, memcmp(map, "there", 5), "%#.*s", 5, map);
EXPECT_NE(-1, munmap(map, FRAMESIZE));
EXPECT_NE(-1, close(fd));
}
TEST(mmap, mapPrivate_writesDontChangeFile) {
int fd;
char *map, buf[6];
ASSERT_NE(-1, (fd = open("bar", O_CREAT | O_RDWR, 0644)));
EXPECT_NE(-1, ftruncate(fd, FRAMESIZE));
EXPECT_NE(-1, pwrite(fd, "hello", 5, 0));
ASSERT_NE(MAP_FAILED, (map = mmap(NULL, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE, fd, 0)));
memcpy(map, "there", 5);
EXPECT_NE(-1, msync(map, FRAMESIZE, MS_SYNC));
EXPECT_NE(-1, munmap(map, FRAMESIZE));
EXPECT_NE(-1, pread(fd, buf, 6, 0));
EXPECT_EQ(0, memcmp(buf, "hello", 5), "%#.*s", 5, buf);
EXPECT_NE(-1, close(fd));
}
TEST(mmap, twoPowerSize_automapsAddressWithThatAlignment) {
char *q, *p;
// increase the likelihood automap is unaligned w.r.t. following call
ASSERT_NE(MAP_FAILED, (q = mmap(NULL, 0x00010000, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
// ask for a nice big round size
ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 0x00080000, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
// verify it's aligned
ASSERT_EQ(0, (intptr_t)p & 0x0007ffff);
EXPECT_SYS(0, 0, munmap(p, 0x00080000));
}
TEST(isheap, nullPtr) {
ASSERT_FALSE(_isheap(NULL));
}
TEST(isheap, malloc) {
ASSERT_TRUE(_isheap(_gc(malloc(1))));
}
TEST(isheap, emptyMalloc) {
ASSERT_TRUE(_isheap(_gc(malloc(0))));
}
TEST(isheap, mallocOffset) {
char *p = _gc(malloc(131072));
ASSERT_TRUE(_isheap(p + 100000));
}
static const char *ziposLifePath = "/zip/life.elf";
TEST(mmap, ziposCannotBeAnonymous) {
int fd;
void *p;
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
EXPECT_SYS(EINVAL, MAP_FAILED,
(p = mmap(NULL, 0x00010000, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS,
fd, 0)));
close(fd);
}
TEST(mmap, ziposCannotBeShared) {
int fd;
void *p;
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
EXPECT_SYS(EINVAL, MAP_FAILED,
(p = mmap(NULL, 0x00010000, PROT_READ, MAP_SHARED, fd, 0)));
close(fd);
}
////////////////////////////////////////////////////////////////////////////////
// zipos NON-SHARED READ-ONLY FILE MEMORY
TEST(mmap, ziposCow) {
int fd;
void *p;
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, 0x00010000, PROT_READ, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("\177ELF", ((const char *)p), 4);
EXPECT_NE(-1, munmap(p, 0x00010000));
EXPECT_NE(-1, close(fd));
}
////////////////////////////////////////////////////////////////////////////////
// zipos NON-SHARED READ-ONLY FILE MEMORY BETWEEN PROCESSES
TEST(mmap, ziposCowFileMapReadonlyFork) {
int fd, ws;
void *p;
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 4, PROT_READ, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("ELF", ((const char *)p) + 1, 3);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("ELF", ((const char *)p) + 1, 3);
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("ELF", ((const char *)p) + 1, 3);
EXPECT_NE(-1, munmap(p, 6));
EXPECT_NE(-1, close(fd));
}
////////////////////////////////////////////////////////////////////////////////
// zipos NON-SHARED READ/WRITE FILE MEMORY BETWEEN PROCESSES
TEST(mmap, ziposCowFileMapFork) {
int fd, ws;
void *p;
char lol[4];
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
memcpy(p, "parnt", 6);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("parnt", p, 5);
strcpy(p, "child");
ASSERT_STREQN("child", p, 5);
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("parnt", p, 5); // child changing memory did not change parent
EXPECT_EQ(4, pread(fd, lol, 4, 0));
EXPECT_STREQN("ELF", &lol[1], 3); // changing memory did not change file
EXPECT_NE(-1, munmap(p, 6));
EXPECT_NE(-1, close(fd));
}
////////////////////////////////////////////////////////////////////////////////
// NON-SHARED READ-ONLY FILE MEMORY
TEST(mmap, cow) {
int fd;
char *p;
char path[PATH_MAX];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)), "%s",
path);
EXPECT_EQ(5, write(fd, "hello", 5));
EXPECT_NE(-1, fdatasync(fd));
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("hello", p, 5);
EXPECT_NE(-1, munmap(p, 5));
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, unlink(path));
}
////////////////////////////////////////////////////////////////////////////////
// NON-SHARED READ-ONLY FILE MEMORY BETWEEN PROCESSES
TEST(mmap, cowFileMapReadonlyFork) {
char *p;
int fd, pid, ws;
char path[PATH_MAX], lol[6];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
EXPECT_EQ(6, write(fd, "hello", 6));
EXPECT_NE(-1, close(fd));
ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("hello", p, 5);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("hello", p, 5);
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("hello", p, 5);
EXPECT_NE(-1, munmap(p, 6));
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, unlink(path));
}
////////////////////////////////////////////////////////////////////////////////
// NON-SHARED READ/WRITE FILE MEMORY BETWEEN PROCESSES
TEST(mmap, cowFileMapFork) {
char *p;
int fd, pid, ws;
char path[PATH_MAX], lol[6];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
EXPECT_EQ(6, write(fd, "parnt", 6));
EXPECT_NE(-1, fdatasync(fd));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
EXPECT_STREQN("parnt", p, 5);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("parnt", p, 5);
strcpy(p, "child");
ASSERT_STREQN("child", p, 5);
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("parnt", p, 5); // child changing memory did not change parent
EXPECT_EQ(6, pread(fd, lol, 6, 0));
EXPECT_STREQN("parnt", lol, 5); // changing memory did not change file
EXPECT_NE(-1, munmap(p, 6));
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, unlink(path));
}
////////////////////////////////////////////////////////////////////////////////
// SHARED ANONYMOUS MEMORY BETWEEN PROCESSES
TEST(mmap, sharedAnonMapFork) {
char *p;
int pid, ws;
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
strcpy(p, "parnt");
EXPECT_STREQN("parnt", p, 5);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("parnt", p, 5);
strcpy(p, "child");
ASSERT_STREQN("child", p, 5);
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("child", p, 5); // boom
EXPECT_NE(-1, munmap(p, 5));
}
////////////////////////////////////////////////////////////////////////////////
// SHARED FILE MEMORY BETWEEN PROCESSES
TEST(mmap, sharedFileMapFork) {
char *p;
int fd, pid, ws;
char path[PATH_MAX], lol[6];
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
EXPECT_EQ(6, write(fd, "parnt", 6));
EXPECT_NE(-1, fdatasync(fd));
EXPECT_NE(MAP_FAILED,
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
EXPECT_STREQN("parnt", p, 5);
ASSERT_NE(-1, (ws = xspawn(0)));
if (ws == -2) {
ASSERT_STREQN("parnt", p, 5);
strcpy(p, "child");
ASSERT_STREQN("child", p, 5);
ASSERT_NE(-1, msync(p, 6, MS_SYNC | MS_INVALIDATE));
_exit(0);
}
EXPECT_EQ(0, ws);
EXPECT_STREQN("child", p, 5); // child changing memory changed parent memory
// XXX: RHEL5 has a weird issue where if we read the file into its own
// shared memory then corruption occurs!
EXPECT_EQ(6, pread(fd, lol, 6, 0));
EXPECT_STREQN("child", lol, 5); // changing memory changed file
EXPECT_NE(-1, munmap(p, 6));
EXPECT_NE(-1, close(fd));
EXPECT_NE(-1, unlink(path));
}
////////////////////////////////////////////////////////////////////////////////
// BENCHMARKS
#define N (EZBENCH_COUNT * EZBENCH_TRIES)
int count;
void *ptrs[N];
void BenchUnmap(void) {
ASSERT_EQ(0, munmap(ptrs[count++], FRAMESIZE));
}
void BenchMmapPrivate(void) {
void *p;
p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
if (p == MAP_FAILED) abort();
ptrs[count++] = p;
}
BENCH(mmap, bench) {
EZBENCH2("mmap", donothing, BenchMmapPrivate());
EZBENCH2("munmap", donothing, BenchUnmap());
}
void BenchUnmapLinux(void) {
ASSERT_EQ(0, LinuxMunmap(ptrs[count++], FRAMESIZE));
}
void BenchMmapPrivateLinux(void) {
void *p;
p = (void *)LinuxMmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (p == MAP_FAILED) abort();
ptrs[count++] = p;
}
BENCH(mmap, benchLinux) {
void *p;
if (!IsLinux()) return;
EZBENCH2("mmap (linux)", donothing, BenchMmapPrivateLinux());
EZBENCH2("munmap (linux)", donothing, BenchUnmapLinux());
}
| 16,988 | 481 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/munmap_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/prot.h"
#include "libc/testlib/testlib.h"
char testlib_enable_tmp_setup_teardown;
TEST(munmap, doesntExist_doesntCare) {
EXPECT_SYS(0, 0, munmap(0, FRAMESIZE * 8));
if (IsAsan()) {
// make sure it didn't unmap the null pointer shadow memory
EXPECT_TRUE(testlib_memoryexists((char *)0x7fff8000));
}
}
TEST(munmap, invalidParams) {
EXPECT_SYS(EINVAL, -1, munmap(0, 0));
EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000000, 0));
EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000001, FRAMESIZE));
}
TEST(munmap, test) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists(p));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_FALSE(testlib_memoryexists(p));
}
TEST(munmap, punchHoleInMemory) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 2));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 2));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 2, FRAMESIZE));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 2));
}
TEST(munmap, memoryHasHole) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 2));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 3));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 2));
}
TEST(munmap, blanketFree) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 2));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 0, FRAMESIZE));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 2, FRAMESIZE));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 2));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 3));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 2));
}
TEST(munmap, trimLeft) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 2, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 2));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
}
TEST(munmap, trimRight) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 2, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
EXPECT_TRUE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 2));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 0));
EXPECT_FALSE(testlib_memoryexists(p + FRAMESIZE * 1));
}
TEST(munmap, memoryGone) {
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
}
TEST(munmap, testTooSmallToUnmapAsan) {
if (!IsAsan()) return;
char *p;
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_TRUE(testlib_memoryexists((char *)(((intptr_t)p >> 3) + 0x7fff8000)));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_TRUE(testlib_memoryexists((char *)(((intptr_t)p >> 3) + 0x7fff8000)));
}
TEST(munmap, testLargeEnoughToUnmapAsan) {
if (!IsAsan()) return;
if (IsWindows()) {
// we're unfortunately never able to unmap asan pages on windows
// because the memtrack array items always have to be 64kb so we
// we're able to store a handle for each
return;
}
char *p;
size_t n;
n = FRAMESIZE * 8 * 2;
ASSERT_NE(MAP_FAILED, (p = mmap(0, n, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
EXPECT_SYS(0, 0, munmap(p, n));
#if 0
EXPECT_FALSE(
testlib_memoryexists((char *)(((intptr_t)(p + n / 2) >> 3) + 0x7fff8000)));
#endif
}
TEST(munmap, tinyFile_roundupUnmapSize) {
char *p;
ASSERT_SYS(0, 3, open("doge", O_WRONLY | O_CREAT | O_TRUNC, 0644));
ASSERT_SYS(0, 5, write(3, "hello", 5));
ASSERT_SYS(0, 0, close(3));
ASSERT_SYS(0, 3, open("doge", O_RDONLY));
ASSERT_NE(MAP_FAILED, (p = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
ASSERT_SYS(0, 0, close(3));
EXPECT_TRUE(testlib_memoryexists(p));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
EXPECT_FALSE(testlib_memoryexists(p));
EXPECT_FALSE(testlib_memoryexists(p + 5));
}
TEST(munmap, tinyFile_preciseUnmapSize) {
char *p, *q;
ASSERT_SYS(0, 3, open("doge", O_WRONLY | O_CREAT | O_TRUNC, 0644));
ASSERT_SYS(0, 5, write(3, "hello", 5));
ASSERT_SYS(0, 0, close(3));
ASSERT_SYS(0, 3, open("doge", O_RDONLY));
ASSERT_NE(MAP_FAILED, (p = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
ASSERT_NE(MAP_FAILED, (q = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
ASSERT_SYS(0, 0, close(3));
EXPECT_TRUE(testlib_memoryexists(p));
EXPECT_TRUE(testlib_memoryexists(q));
EXPECT_SYS(0, 0, munmap(p, 5));
EXPECT_FALSE(testlib_memoryexists(p));
EXPECT_TRUE(testlib_memoryexists(q));
EXPECT_SYS(0, 0, munmap(q, 5));
EXPECT_FALSE(testlib_memoryexists(q));
}
// clang-format off
TEST(munmap, tinyFile_mapThriceUnmapOnce) {
char *p = (char *)0x02000000;
ASSERT_SYS(0, 3, open("doge", O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_SYS (0, 5, write(3, "hello", 5));
ASSERT_NE(MAP_FAILED, mmap(p+FRAMESIZE*0, FRAMESIZE, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0));
ASSERT_NE(MAP_FAILED, mmap(p+FRAMESIZE*1, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0));
ASSERT_NE(MAP_FAILED, mmap(p+FRAMESIZE*3, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0));
ASSERT_SYS(0, 0, close(3));
EXPECT_TRUE(testlib_memoryexists(p+FRAMESIZE*0));
EXPECT_TRUE(testlib_memoryexists(p+FRAMESIZE*1));
EXPECT_FALSE(testlib_memoryexists(p+FRAMESIZE*2));
EXPECT_TRUE(testlib_memoryexists(p+FRAMESIZE*3));
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE*5));
EXPECT_FALSE(testlib_memoryexists(p+FRAMESIZE*0));
EXPECT_FALSE(testlib_memoryexists(p+FRAMESIZE*1));
EXPECT_FALSE(testlib_memoryexists(p+FRAMESIZE*2));
EXPECT_FALSE(testlib_memoryexists(p+FRAMESIZE*3));
}
// clang-format on
| 10,005 | 221 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/arch_prctl_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/calls/syscall-sysv.internal.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/intrin/fsgsbase.h"
#include "libc/intrin/kprintf.h"
#include "libc/intrin/segmentation.h"
#include "libc/nt/version.h"
#include "libc/sysv/consts/sa.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/tls.h"
#ifdef __x86_64__
void SetUpOnce(void) {
__tls_enabled_set(false);
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
void OnTrap(int sig, struct siginfo *si, void *vctx) {
struct ucontext *ctx = vctx;
}
void TriggerSignal(void) {
struct sigaction old;
struct sigaction sig = {.sa_sigaction = OnTrap, .sa_flags = SA_SIGINFO};
sched_yield();
sigaction(SIGTRAP, &sig, &old);
asm("int3");
sigaction(SIGTRAP, &old, 0);
sched_yield();
}
TEST(arch_prctl, fs) {
if (IsLinux() || IsFreebsd() || IsNetbsd() || IsOpenbsd()) {
uint64_t n, x;
x = 0xdeadbeef;
arch_prctl(ARCH_SET_FS, &x);
ASSERT_NE(-1, arch_prctl(ARCH_GET_FS, (intptr_t)&n));
ASSERT_EQ((intptr_t)&x, n);
ASSERT_EQ(0xdeadbeef, fs((int64_t *)0));
TriggerSignal();
ASSERT_EQ(0xdeadbeef, fs((int64_t *)0));
}
}
TEST(arch_prctl, pointerRebasingFs) {
if (IsLinux() || IsFreebsd() || IsOpenbsd() || IsNetbsd()) {
unsigned long s[] = {0x0706050403020100, 0x0f0e0d0c0b0a0908};
ASSERT_EQ(0x0706050403020100, s[0]);
ASSERT_EQ(0, arch_prctl(ARCH_SET_FS, 1));
ASSERT_EQ(0x0807060504030201, fs(&s[0]));
ASSERT_EQ(0, arch_prctl(ARCH_SET_FS, 2));
ASSERT_EQ(0x0908070605040302, fs(&s[0]));
intptr_t fs;
ASSERT_EQ(0, arch_prctl(ARCH_GET_FS, &fs));
ASSERT_EQ(2, fs);
}
}
TEST(arch_prctl, gs) {
if (IsLinux() || IsFreebsd() || IsNetbsd() || IsXnu()) {
uint64_t n, x;
x = 0xdeadbeef;
arch_prctl(ARCH_SET_GS, &x);
if (!IsXnu()) {
ASSERT_NE(-1, arch_prctl(ARCH_GET_GS, (intptr_t)&n));
ASSERT_EQ((intptr_t)&x, n);
}
ASSERT_EQ(0xdeadbeef, gs((int64_t *)0));
TriggerSignal();
ASSERT_EQ(0xdeadbeef, gs((int64_t *)0));
}
}
TEST(arch_prctl, pointerRebasing) {
if (IsLinux() || IsFreebsd() || IsNetbsd() || IsXnu()) {
unsigned long s[] = {0x0706050403020100, 0x0f0e0d0c0b0a0908};
ASSERT_EQ(0x0706050403020100, s[0]);
ASSERT_EQ(0, arch_prctl(ARCH_SET_GS, 1));
ASSERT_EQ(0x0807060504030201, gs(&s[0]));
ASSERT_EQ(0, arch_prctl(ARCH_SET_GS, 2));
ASSERT_EQ(0x0908070605040302, gs(&s[0]));
if (!IsXnu()) {
intptr_t gs;
ASSERT_EQ(0, arch_prctl(ARCH_GET_GS, &gs));
ASSERT_EQ(2, gs);
}
}
}
TEST(fsgsbase, fs) {
if (!_have_fsgsbase()) return;
int64_t mem = 0xdeadbeef;
_wrfsbase(&mem);
ASSERT_EQ(&mem, _rdfsbase());
ASSERT_EQ(0xdeadbeef, fs((int64_t *)0));
TriggerSignal();
ASSERT_EQ(0xdeadbeef, fs((int64_t *)0));
}
TEST(fsgsbase, gs) {
if (!_have_fsgsbase()) return;
int64_t mem = 0xdeadbeef;
_wrgsbase(&mem);
ASSERT_EQ(&mem, _rdgsbase());
ASSERT_EQ(0xdeadbeef, gs((int64_t *)0));
TriggerSignal();
ASSERT_EQ(0xdeadbeef, gs((int64_t *)0));
}
#endif /* __x86_64__ */
| 4,976 | 132 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/clone_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/atomic.h"
#include "libc/calls/calls.h"
#include "libc/errno.h"
#include "libc/macros.internal.h"
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/runtime/internal.h"
#include "libc/runtime/stack.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/spawn.h"
int x, me, tid;
atomic_int thechilde;
void SetUpOnce(void) {
__enable_threads();
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
int Hog(void *arg, int tid) {
return 0;
}
void SetUp(void) {
x = 0;
me = gettid();
}
void TearDown(void) {
}
int DoNothing(void *arg) {
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// TEST THREADS WORK
int CloneTest1(void *arg, int tid) {
intptr_t rsp, top, bot;
CheckStackIsAligned();
// PrintBacktraceUsingSymbols(2, __builtin_frame_address(0),
// GetSymbolTable());
rsp = (intptr_t)__builtin_frame_address(0);
bot = ROUNDDOWN((intptr_t)rsp, GetStackSize());
top = bot + GetStackSize();
ASSERT_GT(rsp, bot); // check we're on stack
ASSERT_LT(rsp, top); // check we're on stack
ASSERT_GT(rsp, top - 256); // check we're near top of stack
ASSERT_TRUE(IS2POW(GetStackSize()));
ASSERT_EQ(0, bot & (GetStackSize() - 1));
x = 42;
ASSERT_EQ(23, (intptr_t)arg);
ASSERT_NE(gettid(), getpid());
return 0;
}
TEST(clone, test1) {
int ptid = 0;
struct spawn th;
ASSERT_SYS(0, 0, _spawn(CloneTest1, (void *)23, &th));
ASSERT_SYS(0, 0, _join(&th));
ASSERT_NE(gettid(), tid);
ASSERT_EQ(tid, ptid);
ASSERT_EQ(42, x);
ASSERT_NE(me, tid);
ASSERT_EQ(0, errno);
errno = 31337;
ASSERT_EQ(31337, errno);
errno = 0;
}
////////////////////////////////////////////////////////////////////////////////
// TEST THREADS CAN ISSUE SYSTEM CALLS WITH INDEPENDENT ERRNOS
atomic_int sysbarrier;
int CloneTestSys(void *arg, int tid) {
int i, id = (intptr_t)arg;
CheckStackIsAligned();
while (!sysbarrier) donothing;
for (i = 0; i < 20; ++i) {
switch (id % 3) {
case 0:
errno = 123;
open(0, 0);
donothing;
ASSERT_EQ(EFAULT, errno);
break;
case 1:
errno = 123;
dup(-1);
donothing;
ASSERT_EQ(EBADF, errno);
break;
case 2:
errno = 123;
dup3(0, 0, 0);
donothing;
ASSERT_EQ(EINVAL, errno);
break;
default:
unreachable;
}
}
return 0;
}
TEST(clone, tlsSystemCallsErrno_wontClobberMainThreadBecauseTls) {
int i;
struct spawn th[8];
ASSERT_EQ(0, errno);
for (i = 0; i < 8; ++i) {
ASSERT_SYS(0, 0, _spawn(CloneTestSys, (void *)(intptr_t)i, th + i));
}
sysbarrier = 1;
for (i = 0; i < 8; ++i) {
ASSERT_SYS(0, 0, _join(th + i));
}
ASSERT_EQ(0, errno);
}
| 4,596 | 139 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/fork_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/calls/struct/timespec.h"
#include "libc/dce.h"
#include "libc/intrin/kprintf.h"
#include "libc/log/check.h"
#include "libc/macros.internal.h"
#include "libc/nexgen32e/rdtsc.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/msync.h"
#include "libc/sysv/consts/prot.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/subprocess.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/tls.h"
TEST(fork, testPipes) {
int a, b;
int ws, pid;
int pipefds[2];
ASSERT_NE(-1, pipe(pipefds));
ASSERT_NE(-1, (pid = fork()));
if (!pid) {
a = 31337;
close(pipefds[0]);
write(pipefds[1], &a, sizeof(a));
close(pipefds[1]);
_exit(0);
}
EXPECT_NE(-1, close(pipefds[1]));
EXPECT_EQ(sizeof(b), read(pipefds[0], &b, sizeof(b)));
EXPECT_NE(-1, close(pipefds[0]));
EXPECT_NE(-1, waitpid(pid, &ws, 0));
EXPECT_EQ(31337, b);
}
TEST(fork, testSharedMemory) {
int ws, pid;
int stackvar;
int *sharedvar;
int *privatevar;
EXPECT_NE(MAP_FAILED,
(sharedvar = mmap(NULL, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
EXPECT_NE(MAP_FAILED,
(privatevar = mmap(NULL, FRAMESIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
stackvar = 1;
*sharedvar = 1;
*privatevar = 1;
EXPECT_NE(-1, (pid = fork()));
if (!pid) {
EXPECT_EQ(NULL, getenv("_FORK"));
++stackvar;
++*sharedvar;
++*privatevar;
msync((void *)ROUNDDOWN((intptr_t)&stackvar, FRAMESIZE), FRAMESIZE,
MS_SYNC);
EXPECT_NE(-1, msync(privatevar, FRAMESIZE, MS_SYNC));
EXPECT_NE(-1, msync(sharedvar, FRAMESIZE, MS_SYNC));
_exit(0);
}
EXPECT_NE(-1, waitpid(pid, &ws, 0));
EXPECT_EQ(1, stackvar);
EXPECT_EQ(2, *sharedvar);
EXPECT_EQ(1, *privatevar);
EXPECT_NE(-1, munmap(sharedvar, FRAMESIZE));
EXPECT_NE(-1, munmap(privatevar, FRAMESIZE));
}
static volatile bool gotsigusr1;
static volatile bool gotsigusr2;
static void OnSigusr1(int sig) {
gotsigusr1 = true;
}
static void OnSigusr2(int sig) {
gotsigusr2 = true;
}
TEST(fork, childToChild) {
if (IsWindows()) return; // :'(
sigset_t mask, oldmask;
int ws, parent, child1, child2;
gotsigusr1 = false;
gotsigusr2 = false;
parent = getpid();
signal(SIGUSR1, OnSigusr1);
signal(SIGUSR2, OnSigusr2);
sigemptyset(&mask);
sigaddset(&mask, SIGUSR2);
sigprocmask(SIG_BLOCK, &mask, &oldmask);
ASSERT_NE(-1, (child1 = fork()));
if (!child1) {
kill(parent, SIGUSR2);
sigsuspend(0);
_Exit(!gotsigusr1);
}
sigdelset(&mask, SIGUSR2);
sigsuspend(&mask);
ASSERT_NE(-1, (child2 = fork()));
if (!child2) {
kill(child1, SIGUSR1);
_Exit(0);
}
ASSERT_NE(-1, wait(&ws));
EXPECT_TRUE(WIFEXITED(ws));
EXPECT_EQ(0, WEXITSTATUS(ws));
ASSERT_NE(-1, wait(&ws));
EXPECT_TRUE(WIFEXITED(ws));
EXPECT_EQ(0, WEXITSTATUS(ws));
sigprocmask(SIG_SETMASK, &oldmask, 0);
}
TEST(fork, preservesTlsMemory) {
int pid;
__get_tls()->tib_errno = 31337;
SPAWN(fork);
ASSERT_EQ(31337, __get_tls()->tib_errno);
EXITS(0);
}
void ForkInSerial(void) {
int pid, ws;
ASSERT_NE(-1, (pid = fork()));
if (!pid) _Exit(0);
ASSERT_NE(-1, waitpid(pid, &ws, 0));
ASSERT_TRUE(WIFEXITED(ws));
ASSERT_EQ(0, WEXITSTATUS(ws));
}
BENCH(fork, bench) {
EZBENCH2("fork a", donothing, ForkInSerial());
}
| 5,377 | 156 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/itsatrap_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/limits.h"
#include "libc/runtime/runtime.h"
#include "libc/testlib/testlib.h"
/**
* @fileoverview Tests for arithmetic overflow traps.
*
* This module assumes -ftrapv, but not -fsanitize=undefined; since
* Ubsan provides a superset trapping functionality, and therefore
* overrides the prior. The nice thing about -ftrapv is that it doesn't
* leak huge amounts of information into the binary. So it's appropriate
* to enable in a release build.
*
* @note LLVM's implementation of the runtime for this crashes due to
* relying on undefined behavior lool, the very thing the flag was
* meant to help prevent, so we don't get punked by the compiler
* @see __addvsi3, __mulvsi3, etc.
*/
#ifndef __llvm__ /* TODO(jart): wut */
volatile bool overflowed_;
void __on_arithmetic_overflow(void) {
overflowed_ = true;
}
void SetUp(void) {
overflowed_ = false;
}
/* 32-BIT SIGNED NEGATION */
TEST(__negvsi2, testMax) {
EXPECT_EQ(-INT_MAX, -VEIL("r", INT_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__negvsi2, testMin0) {
EXPROPRIATE(-VEIL("r", INT_MIN));
EXPECT_TRUE(overflowed_);
}
/* 64-BIT SIGNED NEGATION */
TEST(__negvdi2, testMax) {
EXPECT_EQ(-LONG_MAX, -VEIL("r", LONG_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__negvdi2, testMin0) {
EXPROPRIATE(-VEIL("r", LONG_MIN));
EXPECT_TRUE(overflowed_);
}
/* 32-BIT SIGNED MULTIPLICATION */
TEST(__mulvsi3, testMin0) {
EXPECT_EQ(0, 0 * VEIL("r", INT_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvsi3, testMin1) {
EXPECT_EQ(INT_MIN, 1 * VEIL("r", INT_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvsi3, testMin2) {
EXPROPRIATE(2 * VEIL("r", INT_MIN));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvsi3, testMax0) {
EXPECT_EQ(0, 0 * VEIL("r", INT_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvsi3, testMax1) {
EXPECT_EQ(INT_MAX, 1 * VEIL("r", INT_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvsi3, testMax2) {
EXPROPRIATE(2 * VEIL("r", INT_MAX));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvsi3, test7) {
EXPECT_EQ(0x70000000, 7 * VEIL("r", 0x10000000));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvsi3, test8) {
EXPROPRIATE(8 * VEIL("r", 0x10000000));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvsi3, test31337) {
EXPROPRIATE(0x31337 * VEIL("r", 0x31337));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvsi3, standAndDeliver_aNegativeTimesANegativeEqualsAPositive) {
EXPECT_EQ(25, -5 * VEIL("r", -5));
EXPECT_FALSE(overflowed_);
}
/* 64-BIT SIGNED MULTIPLICATION */
TEST(__mulvdi3, testMin0) {
EXPECT_EQ(0, 0 * VEIL("r", LONG_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, testMin1) {
EXPECT_EQ(LONG_MIN, 1 * VEIL("r", LONG_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, testMin2) {
EXPROPRIATE(2 * VEIL("r", LONG_MIN));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvdi3, testMax0) {
EXPECT_EQ(0, 0 * VEIL("r", LONG_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, testMax1) {
EXPECT_EQ(LONG_MAX, 1 * VEIL("r", LONG_MAX));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, testMax2) {
EXPROPRIATE(2 * VEIL("r", LONG_MAX));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvdi3, test7) {
EXPECT_EQ(0x7000000000000000l, 7 * VEIL("r", 0x1000000000000000l));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, test8) {
EXPROPRIATE(8 * VEIL("r", 0x1000000000000000l));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvdi3, test31337) {
EXPROPRIATE(0x3133700000000l * VEIL("r", 0x3133700000000l));
EXPECT_TRUE(overflowed_);
}
TEST(__mulvdi3, standAndDeliver_aNegativeTimesANegativeEqualsAPositive) {
EXPECT_EQ(25l, -5l * VEIL("r", -5l));
EXPECT_FALSE(overflowed_);
}
TEST(__mulvdi3, testOverflow) {
volatile int64_t x;
x = 3037000500;
x *= 3037000499;
EXPECT_FALSE(overflowed_);
x = 3037000500;
x *= 3037000500;
EXPECT_TRUE(overflowed_);
}
/* 32-BIT SIGNED ADDITION */
TEST(__addvsi3, testMin1) {
EXPECT_EQ(INT_MIN + 1, 1 + VEIL("r", INT_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__addvsi3, testMax1) {
EXPROPRIATE(1 + VEIL("r", INT_MAX));
EXPECT_TRUE(overflowed_);
}
TEST(__addvsi3, testNegPos) {
EXPECT_EQ(2, -2 + VEIL("r", 4));
EXPECT_FALSE(overflowed_);
}
TEST(__addvsi3, testPosNeg) {
EXPECT_EQ(-2, 2 + VEIL("r", -4));
EXPECT_FALSE(overflowed_);
}
/* 64-BIT SIGNED ADDITION */
TEST(__addvdi3, testMin1) {
EXPECT_EQ(LONG_MIN + 1, 1 + VEIL("r", LONG_MIN));
EXPECT_FALSE(overflowed_);
}
TEST(__addvdi3, testMax1) {
EXPROPRIATE(1 + VEIL("r", LONG_MAX));
EXPECT_TRUE(overflowed_);
}
TEST(__addvdi3, testNegPos) {
EXPECT_EQ(2l, -2l + VEIL("r", 4l));
EXPECT_FALSE(overflowed_);
}
TEST(__addvdi3, testPosNeg) {
EXPECT_EQ(-2l, 2l + VEIL("r", -4l));
EXPECT_FALSE(overflowed_);
}
/* 32-BIT SIGNED SUBTRACTION */
TEST(__subvsi3, testMin1) {
EXPROPRIATE(VEIL("r", INT_MIN) - 1);
EXPECT_TRUE(overflowed_);
}
TEST(__subvsi3, testMax1) {
EXPECT_EQ(INT_MAX - 1, VEIL("r", INT_MAX) - 1);
EXPECT_FALSE(overflowed_);
}
TEST(__subvsi3, testPosNeg) {
EXPECT_EQ(-2, 2 - VEIL("r", 4));
EXPECT_FALSE(overflowed_);
}
/* 64-BIT SIGNED SUBTRACTION */
TEST(__subvdi3, testMin1) {
EXPROPRIATE(VEIL("r", LONG_MIN) - 1);
EXPECT_TRUE(overflowed_);
}
TEST(__subvdi3, testMax1) {
EXPECT_EQ(LONG_MAX - 1, VEIL("r", LONG_MAX) - 1);
EXPECT_FALSE(overflowed_);
}
/* 128-BIT SIGNED ADDITION */
TEST(__addvti3, testMath) {
volatile int128_t x;
x = 2;
x += 2;
EXPECT_EQ(4, x);
x = -2;
x += -2;
EXPECT_EQ(-4, x);
x = UINT64_MAX;
x += 1;
EXPECT_EQ((int128_t)UINT64_MAX + 1, x);
EXPECT_FALSE(overflowed_);
}
TEST(__addvti3, testOverflow) {
volatile int128_t x;
x = INT128_MAX;
x += 1;
EXPECT_TRUE(overflowed_);
}
/* 128-BIT SIGNED SUBTRACTION */
TEST(__subvti3, testMath) {
volatile int128_t x;
x = -2;
x -= 2;
EXPECT_EQ(-4, x);
x = UINT64_MIN;
x -= 1;
EXPECT_EQ((int128_t)UINT64_MIN - 1, x);
EXPECT_FALSE(overflowed_);
}
TEST(__subvti3, testOverflow) {
volatile int128_t x;
x = INT128_MIN;
x -= 1;
EXPECT_TRUE(overflowed_);
}
/* 128-BIT SIGNED NEGATION */
TEST(__negvti3, testMath) {
volatile int128_t x;
x = -2;
x = -x;
EXPECT_EQ(2, x);
EXPECT_FALSE(overflowed_);
x = INT128_MAX;
x = -x;
EXPECT_EQ(INT128_MIN + 1, x);
EXPECT_FALSE(overflowed_);
x = (uint128_t)0x8000000000000000 << 64 | 0x8000000000000000;
x = -x;
EXPECT_EQ((uint128_t)0x7fffffffffffffff << 64 | 0x8000000000000000, x);
EXPECT_FALSE(overflowed_);
}
TEST(__negvti3, testOverflow) {
volatile int128_t x;
x = INT128_MIN;
x = -x;
EXPECT_TRUE(overflowed_);
}
/* 128-BIT SIGNED MULTIPLICATION */
TEST(__mulvti3, testMath) {
volatile int128_t x;
x = 7;
x *= 11;
EXPECT_EQ(77, x);
EXPECT_FALSE(overflowed_);
x = 0x1fffffffffffffff;
x *= 0x1fffffffffffffff;
EXPECT_EQ((uint128_t)0x3ffffffffffffff << 64 | 0xc000000000000001, x);
EXPECT_FALSE(overflowed_);
x = -0x1fffffffffffffff;
x *= 0x1fffffffffffffff;
EXPECT_EQ((uint128_t)0xfc00000000000000 << 64 | 0x3fffffffffffffff, x);
EXPECT_FALSE(overflowed_);
}
TEST(__mulvti3, testOverflow) {
volatile int128_t x;
x = 0xb504f333f9de5be0;
x *= 0xb504f333f9de6d28;
EXPECT_FALSE(overflowed_);
x = 0xb504f333f9de5be0;
x *= 0xb504f333f9de6d29;
EXPECT_TRUE(overflowed_);
}
#endif /* __llvm__ */
| 9,057 | 358 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/grow_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/kprintf.h"
#include "libc/intrin/pushpop.h"
#include "libc/limits.h"
#include "libc/macros.internal.h"
#include "libc/mem/mem.h"
#include "libc/nt/enum/version.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(grow, testNull_hasAllocatingBehavior) {
void *p = NULL;
size_t capacity = 0;
EXPECT_TRUE(__grow(&p, &capacity, 1, 0));
EXPECT_NE(NULL, p);
EXPECT_EQ(32, capacity);
free(p);
}
TEST(grow, testCapacity_isInUnits_withTerminatorGuarantee) {
void *p = NULL;
size_t capacity = 0;
EXPECT_TRUE(__grow(&p, &capacity, 8, 0));
EXPECT_NE(NULL, p);
EXPECT_EQ(32 / 8 + 1, capacity);
free(p);
}
TEST(grow, testStackMemory_convertsToDynamic) {
int A[] = {1, 2, 3};
int *p = A;
size_t capacity = ARRAYLEN(A);
if (!_isheap(p)) {
EXPECT_TRUE(__grow(&p, &capacity, sizeof(int), 0));
EXPECT_TRUE(_isheap(p));
EXPECT_GT(capacity, ARRAYLEN(A));
EXPECT_EQ(1, p[0]);
EXPECT_EQ(2, p[1]);
EXPECT_EQ(3, p[2]);
p[0] = 7;
EXPECT_EQ(1, A[0]);
free(p);
}
}
TEST(grow, testGrowth_clearsNewMemory) {
size_t i, capacity = 123;
char *p = malloc(capacity);
memset(p, 'a', capacity);
EXPECT_TRUE(__grow(&p, &capacity, 1, 0));
EXPECT_GT(capacity, 123);
for (i = 0; i < 123; ++i) ASSERT_EQ('a', p[i]);
for (i = 123; i < capacity; ++i) ASSERT_EQ(0, p[i]);
free(p);
}
TEST(grow, testBonusParam_willGoAboveAndBeyond) {
size_t capacity = 32;
char *p = malloc(capacity);
EXPECT_TRUE(__grow(&p, &capacity, 1, 0));
EXPECT_LT(capacity, 1024);
free(p);
p = malloc((capacity = 32));
EXPECT_TRUE(__grow(&p, &capacity, 1, 1024));
EXPECT_GT(capacity, 1024);
free(p);
}
TEST(grow, testOverflow_returnsFalseAndDoesNotFree) {
int A[] = {1, 2, 3};
int *p = A;
size_t capacity = ARRAYLEN(A);
if (!_isheap(p)) {
EXPECT_FALSE(__grow(&p, &capacity, pushpop(SIZE_MAX), 0));
EXPECT_FALSE(_isheap(p));
EXPECT_EQ(capacity, ARRAYLEN(A));
EXPECT_EQ(1, p[0]);
EXPECT_EQ(2, p[1]);
EXPECT_EQ(3, p[2]);
}
}
| 3,929 | 101 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
PKGS += TEST_LIBC_RUNTIME
TEST_LIBC_RUNTIME_SRCS := $(wildcard test/libc/runtime/*.c)
TEST_LIBC_RUNTIME_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_RUNTIME_SRCS))
TEST_LIBC_RUNTIME_OBJS = \
$(TEST_LIBC_RUNTIME_SRCS:%.c=o/$(MODE)/%.o)
TEST_LIBC_RUNTIME_COMS = \
$(TEST_LIBC_RUNTIME_SRCS:%.c=o/$(MODE)/%.com)
TEST_LIBC_RUNTIME_BINS = \
$(TEST_LIBC_RUNTIME_COMS) \
$(TEST_LIBC_RUNTIME_COMS:%=%.dbg)
TEST_LIBC_RUNTIME_TESTS = \
$(TEST_LIBC_RUNTIME_SRCS_TEST:%.c=o/$(MODE)/%.com.ok)
TEST_LIBC_RUNTIME_CHECKS = \
$(TEST_LIBC_RUNTIME_SRCS_TEST:%.c=o/$(MODE)/%.com.runs)
TEST_LIBC_RUNTIME_DIRECTDEPS = \
LIBC_CALLS \
LIBC_FMT \
LIBC_INTRIN \
LIBC_LOG \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STDIO \
LIBC_STR \
LIBC_STUBS \
LIBC_SYSV \
LIBC_THREAD \
LIBC_TESTLIB \
LIBC_TINYMATH \
LIBC_X \
LIBC_ZIPOS \
TOOL_BUILD_LIB \
THIRD_PARTY_XED
TEST_LIBC_RUNTIME_DEPS := \
$(call uniq,$(foreach x,$(TEST_LIBC_RUNTIME_DIRECTDEPS),$($(x))))
o/$(MODE)/test/libc/runtime/runtime.pkg: \
$(TEST_LIBC_RUNTIME_OBJS) \
$(foreach x,$(TEST_LIBC_RUNTIME_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/libc/runtime/%.com.dbg: \
$(TEST_LIBC_RUNTIME_DEPS) \
o/$(MODE)/test/libc/mem/prog/life.elf.zip.o \
o/$(MODE)/test/libc/runtime/%.o \
o/$(MODE)/test/libc/runtime/runtime.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
o/$(MODE)/test/libc/runtime/ape_test.com.dbg: \
$(TEST_LIBC_RUNTIME_DEPS) \
o/$(MODE)/test/libc/runtime/ape_test.o \
o/$(MODE)/test/libc/runtime/runtime.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
$(TEST_LIBC_RUNTIME_OBJS): private \
DEFAULT_CCFLAGS += \
-fno-builtin
o/$(MODE)/test/libc/runtime/getenv_test.com.runs: \
o/$(MODE)/test/libc/runtime/getenv_test.com
@HELLO=THERE build/runit $@ $<
o/$(MODE)/test/libc/runtime/itsatrap_test.o: private \
OVERRIDE_CFLAGS += \
-fno-sanitize=all \
-ftrapv
.PHONY: o/$(MODE)/test/libc/runtime
o/$(MODE)/test/libc/runtime: \
$(TEST_LIBC_RUNTIME_BINS) \
$(TEST_LIBC_RUNTIME_CHECKS)
| 2,422 | 88 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/tls_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/thread/tls.h"
#include "libc/dce.h"
#include "libc/intrin/asan.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/thread.h"
#define A TLS_ALIGNMENT
long z = 2;
pthread_t t;
_Thread_local long x;
_Thread_local long y[1] = {40};
_Alignas(A) _Thread_local long a;
noubsan void *Worker(void *arg) {
ASSERT_EQ(42, x + y[0] + z);
ASSERT_EQ(0, (intptr_t)&a & (A - 1));
if (IsAsan()) {
ASSERT_EQ(kAsanProtected, __asan_check(y + 1, sizeof(long)).kind);
}
return 0;
}
TEST(tls, test) {
ASSERT_EQ(A, _Alignof(a));
ASSERT_EQ(0, sizeof(struct CosmoTib) % A);
ASSERT_EQ(0, (intptr_t)__get_tls() & (A - 1));
EXPECT_EQ(2, z);
EXPECT_EQ(40, y[0]);
EXPECT_EQ(42, x + y[0] + z);
y[0] = 666;
ASSERT_EQ(0, (intptr_t)&a & (A - 1));
ASSERT_EQ(0, pthread_create(&t, 0, Worker, 0));
ASSERT_EQ(0, pthread_join(t, 0));
if (IsAsan()) {
// TODO(jart): Why isn't it poisoned?
// ASSERT_EQ(kAsanProtected, __asan_check(y + 1, sizeof(long)).kind);
}
}
| 2,839 | 58 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/memtrack_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/intrin/kprintf.h"
#include "libc/limits.h"
#include "libc/log/check.h"
#include "libc/mem/mem.h"
#include "libc/runtime/memtrack.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
#define I(x, y) \
{ x, y, 0, (y - x) * FRAMESIZE + FRAMESIZE }
void SetUpOnce(void) {
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
static bool AreMemoryIntervalsEqual(const struct MemoryIntervals *mm1,
const struct MemoryIntervals *mm2) {
if (mm1->i != mm2->i) return false;
if (memcmp(mm1->p, mm2->p, mm1->i * sizeof(*mm2->p)) != 0) return false;
return true;
}
static void PrintMemoryInterval(const struct MemoryIntervals *mm) {
int i;
for (i = 0; i < mm->i; ++i) {
if (i) fprintf(stderr, ",");
fprintf(stderr, "{%d,%d}", mm->p[i].x, mm->p[i].y);
}
fprintf(stderr, "\n");
}
static void CheckMemoryIntervalsEqual(const struct MemoryIntervals *mm1,
const struct MemoryIntervals *mm2) {
if (!AreMemoryIntervalsEqual(mm1, mm2)) {
kprintf("got:\n");
PrintMemoryIntervals(2, mm1);
kprintf("want:\n");
PrintMemoryIntervals(2, mm2);
CHECK(!"memory intervals not equal");
exit(1);
}
}
static void CheckMemoryIntervalsAreOk(const struct MemoryIntervals *mm) {
if (!AreMemoryIntervalsOk(mm)) {
PrintMemoryInterval(mm);
CHECK(!"memory intervals not ok");
exit(1);
}
}
static void RunTrackMemoryIntervalTest(const struct MemoryIntervals t[2], int x,
int y, long h) {
struct MemoryIntervals *mm;
mm = memcpy(memalign(64, sizeof(*t)), t, sizeof(*t));
CheckMemoryIntervalsAreOk(mm);
CHECK_NE(-1, TrackMemoryInterval(mm, x, y, h, 0, 0, 0, 0, 0,
(y - x) * FRAMESIZE + FRAMESIZE));
CheckMemoryIntervalsAreOk(mm);
CheckMemoryIntervalsEqual(mm, t + 1);
free(mm);
}
static int RunReleaseMemoryIntervalsTest(const struct MemoryIntervals t[2],
int x, int y) {
int rc;
struct MemoryIntervals *mm;
mm = memcpy(memalign(64, sizeof(*t)), t, sizeof(*t));
CheckMemoryIntervalsAreOk(mm);
if ((rc = ReleaseMemoryIntervals(mm, x, y, NULL)) != -1) {
CheckMemoryIntervalsAreOk(mm);
CheckMemoryIntervalsEqual(t + 1, mm);
}
free(mm);
return rc;
}
TEST(TrackMemoryInterval, TestEmpty) {
static struct MemoryIntervals mm[2] = {
{0, OPEN_MAX, 0, {}},
{1, OPEN_MAX, 0, {{2, 2, 0, FRAMESIZE}}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 2, 2, 0);
}
TEST(TrackMemoryInterval, TestFull) {
#if 0 // TODO(jart): Find way to re-enable
int i;
struct MemoryIntervals *mm;
mm = calloc(1, sizeof(struct MemoryIntervals));
for (i = 0; i < mm->n; ++i) {
CheckMemoryIntervalsAreOk(mm);
CHECK_NE(-1, TrackMemoryInterval(mm, i, i, i, 0, 0, 0, 0, 0, 0));
CheckMemoryIntervalsAreOk(mm);
}
CHECK_EQ(-1, TrackMemoryInterval(mm, i, i, i, 0, 0, 0, 0, 0, 0));
CHECK_EQ(ENOMEM, errno);
CheckMemoryIntervalsAreOk(mm);
free(mm);
#endif
}
TEST(TrackMemoryInterval, TestAppend) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(2, 2)}},
{1, OPEN_MAX, 0, {I(2, 3)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 3, 3, 0);
}
TEST(TrackMemoryInterval, TestPrepend) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(2, 2)}},
{1, OPEN_MAX, 0, {I(1, 2)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 1, 1, 0);
}
TEST(TrackMemoryInterval, TestFillHole) {
static struct MemoryIntervals mm[2] = {
{4, OPEN_MAX, 0, {I(1, 1), I(3, 4), {5, 5, 1, FRAMESIZE}, I(6, 8)}},
{3, OPEN_MAX, 0, {I(1, 4), {5, 5, 1, FRAMESIZE}, I(6, 8)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 2, 2, 0);
}
TEST(TrackMemoryInterval, TestAppend2) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(2, 2)}},
{2, OPEN_MAX, 0, {I(2, 2), {3, 3, 1, FRAMESIZE}}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 3, 3, 1);
}
TEST(TrackMemoryInterval, TestPrepend2) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(2, 2)}},
{2, OPEN_MAX, 0, {{1, 1, 1, FRAMESIZE}, I(2, 2)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 1, 1, 1);
}
TEST(TrackMemoryInterval, TestFillHole2) {
static struct MemoryIntervals mm[2] = {
{4,
OPEN_MAX,
0,
{
I(1, 1),
I(3, 4),
{5, 5, 1, FRAMESIZE},
I(6, 8),
}},
{5,
OPEN_MAX,
0,
{
I(1, 1),
{2, 2, 1, FRAMESIZE},
{3, 4, 0, FRAMESIZE * 2},
{5, 5, 1, FRAMESIZE},
{6, 8, 0, FRAMESIZE * 3},
}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
RunTrackMemoryIntervalTest(mm, 2, 2, 1);
}
TEST(FindMemoryInterval, Test) {
static struct MemoryIntervals mm[1] = {
{
4,
OPEN_MAX,
0,
{
[0] = {1, 1},
[1] = {3, 4},
[2] = {5, 5, 1},
[3] = {6, 8},
},
},
};
mm[0].p = mm[0].s;
EXPECT_EQ(0, FindMemoryInterval(mm, 0));
EXPECT_EQ(0, FindMemoryInterval(mm, 1));
EXPECT_EQ(1, FindMemoryInterval(mm, 2));
EXPECT_EQ(1, FindMemoryInterval(mm, 3));
EXPECT_EQ(1, FindMemoryInterval(mm, 4));
EXPECT_EQ(2, FindMemoryInterval(mm, 5));
EXPECT_EQ(3, FindMemoryInterval(mm, 6));
EXPECT_EQ(3, FindMemoryInterval(mm, 7));
EXPECT_EQ(3, FindMemoryInterval(mm, 8));
EXPECT_EQ(4, FindMemoryInterval(mm, 9));
}
TEST(ReleaseMemoryIntervals, TestEmpty) {
static struct MemoryIntervals mm[2] = {
{0, OPEN_MAX, 0, {}},
{0, OPEN_MAX, 0, {}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 2, 2));
}
TEST(ReleaseMemoryIntervals, TestRemoveElement_UsesInclusiveRange) {
static struct MemoryIntervals mm[2] = {
{3, OPEN_MAX, 0, {I(0, 0), I(2, 2), I(4, 4)}},
{2, OPEN_MAX, 0, {I(0, 0), I(4, 4)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 2, 2));
}
TEST(ReleaseMemoryIntervals, TestPunchHole) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(0, 9)}},
{2, OPEN_MAX, 0, {I(0, 3), I(6, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 4, 5));
}
TEST(ReleaseMemoryIntervals, TestShortenLeft) {
if (IsWindows()) return;
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(0, 9)}},
{1, OPEN_MAX, 0, {I(0, 7)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 8, 9));
}
TEST(ReleaseMemoryIntervals, TestShortenRight) {
if (IsWindows()) return;
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(0, 9)}},
{1, OPEN_MAX, 0, {I(3, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 0, 2));
}
TEST(ReleaseMemoryIntervals, TestShortenLeft2) {
if (IsWindows()) return;
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(0, 9)}},
{1, OPEN_MAX, 0, {I(0, 7)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 8, 11));
}
TEST(ReleaseMemoryIntervals, TestShortenRight2) {
if (IsWindows()) return;
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(0, 9)}},
{1, OPEN_MAX, 0, {I(3, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, -3, 2));
}
TEST(ReleaseMemoryIntervals, TestZeroZero) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(3, 9)}},
{1, OPEN_MAX, 0, {I(3, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 0, 0));
}
TEST(ReleaseMemoryIntervals, TestNoopLeft) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(3, 9)}},
{1, OPEN_MAX, 0, {I(3, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 1, 2));
}
TEST(ReleaseMemoryIntervals, TestNoopRight) {
static struct MemoryIntervals mm[2] = {
{1, OPEN_MAX, 0, {I(3, 9)}},
{1, OPEN_MAX, 0, {I(3, 9)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 10, 10));
}
TEST(ReleaseMemoryIntervals, TestBigFree) {
static struct MemoryIntervals mm[2] = {
{2, OPEN_MAX, 0, {I(0, 3), I(6, 9)}},
{0, OPEN_MAX, 0, {}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, INT_MIN, INT_MAX));
}
TEST(ReleaseMemoryIntervals, TestWeirdGap) {
static struct MemoryIntervals mm[2] = {
{3, OPEN_MAX, 0, {I(10, 10), I(20, 20), I(30, 30)}},
{2, OPEN_MAX, 0, {I(10, 10), I(30, 30)}},
};
mm[0].p = mm[0].s;
mm[1].p = mm[1].s;
EXPECT_NE(-1, RunReleaseMemoryIntervalsTest(mm, 15, 25));
}
| 11,044 | 353 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/getdosargv_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/runtime/internal.h"
#include "libc/testlib/testlib.h"
TEST(GetDosArgv, empty) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(0, GetDosArgv(u"", buf, size, argv, max));
EXPECT_EQ(NULL, argv[0]);
free(argv);
free(buf);
}
TEST(GetDosArgv, emptyish) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(0, GetDosArgv(u" ", buf, size, argv, max));
EXPECT_EQ(NULL, argv[0]);
free(argv);
free(buf);
}
TEST(GetDosArgv, basicUsage) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(3, GetDosArgv(u"a\t \"b c\" d ", buf, size, argv, max));
EXPECT_STREQ("a", argv[0]);
EXPECT_STREQ("b c", argv[1]);
EXPECT_STREQ("d", argv[2]);
EXPECT_EQ(NULL, argv[3]);
free(argv);
free(buf);
}
TEST(GetDosArgv, advancedUsage) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(2, GetDosArgv(u"(â¯Â°â¡Â°)â¯ï¸µ â»ââ»", buf, size, argv, max));
EXPECT_STREQ("(â¯Â°â¡Â°)â¯ï¸µ", argv[0]);
EXPECT_STREQ("â»ââ»", argv[1]);
EXPECT_EQ(NULL, argv[2]);
free(argv);
free(buf);
}
TEST(GetDosArgv, testAegeanGothicSupplementaryPlanes) {
size_t max = 4; /* these symbols are almost as old as dos */
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(2, GetDosArgv(u"ð·ð¸ð¹ðºð»ð¼ ð°ð±ð²ð³ð´ðµð¶ð·", buf, size, argv, max));
EXPECT_STREQ("ð·ð¸ð¹ðºð»ð¼", argv[0]);
EXPECT_STREQ("ð°ð±ð²ð³ð´ðµð¶ð·", argv[1]);
EXPECT_EQ(NULL, argv[2]);
free(argv);
free(buf);
}
TEST(GetDosArgv, realWorldUsage) {
size_t max = 512;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(5, GetDosArgv(u"C:\\Users\\jtunn\\printargs.com oh yes yes yes",
buf, size, argv, max));
EXPECT_STREQ("C:\\Users\\jtunn\\printargs.com", argv[0]);
EXPECT_STREQ("oh", argv[1]);
EXPECT_STREQ("yes", argv[2]);
EXPECT_STREQ("yes", argv[3]);
EXPECT_STREQ("yes", argv[4]);
EXPECT_EQ(NULL, argv[5]);
free(argv);
free(buf);
}
TEST(GetDosArgv, bufferOverrun_countIsStillAccurate_truncatesMemoryWithGrace) {
size_t max = 3;
size_t size = 7;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(3, GetDosArgv(u"a\t \"b c\" d ", buf, size, argv, max));
EXPECT_STREQ("a", argv[0]);
EXPECT_STREQ("b c", argv[1]);
EXPECT_EQ(NULL, argv[2]);
free(argv);
free(buf);
}
TEST(GetDosArgv, pureScanningMode) {
size_t max = 0;
size_t size = 0;
char *buf = NULL;
char **argv = NULL;
EXPECT_EQ(3, GetDosArgv(u"a b c", buf, size, argv, max));
}
TEST(GetDosArgv, justSlashQuote) {
size_t max = 4, size = 16;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(1, GetDosArgv(u"\"\\\\\\\"\"", buf, size, argv, max));
EXPECT_STREQ("\\\"", argv[0]);
free(argv);
free(buf);
}
TEST(GetDosArgv, quoteInMiddleOfArg_wontSplitArg) {
size_t max = 4, size = 16;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(1, GetDosArgv(u"hi\"\"there", buf, size, argv, max));
EXPECT_STREQ("hithere", argv[0]);
max = 4, size = 16;
EXPECT_EQ(1, GetDosArgv(u"hi\" \"there", buf, size, argv, max));
EXPECT_STREQ("hi there", argv[0]);
free(argv);
free(buf);
}
TEST(GetDosArgv, waqQuoting1) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(2,
GetDosArgv(u"a\\\\\"\"\"\"\"\"\"\"b c\" d", buf, size, argv, max));
EXPECT_STREQ("a\\\"\"b", argv[0]);
EXPECT_STREQ("c d", argv[1]);
EXPECT_EQ(NULL, argv[2]);
free(argv);
free(buf);
}
TEST(GetDosArgv, waqQuoting2) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(2, GetDosArgv(u"\"a\\\"b c\" d", buf, size, argv, max));
EXPECT_STREQ("a\"b c", argv[0]);
EXPECT_STREQ("d", argv[1]);
EXPECT_EQ(NULL, argv[2]);
free(argv);
free(buf);
}
TEST(GetDosArgv, cmdToil) {
size_t max = 4;
size_t size = ARG_MAX / 2;
char *buf = malloc(size * sizeof(char));
char **argv = malloc(max * sizeof(char *));
EXPECT_EQ(3, GetDosArgv(u"cmd.exe /C \"echo hi >\"\"\"ððð bar.txt\"\"\"\"",
buf, size, argv, max));
EXPECT_STREQ("cmd.exe", argv[0]);
EXPECT_STREQ("/C", argv[1]);
EXPECT_STREQ("echo hi >\"ððð bar.txt\"", argv[2]);
EXPECT_EQ(NULL, argv[3]);
free(argv);
free(buf);
}
| 6,863 | 187 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/sigsetjmp_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/calls/struct/siginfo.h"
#include "libc/calls/struct/sigset.h"
#include "libc/dce.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/sa.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/testlib.h"
#ifdef __x86_64__
sigjmp_buf jb;
volatile int sigs;
volatile int jumps;
void OnSignal(int sig, siginfo_t *si, void *ctx) {
++sigs;
}
TEST(sigsetjmp, test) {
if (IsWindows()) return; // no sigusr1 support
sigset_t ss;
int i, n = 1000;
struct sigaction sa = {.sa_sigaction = OnSignal};
ASSERT_SYS(0, 0, sigaction(SIGUSR1, &sa, 0));
for (i = 0; i < n; ++i) {
if (!sigsetjmp(jb, 1)) {
sigemptyset(&ss);
sigaddset(&ss, SIGUSR1);
ASSERT_SYS(0, 0, sigprocmask(SIG_BLOCK, &ss, 0));
ASSERT_SYS(0, 0, raise(SIGUSR1));
siglongjmp(jb, 1);
} else {
++jumps;
}
}
ASSERT_EQ(1000, jumps);
ASSERT_EQ(1000, sigs);
}
#endif /* __x86_64__ */
| 2,836 | 60 | jart/cosmopolitan | false |
cosmopolitan/test/libc/runtime/msync_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2023 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/msync.h"
#include "libc/sysv/consts/prot.h"
#include "libc/testlib/testlib.h"
TEST(msync, changeFileMappingAndExit) {
int ws;
char byte;
char *map;
ASSERT_SYS(0, 3, tmpfd());
ASSERT_SYS(0, 0, ftruncate(3, 4));
ASSERT_NE(MAP_FAILED,
(map = mmap(0, 4, PROT_READ | PROT_WRITE, MAP_SHARED, 3, 0)));
if (!fork()) {
map[0] = 1;
ASSERT_SYS(0, 0, msync(map, 4, MS_SYNC));
_Exit(123);
}
ASSERT_NE(-1, wait(&ws));
ASSERT_TRUE(WIFEXITED(ws));
ASSERT_EQ(123, WEXITSTATUS(ws));
ASSERT_SYS(0, 1, pread(3, &byte, 1, 0));
ASSERT_EQ(1, byte);
ASSERT_EQ(1, map[0]);
ASSERT_SYS(0, 0, munmap(map, 4));
ASSERT_SYS(0, 0, close(3));
}
| 2,630 | 48 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memcasecmp_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(memcasecmp, test) {
EXPECT_EQ(0, memcasecmp("HELLOHELLO", "hellohello", 10));
EXPECT_EQ(-17, memcasecmp("HELLOHELLO", "yelloyello", 10));
EXPECT_EQ(-17, memcasecmp("HELLOHELLO", "YELLOYELLO", 10));
EXPECT_EQ(+17, memcasecmp("yelloyello", "HELLOHELLO", 10));
EXPECT_EQ(0, memcasecmp("\0ELLo\0ELLo", "\0ELLO\0ELLO", 10));
EXPECT_NE(0, memcasecmp("\0ELLo\0ELLo", "\0ELL-\0ELL-", 10));
}
BENCH(memcasecmp, bench) {
volatile char *copy = gc(strdup(kHyperion));
EZBENCH2("memcasecmp", donothing,
EXPROPRIATE(memcasecmp(kHyperion, copy, kHyperionSize)));
}
| 2,609 | 40 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/longsort_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/alg.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "third_party/vqsort/vqsort.h"
void InsertionSort(int *A, int n) {
for (int i = 1; i < n; i++) {
int key = A[i];
int j = i - 1;
while (j >= 0 && A[j] > key) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}
int CompareLong(const void *a, const void *b) {
const long *x = a;
const long *y = b;
if (*x < *y) return -1;
if (*x > *y) return +1;
return 0;
}
TEST(_longsort, test) {
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
_longsort(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
#ifdef __x86_64__
TEST(vqsort_int64_avx2, test) {
if (!X86_HAVE(AVX2)) return;
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
vqsort_int64_avx2(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
TEST(vqsort_int64_sse4, test) {
if (!X86_HAVE(SSE4_2)) return;
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
vqsort_int64_sse4(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
TEST(vqsort_int64_ssse3, test) {
if (!X86_HAVE(SSSE3)) return;
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
vqsort_int64_ssse3(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
TEST(vqsort_int64_sse2, test) {
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
vqsort_int64_sse2(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
#endif /* __x86_64__ */
TEST(radix_sort_int64, test) {
size_t n = 5000;
long *a = gc(calloc(n, sizeof(long)));
long *b = gc(calloc(n, sizeof(long)));
rngset(a, n * sizeof(long), 0, 0);
memcpy(b, a, n * sizeof(long));
qsort(a, n, sizeof(long), CompareLong);
radix_sort_int64(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(long)));
}
BENCH(_longsort, bench) {
printf("\n");
size_t n = 5000;
long *p1 = gc(malloc(n * sizeof(long)));
long *p2 = gc(malloc(n * sizeof(long)));
rngset(p1, n * sizeof(long), 0, 0);
EZBENCH2("_longsort", memcpy(p2, p1, n * sizeof(long)), _longsort(p2, n));
#ifdef __x86_64__
if (X86_HAVE(AVX2)) {
EZBENCH2("vqsort_int64_avx2", memcpy(p2, p1, n * sizeof(long)),
vqsort_int64_avx2(p2, n));
}
if (X86_HAVE(SSE4_2)) {
EZBENCH2("vqsort_int64_sse4", memcpy(p2, p1, n * sizeof(long)),
vqsort_int64_sse4(p2, n));
}
if (X86_HAVE(SSSE3)) {
EZBENCH2("vqsort_int64_ssse3", memcpy(p2, p1, n * sizeof(long)),
vqsort_int64_ssse3(p2, n));
}
EZBENCH2("vqsort_int64_sse2", memcpy(p2, p1, n * sizeof(long)),
vqsort_int64_sse2(p2, n));
#endif /* __x86_64__ */
EZBENCH2("radix_sort_int64", memcpy(p2, p1, n * sizeof(long)),
radix_sort_int64(p2, n));
EZBENCH2("qsort(long)", memcpy(p2, p1, n * sizeof(long)),
qsort(p2, n, sizeof(long), CompareLong));
}
int CompareInt(const void *a, const void *b) {
const int *x = a;
const int *y = b;
if (*x < *y) return -1;
if (*x > *y) return +1;
return 0;
}
TEST(InsertionSort, test) {
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
InsertionSort(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
#ifdef __x86_64__
TEST(vqsort_int32_avx2, test) {
if (!X86_HAVE(AVX2)) return;
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
vqsort_int32_avx2(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
TEST(vqsort_int32_sse4, test) {
if (!X86_HAVE(SSE4_2)) return;
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
vqsort_int32_sse4(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
TEST(vqsort_int32_ssse3, test) {
if (!X86_HAVE(SSSE3)) return;
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
vqsort_int32_ssse3(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
TEST(vqsort_int32_sse2, test) {
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
vqsort_int32_sse2(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
#endif /* __x86_64__ */
TEST(radix_sort_int32, test) {
size_t n = 5000;
int *a = gc(calloc(n, sizeof(int)));
int *b = gc(calloc(n, sizeof(int)));
rngset(a, n * sizeof(int), 0, 0);
memcpy(b, a, n * sizeof(int));
qsort(a, n, sizeof(int), CompareInt);
radix_sort_int32(b, n);
ASSERT_EQ(0, memcmp(b, a, n * sizeof(int)));
}
BENCH(InsertionSort, bench) {
printf("\n");
size_t n = 10000;
int *p1 = gc(malloc(n * sizeof(int)));
int *p2 = gc(malloc(n * sizeof(int)));
rngset(p1, n * sizeof(int), 0, 0);
EZBENCH2("InsertionSort", memcpy(p2, p1, n * sizeof(int)),
InsertionSort(p2, n));
#ifdef __x86_64__
if (X86_HAVE(AVX2)) {
EZBENCH2("vqsort_int32_avx2", memcpy(p2, p1, n * sizeof(int)),
vqsort_int32_avx2(p2, n));
}
if (X86_HAVE(SSE4_2)) {
EZBENCH2("vqsort_int32_sse4", memcpy(p2, p1, n * sizeof(int)),
vqsort_int32_sse4(p2, n));
}
if (X86_HAVE(SSSE3)) {
EZBENCH2("vqsort_int32_ssse3", memcpy(p2, p1, n * sizeof(int)),
vqsort_int32_ssse3(p2, n));
}
EZBENCH2("vqsort_int32_sse2", memcpy(p2, p1, n * sizeof(int)),
vqsort_int32_sse2(p2, n));
#endif /* __x86_64__ */
EZBENCH2("djbsort", memcpy(p2, p1, n * sizeof(int)), djbsort(p2, n));
EZBENCH2("radix_sort_int32", memcpy(p2, p1, n * sizeof(int)),
radix_sort_int32(p2, n));
EZBENCH2("qsort(int)", memcpy(p2, p1, n * sizeof(int)),
qsort(p2, n, sizeof(int), CompareInt));
}
| 8,917 | 263 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memccpy_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
void *memccpy_pure(void *d, const void *s, int c, size_t n) {
size_t i;
unsigned char *x;
const unsigned char *y;
for (c &= 0xff, x = d, y = s, i = 0; i < n; ++i) {
if ((x[i] = y[i]) == c) return x + i + 1;
}
return NULL;
}
TEST(memccpy, testStringCopy) {
char buf[16];
EXPECT_EQ(buf + 3, memccpy(buf, "hi", '\0', sizeof(buf)));
EXPECT_STREQ("hi", buf);
}
TEST(memccpy, testOverflow) {
char buf[1];
EXPECT_EQ(NULL, memccpy(buf, "hi", '\0', sizeof(buf)));
}
TEST(memccpy, testZeroLength_doesNothing) {
char buf[1];
EXPECT_EQ(NULL, memccpy(buf, "hi", '\0', 0));
}
TEST(memccpy, memcpy) {
unsigned n, n1, n2;
char *b1, *b2, *b3, *e1, *e2;
for (n = 0; n < 1026; ++n) {
b1 = calloc(1, n);
b2 = calloc(1, n);
b3 = calloc(1, n);
rngset(b1, n, _rand64, -1);
e1 = memccpy_pure(b2, b1, 31337, n);
e2 = memccpy(b3, b1, 31337, n);
n1 = e1 ? e1 - b2 : n;
n2 = e2 ? e2 - b3 : n;
ASSERT_LE(n1, n);
ASSERT_LE(n2, n);
ASSERT_EQ(n1, n2,
"n=%ld\r\n\t"
"n1=%8ld e1=%p b2=%p %p\r\n\t"
"n2=%8ld e2=%p b3=%p %p\r\n\t"
"%#.*s\r\n\t"
"%#.*s\r\n\t"
"%#.*s",
n, n1, e1, b2, e1 - b2, n2, e2, b3, e2 - b3, n, b1, n, b2, n, b3);
ASSERT_EQ(0, memcmp(b2, b3, n2));
free(b3);
free(b2);
free(b1);
}
}
| 3,383 | 80 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/isutf8_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/runtime/symbols.internal.h"
#include "libc/str/str.h"
#include "libc/testlib/blocktronics.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
void SetUpOnce(void) {
GetSymbolTable();
ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
}
TEST(isutf8, good) {
ASSERT_TRUE(_isutf8("\0\1\2\3", 4));
EXPECT_TRUE(_isutf8(kHyperion, kHyperionSize));
EXPECT_TRUE(_isutf8("ð°ð±ð²ð³ð´ðµð¶ð·ââââââââââââ", -1));
EXPECT_TRUE(_isutf8("天å°çé» å®å®æ´ªè æ¥æçæ 辰宿åå¼ å¯æ¥æå¾ ç§æ¶å¬è"
"é°é¦æå² å¾åè°é³ äºè
¾è´é¨ é²ç»ä¸ºé éç丽水 çåºæå"
"åå·å·¨é ç 称å¤å
æçææ° èéè¥å§ æµ·å¸æ²³æ·¡ é³æ½ç¾½ç¿"
"é¾å¸ç«å¸ é¸å®äººç å§å¶æå ä¹æ衣裳 æ¨ä½è®©å½ æèé¶å",
-1));
}
TEST(isutf8, bad) {
ASSERT_FALSE(_isutf8("\300\200", -1)); // overlong nul
ASSERT_FALSE(_isutf8("\200\300", -1)); // latin1 c1 control code
ASSERT_FALSE(_isutf8("\300\300", -1)); // missing continuation
ASSERT_FALSE(_isutf8("\377\200\200\200\200", -1)); // thompson-pike varint
}
TEST(isutf8, oob) {
int n;
char *p;
for (n = 0; n < 32; ++n) {
p = memset(malloc(n), 'a', n);
ASSERT_TRUE(_isutf8(p, n));
free(p);
}
}
BENCH(isutf8, bench) {
EZBENCH_N("_isutf8", 0, _isutf8(0, 0));
EZBENCH_N("_isutf8", 5, _isutf8("hello", 5));
EZBENCH_N("_isutf8 ascii", kHyperionSize, _isutf8(kHyperion, kHyperionSize));
EZBENCH_N("_isutf8 unicode", kBlocktronicsSize,
_isutf8(kBlocktronics, kBlocktronicsSize));
}
| 3,666 | 69 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/classifypath_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/dce.h"
#include "libc/str/path.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(isabspath, testUniversal) {
ASSERT_TRUE(_isabspath("/home/jart/foo.txt"));
}
TEST(isabspath, testDosPaths) {
if (!SupportsWindows()) return;
ASSERT_FALSE(_isabspath("C:"));
ASSERT_FALSE(_isabspath("C:foo.txt"));
ASSERT_TRUE(_isabspath("C:/"));
ASSERT_TRUE(_isabspath("C:/Users/jart/foo.txt"));
ASSERT_TRUE(_isabspath("C:\\Users\\jart\\foo.txt"));
ASSERT_TRUE(_isabspath("\\Users\\jart\\foo.txt"));
}
TEST(isabspath, testWin32Paths) {
if (!SupportsWindows()) return;
ASSERT_TRUE(_isabspath("\\\\?\\C:\\.."));
ASSERT_TRUE(_isabspath("\\\\.\\C:\\Users\\jart\\foo.txt"));
}
TEST(isabspath, testNtPaths) {
if (!SupportsWindows()) return;
ASSERT_TRUE(_isabspath("\\??\\C:\\Users\\jart\\foo.txt"));
}
TEST(_classifypath, test) {
if (!SupportsWindows()) return;
EXPECT_EQ(0, _classifypath(""));
EXPECT_EQ(0, _classifypath("xyz"));
EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("CON"));
EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("NUL"));
EXPECT_EQ(0, _classifypath(":"));
EXPECT_EQ(_kPathDos, _classifypath("::"));
EXPECT_EQ(_kPathDos, _classifypath(":::"));
EXPECT_EQ(_kPathDos, _classifypath("::::"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("::\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\:"));
EXPECT_EQ(_kPathAbs, _classifypath("\\C:"));
EXPECT_EQ(_kPathAbs, _classifypath("\\C:\\"));
EXPECT_EQ(_kPathAbs, _classifypath("/"));
EXPECT_EQ(_kPathAbs, _classifypath("/:"));
EXPECT_EQ(_kPathAbs, _classifypath("/C:"));
EXPECT_EQ(_kPathAbs, _classifypath("/C:/"));
EXPECT_EQ(0, _classifypath("C"));
EXPECT_EQ(_kPathDos, _classifypath("C:"));
EXPECT_EQ(_kPathDos, _classifypath("C:a"));
EXPECT_EQ(_kPathDos, _classifypath("C:a\\"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\a"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/a"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\;"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\?\\UNC\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\?"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\C:\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\."));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\C:\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\/"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("/\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("///"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//;"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//?"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\?"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/?"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//??"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//."));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/."));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\."));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./C:/"));
}
| 6,501 | 122 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/highwayhash64_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2017 Google LLC â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/highwayhash64.h"
#include "libc/inttypes.h"
#include "libc/nexgen32e/crc32.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#include "third_party/zlib/zlib.h"
#define kMaxSize 64
static const uint64_t kTestKey1[4] = {
0x0706050403020100,
0x0F0E0D0C0B0A0908,
0x1716151413121110,
0x1F1E1D1C1B1A1918,
};
static const uint64_t kTestKey2[4] = {1, 2, 3, 4};
const uint64_t kExpected64[kMaxSize + 1] = {
0x907A56DE22C26E53, 0x7EAB43AAC7CDDD78, 0xB8D0569AB0B53D62,
0x5C6BEFAB8A463D80, 0xF205A46893007EDA, 0x2B8A1668E4A94541,
0xBD4CCC325BEFCA6F, 0x4D02AE1738F59482, 0xE1205108E55F3171,
0x32D2644EC77A1584, 0xF6E10ACDB103A90B, 0xC3BBF4615B415C15,
0x243CC2040063FA9C, 0xA89A58CE65E641FF, 0x24B031A348455A23,
0x40793F86A449F33B, 0xCFAB3489F97EB832, 0x19FE67D2C8C5C0E2,
0x04DD90A69C565CC2, 0x75D9518E2371C504, 0x38AD9B1141D3DD16,
0x0264432CCD8A70E0, 0xA9DB5A6288683390, 0xD7B05492003F028C,
0x205F615AEA59E51E, 0xEEE0C89621052884, 0x1BFC1A93A7284F4F,
0x512175B5B70DA91D, 0xF71F8976A0A2C639, 0xAE093FEF1F84E3E7,
0x22CA92B01161860F, 0x9FC7007CCF035A68, 0xA0C964D9ECD580FC,
0x2C90F73CA03181FC, 0x185CF84E5691EB9E, 0x4FC1F5EF2752AA9B,
0xF5B7391A5E0A33EB, 0xB9B84B83B4E96C9C, 0x5E42FE712A5CD9B4,
0xA150F2F90C3F97DC, 0x7FA522D75E2D637D, 0x181AD0CC0DFFD32B,
0x3889ED981E854028, 0xFB4297E8C586EE2D, 0x6D064A45BB28059C,
0x90563609B3EC860C, 0x7AA4FCE94097C666, 0x1326BAC06B911E08,
0xB926168D2B154F34, 0x9919848945B1948D, 0xA2A98FC534825EBE,
0xE9809095213EF0B6, 0x582E5483707BC0E9, 0x086E9414A88A6AF5,
0xEE86B98D20F6743D, 0xF89B7FF609B1C0A7, 0x4C7D9CC19E22C3E8,
0x9A97005024562A6F, 0x5DD41CF423E6EBEF, 0xDF13609C0468E227,
0x6E0DA4F64188155A, 0xB755BA4B50D7D4A1, 0x887A3484647479BD,
0xAB8EEBE9BF2139A0, 0x75542C5D4CD2A6FF,
};
uint32_t KnuthMultiplicativeHash32(const void *buf, size_t size) {
size_t i;
uint32_t h;
const uint32_t kPhiPrime = 0x9e3779b1;
const unsigned char *p = (const unsigned char *)buf;
for (h = i = 0; i < size; i++) h = (p[i] + h) * kPhiPrime;
return h;
}
void TestHash64(uint64_t expected, const uint8_t *data, size_t size,
const uint64_t *key) {
uint64_t hash = HighwayHash64(data, size, key);
if (expected != hash) {
printf("Test failed: expected %016" PRIx64 ", got %016" PRIx64
", size: %d\n",
expected, hash, (int)size);
exit(1);
}
}
TEST(highwayhash64, test) {
int i;
uint8_t data[kMaxSize + 1] = {0};
for (i = 0; i <= kMaxSize; i++) {
data[i] = i;
TestHash64(kExpected64[i], data, i, kTestKey1);
}
for (i = 0; i < 33; i++) {
data[i] = 128 + i;
}
TestHash64(0x53c516cce478cad7ull, data, 33, kTestKey2);
}
BENCH(highwayhash64, newbench) {
char fun[256];
rngset(fun, 256, _rand64, -1);
EZBENCH_N("highwayhash64", 0, HighwayHash64(0, 0, kTestKey1));
EZBENCH_N("highwayhash64", 8, HighwayHash64("helloooo", 8, kTestKey1));
EZBENCH_N("highwayhash64", 31, HighwayHash64(fun, 31, kTestKey1));
EZBENCH_N("highwayhash64", 32, HighwayHash64(fun, 32, kTestKey1));
EZBENCH_N("highwayhash64", 63, HighwayHash64(fun, 63, kTestKey1));
EZBENCH_N("highwayhash64", 64, HighwayHash64(fun, 64, kTestKey1));
EZBENCH_N("highwayhash64", 128, HighwayHash64(fun, 128, kTestKey1));
EZBENCH_N("highwayhash64", 256, HighwayHash64(fun, 256, kTestKey1));
EZBENCH_N("highwayhash64", kHyperionSize,
HighwayHash64(kHyperion, kHyperionSize, kTestKey1));
}
BENCH(highwayhash64, bench) {
EZBENCH2("knuth small", donothing,
EXPROPRIATE(KnuthMultiplicativeHash32(VEIL("r", "hello"), 5)));
EZBENCH2("crc32c small", donothing, crc32c(0, "hello", 5));
EZBENCH2("crc32 small", donothing,
EXPROPRIATE(crc32_z(0, VEIL("r", "hello"), 5)));
EZBENCH2("highwayhash64 small", donothing,
HighwayHash64((void *)"hello", 5, kTestKey1));
EZBENCH2("crc32 big", donothing, crc32_z(0, kHyperion, kHyperionSize));
EZBENCH2("crc32c big", donothing, crc32c(0, kHyperion, kHyperionSize));
EZBENCH2("highwayhash64 big", donothing,
HighwayHash64((void *)kHyperion, kHyperionSize, kTestKey1));
EZBENCH2("knuth big", donothing,
EXPROPRIATE(
KnuthMultiplicativeHash32(VEIL("r", kHyperion), kHyperionSize)));
}
| 6,217 | 130 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strcasestr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/dce.h"
#include "libc/intrin/bits.h"
#include "libc/mem/alg.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/str/internal.h"
#include "libc/str/tab.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#define MAKESTRING(NAME, VALUE) \
char *NAME = strcpy(malloc(sizeof(VALUE) + 16), VALUE)
char *strcasestr_naive(const char *haystack, const char *needle) {
size_t i;
unsigned k, m;
if (haystack == needle || !*needle) return haystack;
for (;;) {
for (i = 0;; ++i) {
if (!needle[i]) return (/*unconst*/ char *)haystack;
if (!haystack[i]) break;
if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255]) break;
}
if (!*haystack++) break;
}
return 0;
}
TEST(strcasestr, test_emptyString_isFoundAtBeginning) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[0], strcasestr(haystack, gc(strdup(""))));
free(haystack);
}
TEST(strcasestr, test_notFound) {
MAKESTRING(haystack, "abc123def");
ASSERT_EQ(NULL, strcasestr(haystack, gc(strdup("xyz"))));
ASSERT_EQ(NULL, strcasestr(haystack, gc(strdup("XYZ"))));
free(haystack);
}
TEST(strcasestr, test_notFound1) {
MAKESTRING(haystack, "abc123def");
ASSERT_EQ(NULL, strcasestr(haystack, gc(strdup("x"))));
ASSERT_EQ(NULL, strcasestr(haystack, gc(strdup("X"))));
free(haystack);
}
TEST(strcasestr, test_middleOfString) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[3], strcasestr(haystack, gc(strdup("123"))));
free(haystack);
}
TEST(strcasestr, test_endOfString) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[8], strcasestr(haystack, gc(strdup("f"))));
ASSERT_STREQ(&haystack[8], strcasestr(haystack, gc(strdup("F"))));
free(haystack);
}
TEST(strcasestr, test_secondXmmWord) {
MAKESTRING(haystack, "eeeeeeeeeeeeeeeebbbbbbbbbbb123");
ASSERT_STREQ(&haystack[27], strcasestr(haystack, gc(strdup("123"))));
free(haystack);
}
TEST(strcasestr, test_overlapsXmmWords) {
MAKESTRING(haystack, "eeeeeeeeeeeeeeeebbbbbbbbbbbbbbb");
ASSERT_STREQ(&haystack[15], strcasestr(haystack, gc(strdup("eb"))));
ASSERT_STREQ(&haystack[15], strcasestr(haystack, gc(strdup("Eb"))));
ASSERT_STREQ(&haystack[15], strcasestr(haystack, gc(strdup("eB"))));
free(haystack);
}
TEST(strcasestr, test) {
ASSERT_EQ(NULL, strcasestr("x86_64-linux-musl-gcc", "clang"));
ASSERT_STREQ("gcc", strcasestr("x86_64-linux-musl-gcc", "gcc"));
ASSERT_EQ(NULL, strcasestr("-Wl,--gc-sections", "stack-protector"));
ASSERT_EQ(NULL, strcasestr("-Wl,--gc-sections", "sanitize"));
ASSERT_STREQ("x", strcasestr("x", "x"));
}
/*
* strstr naive l: 103,057c 33,287ns m: 47,035c 15,192ns
* strstr l: 3,186c 1,029ns m: 3,218c 1,039ns
* strstr torture 1 l: 27c 9ns m: 61c 20ns
* strstr torture 2 l: 2,322c 750ns m: 2,362c 763ns
* strstr torture 4 l: 2,407c 777ns m: 2,448c 791ns
* strstr torture 8 l: 2,803c 905ns m: 2,862c 924ns
* strstr torture 16 l: 4,559c 1,473ns m: 3,614c 1,167ns
* strstr torture 32 l: 5,324c 1,720ns m: 5,577c 1,801ns
*
* strcasestr naive l: 129,908c 41,959ns m: 155,420c 50,200ns
* strcasestr l: 33,464c 10,809ns m: 31,636c 10,218ns
* strcasestr tort 1 l: 38c 12ns m: 69c 22ns
* strcasestr tort 2 l: 2,544c 822ns m: 2,580c 833ns
* strcasestr tort 4 l: 2,745c 887ns m: 2,767c 894ns
* strcasestr tort 8 l: 4,198c 1,356ns m: 4,216c 1,362ns
* strcasestr tort 16 l: 7,402c 2,391ns m: 7,487c 2,418ns
* strcasestr tort 32 l: 13,772c 4,448ns m: 12,945c 4,181ns
*/
BENCH(strcasestr, bench) {
EZBENCH2("strcasestr naive", donothing,
EXPROPRIATE(strcasestr_naive(kHyperion, "THE END")));
EZBENCH2("strcasestr", donothing,
EXPROPRIATE(strcasestr(kHyperion, "THE END")));
EZBENCH2("strcasestr tort 1", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"B")));
EZBENCH2("strcasestr tort 2", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"ab")));
EZBENCH2("strcasestr tort 4", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaab")));
EZBENCH2("strcasestr tort 8", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaab")));
EZBENCH2("strcasestr tort 16", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaaaaaaaaaab")));
EZBENCH2("strcasestr tort 32", donothing,
EXPROPRIATE(strcasestr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab")));
}
| 8,186 | 165 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memcpy_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(memcpy, test) {
char *b1, *b2;
for (unsigned n = 0; n < 1026; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1, memcpy(b1, b2, n), "%ld\n\t%#.*s\n\t%#.*s", n, n, b1, n, b2);
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
for (unsigned n = kHalfCache3 - 1; n < kHalfCache3 + 2; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1, memcpy(b1, b2, n), "%ld\n\t%#.*s\n\t%#.*s", n, n, b1, n, b2);
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
}
TEST(mempcpy, test) {
char *b1, *b2;
for (unsigned n = 0; n < 1026; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1 + n, mempcpy(b1, b2, n));
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
for (unsigned n = kHalfCache3 - 1; n < kHalfCache3 + 2; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1 + n, mempcpy(b1, b2, n));
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
}
TEST(memcpy, direct) {
char *b1, *b2;
for (unsigned n = 0; n < 1026; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1, (memcpy)(b1, b2, n), "%ld\n\t%#.*s\n\t%#.*s", n, n, b1, n,
b2);
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
for (unsigned n = kHalfCache3 - 1; n < kHalfCache3 + 2; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1, (memcpy)(b1, b2, n), "%ld\n\t%#.*s\n\t%#.*s", n, n, b1, n,
b2);
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
}
TEST(mempcpy, direct) {
char *b1, *b2;
for (unsigned n = 0; n < 1026; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1 + n, (mempcpy)(b1, b2, n));
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
for (unsigned n = kHalfCache3 - 1; n < kHalfCache3 + 2; ++n) {
b1 = malloc(n);
b2 = malloc(n);
rngset(b1, n, _rand64, -1);
rngset(b2, n, _rand64, -1);
ASSERT_EQ(b1 + n, (mempcpy)(b1, b2, n));
ASSERT_EQ(0, memcmp(b1, b2, n));
free(b2);
free(b1);
}
}
TEST(memcpy, overlapping_isFineIfCopyingBackwards) {
for (size_t i = 0; i < 32; ++i) {
char *b1 = malloc(64 + i);
char *b2 = malloc(64 + i);
memcpy(b1, b2, 64);
memcpy(b1, b1 + i, 64 - i);
memmove(b2, b2 + i, 64 - i);
ASSERT_EQ(0, memcmp(b1, b2, 64));
free(b2);
free(b1);
}
}
TEST(stpcpy, test) {
volatile char *p;
volatile char b[16];
volatile const char *s1 = "hello";
volatile const char *s2 = "there";
p = b;
p = stpcpy(p, s1);
EXPECT_EQ((intptr_t)b + 5, (intptr_t)p);
EXPECT_STREQ("hello", b);
p = stpcpy(p, s2);
EXPECT_EQ((intptr_t)b + 10, (intptr_t)p);
EXPECT_STREQ("hellothere", b);
}
TEST(memcpy, testBackwardsOverlap3) {
volatile char *c;
c = malloc(3);
memcpy(c, "\e[C", 3);
memcpy(c, c + 1, VEIL("r", 3) - 1);
EXPECT_EQ('[', c[0]);
EXPECT_EQ('C', c[1]);
free(c);
}
#define B(F, N) \
do { \
char *d = rngset(malloc(N), N, _rand64, -1); \
char *s = rngset(malloc(N), N, _rand64, -1); \
EZBENCH2(#F " " #N, donothing, \
EXPROPRIATE(F(VEIL("r", d), VEIL("r", s), N))); \
free(d); \
free(s); \
} while (0)
void BB(size_t N) {
B(memcpy, N);
(fprintf)(stderr, "\n");
}
BENCH(memcpy, bench) {
BB(0);
BB(1);
BB(2);
BB(3);
BB(7);
BB(8);
BB(15);
BB(16);
BB(31);
BB(32);
BB(63);
BB(64);
BB(255);
BB(256);
BB(1023);
BB(1024);
BB(PAGESIZE);
BB(FRAMESIZE);
}
| 6,241 | 198 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/str_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/intrin/bits.h"
#include "libc/testlib/testlib.h"
TEST(strlen16, testEmpty) {
EXPECT_EQ(0, strlen16(u""));
}
TEST(strlen16, testAscii) {
EXPECT_EQ(5, strlen16(u"hello"));
}
TEST(strlen16, testUnicode) {
EXPECT_EQ(28, strlen16(u"αcϵαlly pδrÏαblε εxεcµÏαblε"));
}
TEST(len, testAegeanNumberSupplementaryPlane) {
EXPECT_EQ(36, strlen("ð·ð¸ð¹ðºð»ð¼ð½ð¾ð¿"));
EXPECT_EQ(18, strlen16(u"ð·ð¸ð¹ðºð»ð¼ð½ð¾ð¿"));
EXPECT_EQ(9, wcslen(L"ð·ð¸ð¹ðºð»ð¼ð½ð¾ð¿"));
EXPECT_EQ(9, wcslen(L"ð·ð¸ð¹ðºð»ð¼ð½ð¾ð¿"));
}
TEST(strlen16, testCoolKidNulTerminator) {
union {
uint8_t s8[6];
char16_t s16[3];
} u = {.s8 = {0x00, 0xd8, 0x00, 0xdc, 0x00, 0x00}};
EXPECT_EQ(2, strlen16(u.s16));
}
| 2,658 | 48 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/bzero_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(bzero, test) {
int n;
char *a, *b;
a = gc(malloc(128));
b = gc(malloc(128));
for (n = 0; n < 128; ++n) {
rngset(a, 128, _rand64, -1);
memcpy(b, a, 128);
bzero(a, n);
memset(b, 0, n);
ASSERT_EQ(0, memcmp(a, b, 128), "%d", n);
}
}
void explicit_memset(void *, int, size_t) asm("memset");
char doge[129];
BENCH(bzero, bench) {
EZBENCH2("bzero 0", donothing, explicit_bzero(doge, 0));
EZBENCH2("memset 0", donothing, explicit_memset(doge, 0, 0));
EZBENCH2("bzero 1", donothing, explicit_bzero(doge, 1));
EZBENCH2("memset 1", donothing, explicit_memset(doge, 0, 1));
EZBENCH2("bzero 2", donothing, explicit_bzero(doge, 2));
EZBENCH2("memset 2", donothing, explicit_memset(doge, 0, 2));
EZBENCH2("bzero 4", donothing, explicit_bzero(doge, 4));
EZBENCH2("memset 4", donothing, explicit_memset(doge, 0, 4));
EZBENCH2("bzero 8", donothing, explicit_bzero(doge, 8));
EZBENCH2("memset 8", donothing, explicit_memset(doge, 0, 8));
EZBENCH2("bzero 16", donothing, explicit_bzero(doge, 16));
EZBENCH2("memset 16", donothing, explicit_memset(doge, 0, 16));
EZBENCH2("bzero 31", donothing, explicit_bzero(doge, 31));
EZBENCH2("memset 31", donothing, explicit_memset(doge, 0, 31));
EZBENCH2("bzero 32", donothing, explicit_bzero(doge, 32));
EZBENCH2("memset 32", donothing, explicit_memset(doge, 0, 32));
EZBENCH2("bzero 33", donothing, explicit_bzero(doge, 33));
EZBENCH2("memset 33", donothing, explicit_memset(doge, 0, 33));
EZBENCH2("bzero 64", donothing, explicit_bzero(doge, 64));
EZBENCH2("memset 64", donothing, explicit_memset(doge, 0, 64));
EZBENCH2("bzero 127", donothing, explicit_bzero(doge, 127));
EZBENCH2("memset 127", donothing, explicit_memset(doge, 0, 127));
EZBENCH2("bzero 128", donothing, explicit_bzero(doge, 128));
EZBENCH2("memset 128", donothing, explicit_memset(doge, 0, 128));
EZBENCH2("bzero 0 [misalign]", donothing, explicit_bzero(doge + 1, 0));
EZBENCH2("memset 0 [misalign]", donothing, explicit_memset(doge + 1, 0, 0));
EZBENCH2("bzero 1 [misalign]", donothing, explicit_bzero(doge + 1, 1));
EZBENCH2("memset 1 [misalign]", donothing, explicit_memset(doge + 1, 0, 1));
EZBENCH2("bzero 2 [misalign]", donothing, explicit_bzero(doge + 1, 2));
EZBENCH2("memset 2 [misalign]", donothing, explicit_memset(doge + 1, 0, 2));
EZBENCH2("bzero 4 [misalign]", donothing, explicit_bzero(doge + 1, 4));
EZBENCH2("memset 4 [misalign]", donothing, explicit_memset(doge + 1, 0, 4));
EZBENCH2("bzero 8 [misalign]", donothing, explicit_bzero(doge + 1, 8));
EZBENCH2("memset 8 [misalign]", donothing, explicit_memset(doge + 1, 0, 8));
EZBENCH2("bzero 16 [misalign]", donothing, explicit_bzero(doge + 1, 16));
EZBENCH2("memset 16 [misalign]", donothing, explicit_memset(doge + 1, 0, 16));
EZBENCH2("bzero 31 [misalign]", donothing, explicit_bzero(doge + 1, 31));
EZBENCH2("memset 31 [misalign]", donothing, explicit_memset(doge + 1, 0, 31));
EZBENCH2("bzero 32 [misalign]", donothing, explicit_bzero(doge + 1, 32));
EZBENCH2("memset 32 [misalign]", donothing, explicit_memset(doge + 1, 0, 32));
EZBENCH2("bzero 33 [misalign]", donothing, explicit_bzero(doge + 1, 33));
EZBENCH2("memset 33 [misalign]", donothing, explicit_memset(doge + 1, 0, 33));
EZBENCH2("bzero 64 [misalign]", donothing, explicit_bzero(doge + 1, 64));
EZBENCH2("memset 64 [misalign]", donothing, explicit_memset(doge + 1, 0, 64));
EZBENCH2("bzero 127 [misalign]", donothing, explicit_bzero(doge + 1, 127));
EZBENCH2("memset 127 [misalign]", donothing,
explicit_memset(doge + 1, 0, 127));
EZBENCH2("bzero 128 [misalign]", donothing, explicit_bzero(doge + 1, 128));
EZBENCH2("memset 128 [misalign]", donothing,
explicit_memset(doge + 1, 0, 128));
}
| 5,822 | 97 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/crc32c_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/dce.h"
#include "libc/intrin/bits.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/crc32.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#include "third_party/zlib/zlib.h"
#define FANATICS "Fanatics"
static const char hyperion[] =
FANATICS " have their dreams, wherewith they weave / "
"A paradise for a sect; the savage too / "
"From forth the loftiest fashion of his sleep / "
"...";
TEST(crc32c, test) {
EXPECT_EQ(0, crc32c(0, "", 0));
EXPECT_EQ(crc32c(0, "hello", 5), crc32c(0, "hello", 5));
EXPECT_EQ(0xe3069283, crc32c(0, "123456789", 9));
EXPECT_EQ(0x6d6eefba, crc32c(0, hyperion, strlen(hyperion)));
EXPECT_EQ(0x6d6eefba, crc32c(crc32c(0, FANATICS, strlen(FANATICS)),
hyperion + strlen(FANATICS),
strlen(hyperion) - strlen(FANATICS)));
EXPECT_EQ(0xf372f045, crc32c(0, hyperion + 1, strlen(hyperion) - 1));
EXPECT_EQ(0x5aaad5f8, crc32c(0, hyperion + 7, strlen(hyperion) - 7));
EXPECT_EQ(0xf8e51ea6, crc32c(0, hyperion + 7, strlen(hyperion) - 8));
EXPECT_EQ(0xecc9871d, crc32c(0, kHyperion, kHyperionSize));
}
dontinline uint64_t fnv_hash(char *s, int len) {
uint64_t hash = 0xcbf29ce484222325;
for (int i = 0; i < len; i++) {
hash *= 0x100000001b3;
hash ^= (unsigned char)s[i];
}
return hash;
}
static unsigned KMH(const void *p, unsigned long n) {
unsigned h, i;
for (h = i = 0; i < n; i++) {
h += ((unsigned char *)p)[i];
h *= 0x9e3779b1;
}
return MAX(1, h);
}
BENCH(crc32c, bench) {
for (int i = 1; i < 256; i *= 2) {
EZBENCH_N("crc32c", i, crc32c(0, kHyperion, i));
EZBENCH_N("crc32_z", i, crc32_z(0, kHyperion, i));
EZBENCH_N("fnv_hash", i,
EXPROPRIATE(fnv_hash(VEIL("r", kHyperion), VEIL("r", i))));
EZBENCH_N("KMH", i, EXPROPRIATE(KMH(VEIL("r", kHyperion), VEIL("r", i))));
fprintf(stderr, "\n");
}
EZBENCH_N("crc32c", kHyperionSize, crc32c(0, kHyperion, kHyperionSize));
EZBENCH_N("crc32_z", kHyperionSize, crc32_z(0, kHyperion, kHyperionSize));
EZBENCH_N(
"fnv_hash", kHyperionSize,
EXPROPRIATE(fnv_hash(VEIL("r", kHyperion), VEIL("r", kHyperionSize))));
EZBENCH_N("KMH", kHyperionSize,
EXPROPRIATE(KMH(VEIL("r", kHyperion), VEIL("r", kHyperionSize))));
}
| 4,346 | 89 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/blake2_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/assert.h"
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/str/blake2.h"
#include "libc/str/str.h"
#include "libc/str/tab.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
uint8_t *EZBLAKE2B256(const char *s, size_t n) {
static uint8_t digest[BLAKE2B256_DIGEST_LENGTH];
BLAKE2B256(s, n, digest);
return digest;
}
uint8_t *HEXBLAKE2B256(const char *s) {
char *p;
int a, b;
size_t i, n;
static uint8_t digest[BLAKE2B256_DIGEST_LENGTH];
n = strlen(s);
assert(!(n & 1));
n /= 2;
p = malloc(n);
for (i = 0; i < n; ++i) {
a = kHexToInt[s[i * 2 + 0] & 255];
b = kHexToInt[s[i * 2 + 1] & 255];
assert(a != -1);
assert(b != -1);
p[i] = a << 4 | b;
}
BLAKE2B256(p, n, digest);
free(p);
return digest;
}
TEST(BLAKE2B256Test, ABC) {
EXPECT_BINEQ(
"bddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319",
EZBLAKE2B256("abc", 3));
EXPECT_BINEQ(
"0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8",
HEXBLAKE2B256(""));
EXPECT_BINEQ(
"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314",
HEXBLAKE2B256("00"));
/* TODO(jart): do rest */
}
BENCH(blake2, bench) {
char fun[256];
rngset(fun, 256, _rand64, -1);
EZBENCH_N("blake2b256", 0, EZBLAKE2B256(0, 0));
EZBENCH_N("blake2b256", 8, EZBLAKE2B256("helloooo", 8));
EZBENCH_N("blake2b256", 31, EZBLAKE2B256(fun, 31));
EZBENCH_N("blake2b256", 32, EZBLAKE2B256(fun, 32));
EZBENCH_N("blake2b256", 63, EZBLAKE2B256(fun, 63));
EZBENCH_N("blake2b256", 64, EZBLAKE2B256(fun, 64));
EZBENCH_N("blake2b256", 128, EZBLAKE2B256(fun, 128));
EZBENCH_N("blake2b256", 256, EZBLAKE2B256(fun, 256));
EZBENCH_N("blake2b256", kHyperionSize,
EZBLAKE2B256(kHyperion, kHyperionSize));
}
| 3,705 | 83 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strcpy_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(strcpy, test) {
char buf[64];
EXPECT_STREQ("hello", strcpy(buf, "hello"));
EXPECT_STREQ("hello there what's up", strcpy(buf, "hello there what's up"));
}
TEST(strncpy, test) {
char b[8] = {0, 1, 2, 3, 4, 5, 6, 7};
strncpy(b, "key", 8);
ASSERT_EQ('k', b[0]);
ASSERT_EQ('e', b[1]);
ASSERT_EQ('y', b[2]);
ASSERT_EQ('\0', b[3]);
ASSERT_EQ('\0', b[4]);
ASSERT_EQ('\0', b[5]);
ASSERT_EQ('\0', b[6]);
ASSERT_EQ('\0', b[7]);
}
TEST(strncpy, testSameLength_isNotNulTerminated) {
char b[8] = {0, 1, 2, 3, 4, 5, 6, 7};
strncpy(b, "keyword", 7);
ASSERT_EQ('k', b[0]);
ASSERT_EQ('e', b[1]);
ASSERT_EQ('y', b[2]);
ASSERT_EQ('w', b[3]);
ASSERT_EQ('o', b[4]);
ASSERT_EQ('r', b[5]);
ASSERT_EQ('d', b[6]);
ASSERT_EQ(7, b[7]);
}
BENCH(strcpy, bench) {
extern char *strcpy_(char *, const char *) asm("strcpy");
static char buf[1024], buf2[1024];
memset(buf2, -1, sizeof(buf2) - 1);
EZBENCH2("strcpy 1", donothing, strcpy_(buf, ""));
EZBENCH2("strcpy 2", donothing, strcpy_(buf, "1"));
EZBENCH2("strcpy 7", donothing, strcpy_(buf, "123456"));
EZBENCH2("strcpy 8", donothing, strcpy_(buf, "1234567"));
EZBENCH2("strcpy 9", donothing, strcpy_(buf, "12345678"));
EZBENCH2("strcpy 16", donothing, strcpy_(buf, "123456781234567"));
EZBENCH2("strcpy 1023", donothing, strcpy_(buf, buf2));
}
| 3,269 | 67 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/crc32z_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/assert.h"
#include "libc/dce.h"
#include "libc/intrin/asan.internal.h"
#include "libc/intrin/bits.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/crc32.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#include "third_party/zlib/zlib.h"
#define FANATICS "Fanatics"
static const char hyperion[] =
FANATICS " have their dreams, wherewith they weave / "
"A paradise for a sect; the savage too / "
"From forth the loftiest fashion of his sleep / "
"...";
TEST(crc32_z, test) {
char *p;
p = gc(strdup(kHyperion));
EXPECT_EQ(0, crc32_z(0, 0, 0));
EXPECT_EQ(0, crc32_z(0, "", 0));
EXPECT_EQ(0xcbf43926, crc32_z(0, "123456789", 9));
EXPECT_EQ(0xc386e7e4, crc32_z(0, hyperion, strlen(hyperion)));
EXPECT_EQ(0xc386e7e4, crc32_z(crc32_z(0, FANATICS, strlen(FANATICS)),
hyperion + strlen(FANATICS),
strlen(hyperion) - strlen(FANATICS)));
EXPECT_EQ(0xcbfc3df2, crc32_z(0, hyperion + 1, strlen(hyperion) - 1));
EXPECT_EQ(0x9feb0e30, crc32_z(0, hyperion + 7, strlen(hyperion) - 7));
EXPECT_EQ(0x5b80e54e, crc32_z(0, hyperion + 7, strlen(hyperion) - 8));
EXPECT_EQ(0xe9ded8e6, crc32_z(0, p, kHyperionSize));
}
BENCH(crc32_z, bench) {
EZBENCH_N("crc32_z", kHyperionSize, crc32_z(0, kHyperion, kHyperionSize));
EZBENCH_N("crc32_z", kHyperionSize, crc32_z(0, kHyperion, kHyperionSize));
}
| 3,449 | 62 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/tpenc_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/limits.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/intrin/tpenc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
STATIC_YOINK("strwidth");
volatile uint64_t v;
TEST(_tpenc, test) {
EXPECT_EQ(0, _tpenc(0));
EXPECT_EQ(1, _tpenc(1));
EXPECT_EQ(' ', _tpenc(' '));
EXPECT_EQ(0x7f, _tpenc(0x7f));
EXPECT_EQ(0x008496E2, _tpenc(L'â'));
EXPECT_EQ(0x8080808080FEul, _tpenc(INT_MIN));
}
TEST(_tpenc, theimp) {
ASSERT_EQ(0x88989FF0, _tpenc(L'ð'));
}
TEST(_tpenc, testBeyondTheStandard) {
ASSERT_EQ(0xBFBFBFBFBFFF, _tpenc(-1));
}
uint64_t _Tpenc(int x) {
return (v = EXPROPRIATE(_tpenc(VEIL("r", x))));
}
BENCH(_tpenc, bench) {
EZBENCH(donothing, _Tpenc(0));
EZBENCH(donothing, _Tpenc(1));
EZBENCH(donothing, _Tpenc(' '));
EZBENCH(donothing, _Tpenc(0x7f));
EZBENCH(donothing, _Tpenc(L'â'));
EZBENCH(donothing, _Tpenc(-1));
EZBENCH(donothing, _Tpenc(INT_MIN));
fprintf(stderr, "\n");
}
| 2,852 | 62 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/hexpcpy_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/macros.internal.h"
#include "libc/stdio/rand.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(hexpcpy, test) {
char buf[] = {0x00, 0x02, 0x20, 0x80, 0xf5, 0xff};
char str[ARRAYLEN(buf) * 2 + 1];
rngset(str, sizeof(str), _rand64, -1);
EXPECT_EQ(str + ARRAYLEN(buf) * 2, hexpcpy(str, buf, ARRAYLEN(buf)));
EXPECT_STREQ("00022080f5ff", str);
}
TEST(hexpcpy, emptyBuf_writesNulTerminator) {
char buf[1];
char str[1];
rngset(str, sizeof(str), _rand64, -1);
EXPECT_EQ(str, hexpcpy(str, buf, 0));
EXPECT_STREQ("", str);
}
| 2,407 | 39 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strnwidth_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/assert.h"
#include "libc/str/strwidth.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(strwidth, test) {
EXPECT_EQ(5, strwidth("hello", 0));
EXPECT_EQ(5, strwidth("\1he\e[0;0mllo\e#8", 0));
EXPECT_EQ(10, strwidth("ＨＥＬＬＯ", 0));
}
TEST(strwidth, tab) {
EXPECT_EQ(8, strwidth("\t", 0));
EXPECT_EQ(8, strwidth(" \t", 0));
EXPECT_EQ(8, strwidth(" \t", 0));
EXPECT_EQ(16, strwidth(" \t", 0));
}
TEST(strwidth, hyperion) {
ASSERT_EQ(22304, strwidth(kHyperion, 0));
}
TEST(strwidth, chinese) {
ASSERT_EQ(53 * 4,
strwidth("天å°çé» å®å®æ´ªè æ¥æçæ 辰宿åå¼ å¯æ¥æå¾ ç§æ¶å¬è"
"é°é¦æå² å¾åè°é³ äºè
¾è´é¨ é²ç»ä¸ºé éç丽水 çåºæå"
"åå·å·¨é ç 称å¤å
æçææ° èéè¥å§ æµ·å¸æ²³æ·¡ é³æ½ç¾½ç¿"
"é¾å¸ç«å¸ é¸å®äººç å§å¶æå ä¹æ衣裳 æ¨ä½è®©å½ æèé¶å",
0));
}
TEST(strwidth, cjk) {
ASSERT_EQ(37, strwidth("거주íë ì¬ëë¤ ì¤ìì íêµì´ë¥¼ ì£¼ë¡ ", 0));
}
BENCH(strnwidth, bench) {
EZBENCH2("strnwidth", donothing, EXPROPRIATE(strnwidth(kHyperion, -1, 0)));
}
| 3,114 | 58 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/wmemrchr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(wmemrchr, test) {
EXPECT_EQ(NULL, wmemrchr(L"yo.hi.thereeuhcruhrceeuhcre", '-', 27));
EXPECT_STREQ(L".there", wmemrchr(L"yo.hi.there", '.', 11));
EXPECT_STREQ(L".thereeuhcruhrceeuhcre",
wmemrchr(L"yo.hi.thereeuhcruhrceeuhcre", '.', 27));
}
BENCH(wmemrchr, bench) {
EZBENCH2("wmemrchr", donothing,
EXPROPRIATE(wmemrchr(L"yo.hi.there", '.', 11)));
}
| 2,354 | 35 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/a64l_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/errno.h"
#include "libc/limits.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(l64a, test) {
EXPECT_STREQ("", l64a(0));
EXPECT_STREQ("zzzzz/", l64a(0x7fffffff));
}
TEST(a64l, test) {
EXPECT_EQ(0, a64l(""));
EXPECT_EQ(0x7fffffff, a64l("zzzzz/"));
}
dontinline long openbsd_a64l(const char *s) {
long value, digit, shift;
int i;
if (s == NULL) {
errno = EINVAL;
return (-1L);
}
value = 0;
shift = 0;
for (i = 0; *s && i < 6; i++, s++) {
if (*s >= '.' && *s <= '/')
digit = *s - '.';
else if (*s >= '0' && *s <= '9')
digit = *s - '0' + 2;
else if (*s >= 'A' && *s <= 'Z')
digit = *s - 'A' + 12;
else if (*s >= 'a' && *s <= 'z')
digit = *s - 'a' + 38;
else {
errno = EINVAL;
return (-1L);
}
value |= digit << shift;
shift += 6;
}
return (value);
}
dontinline char *openbsd_l64a(long value) {
static char buf[8];
char *s = buf;
int digit;
int i;
if (value < 0) {
errno = EINVAL;
return (NULL);
}
for (i = 0; value != 0 && i < 6; i++) {
digit = value & 0x3f;
if (digit < 2)
*s = digit + '.';
else if (digit < 12)
*s = digit + '0' - 2;
else if (digit < 38)
*s = digit + 'A' - 12;
else
*s = digit + 'a' - 38;
value >>= 6;
s++;
}
*s = '\0';
return (buf);
}
TEST(openbsd, consistency) {
long i;
for (i = 0; i < 512; ++i) {
ASSERT_STREQ(openbsd_l64a(i), l64a(i));
ASSERT_EQ(openbsd_a64l(openbsd_l64a(i)), a64l(l64a(i)));
}
for (i = INT_MAX; i > INT_MAX - 100; --i) {
ASSERT_STREQ(openbsd_l64a(i), l64a(i));
ASSERT_EQ(openbsd_a64l(openbsd_l64a(i)), a64l(l64a(i)));
}
}
BENCH(a64l, bench) {
EZBENCH2("l64a", donothing, l64a(INT_MAX));
EZBENCH2(
"a64l", donothing,
a64l("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
EZBENCH2("openbsd_l64a", donothing, openbsd_l64a(INT_MAX));
EZBENCH2(
"openbsd_a64l", donothing,
openbsd_a64l(
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
| 3,970 | 112 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memrchr16_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(memrchr16, test) {
EXPECT_EQ(NULL, memrchr16(u"yo.hi.thereeuhcruhrceeuhcre", '-', 27));
EXPECT_STREQ(u".there", memrchr16(u"yo.hi.there", '.', 11));
EXPECT_STREQ(u".thereeuhcruhrceeuhcre",
memrchr16(u"yo.hi.thereeuhcruhrceeuhcre", '.', 27));
}
BENCH(memrchr16, bench) {
EZBENCH2("memrchr16", donothing,
EXPROPRIATE(memrchr16(u"yo.hi.there", '.', 11)));
EZBENCH2("memrchr16 hyperion", donothing,
EXPROPRIATE(memrchr16(kHyperion, '.', kHyperionSize / 2)));
}
| 2,514 | 38 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strtolower_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(strntolower, test) {
char s[128] = "ABCD";
strntolower(s, -1);
EXPECT_STREQ("abcd", s);
}
TEST(strntolower, testLong) {
char s[128] = "ABCDabcdABCDabcdABCDabcdABCDabcdABCDabcd";
strntolower(s, -1);
EXPECT_STREQ("abcdabcdabcdabcdabcdabcdabcdabcdabcdabcd", s);
}
| 2,206 | 34 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strtok_r_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(strtok_r, testEmpty) {
static const char *const kInput = "";
static const char *const kSeparators = "/";
char *s = strcpy(malloc(strlen(kInput) + 1), kInput);
char *state;
EXPECT_EQ(NULL, strtok_r(s, kSeparators, &state));
free(s);
}
TEST(strtok_r, test) {
static const char *const kInput = ".,lol..cat..";
static const char *const kSeparators = ".,";
char *s = strcpy(malloc(strlen(kInput) + 1), kInput);
char *state;
EXPECT_STREQ("lol", strtok_r(s, kSeparators, &state));
EXPECT_STREQ("cat", strtok_r(NULL, kSeparators, &state));
EXPECT_EQ(NULL, strtok_r(NULL, kSeparators, &state));
EXPECT_EQ(NULL, strtok_r(NULL, kSeparators, &state));
free(s);
}
TEST(strtok, test) {
static const char *const kInput = ".,lol..cat..";
static const char *const kSeparators = ".,";
char *s = strcpy(malloc(strlen(kInput) + 1), kInput);
EXPECT_STREQ("lol", strtok(s, kSeparators));
EXPECT_STREQ("cat", strtok(NULL, kSeparators));
EXPECT_EQ(NULL, strtok(NULL, kSeparators));
EXPECT_EQ(NULL, strtok(NULL, kSeparators));
free(s);
}
TEST(strtok_r, testHostsTxtLine) {
static const char *const kInput = "203.0.113.1 lol.example. lol";
static const char *const kSeparators = " \t";
char *s = strcpy(malloc(strlen(kInput) + 1), kInput);
char *state;
EXPECT_STREQ("203.0.113.1", strtok_r(s, kSeparators, &state));
EXPECT_STREQ("lol.example.", strtok_r(NULL, kSeparators, &state));
EXPECT_STREQ("lol", strtok_r(NULL, kSeparators, &state));
EXPECT_EQ(NULL, strtok_r(NULL, kSeparators, &state));
free(s);
}
| 3,479 | 66 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/wcwidth_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "libc/str/strwidth.h"
#include "libc/str/unicode.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(wcwidth, test) {
ASSERT_EQ(0, wcwidth(0));
ASSERT_EQ(-1, wcwidth(1));
ASSERT_EQ(-1, wcwidth(-7));
ASSERT_EQ(1, wcwidth(0x10FFFD));
ASSERT_EQ(-1, wcwidth(0x10FFFD + 1));
}
TEST(strwidth, testCjkWidesAndCombiningLowLines_withThompsonPikeEncoding) {
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââ¬â*/
EXPECT_EQ(20, strwidth(/**/ "ð°ð±ð²ð³ð´ðµð¶ð·ââââââââââââ" /*â*/, 0));
EXPECT_EQ(20, strwidth(/**/ "(â¯Â°â¡Â°)â¯ð»ï¸µ ̲â»Ì²â̲â»ââââââ" /*â*/, 0));
EXPECT_EQ(20, strwidth(/**/ "ã¡ãã¶å°è¿ãââââââââ" /*â*/, 0));
EXPECT_EQ(68, strlen(/*ââ*/ "ð°ð±ð²ð³ð´ðµð¶ð·ââââââââââââ" /*â*/));
EXPECT_EQ(56, strlen(/*ââ*/ "(â¯Â°â¡Â°)â¯ð»ï¸µ ̲â»Ì²â̲â»ââââââ" /*â*/));
EXPECT_EQ(42, strlen(/*ââ*/ "ã¡ãã¶å°è¿ãââââââââ" /*â*/));
/*ââââââââââââââââââââââââââââââââââââââââââââââââââââ´â*/
}
TEST(strwidth16, testCjkWidesAndCombiningLowLines_lengthIsNotShorts) {
/*âââââââââââââââââââââââââââââââââââââââââââââââââââââââ¬â*/
EXPECT_EQ(20, strwidth16(/**/ u"ð°ð±ð²ð³ð´ðµð¶ð·ââââââââââââ" /*â*/, 0));
EXPECT_EQ(20, strwidth16(/**/ u"(â¯Â°â¡Â°)â¯ð»ï¸µ ̲â»Ì²â̲â»ââââââ" /*â*/, 0));
EXPECT_EQ(20, strwidth16(/**/ u"ã¡ãã¶å°è¿ãââââââââ" /*â*/, 0));
EXPECT_EQ(28, strlen16(/*ââ*/ u"ð°ð±ð²ð³ð´ðµð¶ð·ââââââââââââ" /*â*/));
EXPECT_EQ(23, strlen16(/*ââ*/ u"(â¯Â°â¡Â°)â¯ð»ï¸µ ̲â»Ì²â̲â»ââââââ" /*â*/));
EXPECT_EQ(14, strlen16(/*ââ*/ u"ã¡ãã¶å°è¿ãââââââââ" /*â*/));
/*âââââââââââââââââââââââââââââââââââââââââââââââââââââââ´â*/
}
TEST(wcwidth, testCjkWidesAndCombiningLowLines_widthIsNotLength) {
/*âââââââââââââââââââââââââââââââââââââââââââââââââââââ¬â*/
EXPECT_EQ(20, wcswidth(/**/ L"Table flipââââââââââ" /*â*/, 0));
EXPECT_EQ(20, wcswidth(/**/ L"(â¯Â°â¡Â°)â¯ï¸µ ̲â»Ì²â̲â»âââââââ" /*â*/, 0));
EXPECT_EQ(20, wcswidth(/**/ L"ã¡ãã¶å°è¿ãââââââââ" /*â*/, 0));
EXPECT_EQ(20, wcslen(/*ââ*/ L"Table flipââââââââââ" /*â*/));
EXPECT_EQ(22, wcslen(/*ââ*/ L"(â¯Â°â¡Â°)â¯ï¸µ ̲â»Ì²â̲â»âââââââ" /*â*/));
EXPECT_EQ(14, wcslen(/*ââ*/ L"ã¡ãã¶å°è¿ãââââââââ" /*â*/));
/*âââââââââââââââââââââââââââââââââââââââââââââââââââââ´â*/
}
TEST(wcwidth, block) {
EXPECT_EQ(1, wcwidth(u'â'));
EXPECT_EQ(0x3061, L'ã¡');
EXPECT_EQ(2, wcwidth(L'ã¡'));
}
TEST(strwidth, testTextDelimitingControlCodes_dontHaveSubstance) {
EXPECT_EQ(0, strwidth("\0", 0));
EXPECT_EQ(0, strwidth("\1", 0));
}
BENCH(wcwidth, bench) {
volatile int x;
EZBENCH2("wcwidth", donothing, x = wcwidth(VEIL("r", u'â')));
}
| 5,640 | 82 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/bsr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bsr.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
static unsigned _Bsr(unsigned x) {
static const char kDebruijn[32] = {
0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31,
};
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x *= 0x07c4acdd;
x >>= 27;
return kDebruijn[x];
}
TEST(_bsr, test) {
for (int i = 1; i < 1000; ++i) {
ASSERT_EQ(_bsr(i), _Bsr(i));
}
}
| 2,366 | 43 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memfrob_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(memfrob, test) {
char buf[6];
EXPECT_STREQ("*****", memfrob(memcpy(buf, "\0\0\0\0\0", 6), 5));
EXPECT_STREQ("BOFFE", memfrob(strcpy(buf, "hello"), 5));
EXPECT_STREQ("hello", memfrob(memfrob(strcpy(buf, "hello"), 5), 5));
}
| 2,163 | 29 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strlcpy_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(strlcpy, testEmptyBuffer_doesNothing) {
EXPECT_EQ(5, strlcpy(NULL, "hello", 0));
}
TEST(strlcpy, testShortBuffer_nulTerminates) {
char buf[1] = {1};
EXPECT_EQ(5, strlcpy(buf, "hello", 1));
EXPECT_STREQ("", buf);
}
TEST(strlcpy, testShortBuffer_copies) {
char buf[2] = {1, 1};
EXPECT_EQ(5, strlcpy(buf, "hello", 2));
EXPECT_STREQ("h", buf);
}
BENCH(strlcpy, bench) {
char buf[256];
EZBENCH2("strlcpy", donothing,
EXPROPRIATE(strlcpy(VEIL("r", buf), "hello there", sizeof(buf))));
EZBENCH2("strncpy", donothing,
EXPROPRIATE(strncpy(VEIL("r", buf), "hello there", sizeof(buf))));
}
| 2,620 | 48 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memmove_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
forceinline void *Memmove(void *restrict d, const void *restrict s, size_t n) {
return __builtin___memmove_chk(d, s, n, __builtin_object_size(d, 0));
}
void foo1(void *p, void *q) {
Memmove(p, q, 19);
}
TEST(memmove, supposedPythonBug_test1) {
char a[32] = "123456789000000000";
foo1(&a[9], a);
EXPECT_STREQ("123456789123456789000000000", a);
foo1(a, &a[9]);
EXPECT_STREQ("123456789000000000", a);
}
void foo2(void *p, void *q) {
memmove(p, q, 19);
}
TEST(memmove, supposedPythonBug_test2) {
char a[32] = "123456789000000000";
foo2(&a[9], a);
EXPECT_STREQ("123456789123456789000000000", a);
foo2(a, &a[9]);
EXPECT_STREQ("123456789000000000", a);
}
| 2,575 | 49 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strpbrk_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(strpbrk, test) {
EXPECT_STREQ("o", strpbrk("hello", "abco"));
EXPECT_EQ(NULL, strpbrk("hello", "ABCO"));
}
BENCH(strpbrk, bench) {
char *strchr_(const char *, int) asm("strchr");
char *strpbrk_(const char *, const char *) asm("strpbrk");
EZBENCH2("strchr", donothing, strchr_(kHyperion, 'z'));
EZBENCH2("strpbrk 1", donothing, strpbrk_(kHyperion, "z"));
EZBENCH2("strpbrk 2", donothing, strpbrk_(kHyperion, "Zz"));
EZBENCH2("strpbrk 10", donothing, strpbrk_(kHyperion, ">@#\6\3\2\5\6Zz"));
}
| 2,480 | 37 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strcasecmp_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(strcasecmp, test) {
EXPECT_EQ(0, strcasecmp("HELLO", "hello"));
EXPECT_EQ(0, strcasecmp("HELLOHELLOHELLOHELLOHELLOHELLO",
"hellohellohellohellohellohello"));
EXPECT_EQ(-17, strcasecmp("HELLO", "yello"));
EXPECT_EQ(-17, strcasecmp("HELLO", "YELLO"));
EXPECT_EQ(+17, strcasecmp("yello", "HELLO"));
EXPECT_EQ(+17, strcasecmp("YELLO", "HELLO"));
}
BENCH(strcasecmp, bench) {
EZBENCH2("strcasecmp 16 eq (same)", donothing,
EXPROPRIATE(
strcasecmp(VEIL("r", "abcdefghijklmnop"), "abcdefghijklmnop")));
EZBENCH2("strcasecmp 16 eq (evil)", donothing,
EXPROPRIATE(
strcasecmp(VEIL("r", "abcdefghijklmnop"), "ABCDEFGHIJKLMNOP")));
}
| 2,654 | 41 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/memmem_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/alg.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/likely.h"
#include "libc/mem/mem.h"
#include "libc/stdio/rand.h"
#include "libc/str/internal.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#define MakeMemory(SL) memcpy(malloc(sizeof(SL) - 1), SL, sizeof(SL) - 1)
void *memmem_naive(const void *haystk, size_t haystklen, //
const void *needle, size_t needlelen) {
size_t i, j;
if (!needlelen) return haystk;
if (needlelen > haystklen) return 0;
for (i = 0; i < haystklen; ++i) {
for (j = 0;; ++j) {
if (j == needlelen) return (/*unconst*/ char *)haystk + i;
if (i + j == haystklen) break;
if (((char *)haystk)[i + j] != ((char *)needle)[j]) break;
}
}
return 0;
}
TEST(memmem, special) {
EXPECT_EQ(0, memmem(0, 0, 0, 0));
EXPECT_EQ(0, memmem(0, 0, "", 1));
EXPECT_EQ("", memmem("", 1, 0, 0));
}
TEST(memmem, test) {
char *needle = MakeMemory("abcdefgh");
char *haystk = MakeMemory("acccccccbbbbbbbbabcdefghdddddddd");
EXPECT_BINEQ(u"abcdefghdddddddd", memmem(haystk, 32, needle, 8));
memcpy(needle, "aaaaaaaa", 8);
memcpy(haystk, "acccccccbbbbbbbbaaaaaaaadddddddd", 32);
EXPECT_BINEQ(u"aaaaaaaadddddddd", memmem(haystk, 32, needle, 8));
free(haystk);
free(needle);
}
TEST(memmem, testNoMatch) {
char *needle = MakeMemory("abcdefzh");
char *haystk = MakeMemory("acccccccbbbbbbbbabcdefghdddddddd");
EXPECT_EQ(NULL, memmem(haystk, 32, needle, 8));
free(haystk);
free(needle);
}
TEST(memmem, testStartOfMemory) {
char *needle = MakeMemory("acccc");
char *haystk = MakeMemory("acccccccbbbbbbbbabcdefghdddddddd");
EXPECT_EQ(&haystk[0], memmem(haystk, 32, needle, 5));
free(haystk);
free(needle);
}
TEST(memmem, testEndOfMemory) {
char *haystk = MakeMemory("abc123");
char *needle = MakeMemory("123");
EXPECT_EQ(&haystk[3], memmem(haystk, 6, needle, 3));
free(haystk);
free(needle);
}
TEST(memmem, testOneNo) {
char *needle = MakeMemory("z");
char *haystk = MakeMemory("abc123");
EXPECT_EQ(0, memmem(haystk, 6, needle, 1));
free(haystk);
free(needle);
}
TEST(memmem, testOneYes) {
char *needle = MakeMemory("3");
char *haystk = MakeMemory("abc123");
EXPECT_EQ(&haystk[5], memmem(haystk, 6, needle, 1));
free(haystk);
free(needle);
}
TEST(memmem, testCrossesSseRegister) {
char *haystk = MakeMemory("eeeeeeeeeeeeeeeeffffffffffffffffrrrrrrrrrrrrrrrr");
char *needle = MakeMemory("eeeeeeeeeeeeefffffffffffff");
EXPECT_EQ(&haystk[3], memmem(haystk, 16 * 3, needle, 26));
free(haystk);
free(needle);
}
TEST(memmem, testHasNulCharacters) {
char *needle = MakeMemory("eeeeeeeeeeeee\0ffffffffffff");
char *haystk =
MakeMemory("eeeeeeeeeeeeeeee\0fffffffffffffffrrrrrrrrrrrrrrrr");
EXPECT_EQ(&haystk[3], memmem(haystk, 16 * 3, needle, 26));
free(haystk);
free(needle);
}
TEST(memmem, testWeird) {
char *needle = MakeMemory("-*-+-+-+-+-+-+-+");
char *haystk = MakeMemory("-+-+-+-+-+-+-+-*-+-+-+-+-+-+-+-+");
EXPECT_EQ(14, (intptr_t)memmem(haystk, 32, needle, 16) - (intptr_t)haystk);
free(haystk);
free(needle);
}
TEST(memmem, testEmptyNeedle_matchesStartOfHaystack) {
char *needle = malloc(0);
char *haystk = MakeMemory("-+-+-+-+-+-+-+-*-+-+-+-+-+-+-+-+");
EXPECT_EQ(0, (intptr_t)memmem(haystk, 32, needle, 0) - (intptr_t)haystk);
free(haystk);
free(needle);
}
TEST(memmem, testEmptyHaystack_alwaysReturnsNull) {
char *needle = MakeMemory("-*-+-+-+-+-+-+-+");
char *haystk = malloc(0);
EXPECT_EQ(NULL, memmem(haystk, 0, needle, 16));
EXPECT_EQ(NULL, memmem(haystk, 0, needle, 1));
free(haystk);
free(needle);
}
TEST(memmem, testEmptyHaystackAndNeedle_returnsHaystack) {
char *needle = malloc(0);
char *haystk = malloc(0);
EXPECT_EQ(haystk, memmem(haystk, 0, needle, 0));
free(haystk);
free(needle);
}
TEST(memmem, testWut) {
ASSERT_STREQ("x", memmem("x", 1, "x", 1));
}
TEST(memmem, fuzz) {
int i, j, k, n, m;
char a[128], b[128], *p, *q;
for (i = 0; i < 10000; ++i) {
rngset(a, sizeof(a), lemur64, -1);
rngset(b, sizeof(b), lemur64, -1);
p = a + lemur64() % sizeof(a) / 2;
q = b + lemur64() % sizeof(b) / 2;
n = lemur64() % sizeof(a) / 2;
m = lemur64() % sizeof(b) / 2;
ASSERT_EQ(memmem_naive(p, n, q, m), memmem(p, n, q, m));
}
}
/*
* memmem naive l: 43,783c 14,142ns m: 31,285c 10,105ns
* memmem l: 2,597c 839ns m: 2,612c 844ns
* memmem l: 509c 164ns m: 599c 193ns
*
* strstr naive l: 103,057c 33,287ns m: 47,035c 15,192ns
* strstr l: 3,186c 1,029ns m: 3,218c 1,039ns
* strstr torture 1 l: 27c 9ns m: 61c 20ns
* strstr torture 2 l: 2,322c 750ns m: 2,362c 763ns
* strstr torture 4 l: 2,407c 777ns m: 2,448c 791ns
* strstr torture 8 l: 2,803c 905ns m: 2,862c 924ns
* strstr torture 16 l: 4,559c 1,473ns m: 3,614c 1,167ns
* strstr torture 32 l: 5,324c 1,720ns m: 5,577c 1,801ns
*
* strcasestr naive l: 129,908c 41,959ns m: 155,420c 50,200ns
* strcasestr l: 33,464c 10,809ns m: 31,636c 10,218ns
* strcasestr tort 1 l: 38c 12ns m: 69c 22ns
* strcasestr tort 2 l: 2,544c 822ns m: 2,580c 833ns
* strcasestr tort 4 l: 2,745c 887ns m: 2,767c 894ns
* strcasestr tort 8 l: 4,198c 1,356ns m: 4,216c 1,362ns
* strcasestr tort 16 l: 7,402c 2,391ns m: 7,487c 2,418ns
* strcasestr tort 32 l: 13,772c 4,448ns m: 12,945c 4,181ns
*/
BENCH(memmem, bench) {
EZBENCH2("memmem naive", donothing,
EXPROPRIATE(memmem_naive(kHyperion, kHyperionSize, "THE END", 7)));
EZBENCH2("memmem", donothing,
EXPROPRIATE(memmem(kHyperion, kHyperionSize, "THE END", 7)));
EZBENCH2("memmem", donothing,
EXPROPRIATE(memmem(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
62, "aaaaaab", 7)));
}
| 8,197 | 205 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/towupper_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/dce.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
TEST(iswupper, test) {
EXPECT_TRUE(iswupper(L'ðµ'));
}
TEST(towupper, test) {
EXPECT_EQ(u'!', towupper(u'!'));
EXPECT_EQ(u'A', towupper(u'a'));
EXPECT_EQ(u'Ã', towupper(u'Ã '));
EXPECT_EQ(L'ð¥', towupper(L'ð¿'));
EXPECT_EQ(L'ï¼¢', towupper(L'ï½'));
EXPECT_EQ(u'á ', towupper(u'ê°'));
}
TEST(towlower, test) {
EXPECT_EQ(u'!', towlower(u'!'));
EXPECT_EQ(u'a', towlower(u'A'));
EXPECT_EQ(u'Ã ', towlower(u'Ã'));
EXPECT_EQ(L'ð¿', towlower(L'ð¥'));
EXPECT_EQ(L'ï½', towlower(L'ï¼¢'));
EXPECT_EQ(u'ê°', towlower(u'á '));
}
BENCH(towupper, bench) {
EZBENCH2("towupper ascii", donothing, EXPROPRIATE(towupper(VEIL("r", L'a'))));
EZBENCH2("towupper latin1", donothing,
EXPROPRIATE(towupper(VEIL("r", u'A'))));
EZBENCH2("towupper watinc", donothing,
EXPROPRIATE(towupper(VEIL("r", u'Ỿ'))));
EZBENCH2("towupper greek", donothing, EXPROPRIATE(towupper(VEIL("r", u'α'))));
EZBENCH2("towupper astral", donothing,
EXPROPRIATE(towupper(VEIL("r", L'ð¿'))));
}
BENCH(towlower, bench) {
EZBENCH2("towlower ascii", donothing, EXPROPRIATE(towlower(VEIL("r", L'a'))));
EZBENCH2("towlower latin1", donothing,
EXPROPRIATE(towlower(VEIL("r", u'A'))));
EZBENCH2("towlower watinc", donothing,
EXPROPRIATE(towlower(VEIL("r", u'Ỿ'))));
EZBENCH2("towlower greek", donothing, EXPROPRIATE(towupper(VEIL("r", u'α'))));
EZBENCH2("towlower astral", donothing,
EXPROPRIATE(towlower(VEIL("r", L'ð¿'))));
}
BENCH(iswupper, bench) {
EZBENCH2("iswupper ascii", donothing, EXPROPRIATE(iswupper(VEIL("r", L'A'))));
EZBENCH2("iswupper latin1", donothing,
EXPROPRIATE(iswupper(VEIL("r", u'A'))));
EZBENCH2("iswupper astral", donothing,
EXPROPRIATE(iswupper(VEIL("r", L'ð¿'))));
}
BENCH(iswlower, bench) {
EZBENCH2("iswlower ascii", donothing, EXPROPRIATE(iswlower(VEIL("r", L'a'))));
EZBENCH2("iswlower latin1", donothing,
EXPROPRIATE(iswlower(VEIL("r", u'A'))));
EZBENCH2("iswlower astral", donothing,
EXPROPRIATE(iswlower(VEIL("r", L'ð¿'))));
}
| 4,062 | 83 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/wcsrchr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(wcsrchr, test) {
EXPECT_STREQ(L"/there", wcsrchr(L"sup/hello/there", L'/'));
EXPECT_STREQ(L"/there",
wcsrchr(L"sup/hello/theresup/hello/theresup/hello/there", L'/'));
EXPECT_STREQ(L"p/hello/there",
wcsrchr(L"sup/hello/theresup/hello/theresup/hello/there", L'p'));
}
| 2,204 | 29 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/setlocale_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Gavin Arthur Hayes â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/locale.h"
#include "libc/testlib/testlib.h"
TEST(setlocale, test) {
EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
EXPECT_STREQ("C", setlocale(LC_ALL, "C"));
EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
EXPECT_STREQ("POSIX", setlocale(LC_ALL, "POSIX"));
EXPECT_STREQ("C", setlocale(LC_ALL, ""));
EXPECT_EQ(0, setlocale(LC_ALL, "ja_JP.PCK"));
EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
}
| 2,254 | 31 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strstr_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/alg.h"
#include "libc/intrin/bits.h"
#include "libc/dce.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#define MAKESTRING(NAME, VALUE) \
char *NAME = strcpy(malloc(sizeof(VALUE) + 16), VALUE)
char *strstr_naive(const char *haystack, const char *needle) {
size_t i;
unsigned k, m;
if (haystack == needle || !*needle) return haystack;
for (;;) {
for (i = 0;; ++i) {
if (!needle[i]) return (/*unconst*/ char *)haystack;
if (!haystack[i]) break;
if (needle[i] != haystack[i]) break;
}
if (!*haystack++) break;
}
return 0;
}
TEST(strstr, test_emptyString_isFoundAtBeginning) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[0], strstr(haystack, gc(strdup(""))));
free(haystack);
}
TEST(strstr, test_notFound) {
MAKESTRING(haystack, "abc123def");
ASSERT_EQ(NULL, strstr(haystack, gc(strdup("xyz"))));
free(haystack);
}
TEST(strstr, test_notFound1) {
MAKESTRING(haystack, "abc123def");
ASSERT_EQ(NULL, strstr(haystack, gc(strdup("x"))));
free(haystack);
}
TEST(strstr, test_middleOfString) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[3], strstr(haystack, gc(strdup("123"))));
free(haystack);
}
TEST(strstr, test_endOfString) {
MAKESTRING(haystack, "abc123def");
ASSERT_STREQ(&haystack[8], strstr(haystack, gc(strdup("f"))));
free(haystack);
}
TEST(strstr, test_secondXmmWord) {
MAKESTRING(haystack, "eeeeeeeeeeeeeeeebbbbbbbbbbb123");
ASSERT_STREQ(&haystack[27], strstr(haystack, gc(strdup("123"))));
free(haystack);
}
TEST(strstr, test_overlapsXmmWords) {
MAKESTRING(haystack, "eeeeeeeeeeeeeeeebbbbbbbbbbbbbbb");
ASSERT_STREQ(&haystack[15], strstr(haystack, gc(strdup("eb"))));
free(haystack);
}
TEST(strstr, test) {
ASSERT_EQ(NULL, strstr("x86_64-linux-musl-gcc", "clang"));
ASSERT_STREQ("gcc", strstr("x86_64-linux-musl-gcc", "gcc"));
ASSERT_EQ(NULL, strstr("-Wl,--gc-sections", "stack-protector"));
ASSERT_EQ(NULL, strstr("-Wl,--gc-sections", "sanitize"));
ASSERT_STREQ("x", strstr("x", "x"));
}
TEST(strstr, breakit) {
char *p;
p = gc(calloc(1, 32));
p[0] = 'c';
p[1] = 'c';
p[10] = 'b';
ASSERT_EQ(NULL, strstr(p, "b"));
}
/*
* memmem naive l: 43,783c 14,142ns m: 31,285c 10,105ns
* memmem l: 2,597c 839ns m: 2,612c 844ns
* memmem l: 509c 164ns m: 599c 193ns
*
* strstr naive l: 103,057c 33,287ns m: 47,035c 15,192ns
* strstr l: 3,186c 1,029ns m: 3,218c 1,039ns
* strstr torture 1 l: 27c 9ns m: 61c 20ns
* strstr torture 2 l: 2,322c 750ns m: 2,362c 763ns
* strstr torture 4 l: 2,407c 777ns m: 2,448c 791ns
* strstr torture 8 l: 2,803c 905ns m: 2,862c 924ns
* strstr torture 16 l: 4,559c 1,473ns m: 3,614c 1,167ns
* strstr torture 32 l: 5,324c 1,720ns m: 5,577c 1,801ns
*
* strcasestr naive l: 129,908c 41,959ns m: 155,420c 50,200ns
* strcasestr l: 33,464c 10,809ns m: 31,636c 10,218ns
* strcasestr tort 1 l: 38c 12ns m: 69c 22ns
* strcasestr tort 2 l: 2,544c 822ns m: 2,580c 833ns
* strcasestr tort 4 l: 2,745c 887ns m: 2,767c 894ns
* strcasestr tort 8 l: 4,198c 1,356ns m: 4,216c 1,362ns
* strcasestr tort 16 l: 7,402c 2,391ns m: 7,487c 2,418ns
* strcasestr tort 32 l: 13,772c 4,448ns m: 12,945c 4,181ns
*/
BENCH(strstr, bench) {
EZBENCH2("strstr naive", donothing,
EXPROPRIATE(strstr_naive(kHyperion, "THE END")));
EZBENCH2("strstr", donothing, EXPROPRIATE(strstr(kHyperion, "THE END")));
EZBENCH2("strstr torture 1", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"b")));
EZBENCH2("strstr torture 2", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"ab")));
EZBENCH2("strstr torture 4", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaab")));
EZBENCH2("strstr torture 8", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaab")));
EZBENCH2("strstr torture 16", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaaaaaaaaaab")));
EZBENCH2("strstr torture 32", donothing,
EXPROPRIATE(strstr(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab")));
}
| 8,032 | 171 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/strcat_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(strcat, test) {
char buf[128];
EXPECT_STREQ("hello", strcpy(buf, "hello"));
EXPECT_STREQ("hellothere", strcat(buf, "there"));
EXPECT_STREQ("hellothere", buf);
}
TEST(strcat16, test) {
char16_t buf[128];
EXPECT_STREQ(u"hello", strcpy16(buf, u"hello"));
EXPECT_STREQ(u"hellothere", strcat16(buf, u"there"));
EXPECT_STREQ(u"hellothere", buf);
}
TEST(wcscat, test) {
wchar_t buf[128];
EXPECT_STREQ(L"hello", wcscpy(buf, L"hello"));
EXPECT_STREQ(L"hellothere", wcscat(buf, L"there"));
EXPECT_STREQ(L"hellothere", buf);
}
TEST(strncat, test) {
char buf[128];
EXPECT_STREQ("hello", strcpy(buf, "hello"));
EXPECT_STREQ("hellothe", strncat(buf, "there", 3));
EXPECT_STREQ("hellothe", buf);
}
TEST(strncat16, test) {
char16_t buf[128];
EXPECT_STREQ(u"hello", strcpy16(buf, u"hello"));
EXPECT_STREQ(u"hellothe", strncat16(buf, u"there", 3));
EXPECT_STREQ(u"hellothe", buf);
}
TEST(wcsncat, test) {
wchar_t buf[128];
EXPECT_STREQ(L"hello", wcscpy(buf, L"hello"));
EXPECT_STREQ(L"hellothe", wcsncat(buf, L"there", 3));
EXPECT_STREQ(L"hellothe", buf);
}
| 2,995 | 63 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
PKGS += TEST_LIBC_STR
TEST_LIBC_STR_FILES := $(wildcard test/libc/str/*)
TEST_LIBC_STR_SRCS_C = $(filter %.c,$(TEST_LIBC_STR_FILES))
TEST_LIBC_STR_SRCS_CC = $(filter %.cc,$(TEST_LIBC_STR_FILES))
TEST_LIBC_STR_SRCS = $(TEST_LIBC_STR_SRCS_C) $(TEST_LIBC_STR_SRCS_CC)
TEST_LIBC_STR_SRCS_TEST_C = $(filter %_test.c,$(TEST_LIBC_STR_FILES))
TEST_LIBC_STR_SRCS_TEST_CC = $(filter %_test.cc,$(TEST_LIBC_STR_FILES))
TEST_LIBC_STR_OBJS = \
$(TEST_LIBC_STR_SRCS_C:%.c=o/$(MODE)/%.o) \
$(TEST_LIBC_STR_SRCS_CC:%.cc=o/$(MODE)/%.o)
TEST_LIBC_STR_COMS = \
$(TEST_LIBC_STR_SRCS_TEST_C:%.c=o/$(MODE)/%.com) \
$(TEST_LIBC_STR_SRCS_TEST_CC:%.cc=o/$(MODE)/%.com)
TEST_LIBC_STR_BINS = \
$(TEST_LIBC_STR_COMS) \
$(TEST_LIBC_STR_COMS:%=%.dbg)
TEST_LIBC_STR_TESTS = \
$(TEST_LIBC_STR_SRCS_TEST_C:%.c=o/$(MODE)/%.com.ok) \
$(TEST_LIBC_STR_SRCS_TEST_CC:%.cc=o/$(MODE)/%.com.ok)
TEST_LIBC_STR_CHECKS = \
$(TEST_LIBC_STR_SRCS_TEST_C:%.c=o/$(MODE)/%.com.runs) \
$(TEST_LIBC_STR_SRCS_TEST_CC:%.cc=o/$(MODE)/%.com.runs)
TEST_LIBC_STR_DIRECTDEPS = \
LIBC_CALLS \
LIBC_FMT \
LIBC_INTRIN \
LIBC_LOG \
LIBC_TINYMATH \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STDIO \
LIBC_STR \
LIBC_STUBS \
LIBC_SYSV \
LIBC_SYSV_CALLS \
LIBC_TESTLIB \
LIBC_X \
LIBC_ZIPOS \
THIRD_PARTY_COMPILER_RT \
THIRD_PARTY_MBEDTLS \
THIRD_PARTY_REGEX \
THIRD_PARTY_ZLIB \
THIRD_PARTY_LIBCXX \
THIRD_PARTY_SMALLZ4 \
THIRD_PARTY_VQSORT
TEST_LIBC_STR_DEPS := \
$(call uniq,$(foreach x,$(TEST_LIBC_STR_DIRECTDEPS),$($(x))))
o/$(MODE)/test/libc/str/str.pkg: \
$(TEST_LIBC_STR_OBJS) \
$(foreach x,$(TEST_LIBC_STR_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/libc/str/tpenc_test.o: private \
OVERRIDE_CFLAGS += \
$(TRADITIONAL)
o/$(MODE)/test/libc/str/%.com.dbg: \
$(TEST_LIBC_STR_DEPS) \
o/$(MODE)/test/libc/str/%.o \
o/$(MODE)/test/libc/str/str.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
$(TEST_LIBC_STR_OBJS): private \
DEFAULT_CCFLAGS += \
-fno-builtin
o/$(MODE)/test/libc/str/memmove_test.o: private \
OVERRIDE_CFLAGS += \
-O2 -D_FORTIFY_SOURCE=2
.PHONY: o/$(MODE)/test/libc/str
o/$(MODE)/test/libc/str: \
$(TEST_LIBC_STR_BINS) \
$(TEST_LIBC_STR_CHECKS)
| 2,646 | 90 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/tprecode8to16_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(tprecode8to16, test) {
size_t size = 8;
char16_t *buf = malloc(size * sizeof(char16_t));
EXPECT_EQ(7, tprecode8to16(buf, size, "helloâ»â¥").ax);
EXPECT_STREQ(u"helloâ»â¥", buf);
free(buf);
}
TEST(tprecode8to16, testEmptyOut_doesNothingButStillCountsSrcLength) {
axdx_t r;
r = tprecode8to16(NULL, 0, "hi");
EXPECT_EQ(0, r.ax);
EXPECT_EQ(3, r.dx);
}
TEST(tprecode8to16, testOnlyRoomForNul_writesIt) {
axdx_t r;
char16_t b[1] = {1};
r = tprecode8to16(b, 1, "hi");
EXPECT_EQ(0, r.ax);
EXPECT_EQ(3, r.dx);
EXPECT_EQ(0, b[0]);
}
TEST(tprecode8to16, testTooLittle_stillNulTerminates) {
axdx_t r;
char16_t b[2] = {1, 2};
r = tprecode8to16(b, 2, "hi");
EXPECT_EQ(1, r.ax);
EXPECT_EQ(3, r.dx);
EXPECT_EQ('h', b[0]);
EXPECT_EQ(0, b[1]);
}
TEST(tprecode8to16, test2) {
char16_t b[128];
EXPECT_EQ(34, tprecode8to16(b, 128, "(â¯Â°â¡Â°)â¯ï¸µLâ»ââ» ð°ð±ð²ð³ð´ðµð¶ð·ð¸ð¹").ax);
EXPECT_STREQ(u"(â¯Â°â¡Â°)â¯ï¸µLâ»ââ» ð°ð±ð²ð³ð´ðµð¶ð·ð¸ð¹", b);
}
TEST(tprecode8to16, testAscii_vectorSpeedupWorks) {
size_t size = 32;
char16_t *buf = malloc(size * sizeof(char16_t));
EXPECT_EQ(31,
tprecode8to16(buf, size, "babaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").ax);
EXPECT_STREQ(u"babaaaaaaaaaaaaaaaaaaaaaaaaaaaa", buf);
free(buf);
}
BENCH(tprecode8to16, bench) {
char16_t *buf = malloc((kHyperionSize + 1) * 2);
EZBENCH2("tprecode8to16", donothing,
tprecode8to16(buf, kHyperionSize, kHyperion));
free(buf);
}
| 3,552 | 81 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/regex_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "third_party/regex/regex.h"
TEST(regex, test) {
regex_t rx;
EXPECT_EQ(REG_OK, regcomp(&rx, "^[A-Za-z\x7f-\uffff]{2}$", REG_EXTENDED));
EXPECT_EQ(REG_OK, regexec(&rx, "AZ", 0, NULL, 0));
EXPECT_EQ(REG_OK, regexec(&rx, "ââ", 0, NULL, 0));
EXPECT_EQ(REG_NOMATCH, regexec(&rx, "A", 0, NULL, 0));
EXPECT_EQ(REG_NOMATCH, regexec(&rx, "â", 0, NULL, 0));
EXPECT_EQ(REG_NOMATCH, regexec(&rx, "0", 0, NULL, 0));
regfree(&rx);
}
TEST(regex, testDns) {
regex_t rx;
EXPECT_EQ(REG_OK, regcomp(&rx, "^[-._0-9A-Za-z]*$", REG_EXTENDED));
EXPECT_EQ(REG_OK, regexec(&rx, "", 0, NULL, 0));
EXPECT_EQ(REG_OK, regexec(&rx, "foo.com", 0, NULL, 0));
EXPECT_EQ(REG_NOMATCH, regexec(&rx, "bar@example", 0, NULL, 0));
regfree(&rx);
}
TEST(regex, testIpBasic) {
regex_t rx;
EXPECT_EQ(REG_OK, regcomp(&rx,
"^"
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)"
"$",
0));
const char *s = "127.0.0.1";
regmatch_t *m = gc(calloc(rx.re_nsub + 1, sizeof(regmatch_t)));
ASSERT_EQ(4, rx.re_nsub);
EXPECT_EQ(REG_OK, regexec(&rx, s, rx.re_nsub + 1, m, 0));
EXPECT_STREQ("127", gc(strndup(s + m[1].rm_so, m[1].rm_eo - m[1].rm_so)));
EXPECT_STREQ("0", gc(strndup(s + m[2].rm_so, m[2].rm_eo - m[2].rm_so)));
EXPECT_STREQ("0", gc(strndup(s + m[3].rm_so, m[3].rm_eo - m[3].rm_so)));
EXPECT_STREQ("1", gc(strndup(s + m[4].rm_so, m[4].rm_eo - m[4].rm_so)));
regfree(&rx);
}
TEST(regex, testIpExtended) {
regex_t rx;
EXPECT_EQ(REG_OK, regcomp(&rx,
"^"
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})"
"$",
REG_EXTENDED));
const char *s = "127.0.0.1";
regmatch_t *m = gc(calloc(rx.re_nsub + 1, sizeof(regmatch_t)));
ASSERT_EQ(4, rx.re_nsub);
EXPECT_EQ(REG_OK, regexec(&rx, s, rx.re_nsub + 1, m, 0));
EXPECT_STREQ("127", gc(strndup(s + m[1].rm_so, m[1].rm_eo - m[1].rm_so)));
EXPECT_STREQ("0", gc(strndup(s + m[2].rm_so, m[2].rm_eo - m[2].rm_so)));
EXPECT_STREQ("0", gc(strndup(s + m[3].rm_so, m[3].rm_eo - m[3].rm_so)));
EXPECT_STREQ("1", gc(strndup(s + m[4].rm_so, m[4].rm_eo - m[4].rm_so)));
regfree(&rx);
}
TEST(regex, testUnicodeCharacterClass) {
regex_t rx;
EXPECT_EQ(REG_OK, regcomp(&rx, "^[[:alpha:]][[:alpha:]]$", 0));
EXPECT_EQ(REG_OK, regexec(&rx, "ðµð", 0, 0, 0));
EXPECT_NE(REG_OK, regexec(&rx, "ââ", 0, 0, 0));
regfree(&rx);
}
void A(void) {
regex_t rx;
regcomp(&rx, "^[-._0-9A-Za-z]*$", REG_EXTENDED);
regexec(&rx, "foo.com", 0, NULL, 0);
regfree(&rx);
}
void B(regex_t *rx) {
regexec(rx, "foo.com", 0, NULL, 0);
}
void C(void) {
regex_t rx;
regcomp(&rx, "^[-._0-9A-Za-z]*$", 0);
regexec(&rx, "foo.com", 0, NULL, 0);
regfree(&rx);
}
void D(regex_t *rx, regmatch_t *m) {
regexec(rx, "127.0.0.1", rx->re_nsub + 1, m, 0);
}
BENCH(regex, bench) {
regex_t rx;
regmatch_t *m;
regcomp(&rx, "^[-._0-9A-Za-z]*$", REG_EXTENDED);
EZBENCH2("precompiled extended", donothing, B(&rx));
regfree(&rx);
EZBENCH2("easy api extended", donothing, A());
EZBENCH2("easy api basic", donothing, C());
EXPECT_EQ(REG_OK, regcomp(&rx,
"^"
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)\\."
"\\([0-9][0-9]*\\)"
"$",
0));
m = calloc(rx.re_nsub + 1, sizeof(regmatch_t));
EZBENCH2("precompiled basic match", donothing, D(&rx, m));
free(m);
regfree(&rx);
EXPECT_EQ(REG_OK, regcomp(&rx,
"^"
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})"
"$",
REG_EXTENDED));
m = calloc(rx.re_nsub + 1, sizeof(regmatch_t));
EZBENCH2("precompiled extended match", donothing, D(&rx, m));
free(m);
regfree(&rx);
EXPECT_EQ(REG_OK, regcomp(&rx,
"^"
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})\\."
"([0-9]{1,3})"
"$",
REG_EXTENDED | REG_NOSUB));
m = calloc(rx.re_nsub + 1, sizeof(regmatch_t));
EZBENCH2("precompiled nosub match", donothing, D(&rx, m));
free(m);
regfree(&rx);
EXPECT_EQ(REG_OK, regcomp(&rx, "^[a-z]*$", REG_EXTENDED | REG_NOSUB));
m = calloc(rx.re_nsub + 1, sizeof(regmatch_t));
EZBENCH2("precompiled alpha", donothing,
regexec(&rx, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0, 0, 0));
free(m);
regfree(&rx);
EXPECT_EQ(REG_OK,
regcomp(&rx, "^[a-z]*$", REG_EXTENDED | REG_NOSUB | REG_ICASE));
m = calloc(rx.re_nsub + 1, sizeof(regmatch_t));
EZBENCH2("precompiled alpha icase", donothing,
regexec(&rx, "aaaaaaaaaaaaaaaAAAAAAAAAAAAAA", 0, 0, 0));
free(m);
regfree(&rx);
}
| 7,392 | 173 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/blake2b256_tests.txt | # Copyright (c) 2021, Google Inc.
#
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
# Generated by the following Go program.
#
# package main
#
# import (
# "fmt"
# "golang.org/x/crypto/blake2b"
# )
#
# func main() {
# var buf [256]byte
# for i := range buf {
# buf[i] = byte(i)
# }
#
# for i := 0; i < 256; i++ {
# h, err := blake2b.New256(nil)
# if err != nil {
# panic(err)
# }
# h.Write(buf[:i])
# fmt.Printf("IN: %x\n", buf[:i])
# fmt.Printf("HASH: %x\n", h.Sum(nil))
# fmt.Printf("\n")
# }
# }
IN:
HASH: 0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8
IN: 00
HASH: 03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314
IN: 0001
HASH: 01cf79da4945c370c68b265ef70641aaa65eaa8f5953e3900d97724c2c5aa095
IN: 000102
HASH: 3d8c3d594928271f44aad7a04b177154806867bcf918e1549c0bc16f9da2b09b
IN: 00010203
HASH: e1eae5a8adae652ec9af9677346a9d60eced61e3a0a69bfacf518db31f86e36b
IN: 0001020304
HASH: 663694ac6520bdce7caab1cf3929ffe78cb2fea67a3dfc8559753a9f512a0c85
IN: 000102030405
HASH: 274327d0e2a207844988fac0b39e071422e3f621913d69a5cfef23b38601a56f
IN: 00010203040506
HASH: 9df14b7248764a869197c35e392d2a6d6fdc5b79d597297920fd3f1491b442d2
IN: 0001020304050607
HASH: 77065d25b622a8251094d869edf6b4e9ba0708a8db1f239cb68e4eeb45851621
IN: 000102030405060708
HASH: 8660231b62ce1d61fc8be93bd6acdb43ff61a7ab4cc9494f0cc803362360b07b
IN: 00010203040506070809
HASH: 8b57a796a5d07cb04cc1614dfc2acb3f73edc712d7f433619ca3bbe66bb15f49
IN: 000102030405060708090a
HASH: cc932bee351be391849c87925f2e00a83051419dc310b288d4304d4adea3d0e0
IN: 000102030405060708090a0b
HASH: 99bd72c73bea193f7040ac279bd656cdec7fd35e097a657b6c03b4fa967223ed
IN: 000102030405060708090a0b0c
HASH: 695e93b723e0a08e8dd8dd4656389363519564daf4cde5fe95a6a0ca71d3705e
IN: 000102030405060708090a0b0c0d
HASH: 4cce7128e4f659ba41ee163c45280d468163adc8c76c4937a0bbfa0cf3bdeae7
IN: 000102030405060708090a0b0c0d0e
HASH: 929cec40e9e746e771c6ad05cfcf37641254ef5e802fa71a02f8982f525f2b00
IN: 000102030405060708090a0b0c0d0e0f
HASH: c7cb5d1a1a214f1d833a21fe6c7b2420e417c2f220784cbe90072975131bc367
IN: 000102030405060708090a0b0c0d0e0f10
HASH: ced0cd609f3c8ff85b9cec93bba556dbe3caa996ac5beb629d4512473d6b31ae
IN: 000102030405060708090a0b0c0d0e0f1011
HASH: 584c9cb4da3be635d86e803c9eebccfd27fbed4aae27b0207ce3c934a0043aa4
IN: 000102030405060708090a0b0c0d0e0f101112
HASH: 9b508680d1f75d5f1e5306fbfaf7e88621cebf39f7f5cbf9e2dbb7ebb88504d4
IN: 000102030405060708090a0b0c0d0e0f10111213
HASH: 5d597f201ead11daa0687185c579efd702e288d5bd72b6b21238a4ecb52d288a
IN: 000102030405060708090a0b0c0d0e0f1011121314
HASH: 85b8afd95165d04681ab948f2f0545c47a8d11d9d1866cb7ecc88bc31a634891
IN: 000102030405060708090a0b0c0d0e0f101112131415
HASH: 93c541c87fb52d506b1b262e49ed71689a15b745e8f3e003893c8c59cfc669fe
IN: 000102030405060708090a0b0c0d0e0f10111213141516
HASH: 395d6a5e3b41b6151411b9b22f07fcbae6c7c30df59c10ca2dfcfe333ac8e3fb
IN: 000102030405060708090a0b0c0d0e0f1011121314151617
HASH: 8d71aeb3137041d31ed42466ea5fdca2ec7a35c7701d142ccb813f8c614ceca2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718
HASH: 3b0b9b4027203daeb62f4ff868ac6cdd78a5cbbf7664725421a613794702f4f4
IN: 000102030405060708090a0b0c0d0e0f10111213141516171819
HASH: 7384c8812f6803d8649bed21a3acbbf36239bbd17274d249369dd65e6329fd84
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a
HASH: 3890962f7d604fe0fcade7d8fc03c7e6285da2035bac5a9362c1d68a353d5350
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b
HASH: 9dc0b41d6a6a6c194d04336eb383ac7f4ea537700d5926346dfb1379e9453460
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c
HASH: bd78e1c368d70b968e194dca2c6fbda605a67d5e52824289e058c93eee073ef5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d
HASH: 4cc3e428d63dc132471d3135d406f8d6e30d2480d571bffbd64957bbb090f582
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e
HASH: 9adf65b53153b1caec84cd717e00e01c2000d0569704ce38d065180adee5d964
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
HASH: cb2f5160fc1f7e05a55ef49d340b48da2e5a78099d53393351cd579dd42503d6
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
HASH: b7634fe13c7aca3914ee896e22cfabc9da5b4f13e72a2ccbecb6d44bbda95bcc
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021
HASH: 9badddebf24552cb1f66d32990476594e5249a729254f7b5c840728a42749a45
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122
HASH: 13891b823d3a2cfe0d1a5e60fe89d8c091524f994cdc3241c4da19c4bb3c2c6b
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223
HASH: c1b7eb8d130d705c5fa9ee8061076a3151f2e36e42d9c9289d85065b9ab343dd
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324
HASH: ee6a288c4fcae34572fc6dba3e0b7d698bef65dcc63bf28ebd74207a2065718a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425
HASH: 1b5ad5f31e4061f423ee11e3de88fef05dfed9393c268fd360d05fe4465fe40a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526
HASH: 87c40636d0ee94687fdf020e3d165f4e45f21d62fa04aa2b9103a8187da6e64a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627
HASH: 70a3082dfc7582b9d252939a474338db1f94a6dcc7724709377797d17ff51ac5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728
HASH: 109036d1dece657ac6471f7f7ed33846986fdcb9dae8a73ea0881607e5e45f13
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829
HASH: deda4f3e98e58392adaee3c2e7b91d172551c50945a8ae9e9e1ad10c2ae510a8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a
HASH: 2a82cabbbb09956d212d182cfaf7cde2f55fa33f96e3a1ab19fccfdb668ce2f2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b
HASH: 4a21b38c69f755c016ebb4a66eb76b4f9d4087a02fc8c3c257c1183efebda824
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c
HASH: d3ecaa4853a092755c3692cac3fea5d9ccfaca2d32b59ccae151705333359e79
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d
HASH: 0ab5250248686afe6eca3f3ed89e061c0b3ae2a13454b907bbdb643a72b25a66
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e
HASH: 2fb57ab5fc0927e8301b6933325530e90fa7a94eaea95bad7c3f2f1052032900
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f
HASH: 48de881e6c1dc35253d9c8d56e773743640f097bb7274b80ec090f1b33d1dc2e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30
HASH: 71745158a70425e25a8446122dda82fcfeb6bfcb593b25d79c539c6b989c526d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031
HASH: 45d3d95f04f304be5a61ef38357bd01e61f9bb7f8c9979458d846d9899436167
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132
HASH: d5afebad633b7d595e6c8482d8c9a429091f58acbd84725adbac12e8be80ada9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233
HASH: 06bbb3b17ea95e7e00ac21b8632f84615f11456fabcda9d99cbf079e3134cfe5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334
HASH: 02b8e881b5f78b451995f07116af3549066cbce498497f546a9772981779d908
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435
HASH: 370c5efe99822c30460a123467e8f151f012065ba3639bc0407ed3b3609e5d56
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536
HASH: ace7db9e8f298e823b7b265bbcd004577e0029256c48684b2d7a7cdfcbff5e47
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637
HASH: a6c1d35f74218e57b4dbd4ed467b41981208666738ffa0d9dc53d3de96be702a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738
HASH: 25e44457f063ae4ea799502c38d66eeefb46f520b4fc9a298df9826c9d62eea9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839
HASH: 1b35b64cf659d6d7d0ca933c9a52fb0e67fba76a304fadb7c47dd8ff6b6ff0fa
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a
HASH: a72de68ff63bbe9ccfaccfa6859af660bb413f9e5d0200106100919c10301ef8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b
HASH: cfe37ab9c02bf84afa7a734a10317150479b791a27efc374dd669f4ef67a801d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c
HASH: a55a2c06f3db74c95b33d1e962da18772c3601eb13fe0b86a78667b2b9f9df86
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d
HASH: 1b8a9195724ac01ad7da4a76c2545d2f3dc223a0242537050d7395f588748079
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e
HASH: 29e41a64fbdd2fd27612228623c0702222bf367451e7324287f181cb3dcf7237
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f
HASH: 10d8e6d534b00939843fe9dcc4dae48cdf008f6b8b2b82b156f5404d874887f5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40
HASH: 84c04ab082c8ae24206561f77397704b627892089a05887a2a1996472bcfe15d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041
HASH: 2b684baba4a7245e38c3263d85b5524a51baa8ca18444af1b5958596bc30d424
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142
HASH: 1d59fa9501213440975a0b27e4b52eea7274f8794ec35b8ee4824f7b00897ed7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243
HASH: 60669608711b9df3715b631b474d5206179a81d054ef5494612899728b55e103
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344
HASH: 46060cb9dc6be177bafe5425c4f84f9143b71cfc75dd958e15ff7a26cc92859b
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445
HASH: e7f909c8e018bc36b59a8e7848d16c05d6bdb0ebb91fb9baf54cc328192cc362
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546
HASH: 7a9f75439c68869a6595eb63c61db2bc213d3ef067ec0cb3f25e02e554fce2a9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647
HASH: adb39b3e53a791dfd32eca83191eb82fdef4321ac504539b257c3376da240aca
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748
HASH: 240ca19b3671dcc5ef174331fb0dd24b845dfcd01b0fbe52fa72a29bcaef1373
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849
HASH: ebae0805fd52d3e9f5f29aeb33b6be8cab0f28e668990d3cb95444d9ef90b932
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a
HASH: ea7c3c052928f0fa3b8d86b19c87dee905e8a4b26a0a23b3c8e8dc7255ea82d6
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b
HASH: 4ad32c1f2d18c8b7dc29d1526d7c751b89b86882fb12aa3cc9c6eddb7991d266
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c
HASH: c61f81c3e6b899d0501b05df1de32099a7b0e878689dc2a3fd5583de90a74164
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d
HASH: 068a8a0b96076a2773a8e00e00e57eef4fb26886b521285a6c747130850792d7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e
HASH: efab0151162523b18147cba89679bdab2d9b670f5ae222a34c360c094af1d441
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f
HASH: 066de1009daca2b8390a9dc734bce547ac4e3cc4531645bb8b9cbc0070941d88
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50
HASH: 9fbb33b95e79c5c1683ab09a6abff6612fffb4458543dc8bbc7723a6dc2bf2ed
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051
HASH: 88fea89237618cfc0270cbcd08e7ffdaa8933607c0dbccb8dd075b84fba83b11
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152
HASH: b1960beaa4fed01453679c7d6cf78d25442bdf92ae51be479dab18e1b2b922d3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253
HASH: a7d6821a97bc57cf6b5e25953c689439beda79364c903a3e64b6671dc9eceb2f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354
HASH: 90ca93ecd3e0e7c839e4fc0f2e4748954a89b2c7338e55fc18a53ccd08abed2e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455
HASH: 58fe5f45b9915a5b177f4256b51ce5781662352a2dd620a946b8755213fbd61f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556
HASH: d109c8ec77e2253b5e7c761f59b184815e46b06cc5132a92511a93dead6315c2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657
HASH: fd9664ecb814785c8474188706e6ab0952925f9b9d8e351665ced12e84d92fad
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758
HASH: 81342700c48f41ec5b54180d560e73e5ad6782717b2d3320b42280be11f0873e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859
HASH: 523cf9a356076fe8c3538bdd752bc43712c7d28f29499aaae7812f1e4167840e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a
HASH: 9706d70e28a9e99db15974b1c01635868a62c6567eb40903adae58d417b882f2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b
HASH: 2216f01255ff24422e18d906c64506924940451e09d4ec17e4dbc8ea6d14ef59
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c
HASH: 64ad22e77fc9f8a03ad6e06a067add9f0e0360d4533014fa286ccdf40dceb231
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d
HASH: 9908418a2bb564ab9607d2f863b841dd4fe47ee370dde05a9368e400f7f9904b
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e
HASH: 981a7989084e74f6d5fd8870321e860991729eed88e60d85ab5fdaa769be6fd2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f
HASH: 6528ea458efd23391e968e0dd3a40202ac94e3854d1a4642cbbe0d13a15cb849
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60
HASH: 767fdcd43cf16cbf980fd560dfc55f67be20510f9a0c8fcd5c749da8ef23fd7b
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061
HASH: 90afc4e366bcee748591d93ba9f7c2e05a1fda261b58d094f8f0450c8a31ffb8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162
HASH: 660f9f5d430bf89f5946fd4649ad41f806937641c808a80da70660f53179a941
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263
HASH: 5ac86383dec1db602fdbc2c978c3fe1bf4328fea1e1b495b68be2c3b67ba033b
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364
HASH: 7c15cdf3705457eb6b8edd79fb75bf568692ccb778f85fa2e1d462f48ee55c4f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465
HASH: a8df989766fc245edbb4b7268afb7380e4ea3f7123802b72ae2adb938211c9f9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566
HASH: 707aa875c6162027ac2829894c0be750f5ee8fe8a64465080025f708dc200f0e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667
HASH: 6efd41538fec50459b6c2583ade5754c86617580eef3071d38723aaf743f93c7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768
HASH: 5c22d6a56a4fbdb85aa70994b4e118224bb6db2afd017a98c2b992ce26ea8925
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869
HASH: a4a9739a1c83135bab3334990b470164ed81f633d7fe79722b3ac6e65dadd38e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a
HASH: f1ac1ad3348ea6c949fde09cbee706ea0aecf3a93fc51a8a7e2bdb8cd7400b01
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b
HASH: 492d9eae92f27ecce118d3fd8df63158cf709ed5069502263b8be1c105196ea3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c
HASH: 8691c32810f3220c0df76816af0a73b3fade2594cbcc711b855e2cd81dbdec95
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d
HASH: cab341f7059d974cbc620bc423b02f58b5e1a899f416b0858ae1a736d4681162
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e
HASH: e08b3d16f0a3b663f319da999db897488d1677048a38fa7b4f1f783e4f1974e6
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f
HASH: d5587e0b33166a320dd69417adb01cb1129aff5506a2f655574cf2e264636bdb
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70
HASH: 5a69194c22af2b7040a8488738f96c901ae215965d611a572932464261539fc8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071
HASH: d8e7d58cd37acad505940843a8bb046971c43e4d0593c6bb946b07926644f78f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172
HASH: 46b07cc026b633e6245661813d5aca2bcc295d0b8ab01f27f517b4f2823d0b3e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273
HASH: fc169b3e5480e72057d828702f9da4f08d141a178eb8adef03ca0708c1a10df7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374
HASH: ae3e241c1c394190fbac7fccb3df0d0bc317c6e1a15993330e9b648c80264066
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475
HASH: f430aeef864823d8c8b448f2d25452ea3ed7abe2966adc8c42636b69d0a1bad9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576
HASH: b0d6518afa4e3590746aa5fd1e58f7ec06a347981177737ad6631b22c53b6617
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677
HASH: 16684ddd272dfc18dd40c16a7f57cecca70df0a96c4a066b97646953e7c7691a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778
HASH: e8208de0982f3d8e9ac258eb26eb3f130ced7331797b625d6b65ba4ba2064c9c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879
HASH: 8ecd4bdc226fb29dd486cd77b566723e44c77194ba7a000734736dbb76f61c7c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a
HASH: 153d5c1d5edb08f51f6353b6b7bdd48a9bba14068923b8991be59346a4f932f7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b
HASH: 60e555a694396b48273d2d778709c208c0757cd15697a43cf0c2115599c80e68
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c
HASH: 7a4a15b47029005972a6b814d5e7f2c86c616bd98e6a06bd95cbed2f47400c67
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d
HASH: 3de5adb8e3bf8dfabb41afe53c58fad23427a148755148011b5c12b88aba3dc0
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e
HASH: f2fe67ff342e21b8f45e8f2e0bcd1d9243245d50ee6c78042e9c491388791c72
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f
HASH: c3582f71ebb2be66fa5dd750f80baae97554f3b015663c8be377cfcb2488c1d1
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80
HASH: f7f3c46ba2564ff4c4c162da1f5b605f9f1c4aa6a20652a9f9a337c1a2f5b9c9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081
HASH: d3b11b4cbe513ec7b6f4bb5ff0c411de405a8641cf221493447a35927ca3aea7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182
HASH: 62323574c7cdaaca448fcbc7091ae4af3e04decb0d3c7c55636baa0a99c88699
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283
HASH: 89b7d0203387e0332622ca84a879bddbcff155a213997560fc05428e79e06891
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384
HASH: be5cce3e365fbbb139f68a3da3367e42aa8bd79b15f5252f7c08c3c8f0dcab27
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485
HASH: 7ae7702bc025692f2ea5ab0c2eb6552c7975a57c5acb93ff115d303f341a579c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586
HASH: f7c4efacc0a4cb5836f170ea0bf5dc5ce36fe2d88e76a9f259eaab71aef0ff13
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687
HASH: 6a35d3dadc62dfe7819519f92181b2f8d38f5e0ed3d51a22cf8a133ab628d6f4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788
HASH: bacecc2948c41beb73c815ca7cee6c7dbf2e4219190936edac5e4680500dd4d2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889
HASH: 2dce89f76f4f37472ae6374b0825a9cd61619a995c7f49733f62b606a7ce905a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a
HASH: 7b65e63a0d17d68c798b5d5631f17c35faff70dbe90006589ca89277dbeeafc0
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b
HASH: 9477e374453099d2f8679e1d9b167b5f1c4e3cc66f32bdd9a3748a10876a27b3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c
HASH: 448437adad41878e6529fcc2fad9bbdb13697b6cbb2669fc8150d3aa7e0418b8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d
HASH: ce4936743020825f508ca72c8355c88224a52c348a21567e65526ff8f82632fd
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e
HASH: 556a195bf23cba5c3193fbbe472f1cd5478ea4cad2dc6d6a193102a2abd0fac4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f
HASH: e15dc6238e2e58e9ea212b0d7abfd700da3ae5120d4d601341ce9e424a7c5828
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90
HASH: a22022450276c5018d51cd321e0e195a0add003e33ecaa97028d6974b5712187
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091
HASH: 044cabb79e57da22b772249c332bfb43c5d1c9b683d1b2d2b75f4c5e6773a216
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192
HASH: 766e1167593896bdc8793fb7ccdb1d35dc430aaeafe1e7a96aba870416587e7e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293
HASH: e19d72ca8438477db71e1bfa48924c4e75ee4f84c7aa9b0911521c60a2ba6440
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394
HASH: 512ee7aa89497a761f0798c29a1dd37d1d86f1c0870519a0aab69d265df118c0
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495
HASH: 80c199310a2ab7af6a808f6d68843136c30e9228a766618632d4e1210edf365c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596
HASH: 43fdffd19c692b6ef87c103cad9b80fb86919e6ecdcb73364d260da29a5f28d3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697
HASH: 1d1dc1909a6a8e552a0f8964601102d0edc89f5a02d3acced71826bbc5ca37af
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798
HASH: fa77dac317e8c531246e14265ed42a87ade6fc3ce351652e6ad9290f8a157617
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899
HASH: 5bbc0f8b1a52732ed548e600865ae53360f0642a5674ecc7c6185f2cdeeb6601
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a
HASH: 89c5fcbaf3a61d6fa4fa33c3eca8761ebab3c3467aba7d255394a0e70811ef3f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b
HASH: 9b3ecec85fa5ba5e0f1542085fff46bb2262163979879c9565294b2c56842a28
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c
HASH: 4e301b852d473b5d12271209bdc350b4ec615c99cb07bdc2b379f86679b465bb
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d
HASH: b306fbbb65eedbd07aea67a6490db9158a768d8223772d9414b124fe184098ba
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e
HASH: de9fc91112ba62a5b732d4b708d6cc27a4b77d88e8f9c50db361c6f27295b46c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f
HASH: f3aac26dc5197ea8dc068d6bfc9e3ee2217d908df5115fd236ba31828637ab7a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0
HASH: 3a0126ec4db7bd8c0c44e5197a84465c9c97c45f9d1fb8ab256eb5681dc25000
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1
HASH: 7b6b55e2623a8eb6d70fa0913012e3db03cea4a6ddc0f5b875673a225f95d86e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2
HASH: be3ed738f221b53726d8a54ab7171189d77700bca86a2c614f5fefbca37eb5b0
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3
HASH: c90bcb90aea0ab6a2331ecc17f4e68507b544910f3561d20a41916d8abb421db
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4
HASH: 72f18a50776c9efbbb1d360342235bf28ab259648dbc08480390333314e02672
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5
HASH: 2f1c635728444b5189540cf99d92a77057aed5a8c6fd7deadbbf9d86815cf5f9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6
HASH: c372e87d3540fb30e7316af85b65378384de4664a04e51b30ada778e3a226d85
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7
HASH: d244f4ce129ef1c84eb40d30da099a2d65682e025e132b94f630fa3fdbda05af
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8
HASH: 930a3e1f69ef7bcf3b9a81c1feb9758f60f9086b331fc170e6fa20b2a5738540
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9
HASH: 84c3e0415a9d4da972a4fd9ee82d63b00099a2620889bc274ecb8606912cf92f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa
HASH: 6d0d4cde9886218e9240a0c956836ea3939b558b8da0b309ca686f3c631f4942
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab
HASH: 86e476f2f8bacabc996360a0d6d57f0e045c9d3085ffe06d2305601c30d2340c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac
HASH: 6ca5fcf07d2d4b1449924c8c84ad2c2e432a1f923dd365d81d9fde3c4985724f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad
HASH: 9a7e1a3b1e01f24fce4d115eb98e2bb9eef349cf0d40493b8ab33727c9a1ccc8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae
HASH: 165509739c09ec3486143b0c7c009d5b588736aff2813a2dbbfd733d5840ef98
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf
HASH: ad191a623337f01563824b493bd735bee26833e9224d971a67b453d6e113d96a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0
HASH: f99e6d680bcbc6bb384290a5f966b18d4db38951abe695c6444c319058bb8904
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1
HASH: 20e7e81e12c9ad28b7d65d3917051c327031f334a2f82b1f746cbcd7dc41f87d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2
HASH: 14675c8fe5cbe514491f7093aad58e9dcf8dd33ab22f3a8bca1ca5130d5e5bea
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3
HASH: e105be1caf056cf599b91423df3cc1fb2808e0c6a50da68fc9db5693d1e0a9dc
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4
HASH: 8fcade674361487f88d58330acb439a4b3e717341615ba691370becf4905e057
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5
HASH: 70251dcdf7c899bddd4bc745597b998506c34bebc5de115d4fe85af2aa420171
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6
HASH: d987826931a47b9ff871a0f2a8f10bbb659598da57d8abf81714b48a475a1356
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7
HASH: fea31b338415f503dcb3708d68f377c4267e96345158e7b88d24ec8c232ef2b7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8
HASH: 3f2084debfeafa75d0c078bed7eda160459a3792a440c3718fb5c14c118e3263
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9
HASH: e55583bd588fb053f040c541db36603e4959a7421d6281fca88454720da34c17
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba
HASH: 0f433de1bbca62440be5d1ceaec8138a2154b374921d17e2d6493f85529a5ee2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb
HASH: 39cc27d72466d2d63f70f28c59950a0665005b4bc8cfaaa662aeeaf34a19601f
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc
HASH: e7a556efdac11394b6058496b06dad0eb7315cae4cbd509e77e496c85f202aa4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd
HASH: b90cf1fd5dbee8a9c18764962bff431dc560e113073828d839e11929d7d602ff
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe
HASH: 62b227effe8222299e757a065f1b64ab73fe6d2aac5d762303db956bc82b78ce
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf
HASH: 7b8f54247422c43a6d36977260e195d06e1dbba44c392b3fe76dcf4a96c433d5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0
HASH: d1400c9e8c7758b19e29c38e356ebc7abe8c0887741b845426821c7f74ebd35e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1
HASH: 9c557316ebd1e9cde622271e48f654553067c08d58986190bd3108d8bf54f130
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2
HASH: f005478fb35b7a389377b35fb6193aab0e9f3c4138127d0905e488a3e5ed1bd6
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3
HASH: f62114d69c3bfa8493061f44df01566e3a932e83b050b94eca7a1f7f189d6471
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4
HASH: fd915ae6a50c06ba3917bb6d001a4b84c2ff8a906813ba78e80b043a91e7d1d6
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5
HASH: 2176a39525e6a57ceed2f28eda5179172ec4f5a15be41b6cece8ab140ff1194c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6
HASH: bb831d2653af40b4e8a1048309c1f058d21334aa20c78dc63b8eb74a56fbde3c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7
HASH: 63c3d97a9f8894d5e043a707b0fee7f7ec4c049a23bbf1079df20b4165f9e22d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8
HASH: 3e53214e700694863284e7dc8dec3b98c1eaf97add0c1431e3bd321d6742a586
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9
HASH: cb4e69b8adacdcb20dd2d79655117de489030ecc86c210a268b9985126ca9df3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca
HASH: 33eb4a42f46198eb7b52f8fd556fee08430872d3ad16fc3fca466a2d63cc4932
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb
HASH: 4fb1c07cd6e6ed8dbfac72210f3ff9707293dad1f8a4aa19f0ac8ff6c80f3ce9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc
HASH: 22349aa35acbcffa6c84ab0e0231199d8353adde248ca1ff91010234886c94de
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd
HASH: 4ddf8cb3d4e80c9971a9ab171f9bc29fa4fd23eceed01e3bc297892de389d6f7
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce
HASH: 69be23136e4af5f52bb333deb3f32f76610b9fd9dac9ede75b2ef0491bf218ab
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf
HASH: 0b5ce2869ebbbc91bcc4d2e9560bcc21f4da20fffc96cd4eec422b795641c808
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0
HASH: 82c17ce6066f792df2dce06eacd03ab4d202185a0a531e4af9a1a2d7b2d43def
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1
HASH: 97b1b2e7e7aa6a9d1821ee2ad6c8062af397072eb9a8547c75817d0f0ad1659e
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2
HASH: 5aa4d29af9903050d5d329d4d7f3a657ccd038543da764ed931560f799690a50
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3
HASH: c78b17ff5ea603a809668bc06dbd99b78561b37ff615f6f5e5b86165a442ec2c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4
HASH: 2d1f5fb13901a205b158c5dc01bf54a5bfa9914c6b19ab66f501da64975e3a4d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5
HASH: ef7d3f61c537cac2a217cc214cd9d3e80f4adaac8431768f9db88a6571d3a57d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6
HASH: b23a6eb1184e297b5e9ec2e3aeeaec3c8de411dc614f2979de285ce4d3802e18
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7
HASH: 6598f5924005cd92e779a5525636fb061a1cfe4e7afe97d468eb3106817d6c7a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8
HASH: f0aec1c2872dff14f3592c5f7e83c0dc4d299f94a7cfb247d0a4b95b9b0fc077
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9
HASH: 709da24c1ca042c055a3cff57280d72f2b50094bbf029d9aed1dcca3288022c8
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da
HASH: afb0abb463999cc9ab124c95993d62e839bf7409d91d1c377912a895523c3125
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb
HASH: 049eb53d4bc939e817c9572a5f0def95e4e38b4614969d866e738e3ae6e24936
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc
HASH: 1f9df26fb5219482437297326737c0558eb557da4eb6374805dd9a30f842aae4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd
HASH: 11151481e2199be550f9ae696cbd9ddc9be9686dbc77b619c005d0fb5aef9b89
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde
HASH: 0767c2de1353f58b416e3fa492173c9c39792de46a34c6153d5878ba01e5f07d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf
HASH: 46d743927ec8ad5e403c9e20405200481961e7335e90c4ea9c5ad35b77f3681c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0
HASH: d5ffd30325257614674de0b40f7b2ded3a287f48ae229b02c91dd2be28404171
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1
HASH: c36f10f2463b839f4bbe7130c8f3abf29a56608bdf767199faccadecc8245631
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2
HASH: 4265605e9d5b02fc438c15823bdd01cbcec073d57ad7a699d0126312fdbe4322
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3
HASH: 829f989b205831d3c5c002ebf8cea1b5fba3daf966539e3b421b6c2c768f7554
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4
HASH: 406a227d2d1767e0cf417d6bf7ca58a262c79460f421b9c155513714187d10d2
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5
HASH: adf7d0028e41121e47aef77dca9de82fef7fe4f4c82f2d6df253adb4e756f2ec
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6
HASH: b9a11305f92002de551314de53739b1c7e31c257149aee21f3a5ba4af068215d
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7
HASH: 49f9abbe9007e85091827b49256730f552e4a2170a7b6f9cc461483bd8ae0d52
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8
HASH: 98ebce2d0b548d9fb99fbd63d842c119f2ce671317cd080ee036fa69457fccda
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9
HASH: 779042d9184c626289868dc73662e71f413c1df4fecd2f08b0edf40bd8d520f4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea
HASH: f8ad01320e4bbab09282a97511598384089a447f9a6a8fa298b65a82f1731806
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb
HASH: 1d799e024fd1627cc0395c68bec456631153bffaeb625cda58411b9cbe137b34
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec
HASH: a9ba7072400dac24052ef744ca60c8273d743af357c851a7016cafd599225672
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced
HASH: b02147bf83730cc51219f660fe93c63a7463c765395b6721bb842e3ef230e6f5
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee
HASH: b642374d57afa89053dcb7f6e1e72680fb96e3f28adaaf5aed89ab4cfc78214a
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef
HASH: 546b4be370ba614a1761fe8cef8c023d6a7f968981e23a1e8e1168b25cce2efa
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0
HASH: 72dab9724f6e174d48e6b8caf489747995d649828a1b1d7a6e8527d9a01523a4
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1
HASH: 30b611734127b847bed5c68a867bcded79b2b9da0a358dbe15c4dd578f81e6c0
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2
HASH: 986317b1d1afd4692dd533a712718196d412f46a6f3166f417ef01306ab695dd
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3
HASH: db6329f783adf7cf5a10e47369fe03c95bcf523558f3aedf18b51a355a252517
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4
HASH: 54bb60a43c1e045644420916bac42cc72f86649fe8efeec866cd8e8128a88def
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5
HASH: 802875948f79eefb707094e323a0faa2d6d88949a08c044ed3757174492bd2eb
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6
HASH: ffc9e261842e1afdaed9f364f125301f20ac8fb0eea556db975211c7db281daa
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7
HASH: edfe0aa71067c62e894a516a72dd4bef8c3917e46eb22d39626ea826b90804e9
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8
HASH: 98832102b93bab4f82ee872d1dc96d2651ccc9e908c3cf25a56b59cce20319df
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9
HASH: 1248d2d1736f1c125c6928bf893f581ea25be6e6e3d3c46081c557de591d6c6c
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa
HASH: 7a01651d8ffa44f6695270c73066ca9d61733ae3c181e3477d11e7c9563594a3
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb
HASH: ced595397cfd128aadbf451002457ff5b0fc2ac3993cabd47f0fc3ddbc6d0f32
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc
HASH: 8797db8dd8ddd1ecbee1f1d71aed5d41adca8345277a7bc0b12df75bb4536722
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd
HASH: 369b09e04be27275df75c180d7283c083162f35456152f0b16ae680dda5195bc
IN: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe
HASH: 1d0850ee9bca0abc9601e9deabe1418fedec2fb6ac4150bd5302d2430f9be943
# Longer test vectors
IN: 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
HASH: 450eee5f3502c7d5ac7f223d4b4f2c76a11e5bd02d253a37ca9e6e901d5fb56e
IN: 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
HASH: 6ed9bf545705dba5971e83a1f2a46a9dd5ac2fe8a934f13cee8d353003eaf908
IN: 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
HASH: a43b19ed8f147f18c304bffeec559e63e83877507cac11924edaf9eb6b6c1bac
| 98,758 | 821 | jart/cosmopolitan | false |
cosmopolitan/test/libc/str/tprecode16to8_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
TEST(tprecode16to8, test) {
char b[128];
EXPECT_EQ(69, tprecode16to8(b, 128, u"(â¯Â°â¡Â°)â¯ï¸µLâ»ââ» ð°ð±ð²ð³ð´ðµð¶ð·ð¸ð¹").ax);
EXPECT_STREQ("(â¯Â°â¡Â°)â¯ï¸µLâ»ââ» ð°ð±ð²ð³ð´ðµð¶ð·ð¸ð¹", b);
}
TEST(tprecode16to8, testEmptyOut_doesNothingButStillCountsSrcLength) {
axdx_t r;
r = tprecode16to8(NULL, 0, u"hi");
EXPECT_EQ(0, r.ax);
EXPECT_EQ(3, r.dx);
}
TEST(tprecode16to8, testTooLittle_stillNulTerminates) {
axdx_t r;
char b[2] = {1, 2};
r = tprecode16to8(b, 2, u"hi");
EXPECT_EQ(1, r.ax);
EXPECT_EQ(3, r.dx);
EXPECT_EQ('h', b[0]);
EXPECT_EQ(0, b[1]);
}
TEST(tprecode16to8, testAscii_vectorSpeedupWorks) {
size_t size = 32;
char *buf = malloc(size);
EXPECT_EQ(31,
tprecode16to8(buf, size, u"babaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").ax);
EXPECT_STREQ("babaaaaaaaaaaaaaaaaaaaaaaaaaaaa", buf);
free(buf);
}
BENCH(tprecode16to8, bench) {
char *buf8 = malloc(kHyperionSize + 1);
char16_t *buf16 = malloc((kHyperionSize + 1) * 2);
tprecode8to16(buf16, kHyperionSize + 1, kHyperion);
EZBENCH2("tprecode16to8", donothing,
tprecode16to8(buf8, kHyperionSize + 1, buf16));
free(buf16);
free(buf8);
}
| 3,206 | 66 | jart/cosmopolitan | false |
cosmopolitan/test/libc/time/clock_gettime_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/struct/timespec.h"
#include "libc/fmt/conv.h"
#include "libc/macros.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/stdio/stdio.h"
#include "libc/sysv/consts/clock.h"
#include "libc/testlib/testlib.h"
#include "libc/time/time.h"
#include "libc/x/x.h"
TEST(clock_gettime, testClockRealtime) {
struct timeval tv;
struct timespec ts;
EXPECT_NE(-1, gettimeofday(&tv, NULL));
EXPECT_NE(-1, clock_gettime(CLOCK_REALTIME, &ts));
EXPECT_LT((unsigned)ABS(ts.tv_sec - tv.tv_sec), 5u);
}
| 2,358 | 36 | jart/cosmopolitan | false |
cosmopolitan/test/libc/time/strftime_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/limits.h"
#include "libc/runtime/runtime.h"
#include "libc/testlib/testlib.h"
#include "libc/time/struct/tm.h"
#include "libc/time/time.h"
textstartup static void strftime_test_init(void) {
setenv("TZ", "GST", true);
}
const void *const strftime_test_ctor[] initarray = {strftime_test_init};
char *FormatTime(const char *fmt, struct tm *tm) {
static char buf[64];
strftime(buf, sizeof(buf), fmt, tm);
return &buf[0];
}
TEST(strftime_100, iso8601_ShakaZuluTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("2019-05-06T15:04:46Z",
FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t)));
}
TEST(xiso8601, testUnixYearZero) {
int64_t t = 0;
ASSERT_STREQ("1970-01-01T00:00:00Z",
FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t)));
}
TEST(strftime_100, rfc2822_ShakaZuluTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("Mon, 06 May 2019 15:04:46 +0000",
FormatTime("%a, %d %b %Y %T %z", gmtime(&t)));
}
TEST(strftime_100, rfc822_ShakaZuluTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("Mon, 06 May 19 15:04:46 +0000",
FormatTime("%a, %d %b %y %T %z", gmtime(&t)));
}
TEST(strftime_201, iso8601_GoogleStandardTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("GST", getenv("TZ"));
ASSERT_STREQ("2019-05-06T08:04:46PDT",
FormatTime("%Y-%m-%dT%H:%M:%S%Z", localtime(&t)));
}
TEST(strftime_201, rfc2822_GoogleStandardTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("Mon, 06 May 2019 08:04:46 -0700",
FormatTime("%a, %d %b %Y %T %z", localtime(&t)));
}
TEST(strftime_201, rfc822_GoogleStandardTime) {
int64_t t = 0x5cd04d0e;
ASSERT_STREQ("Mon, 06 May 19 08:04:46 -0700",
FormatTime("%a, %d %b %y %T %z", localtime(&t)));
}
/* TEST(xiso8601, testModernity_TODO) { */
/* int64_t t = (1600 - 1970) * 31536000; */
/* ASSERT_STREQ("1600-01-01T00:00:00Z", */
/* FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t))); */
/* } */
TEST(xiso8601, testAtLeastBetterThanTraditionalUnixLimit) {
int64_t t = 10737418235;
ASSERT_STREQ("2310-04-04T16:10:35Z",
FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t)));
}
TEST(xiso8601, testSomethingHuge) {
int64_t t = 7707318812667;
ASSERT_STREQ("246205-03-18T20:24:27Z",
FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t)));
}
/* TEST(xiso8601, testMostOfStelliferousEra_TODO) { */
/* int64_t t = INT64_MAX; */
/* ASSERT_STREQ("somethinghuge-01-01T00:00:00Z", */
/* FormatTime("%Y-%m-%dT%H:%M:%SZ", gmtime(&t))); */
/* } */
| 4,402 | 103 | jart/cosmopolitan | false |
cosmopolitan/test/libc/time/iso8601_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/time/struct/tm.h"
#include "libc/time/time.h"
TEST(iso8601, test) {
char p[20];
struct tm tm;
int64_t t = 0x62820bcd;
gmtime_r(&t, &tm);
EXPECT_EQ(p + 19, iso8601(p, &tm));
EXPECT_STREQ("2022-05-16T08:31:09", p);
}
TEST(iso8601us, test) {
char p[27];
struct tm tm;
int64_t t = 0x62820bcd;
gmtime_r(&t, &tm);
EXPECT_EQ(p + 26, iso8601us(p, &tm, 1234000));
EXPECT_STREQ("2022-05-16T08:31:09.001234", p);
}
BENCH(iso8601, bench) {
char p[27];
struct tm tm;
int64_t t = 0x62820bcd;
gmtime_r(&t, &tm);
EZBENCH2("iso8601", donothing, iso8601(p, &tm));
EZBENCH2("iso8601us", donothing, iso8601us(p, &tm, 123456));
EZBENCH2("strftime", donothing,
strftime(p, sizeof(p), "%Y-%m-%dT%H:%M:%S", &tm));
}
| 2,663 | 52 | jart/cosmopolitan | false |
cosmopolitan/test/libc/time/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
PKGS += TEST_LIBC_TIME
TEST_LIBC_TIME_SRCS := $(wildcard test/libc/time/*.c)
TEST_LIBC_TIME_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_TIME_SRCS))
TEST_LIBC_TIME_BINS = $(TEST_LIBC_TIME_COMS) $(TEST_LIBC_TIME_COMS:%=%.dbg)
TEST_LIBC_TIME_OBJS = \
$(TEST_LIBC_TIME_SRCS:%.c=o/$(MODE)/%.o)
TEST_LIBC_TIME_COMS = \
$(TEST_LIBC_TIME_SRCS:%.c=o/$(MODE)/%.com)
TEST_LIBC_TIME_TESTS = $(TEST_LIBC_TIME_SRCS_TEST:%.c=o/$(MODE)/%.com.ok)
TEST_LIBC_TIME_CHECKS = \
$(TEST_LIBC_TIME_SRCS_TEST:%.c=o/$(MODE)/%.com.runs)
TEST_LIBC_TIME_DIRECTDEPS = \
LIBC_CALLS \
LIBC_INTRIN \
LIBC_LOG \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STUBS \
LIBC_SYSV \
LIBC_TESTLIB \
LIBC_TIME \
LIBC_X
TEST_LIBC_TIME_DEPS := \
$(call uniq,$(foreach x,$(TEST_LIBC_TIME_DIRECTDEPS),$($(x))))
o/$(MODE)/test/libc/time/time.pkg: \
$(TEST_LIBC_TIME_OBJS) \
$(foreach x,$(TEST_LIBC_TIME_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/libc/time/%.com.dbg: \
$(TEST_LIBC_TIME_DEPS) \
o/$(MODE)/test/libc/time/%.o \
o/$(MODE)/test/libc/time/time.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
.PHONY: o/$(MODE)/test/libc/time
o/$(MODE)/test/libc/time: \
$(TEST_LIBC_TIME_BINS) \
$(TEST_LIBC_TIME_CHECKS)
| 1,511 | 53 | jart/cosmopolitan | false |
cosmopolitan/test/tool/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
.PHONY: o/$(MODE)/test/tool
o/$(MODE)/test/tool: \
o/$(MODE)/test/tool/args \
o/$(MODE)/test/tool/build \
o/$(MODE)/test/tool/plinko \
o/$(MODE)/test/tool/net \
o/$(MODE)/test/tool/viz
| 401 | 11 | jart/cosmopolitan | false |
cosmopolitan/test/tool/args/args_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2022 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/testlib/testlib.h"
#include "tool/args/args.h"
void FreeZipArgs(void);
int LoadZipArgsImpl(int *, char ***, char *);
void TearDown(void) {
FreeZipArgs();
}
TEST(LoadZipArgs, testNoFile_noCliArgs_doesNothing) {
int argc = 1;
char *args[] = {"prog", 0};
char **argv = &args[0];
EXPECT_EQ(0, LoadZipArgsImpl(&argc, &argv, 0));
ASSERT_EQ(1, argc);
EXPECT_STREQ("prog", argv[0]);
EXPECT_EQ(NULL, argv[1]);
}
TEST(LoadZipArgs, testDefaultArgs_noCliArgs_replacesArgv) {
int argc = 1;
char *args[] = {"prog", 0};
char **argv = &args[0];
EXPECT_EQ(0, LoadZipArgsImpl(&argc, &argv, strdup("\
-x\r\n\
hello\r\n\
-y\r\n\
world\r\n\
")));
ASSERT_EQ(5, argc);
EXPECT_STREQ("prog", argv[0]);
EXPECT_STREQ("-x", argv[1]);
EXPECT_STREQ("hello", argv[2]);
EXPECT_STREQ("-y", argv[3]);
EXPECT_STREQ("world", argv[4]);
EXPECT_EQ(NULL, argv[5]);
EXPECT_EQ(5, __argc);
EXPECT_STREQ("prog", __argv[0]);
EXPECT_STREQ("-x", __argv[1]);
EXPECT_STREQ("hello", __argv[2]);
EXPECT_STREQ("-y", __argv[3]);
EXPECT_STREQ("world", __argv[4]);
EXPECT_EQ(NULL, __argv[5]);
}
TEST(LoadZipArgs, testDefaultArgs_hasCliArgs_doesNothing) {
int argc = 2;
char *args[] = {"prog", "yo", 0};
char **argv = &args[0];
EXPECT_EQ(0, LoadZipArgsImpl(&argc, &argv, strdup("\
-x\r\n\
hello\r\n\
-y\r\n\
world\r\n\
")));
ASSERT_EQ(2, argc);
EXPECT_STREQ("prog", argv[0]);
EXPECT_STREQ("yo", argv[1]);
EXPECT_EQ(NULL, argv[2]);
}
TEST(LoadZipArgs, testDots_hasCliArgs_mergesThem) {
int argc = 3;
char *args[] = {"prog", "yo", "dawg", 0};
char **argv = &args[0];
EXPECT_EQ(0, LoadZipArgsImpl(&argc, &argv, strdup("\
-x\r\n\
hell o\r\n\
-y\r\n\
world\r\n\
...\r\n\
")));
ASSERT_EQ(7, argc);
EXPECT_STREQ("prog", argv[0]);
EXPECT_STREQ("-x", argv[1]);
EXPECT_STREQ("hell o", argv[2]);
EXPECT_STREQ("-y", argv[3]);
EXPECT_STREQ("world", argv[4]);
EXPECT_STREQ("yo", argv[5]);
EXPECT_STREQ("dawg", argv[6]);
EXPECT_EQ(NULL, argv[7]);
}
| 3,889 | 104 | jart/cosmopolitan | false |
cosmopolitan/test/tool/args/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
PKGS += TEST_TOOL_ARGS
TEST_TOOL_ARGS = $(TOOL_ARGS_A_DEPS) $(TOOL_ARGS_A)
TEST_TOOL_ARGS_A = o/$(MODE)/test/tool/args/argstest.a
TEST_TOOL_ARGS_FILES := $(wildcard test/tool/args/*)
TEST_TOOL_ARGS_SRCS = $(filter %.c,$(TEST_TOOL_ARGS_FILES))
TEST_TOOL_ARGS_SRCS_TEST = $(filter %_test.c,$(TEST_TOOL_ARGS_SRCS))
TEST_TOOL_ARGS_HDRS = $(filter %.h,$(TEST_TOOL_ARGS_FILES))
TEST_TOOL_ARGS_COMS = $(TEST_TOOL_ARGS_OBJS:%.o=%.com)
TEST_TOOL_ARGS_OBJS = \
$(TEST_TOOL_ARGS_SRCS:%.c=o/$(MODE)/%.o)
TEST_TOOL_ARGS_COMS = \
$(TEST_TOOL_ARGS_SRCS:%.c=o/$(MODE)/%.com)
TEST_TOOL_ARGS_BINS = \
$(TEST_TOOL_ARGS_COMS) \
$(TEST_TOOL_ARGS_COMS:%=%.dbg)
TEST_TOOL_ARGS_TESTS = \
$(TEST_TOOL_ARGS_SRCS_TEST:%.c=o/$(MODE)/%.com.ok)
TEST_TOOL_ARGS_CHECKS = \
$(TEST_TOOL_ARGS_HDRS:%=o/$(MODE)/%.ok) \
$(TEST_TOOL_ARGS_SRCS_TEST:%.c=o/$(MODE)/%.com.runs)
TEST_TOOL_ARGS_DIRECTDEPS = \
LIBC_CALLS \
LIBC_FMT \
LIBC_INTRIN \
LIBC_LOG \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STDIO \
LIBC_STR \
LIBC_STUBS \
LIBC_SYSV \
LIBC_TESTLIB \
LIBC_ZIPOS \
LIBC_X \
THIRD_PARTY_COMPILER_RT \
TOOL_ARGS
TEST_TOOL_ARGS_DEPS := \
$(call uniq,$(foreach x,$(TEST_TOOL_ARGS_DIRECTDEPS),$($(x))))
$(TEST_TOOL_ARGS_A): \
test/tool/args/ \
$(TEST_TOOL_ARGS_A).pkg \
$(TEST_TOOL_ARGS_OBJS)
$(TEST_TOOL_ARGS_A).pkg: \
$(TEST_TOOL_ARGS_OBJS) \
$(foreach x,$(TEST_TOOL_ARGS_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/tool/args/%.com.dbg: \
$(TEST_TOOL_ARGS_DEPS) \
$(TEST_TOOL_ARGS_A) \
o/$(MODE)/test/tool/args/%.o \
$(TEST_TOOL_ARGS_A).pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE_NO_MODIFY_SELF)
@$(APELINK)
.PHONY: o/$(MODE)/test/tool/args
o/$(MODE)/test/tool/args: \
$(TEST_TOOL_ARGS_BINS) \
$(TEST_TOOL_ARGS_CHECKS)
| 2,034 | 75 | jart/cosmopolitan | false |
cosmopolitan/test/tool/build/pledge_test.sh | #!/bin/sh
m=tinylinux
t=/tmp/pledge-test
if [ $# = 0 ]; then
if ! [ $(id -u) = 0 ]; then
make -j16 MODE=fastbuild \
o/fastbuild/examples/ls.com \
o/fastbuild/examples/curl.com \
o/fastbuild/examples/life.com \
o/fastbuild/examples/hello.com \
o/fastbuild/examples/printargs.com \
o/fastbuild/tool/build/assimilate.com \
o/fastbuild/tool/build/pledge.com || exit
make -j16 MODE=$m \
o/$m/examples/ls.com \
o/$m/examples/curl.com \
o/$m/examples/life.com \
o/$m/examples/hello.com \
o/$m/examples/printargs.com \
o/$m/tool/build/assimilate.com \
o/$m/tool/build/pledge.com || exit
test/tool/build/pledge_test.sh ape_binfmt_test_suite || exit
test/tool/build/pledge_test.sh ape_loader_test_suite || exit
test/tool/build/pledge_test.sh ape_assimilated_test_suite || exit
test/tool/build/pledge_test.sh ape_native_test_suite || exit
sudo test/tool/build/pledge_test.sh setuid_setup || exit
test/tool/build/pledge_test.sh setuid_test_suite || exit
else
echo need to run as an unprivileged user with sudo access >&2
exit 1
fi
fi
check() {
if [ $? = 0 ]; then
printf '\e[32mok\e[0m\n'
else
echo failed >&2
exit 1
fi
}
startit() {
printf 'testing %-30s ' "$*" >&2
}
checkem() {
if [ $? = 0 ]; then
printf '\e[1;32mOK\e[0m\n'
else
printf '\e[1;31mFAILED\e[0m\n'
exit 1
fi
}
if [ "$1" = setuid_setup ]; then
rm -rf $t || exit
mkdir -p $t || exit
chmod 01777 $t || exit
cp o/$m/tool/build/pledge.com $t || exit
chmod 06755 $t/pledge.com || exit
elif [ "$1" = ape_binfmt_test_suite ]; then
ape/apeinstall.sh >/dev/null 2>&1
startit ape binfmt life.com
o/fastbuild/tool/build/pledge.com -p 'stdio rpath prot_exec' o/fastbuild/examples/life.com
[ $? = 42 ]
checkem
startit ape binfmt hello.com
[ "$(o/fastbuild/tool/build/pledge.com -p 'stdio rpath prot_exec' o/fastbuild/examples/hello.com)" = "hello world" ]
checkem
startit ape binfmt curl.com
[ "$(o/fastbuild/tool/build/pledge.com -p 'stdio inet dns rpath prot_exec' o/fastbuild/examples/curl.com https://justine.lol/hello.txt)" = "hello world" ]
checkem
elif [ "$1" = ape_loader_test_suite ]; then
ape/apeuninstall.sh >/dev/null 2>&1
startit ape loader life.com
o/fastbuild/tool/build/pledge.com -p 'stdio rpath prot_exec' o/fastbuild/examples/life.com
[ $? = 42 ]
checkem
startit ape loader hello.com
[ "$(o/fastbuild/tool/build/pledge.com -p 'stdio rpath prot_exec' o/fastbuild/examples/hello.com)" = "hello world" ]
checkem
startit ape loader curl.com
[ "$(o/fastbuild/tool/build/pledge.com -p 'stdio inet dns rpath prot_exec' o/fastbuild/examples/curl.com https://justine.lol/hello.txt)" = "hello world" ]
checkem
ape/apeinstall.sh >/dev/null 2>&1
elif [ "$1" = ape_assimilated_test_suite ]; then
mkdir -p $t/assimilated
startit ape assimilated life.com
cp o/fastbuild/examples/life.com $t/assimilated
o/fastbuild/tool/build/assimilate.com $t/assimilated/life.com
o/$m/tool/build/pledge.com -p 'stdio' $t/assimilated/life.com
[ $? = 42 ]
checkem
startit ape assimilated hello.com
cp o/fastbuild/examples/hello.com $t/assimilated
o/fastbuild/tool/build/assimilate.com $t/assimilated/hello.com
[ "$(o/$m/tool/build/pledge.com -p 'stdio' $t/assimilated/hello.com)" = "hello world" ]
checkem
startit ape assimilated curl.com
cp o/fastbuild/examples/curl.com $t/assimilated
o/fastbuild/tool/build/assimilate.com $t/assimilated/curl.com
[ "$(o/$m/tool/build/pledge.com -p 'stdio rpath inet dns' $t/assimilated/curl.com https://justine.lol/hello.txt)" = "hello world" ]
checkem
elif [ "$1" = ape_native_test_suite ]; then
startit ape native life.com
o/$m/tool/build/pledge.com -p 'stdio' o/$m/examples/life.com
[ $? = 42 ]
checkem
startit ape native hello.com
[ "$(o/$m/tool/build/pledge.com -p 'stdio' o/$m/examples/hello.com)" = "hello world" ]
checkem
startit ape native curl.com
[ "$(o/$m/tool/build/pledge.com -p 'stdio rpath inet dns' o/$m/examples/curl.com https://justine.lol/hello.txt)" = "hello world" ]
checkem
elif [ "$1" = setuid_test_suite ]; then
startit setuid life.com
$t/pledge.com -p 'stdio' o/$m/examples/life.com
[ $? = 42 ]
checkem
startit setuid hello.com
[ "$($t/pledge.com -p 'stdio' o/$m/examples/hello.com)" = "hello world" ]
checkem
startit setuid curl.com
[ "$($t/pledge.com -p 'stdio rpath inet dns' o/$m/examples/curl.com https://justine.lol/hello.txt)" = "hello world" ]
checkem
startit setuid getuid
[ "$($t/pledge.com -p 'stdio rpath proc tty' o/$m/examples/printargs.com 2>&1 | grep getuid | grep -o [[:digit:]]*)" = "$(id -u)" ]
checkem
startit setuid geteuid
[ "$($t/pledge.com -p 'stdio rpath proc tty' o/$m/examples/printargs.com 2>&1 | grep geteuid | grep -o [[:digit:]]*)" = "$(id -u)" ]
checkem
startit setuid no capabilities
[ "$($t/pledge.com -p 'stdio rpath proc tty' o/$m/examples/printargs.com 2>&1 | grep CAP_ | wc -l)" = 0 ]
checkem
startit setuid maximum nice
$t/pledge.com -np 'stdio rpath proc tty' o/$m/examples/printargs.com 2>&1 | grep SCHED_IDLE >/dev/null
checkem
startit setuid chroot
mkdir $t/jail &&
touch $t/jail/hi &&
cp o/$m/examples/ls.com $t/jail &&
$t/pledge.com -v / -c $t/jail -p 'stdio rpath' /ls.com / | grep 'DT_REG /hi' >/dev/null
checkem
fi
| 5,468 | 178 | jart/cosmopolitan | false |
cosmopolitan/test/tool/build/test.mk | #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-â
#âââvi: set et ft=make ts=8 tw=8 fenc=utf-8 :viââââââââââââââââââââââââ
.PHONY: o/$(MODE)/test/tool/build
o/$(MODE)/test/tool/build: \
o/$(MODE)/test/tool/build/lib
| 299 | 7 | jart/cosmopolitan | false |
cosmopolitan/test/tool/build/lib/divmul_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "tool/build/lib/divmul.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/macros.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/sa.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/testlib.h"
#include "libc/x/xsigaction.h"
#include "third_party/xed/x86.h"
#include "tool/build/lib/endian.h"
#include "tool/build/lib/flags.h"
#include "tool/build/lib/machine.h"
#ifdef __x86_64__
#define CX 1
#define OSZ 00000000040
#define REXW 00000000100
#define RM(x) (0000001600 & ((x) << 007))
#define MOD(x) (0060000000 & ((x) << 026))
jmp_buf sigfpejmp;
struct Machine m[1];
struct sigaction oldsigfpe[1];
struct XedDecodedInst xedd[1];
void OnSigFpe(void) {
/* ProTip: gdb -ex 'handle SIGFPE nostop noprint pass' */
longjmp(sigfpejmp, 1);
}
void SetUp(void) {
m->xedd = xedd;
ASSERT_NE(-1, xsigaction(SIGFPE, OnSigFpe, SA_NODEFER, 0, oldsigfpe));
}
void TearDown(void) {
m->xedd = xedd;
ASSERT_NE(-1, sigaction(SIGFPE, oldsigfpe, NULL));
}
TEST(imul8, test) {
static const uint8_t A[] = {0x00, 0x01, 0x80, 0x7F, 0x81, 0x7E, 0xFF, 0xBF};
int i, j;
int16_t ax;
bool cf, of;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write8(m->ax, A[i]);
Write8(m->cx, A[j]);
OpMulAxAlEbSigned(m, MOD(3) | RM(CX));
asm volatile("imulb\t%3"
: "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "q"(A[j]), "0"(A[i])
: "cc");
EXPECT_EQ(ax, (int16_t)Read16(m->ax));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(imul16, test) {
static const uint16_t A[] = {0x0000, 0x0001, 0x8000, 0x7FFF, 0x8001, 0x7FFE,
0xFFFF, 0xBeef, 0x00b5, 0x00b6, 0xb504, 0xb505};
int i, j;
bool cf, of;
uint16_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write16(m->ax, A[i]);
Write16(m->cx, A[j]);
OpMulRdxRaxEvqpSigned(m, OSZ | MOD(3) | RM(CX));
asm("imulw\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((int32_t)((uint32_t)dx << 16 | ax),
(int32_t)((uint32_t)Read16(m->dx) << 16 | Read16(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(imul32, test) {
static const uint32_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0xDeadBeef,
0x000000b6, 0x0000b504, 0x0000b505, 0xb504f334};
int i, j;
bool cf, of;
uint32_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write32(m->ax, A[i]);
Write32(m->cx, A[j]);
OpMulRdxRaxEvqpSigned(m, MOD(3) | RM(CX));
asm("imull\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((int64_t)((uint64_t)dx << 32 | ax),
(int64_t)((uint64_t)Read32(m->dx) << 32 | Read32(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(imul64, test) {
static const uint64_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0xDeadBeef,
0x000000b6, 0x0000b504, 0x0000b505, 0xb504f334};
int i, j;
bool cf, of;
uint64_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write64(m->ax, A[i]);
Write64(m->cx, A[j]);
OpMulRdxRaxEvqpSigned(m, REXW | MOD(3) | RM(CX));
asm("imulq\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((int128_t)((uint128_t)dx << 64 | ax),
(int128_t)((uint128_t)Read64(m->dx) << 64 | Read64(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(mul8, test) {
static const uint8_t A[] = {0x00, 0x01, 0x80, 0x7F, 0x81, 0x7E, 0xFF, 0xb6};
int i, j;
uint16_t ax;
bool cf, of;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write8(m->ax, A[i]);
Write8(m->cx, A[j]);
OpMulAxAlEbUnsigned(m, MOD(3) | RM(CX));
asm volatile("mulb\t%3"
: "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "q"(A[j]), "0"(A[i])
: "cc");
EXPECT_EQ(ax, Read16(m->ax));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(mul16, test) {
static const uint16_t A[] = {0x0000, 0x0001, 0x8000, 0x7FFF,
0x8001, 0x7FFE, 0xFFFF, 0x00b6};
int i, j;
bool cf, of;
uint16_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write16(m->ax, A[i]);
Write16(m->cx, A[j]);
OpMulRdxRaxEvqpUnsigned(m, OSZ | MOD(3) | RM(CX));
asm("mulw\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((uint32_t)((uint32_t)dx << 16 | ax),
(uint32_t)((uint32_t)Read16(m->dx) << 16 | Read16(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(mul32, test) {
static const uint32_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0x000000b5,
0x000000b6, 0x0000b504, 0x0000b505, 0xb504f334};
int i, j;
bool cf, of;
uint32_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write32(m->ax, A[i]);
Write32(m->cx, A[j]);
OpMulRdxRaxEvqpUnsigned(m, MOD(3) | RM(CX));
asm("mull\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((uint64_t)((uint64_t)dx << 32 | ax),
(uint64_t)((uint64_t)Read32(m->dx) << 32 | Read32(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(mul64, test) {
static const uint64_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0x000000b6,
0x0000b504, 0x0000b505, 0xb504f333, 0xb504f334};
int i, j;
bool cf, of;
uint64_t dx, ax;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
Write64(m->ax, A[i]);
Write64(m->cx, A[j]);
OpMulRdxRaxEvqpUnsigned(m, REXW | MOD(3) | RM(CX));
asm("mulq\t%4"
: "=d"(dx), "=a"(ax), "=@ccc"(cf), "=@cco"(of)
: "r"(A[j]), "1"(A[i])
: "cc");
EXPECT_EQ((uint128_t)((uint128_t)dx << 64 | ax),
(uint128_t)((uint128_t)Read64(m->dx) << 64 | Read64(m->ax)));
EXPECT_EQ(cf, GetFlag(m->flags, FLAGS_CF));
EXPECT_EQ(of, GetFlag(m->flags, FLAGS_OF));
}
}
}
TEST(idiv8, test) {
if (IsWindows()) return; /* TODO */
static const uint8_t A[] = {0x00, 0x01, 0x80, 0x7F, 0x81, 0x7E, 0xFF, 0xBF};
uint16_t remquo;
bool gotthrow, gotsigfpe;
int8_t i, j, k, w, x, a, b;
int8_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
m->ax[1] = A[i];
m->ax[0] = A[j];
m->cx[0] = A[k];
gotthrow = false;
gotsigfpe = false;
if (!setjmp(m->onhalt)) {
OpDivAlAhAxEbSigned(m, MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
asm("idivb\t%1"
: "=a"(remquo)
: "q"(A[k]), "0"((int16_t)(A[i] << 8 | A[j]))
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
quotient = (int8_t)remquo;
remainder = (int8_t)(remquo >> 8);
EXPECT_EQ(quotient, (int8_t)m->ax[0]);
EXPECT_EQ(remainder, (int8_t)m->ax[1]);
}
}
}
}
}
TEST(idiv16, test) {
if (IsWindows()) return; /* TODO */
static const uint16_t A[] = {0x0000, 0x0001, 0x8000, 0x7FFF,
0x8001, 0x7FFE, 0xFFFF, 0xBeef};
bool gotthrow, gotsigfpe;
int16_t i, j, k, w, x, a, b;
int16_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 2);
memcpy(m->ax, &A[j], 2);
memcpy(m->cx, &A[k], 2);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpSigned(m, OSZ | MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("idivw\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (int16_t)Read16(m->ax));
EXPECT_EQ(remainder, (int16_t)Read16(m->dx));
}
}
}
}
}
TEST(idiv32, test) {
if (IsWindows()) return; /* TODO */
static const uint32_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0xDeadBeef};
bool gotthrow, gotsigfpe;
int32_t i, j, k, w, x, a, b;
int32_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 4);
memcpy(m->ax, &A[j], 4);
memcpy(m->cx, &A[k], 4);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpSigned(m, MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("idivl\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (int32_t)Read32(m->ax));
EXPECT_EQ(remainder, (int32_t)Read32(m->dx));
}
}
}
}
}
TEST(idiv64, test) {
if (IsWindows()) return; /* TODO */
static const uint64_t A[] = {0x0000000000000000, 0x0000000000000001,
0x8000000000000000, 0x7FFFFFFFFFFFFFFF,
0x8000000000000001, 0x7FFFFFFFFFFFFFFE,
0xFFFFFFFFFFFFFFFF, 0x00DeadBeefCafe00};
bool gotthrow, gotsigfpe;
int64_t i, j, k, w, x, a, b;
int64_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 8);
memcpy(m->ax, &A[j], 8);
memcpy(m->cx, &A[k], 8);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpSigned(m, REXW | MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("idivq\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (int64_t)Read64(m->ax));
EXPECT_EQ(remainder, (int64_t)Read64(m->dx));
}
}
}
}
}
TEST(div, test) {
if (IsWindows()) return; /* TODO */
static const uint8_t A[] = {0x00, 0x01, 0x80, 0x7F, 0x81, 0x7E, 0xFF, 0xBF};
uint16_t remquo;
bool gotthrow, gotsigfpe;
uint8_t i, j, k, w, x, a, b;
uint8_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
m->ax[1] = A[i];
m->ax[0] = A[j];
m->cx[0] = A[k];
gotthrow = false;
gotsigfpe = false;
if (!setjmp(m->onhalt)) {
OpDivAlAhAxEbUnsigned(m, MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
asm("divb\t%1"
: "=a"(remquo)
: "q"(A[k]), "0"((uint16_t)(A[i] << 8 | A[j]))
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
quotient = (uint8_t)remquo;
remainder = (uint8_t)(remquo >> 8);
EXPECT_EQ(quotient, (uint8_t)m->ax[0]);
EXPECT_EQ(remainder, (uint8_t)m->ax[1]);
}
}
}
}
}
TEST(div16, test) {
if (IsWindows()) return; /* TODO */
static const uint16_t A[] = {0x0000, 0x0001, 0x8000, 0x7FFF,
0x8001, 0x7FFE, 0xFFFF, 0xBeef};
bool gotthrow, gotsigfpe;
uint16_t i, j, k, w, x, a, b;
uint16_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 2);
memcpy(m->ax, &A[j], 2);
memcpy(m->cx, &A[k], 2);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpUnsigned(m, OSZ | MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("divw\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (uint16_t)Read16(m->ax));
EXPECT_EQ(remainder, (uint16_t)Read16(m->dx));
}
}
}
}
}
TEST(div32, test) {
if (IsWindows()) return; /* TODO */
static const uint32_t A[] = {0x00000000, 0x00000001, 0x80000000, 0x7FFFFFFF,
0x80000001, 0x7FFFFFFE, 0xFFFFFFFF, 0xDeadBeef};
bool gotthrow, gotsigfpe;
uint32_t i, j, k, w, x, a, b;
uint32_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 4);
memcpy(m->ax, &A[j], 4);
memcpy(m->cx, &A[k], 4);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpUnsigned(m, MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("divl\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (uint32_t)Read32(m->ax));
EXPECT_EQ(remainder, (uint32_t)Read32(m->dx));
}
}
}
}
}
TEST(div64, test) {
if (IsWindows()) return; /* TODO */
static const uint64_t A[] = {0x0000000000000000, 0x0000000000000001,
0x8000000000000000, 0x7FFFFFFFFFFFFFFF,
0x8000000000000001, 0x7FFFFFFFFFFFFFFE,
0xFFFFFFFFFFFFFFFF, 0x00DeadBeefCafe00};
bool gotthrow, gotsigfpe;
uint64_t i, j, k, w, x, a, b;
uint64_t quotient, remainder;
for (i = 0; i < ARRAYLEN(A); ++i) {
for (j = 0; j < ARRAYLEN(A); ++j) {
for (k = 0; k < ARRAYLEN(A); ++k) {
memcpy(m->dx, &A[i], 8);
memcpy(m->ax, &A[j], 8);
memcpy(m->cx, &A[k], 8);
if (!setjmp(m->onhalt)) {
gotthrow = false;
OpDivRdxRaxEvqpUnsigned(m, REXW | MOD(3) | RM(CX));
} else {
gotthrow = true;
}
if (!setjmp(sigfpejmp)) {
gotsigfpe = false;
asm("divq\t%2"
: "=d"(remainder), "=a"(quotient)
: "r"(A[k]), "0"(A[i]), "1"(A[j])
: "cc");
} else {
gotsigfpe = true;
}
EXPECT_EQ(gotsigfpe, gotthrow);
if (!gotsigfpe && !gotthrow) {
EXPECT_EQ(quotient, (uint64_t)Read64(m->ax));
EXPECT_EQ(remainder, (uint64_t)Read64(m->dx));
}
}
}
}
}
#endif /* __x86_64__ */
| 18,769 | 557 | jart/cosmopolitan | false |
cosmopolitan/test/tool/build/lib/interner_test.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2020 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/mem/mem.h"
#include "libc/mem/gc.internal.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/fastrandomstring.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"
#include "tool/build/lib/interner.h"
TEST(interner, test) {
struct Interner *t = defer(freeinterner, newinterner());
EXPECT_STREQ("hi", &t->p[intern(t, gc(strdup("hi")))]);
EXPECT_STREQ("there", &t->p[intern(t, gc(strdup("there")))]);
EXPECT_STREQ("hi", &t->p[intern(t, gc(strdup("hi")))]);
EXPECT_STREQ("there", &t->p[intern(t, gc(strdup("there")))]);
EXPECT_BINEQ(u"hi there  ", t->p);
EXPECT_EQ(strlen("hi") + 1 + strlen("there") + 1, t->i);
}
TEST(isinterned, test) {
struct Interner *t = defer(freeinterner, newinterner());
ASSERT_FALSE(isinterned(t, "doge"));
intern(t, "doge");
ASSERT_TRUE(isinterned(t, "doge"));
}
TEST(interner, testWordCount) {
struct Interner *t = defer(freeinterner, newinterner());
size_t i, j;
char word[16];
for (i = 0, j = 0; i < kHyperionSize; ++i) {
if (isalpha(kHyperion[i]) || kHyperion[i] == '\'') {
word[j++] = tolower(kHyperion[i]);
} else if (j) {
word[j] = '\0';
intern(t, word);
j = 0;
}
}
EXPECT_BINEQ(u"the fall of hyperion a dream", t->p);
/* 1547 = grep -Po "['a-zA-Z]+" hyperion.txt | tr A-Z a-z | dedupe | wc -l */
EXPECT_EQ(1548, interncount(t));
EXPECT_EQ(10502, t->i);
EXPECT_LT(t->i, t->n);
EXPECT_EQ('\0', t->p[t->i]);
}
BENCH(interner, bench) {
struct Interner *t = defer(freeinterner, newinterner());
intern(t, "hellos");
EZBENCH2("intern hit", donothing, intern(t, "hellos"));
EZBENCH2("intern miss", donothing, intern(t, FastRandomString()));
EZBENCH2("isinterned hit", donothing, isinterned(t, "hellos"));
EZBENCH2("isinterned miss", donothing, isinterned(t, FastRandomString()));
}
| 3,774 | 76 | jart/cosmopolitan | false |
Subsets and Splits