diff options
Diffstat (limited to 'test/sanitizer_common/TestCases/NetBSD')
16 files changed, 1359 insertions, 0 deletions
diff --git a/test/sanitizer_common/TestCases/NetBSD/asysctl.cc b/test/sanitizer_common/TestCases/NetBSD/asysctl.cc new file mode 100644 index 000000000000..acdfb17f28b5 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/asysctl.cc @@ -0,0 +1,44 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> +#include <sys/types.h> + +#include <sys/sysctl.h> + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> + +void test_asysctl() { + int mib[] = {CTL_KERN, KERN_OSTYPE}; + size_t len; + char *buf = (char *)asysctl(mib, __arraycount(mib), &len); + assert(buf); + + printf("asysctl: '%s' size: '%zu'\n", buf, len); + + free(buf); +} + +void test_asysctlbyname() { + size_t len; + char *buf = (char *)asysctlbyname("kern.ostype", &len); + assert(buf); + + printf("asysctlbyname: '%s' size: '%zu'\n", buf, len); + + free(buf); +} + +int main(void) { + printf("asysctl\n"); + + test_asysctl(); + test_asysctlbyname(); + + return 0; + + // CHECK: asysctl + // CHECK: asysctl: '{{.*}}' size: '{{.*}}' + // CHECK: asysctlbyname: '{{.*}}' size: '{{.*}}' +} diff --git a/test/sanitizer_common/TestCases/NetBSD/cdb.cc b/test/sanitizer_common/TestCases/NetBSD/cdb.cc new file mode 100644 index 000000000000..065623b7d7d0 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/cdb.cc @@ -0,0 +1,134 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> + +#include <sys/types.h> + +#include <sys/mman.h> +#include <sys/stat.h> + +#include <assert.h> +#include <cdbr.h> +#include <cdbw.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +static char *name; + +const char data1[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; +const char data2[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17}; +const char key1[] = {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27}; +const char key2[] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37}; + +void test_cdbw() { + uint32_t idx; + + struct cdbw *cdbw = cdbw_open(); + assert(cdbw); + + int rv = cdbw_put_data(cdbw, data1, __arraycount(data1), &idx); + assert(!rv); + + rv = cdbw_put_key(cdbw, key1, __arraycount(key1), idx); + assert(!rv); + + rv = cdbw_put(cdbw, key2, __arraycount(key2), data2, __arraycount(data2)); + assert(!rv); + + name = strdup("/tmp/temp.XXXXXX"); + assert(name); + + name = mktemp(name); + assert(name); + + int fd = open(name, O_RDWR | O_CREAT, 0644); + assert(fd != -1); + + cdbw_output(cdbw, fd, "TEST1", cdbw_stable_seeder); + + cdbw_close(cdbw); + + rv = close(fd); + assert(rv != -1); +} + +void test_cdbr1() { + struct cdbr *cdbr = cdbr_open(name, CDBR_DEFAULT); + assert(cdbr); + + uint32_t idx = cdbr_entries(cdbr); + assert(idx > 0); + printf("entries: %" PRIu32 "\n", idx); + + const void *data; + size_t data_len; + int rv = cdbr_get(cdbr, idx - 1, &data, &data_len); + assert(rv == 0); + + printf("data: "); + for (size_t i = 0; i < data_len; i++) + printf("%02" PRIx8, ((uint8_t *)data)[i]); + printf("\n"); + + rv = cdbr_find(cdbr, key1, __arraycount(key1), &data, &data_len); + + printf("data: "); + for (size_t i = 0; i < data_len; i++) + printf("%02" PRIx8, ((uint8_t *)data)[i]); + printf("\n"); + + cdbr_close(cdbr); +} + +#define COOKIE ((void *)1) + +static void cdbr_unmap(void *cookie, void *base, size_t sz) { + assert(cookie == COOKIE); + int rv = munmap(base, sz); + assert(rv != -1); +} + +void test_cdbr2() { + struct stat sb; + + int fd = open(name, O_RDONLY); + assert(fd != -1); + + int rv = fstat(fd, &sb); + assert(rv != -1); + + size_t sz = sb.st_size; + assert(sz < SSIZE_MAX); + + void *base = mmap(NULL, sz, PROT_READ, MAP_FILE | MAP_SHARED, fd, 0); + assert(base != MAP_FAILED); + + rv = close(fd); + assert(rv != -1); + + struct cdbr *cdbr = cdbr_open_mem(base, sz, CDBR_DEFAULT, cdbr_unmap, COOKIE); + assert(cdbr); + + printf("entries: %" PRIu32 "\n", cdbr_entries(cdbr)); + + cdbr_close(cdbr); +} + +int main(void) { + printf("cdb\n"); + + test_cdbw(); + test_cdbr1(); + test_cdbr2(); + + // CHECK: cdb + // CHECK: entries: 2 + // CHECK: data: 1011121314151617 + // CHECK: data: 0001020304050607 + // CHECK: entries: 2 + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/fparseln.cc b/test/sanitizer_common/TestCases/NetBSD/fparseln.cc new file mode 100644 index 000000000000..8a71d5fcdadc --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/fparseln.cc @@ -0,0 +1,25 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> + +int main(void) { + printf("fparseln\n"); + + FILE *fp = fopen("/etc/fstab", "r"); + assert(fp); + + int flags = FPARSELN_UNESCALL; + const char *delim = "\\\\#"; + size_t lineno = 0, len; + char *line; + while ((line = fparseln(fp, &len, &lineno, delim, flags))) { + printf("lineno: %zu, length: %zu, line: %s\n", lineno, len, line); + free(line); + } + + // CHECK: fparseln + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/funopen2.cc b/test/sanitizer_common/TestCases/NetBSD/funopen2.cc new file mode 100644 index 000000000000..181ad03c991f --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/funopen2.cc @@ -0,0 +1,110 @@ +// RUN: %clangxx -g %s -o %t && %run %t | FileCheck %s + +// CHECK: READ CALLED; len={{[0-9]*}} +// CHECK-NEXT: READ: test +// CHECK-NEXT: WRITE CALLED: test +// CHECK-NEXT: READ CALLED; len={{[0-9]*}} +// CHECK-NEXT: READ: test +// CHECK-NEXT: WRITE CALLED: test +// CHECK-NEXT: CLOSE CALLED +// CHECK-NEXT: SEEK CALLED; off=100, whence=0 +// CHECK-NEXT: READ CALLED; len={{[0-9]*}} +// CHECK-NEXT: READ: test +// CHECK-NEXT: WRITE CALLED: test +// CHECK-NEXT: FLUSH CALLED +// CHECK-NEXT: WRITE CALLED: test +// CHECK-NEXT: FLUSH CALLED + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +int cookie_var; + +ssize_t f_read(void *cookie, void *buf, size_t len) { + assert(cookie == &cookie_var); + assert(len >= 6); + printf("READ CALLED; len=%zd\n", len); + return strlcpy((char*)buf, "test\n", len); +} + +ssize_t f_write(void *cookie, const void *buf, size_t len) { + assert(cookie == &cookie_var); + char *data = strndup((char*)buf, len); + assert(data); + printf("WRITE CALLED: %s\n", data); + free(data); + return len; +} + +off_t f_seek(void *cookie, off_t off, int whence) { + assert(cookie == &cookie_var); + assert(whence == SEEK_SET); + printf("SEEK CALLED; off=%d, whence=%d\n", (int)off, whence); + return off; +} + +int f_flush(void *cookie) { + assert(cookie == &cookie_var); + printf("FLUSH CALLED\n"); + return 0; +} + +int f_close(void *cookie) { + assert(cookie == &cookie_var); + printf("CLOSE CALLED\n"); + return 0; +} + +int main(void) { + FILE *fp; + char buf[10]; + + // 1. read-only variant + fp = fropen2(&cookie_var, f_read); + assert(fp); + // verify that fileno() does not crash or report nonsense + assert(fileno(fp) == -1); + assert(fgets(buf, sizeof(buf), fp)); + printf("READ: %s", buf); + assert(!fclose(fp)); + + // 2. write-only variant + fp = fwopen2(&cookie_var, f_write); + assert(fp); + assert(fileno(fp) == -1); + assert(fputs("test", fp) >= 0); + assert(!fclose(fp)); + + // 3. read+write+close + fp = funopen2(&cookie_var, f_read, f_write, NULL, NULL, f_close); + assert(fp); + assert(fileno(fp) == -1); + assert(fgets(buf, sizeof(buf), fp)); + printf("READ: %s", buf); + assert(fputs("test", fp) >= 0); + assert(!fflush(fp)); + assert(!fclose(fp)); + + // 4. read+seek + fp = funopen2(&cookie_var, f_read, NULL, f_seek, NULL, NULL); + assert(fp); + assert(fileno(fp) == -1); + assert(fseek(fp, 100, SEEK_SET) == 0); + assert(fgets(buf, sizeof(buf), fp)); + printf("READ: %s", buf); + assert(!fclose(fp)); + + // 5. write+flush + fp = funopen2(&cookie_var, NULL, f_write, NULL, f_flush, NULL); + assert(fp); + assert(fileno(fp) == -1); + assert(fputs("test", fp) >= 0); + assert(!fflush(fp)); + assert(fputs("test", fp) >= 0); + // NB: fclose() also implicitly calls flush + assert(!fclose(fp)); + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/getgroupmembership.cc b/test/sanitizer_common/TestCases/NetBSD/getgroupmembership.cc index ee27ad6cf365..025ca9052e6f 100644 --- a/test/sanitizer_common/TestCases/NetBSD/getgroupmembership.cc +++ b/test/sanitizer_common/TestCases/NetBSD/getgroupmembership.cc @@ -1,5 +1,7 @@ // RUN: %clangxx -O0 -g %s -o %t && %run %t +// XFAIL: netbsd && msan + #include <stdlib.h> #include <unistd.h> #include <grp.h> diff --git a/test/sanitizer_common/TestCases/NetBSD/getvfsstat.cc b/test/sanitizer_common/TestCases/NetBSD/getvfsstat.cc new file mode 100644 index 000000000000..ea72e41ede0f --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/getvfsstat.cc @@ -0,0 +1,36 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/types.h> + +#include <sys/statvfs.h> + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> + +int main(void) { + printf("getvfsstat\n"); + + int rv = getvfsstat(NULL, 0, ST_WAIT); + assert(rv != -1); + + size_t sz = rv * sizeof(struct statvfs); + struct statvfs *buf = (struct statvfs *)malloc(sz); + assert(buf); + + rv = getvfsstat(buf, sz, ST_WAIT); + assert(rv != -1); + + for (int i = 0; i < rv; i++) { + printf("Filesystem %d\n", i); + printf("\tfstypename=%s\n", buf[i].f_fstypename); + printf("\tmntonname=%s\n", buf[i].f_mntonname); + printf("\tmntfromname=%s\n", buf[i].f_mntfromname); + } + + free(buf); + + // CHECK: getvfsstat + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/md2.cc b/test/sanitizer_common/TestCases/NetBSD/md2.cc new file mode 100644 index 000000000000..7738aecdf822 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/md2.cc @@ -0,0 +1,114 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> + +#include <assert.h> +#include <endian.h> +#include <md2.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void test1() { + MD2_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + uint8_t digest[MD2_DIGEST_LENGTH]; + + MD2Init(&ctx); + MD2Update(&ctx, entropy, __arraycount(entropy)); + MD2Final(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test2() { + MD2_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD2_DIGEST_STRING_LENGTH]; + + MD2Init(&ctx); + MD2Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD2End(&ctx, digest); + assert(p == digest); + + printf("test2: '%s'\n", digest); +} + +void test3() { + MD2_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + MD2Init(&ctx); + MD2Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD2End(&ctx, NULL); + assert(strlen(p) == MD2_DIGEST_STRING_LENGTH - 1); + + printf("test3: '%s'\n", p); + + free(p); +} + +void test4() { + char digest[MD2_DIGEST_STRING_LENGTH]; + + char *p = MD2File("/etc/fstab", digest); + assert(p == digest); + + printf("test4: '%s'\n", p); +} + +void test5() { + char *p = MD2File("/etc/fstab", NULL); + assert(strlen(p) == MD2_DIGEST_STRING_LENGTH - 1); + + printf("test5: '%s'\n", p); + + free(p); +} + +void test6() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD2_DIGEST_STRING_LENGTH]; + + char *p = MD2Data(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test6: '%s'\n", p); +} + +void test7() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + char *p = MD2Data(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == MD2_DIGEST_STRING_LENGTH - 1); + + printf("test7: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("MD2\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + + // CHECK: MD2 + // CHECK: test1: 'e303e49b34f981c2740cdf809200d51b' + // CHECK: test2: 'e303e49b34f981c2740cdf809200d51b' + // CHECK: test3: 'e303e49b34f981c2740cdf809200d51b' + // CHECK: test4: '{{.*}}' + // CHECK: test5: '{{.*}}' + // CHECK: test6: 'e303e49b34f981c2740cdf809200d51b' + // CHECK: test7: 'e303e49b34f981c2740cdf809200d51b' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/md4.cc b/test/sanitizer_common/TestCases/NetBSD/md4.cc new file mode 100644 index 000000000000..a319e89a3519 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/md4.cc @@ -0,0 +1,114 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> + +#include <assert.h> +#include <endian.h> +#include <md4.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void test1() { + MD4_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + uint8_t digest[MD4_DIGEST_LENGTH]; + + MD4Init(&ctx); + MD4Update(&ctx, entropy, __arraycount(entropy)); + MD4Final(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test2() { + MD4_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD4_DIGEST_STRING_LENGTH]; + + MD4Init(&ctx); + MD4Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD4End(&ctx, digest); + assert(p == digest); + + printf("test2: '%s'\n", digest); +} + +void test3() { + MD4_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + MD4Init(&ctx); + MD4Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD4End(&ctx, NULL); + assert(strlen(p) == MD4_DIGEST_STRING_LENGTH - 1); + + printf("test3: '%s'\n", p); + + free(p); +} + +void test4() { + char digest[MD4_DIGEST_STRING_LENGTH]; + + char *p = MD4File("/etc/fstab", digest); + assert(p == digest); + + printf("test4: '%s'\n", p); +} + +void test5() { + char *p = MD4File("/etc/fstab", NULL); + assert(strlen(p) == MD4_DIGEST_STRING_LENGTH - 1); + + printf("test5: '%s'\n", p); + + free(p); +} + +void test6() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD4_DIGEST_STRING_LENGTH]; + + char *p = MD4Data(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test6: '%s'\n", p); +} + +void test7() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + char *p = MD4Data(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == MD4_DIGEST_STRING_LENGTH - 1); + + printf("test7: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("MD4\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + + // CHECK: MD4 + // CHECK: test1: 'bf78fda2ca35eb7a026bfcdd3d17283d' + // CHECK: test2: 'bf78fda2ca35eb7a026bfcdd3d17283d' + // CHECK: test3: 'bf78fda2ca35eb7a026bfcdd3d17283d' + // CHECK: test4: '{{.*}}' + // CHECK: test5: '{{.*}}' + // CHECK: test6: 'bf78fda2ca35eb7a026bfcdd3d17283d' + // CHECK: test7: 'bf78fda2ca35eb7a026bfcdd3d17283d' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/md5.cc b/test/sanitizer_common/TestCases/NetBSD/md5.cc new file mode 100644 index 000000000000..aee21681800d --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/md5.cc @@ -0,0 +1,114 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> + +#include <assert.h> +#include <endian.h> +#include <md5.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void test1() { + MD5_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + uint8_t digest[MD5_DIGEST_LENGTH]; + + MD5Init(&ctx); + MD5Update(&ctx, entropy, __arraycount(entropy)); + MD5Final(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test2() { + MD5_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD5_DIGEST_STRING_LENGTH]; + + MD5Init(&ctx); + MD5Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD5End(&ctx, digest); + assert(p); + + printf("test2: '%s'\n", digest); +} + +void test3() { + MD5_CTX ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + MD5Init(&ctx); + MD5Update(&ctx, entropy, __arraycount(entropy)); + char *p = MD5End(&ctx, NULL); + assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1); + + printf("test3: '%s'\n", p); + + free(p); +} + +void test4() { + char digest[MD5_DIGEST_STRING_LENGTH]; + + char *p = MD5File("/etc/fstab", digest); + assert(p == digest); + + printf("test4: '%s'\n", p); +} + +void test5() { + char *p = MD5File("/etc/fstab", NULL); + assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1); + + printf("test5: '%s'\n", p); + + free(p); +} + +void test6() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[MD5_DIGEST_STRING_LENGTH]; + + char *p = MD5Data(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test6: '%s'\n", p); +} + +void test7() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + char *p = MD5Data(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1); + + printf("test7: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("MD5\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + + // CHECK: MD5 + // CHECK: test1: '86e65b1ef4a830af347ac05ab4f0e999' + // CHECK: test2: '86e65b1ef4a830af347ac05ab4f0e999' + // CHECK: test3: '86e65b1ef4a830af347ac05ab4f0e999' + // CHECK: test4: '{{.*}}' + // CHECK: test5: '{{.*}}' + // CHECK: test6: '86e65b1ef4a830af347ac05ab4f0e999' + // CHECK: test7: '86e65b1ef4a830af347ac05ab4f0e999' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/mi_vector_hash.cc b/test/sanitizer_common/TestCases/NetBSD/mi_vector_hash.cc new file mode 100644 index 000000000000..1f6c14848884 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/mi_vector_hash.cc @@ -0,0 +1,19 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <inttypes.h> +#include <stdio.h> +#include <stdlib.h> + +int main(void) { + unsigned char key[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; + uint32_t hashes[3]; + mi_vector_hash(key, __arraycount(key), 0, hashes); + for (size_t i = 0; i < __arraycount(hashes); i++) + printf("hashes[%zu]='%" PRIx32 "'\n", i, hashes[i]); + + // CHECK: hashes[0]='{{.*}}' + // CHECK: hashes[1]='{{.*}}' + // CHECK: hashes[2]='{{.*}}' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/rmd160.cc b/test/sanitizer_common/TestCases/NetBSD/rmd160.cc new file mode 100644 index 000000000000..5b9ff0cb2e11 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/rmd160.cc @@ -0,0 +1,133 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <assert.h> +#include <rmd160.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void test1() { + RMD160_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + uint8_t digest[RMD160_DIGEST_LENGTH]; + + RMD160Init(&ctx); + RMD160Update(&ctx, entropy, __arraycount(entropy)); + RMD160Final(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test2() { + RMD160_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + char digest[RMD160_DIGEST_STRING_LENGTH]; + + RMD160Init(&ctx); + RMD160Update(&ctx, entropy, __arraycount(entropy)); + char *p = RMD160End(&ctx, digest); + assert(p == digest); + + printf("test2: '%s'\n", digest); +} + +void test3() { + RMD160_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + + RMD160Init(&ctx); + RMD160Update(&ctx, entropy, __arraycount(entropy)); + char *p = RMD160End(&ctx, NULL); + assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1); + + printf("test3: '%s'\n", p); + + free(p); +} + +void test4() { + char digest[RMD160_DIGEST_STRING_LENGTH]; + + char *p = RMD160File("/etc/fstab", digest); + assert(p == digest); + + printf("test4: '%s'\n", p); +} + +void test5() { + char *p = RMD160File("/etc/fstab", NULL); + assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1); + + printf("test5: '%s'\n", p); + + free(p); +} + +void test6() { + char digest[RMD160_DIGEST_STRING_LENGTH]; + + char *p = RMD160FileChunk("/etc/fstab", digest, 10, 20); + assert(p == digest); + + printf("test6: '%s'\n", p); +} + +void test7() { + char *p = RMD160FileChunk("/etc/fstab", NULL, 10, 20); + assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1); + + printf("test7: '%s'\n", p); + + free(p); +} + +void test8() { + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + char digest[RMD160_DIGEST_STRING_LENGTH]; + + char *p = RMD160Data(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test8: '%s'\n", p); +} + +void test9() { + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + + char *p = RMD160Data(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1); + + printf("test9: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("RMD160\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + test8(); + test9(); + + // CHECK: RMD160 + // CHECK: test1: '2787e5a006365df6e8e799315b669dc34866783c' + // CHECK: test2: '2787e5a006365df6e8e799315b669dc34866783c' + // CHECK: test3: '2787e5a006365df6e8e799315b669dc34866783c' + // CHECK: test4: '{{.*}}' + // CHECK: test5: '{{.*}}' + // CHECK: test6: '{{.*}}' + // CHECK: test7: '{{.*}}' + // CHECK: test8: '2787e5a006365df6e8e799315b669dc34866783c' + // CHECK: test9: '2787e5a006365df6e8e799315b669dc34866783c' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/sha1.cc b/test/sanitizer_common/TestCases/NetBSD/sha1.cc new file mode 100644 index 000000000000..ee5060a6601d --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/sha1.cc @@ -0,0 +1,171 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <assert.h> +#include <sha1.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void test1() { + SHA1_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + uint8_t digest[SHA1_DIGEST_LENGTH]; + + SHA1Init(&ctx); + SHA1Update(&ctx, entropy, __arraycount(entropy)); + SHA1Final(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void local_SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len) +{ + unsigned int a, b; + + b = context->count[0]; + context->count[0] += len << 3; + if (context->count[0] < b) + context->count[1] += (len >> 29) + 1; + b = (b >> 3) & 63; + if ((b + len) > 63) { + memcpy(&context->buffer[b], data, (a = 64 - b)); + SHA1Transform(context->state, context->buffer); + for ( ; a + 63 < len; a += 64) + SHA1Transform(context->state, &data[a]); + b = 0; + } else { + a = 0; + } + memcpy(&context->buffer[b], &data[a], len - a); +} + +void test2() { + SHA1_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + uint8_t digest[SHA1_DIGEST_LENGTH]; + + SHA1Init(&ctx); + local_SHA1Update(&ctx, entropy, __arraycount(entropy)); + SHA1Final(digest, &ctx); + + printf("test2: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test3() { + SHA1_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + char digest[SHA1_DIGEST_STRING_LENGTH]; + + SHA1Init(&ctx); + SHA1Update(&ctx, entropy, __arraycount(entropy)); + char *p = SHA1End(&ctx, digest); + assert(p == digest); + + printf("test3: '%s'\n", digest); +} + +void test4() { + SHA1_CTX ctx; + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + + SHA1Init(&ctx); + SHA1Update(&ctx, entropy, __arraycount(entropy)); + char *p = SHA1End(&ctx, NULL); + assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1); + + printf("test4: '%s'\n", p); + + free(p); +} + +void test5() { + char digest[SHA1_DIGEST_STRING_LENGTH]; + + char *p = SHA1File("/etc/fstab", digest); + assert(p == digest); + + printf("test5: '%s'\n", p); +} + +void test6() { + char *p = SHA1File("/etc/fstab", NULL); + assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1); + + printf("test6: '%s'\n", p); + + free(p); +} + +void test7() { + char digest[SHA1_DIGEST_STRING_LENGTH]; + + char *p = SHA1FileChunk("/etc/fstab", digest, 10, 20); + assert(p == digest); + + printf("test7: '%s'\n", p); +} + +void test8() { + char *p = SHA1FileChunk("/etc/fstab", NULL, 10, 20); + assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1); + + printf("test8: '%s'\n", p); + + free(p); +} + +void test9() { + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + char digest[SHA1_DIGEST_STRING_LENGTH]; + + char *p = SHA1Data(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test9: '%s'\n", p); +} + +void test10() { + uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; + + char *p = SHA1Data(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1); + + printf("test10: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("SHA1\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + test8(); + test9(); + test10(); + + // CHECK: SHA1 + // CHECK: test1: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + // CHECK: test2: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + // CHECK: test3: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + // CHECK: test4: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + // CHECK: test5: '{{.*}}' + // CHECK: test6: '{{.*}}' + // CHECK: test7: '{{.*}}' + // CHECK: test8: '{{.*}}' + // CHECK: test9: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + // CHECK: test10: '57d1b759bf3d1811135748cb0328c73b51fa6f57' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/sha2.cc b/test/sanitizer_common/TestCases/NetBSD/sha2.cc new file mode 100644 index 000000000000..e905e3b610fd --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/sha2.cc @@ -0,0 +1,206 @@ +// RUN: %clangxx -O0 -g %s -DSHASIZE=224 -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-224 +// RUN: %clangxx -O0 -g %s -DSHASIZE=256 -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-256 +// RUN: %clangxx -O0 -g %s -DSHASIZE=384 -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-384 +// RUN: %clangxx -O0 -g %s -DSHASIZE=512 -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-512 + +#include <sys/param.h> + +#include <assert.h> +#include <endian.h> +#include <sha2.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifndef SHASIZE +#error SHASIZE must be defined +#endif + +#define _SHA_CTX(x) SHA##x##_CTX +#define SHA_CTX(x) _SHA_CTX(x) + +#define _SHA_DIGEST_LENGTH(x) SHA##x##_DIGEST_LENGTH +#define SHA_DIGEST_LENGTH(x) _SHA_DIGEST_LENGTH(x) + +#define _SHA_DIGEST_STRING_LENGTH(x) SHA##x##_DIGEST_STRING_LENGTH +#define SHA_DIGEST_STRING_LENGTH(x) _SHA_DIGEST_STRING_LENGTH(x) + +#define _SHA_Init(x) SHA##x##_Init +#define SHA_Init(x) _SHA_Init(x) + +#define _SHA_Update(x) SHA##x##_Update +#define SHA_Update(x) _SHA_Update(x) + +#define _SHA_Final(x) SHA##x##_Final +#define SHA_Final(x) _SHA_Final(x) + +#define _SHA_End(x) SHA##x##_End +#define SHA_End(x) _SHA_End(x) + +#define _SHA_File(x) SHA##x##_File +#define SHA_File(x) _SHA_File(x) + +#define _SHA_FileChunk(x) SHA##x##_FileChunk +#define SHA_FileChunk(x) _SHA_FileChunk(x) + +#define _SHA_Data(x) SHA##x##_Data +#define SHA_Data(x) _SHA_Data(x) + +void test1() { + SHA_CTX(SHASIZE) ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + uint8_t digest[SHA_DIGEST_LENGTH(SHASIZE)]; + + SHA_Init(SHASIZE)(&ctx); + SHA_Update(SHASIZE)(&ctx, entropy, __arraycount(entropy)); + SHA_Final(SHASIZE)(digest, &ctx); + + printf("test1: '"); + for (size_t i = 0; i < __arraycount(digest); i++) + printf("%02x", digest[i]); + printf("'\n"); +} + +void test2() { + SHA_CTX(SHASIZE) ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)]; + + SHA_Init(SHASIZE)(&ctx); + SHA_Update(SHASIZE)(&ctx, entropy, __arraycount(entropy)); + char *p = SHA_End(SHASIZE)(&ctx, digest); + assert(p == digest); + + printf("test2: '%s'\n", digest); +} + +void test3() { + SHA_CTX(SHASIZE) ctx; + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + SHA_Init(SHASIZE)(&ctx); + SHA_Update(SHASIZE)(&ctx, entropy, __arraycount(entropy)); + char *p = SHA_End(SHASIZE)(&ctx, NULL); + assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1); + + printf("test3: '%s'\n", p); + + free(p); +} + +void test4() { + char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)]; + + char *p = SHA_File(SHASIZE)("/etc/fstab", digest); + assert(p == digest); + + printf("test4: '%s'\n", p); +} + +void test5() { + char *p = SHA_File(SHASIZE)("/etc/fstab", NULL); + assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1); + + printf("test5: '%s'\n", p); + + free(p); +} + +void test6() { + char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)]; + + char *p = SHA_FileChunk(SHASIZE)("/etc/fstab", digest, 10, 20); + assert(p == digest); + + printf("test6: '%s'\n", p); +} + +void test7() { + char *p = SHA_FileChunk(SHASIZE)("/etc/fstab", NULL, 10, 20); + assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1); + + printf("test7: '%s'\n", p); + + free(p); +} + +void test8() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)]; + + char *p = SHA_Data(SHASIZE)(entropy, __arraycount(entropy), digest); + assert(p == digest); + + printf("test8: '%s'\n", p); +} + +void test9() { + uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + + char *p = SHA_Data(SHASIZE)(entropy, __arraycount(entropy), NULL); + assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1); + + printf("test9: '%s'\n", p); + + free(p); +} + +int main(void) { + printf("SHA" ___STRING(SHASIZE) "\n"); + + test1(); + test2(); + test3(); + test4(); + test5(); + test6(); + test7(); + test8(); + test9(); + + // CHECK-224: SHA224 + // CHECK-224: test1: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48' + // CHECK-224: test2: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48' + // CHECK-224: test3: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48' + // CHECK-224: test4: '{{.*}}' + // CHECK-224: test5: '{{.*}}' + // CHECK-224: test6: '{{.*}}' + // CHECK-224: test7: '{{.*}}' + // CHECK-224: test8: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48' + // CHECK-224: test9: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48' + + // CHECK-256: SHA256 + // CHECK-256: test1: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' + // CHECK-256: test2: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' + // CHECK-256: test3: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' + // CHECK-256: test4: '{{.*}}' + // CHECK-256: test5: '{{.*}}' + // CHECK-256: test6: '{{.*}}' + // CHECK-256: test7: '{{.*}}' + // CHECK-256: test8: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' + // CHECK-256: test9: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' + + // CHECK-384: SHA384 + // CHECK-384: test1: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12' + // CHECK-384: test2: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12' + // CHECK-384: test3: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12' + // CHECK-384: test4: '{{.*}}' + // CHECK-384: test5: '{{.*}}' + // CHECK-384: test6: '{{.*}}' + // CHECK-384: test7: '{{.*}}' + // CHECK-384: test8: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12' + // CHECK-384: test9: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12' + + // CHECK-512: SHA512 + // CHECK-512: test1: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e' + // CHECK-512: test2: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e' + // CHECK-512: test3: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e' + // CHECK-512: test4: '{{.*}}' + // CHECK-512: test5: '{{.*}}' + // CHECK-512: test6: '{{.*}}' + // CHECK-512: test7: '{{.*}}' + // CHECK-512: test8: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e' + // CHECK-512: test9: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/statvfs1.cc b/test/sanitizer_common/TestCases/NetBSD/statvfs1.cc new file mode 100644 index 000000000000..40dfca37bb58 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/statvfs1.cc @@ -0,0 +1,58 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> +#include <sys/types.h> + +#include <sys/statvfs.h> + +#include <assert.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +void test_statvfs1() { + printf("statvfs1\n"); + + struct statvfs buf; + int rv = statvfs1("/etc/fstab", &buf, ST_WAIT); + assert(rv != -1); + + printf("fstypename='%s'\n", buf.f_fstypename); + printf("mntonname='%s'\n", buf.f_mntonname); + printf("mntfromname='%s'\n", buf.f_mntfromname); +} + +void test_fstatvfs1() { + printf("fstatvfs1\n"); + + int fd = open("/etc/fstab", O_RDONLY); + assert(fd > 0); + + struct statvfs buf; + int rv = fstatvfs1(fd, &buf, ST_WAIT); + assert(rv != -1); + + printf("fstypename='%s'\n", buf.f_fstypename); + printf("mntonname='%s'\n", buf.f_mntonname); + printf("mntfromname='%s'\n", buf.f_mntfromname); + + rv = close(fd); + assert(rv != -1); +} + +int main(void) { + test_statvfs1(); + test_fstatvfs1(); + + // CHECK: statvfs1 + // CHECK: fstypename='{{.*}}' + // CHECK: mntonname='{{.*}}' + // CHECK: mntfromname='{{.*}}' + // CHECK: fstatvfs1 + // CHECK: fstypename='{{.*}}' + // CHECK: mntonname='{{.*}}' + // CHECK: mntfromname='{{.*}}' + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/strtoi.cc b/test/sanitizer_common/TestCases/NetBSD/strtoi.cc new file mode 100644 index 000000000000..4d0d8b3aebf0 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/strtoi.cc @@ -0,0 +1,43 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <inttypes.h> +#include <stdio.h> + +void test_strtoi(const char *nptr, int base, intmax_t lo, intmax_t hi) { + char *p; + int status; + intmax_t i = strtoi(nptr, &p, base, lo, hi, &status); + printf("strtoi: conversion of '%s' to a number %s, using %jd, p=%#" PRIx8 + "\n", + nptr, status ? "failed" : "successful", i, *p); +} + +void test_strtou(const char *nptr, int base, intmax_t lo, intmax_t hi) { + char *p; + int status; + uintmax_t i = strtou(nptr, &p, base, lo, hi, &status); + printf("strtou: conversion of '%s' to a number %s, using %ju, p=%#" PRIx8 + "\n", + nptr, status ? "failed" : "successful", i, *p); +} + +int main(void) { + printf("strtoi\n"); + + test_strtoi("100", 0, 1, 100); + test_strtoi("100", 0, 1, 10); + test_strtoi("100xyz", 0, 1, 100); + test_strtou("100", 0, 1, 100); + test_strtou("100", 0, 1, 10); + test_strtou("100xyz", 0, 1, 100); + + // CHECK: strtoi + // CHECK: strtoi: conversion of '100' to a number successful, using 100, p=0 + // CHECK: strtoi: conversion of '100' to a number failed, using 10, p=0 + // CHECK: strtoi: conversion of '100xyz' to a number failed, using 100, p=0x78 + // CHECK: strtou: conversion of '100' to a number successful, using 100, p=0 + // CHECK: strtou: conversion of '100' to a number failed, using 10, p=0 + // CHECK: strtou: conversion of '100xyz' to a number failed, using 100, p=0x78 + + return 0; +} diff --git a/test/sanitizer_common/TestCases/NetBSD/sysctlgetmibinfo.cc b/test/sanitizer_common/TestCases/NetBSD/sysctlgetmibinfo.cc new file mode 100644 index 000000000000..d81c1567fc44 --- /dev/null +++ b/test/sanitizer_common/TestCases/NetBSD/sysctlgetmibinfo.cc @@ -0,0 +1,36 @@ +// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s + +#include <sys/param.h> +#include <sys/types.h> + +#include <sys/sysctl.h> + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> + +void test_sysctlgetmibinfo() { + int mib[CTL_MAXNAME]; + unsigned int mib_len = __arraycount(mib); + int rv = sysctlgetmibinfo("kern.ostype", &mib[0], &mib_len, NULL, NULL, NULL, + SYSCTL_VERSION); + assert(!rv); + + char buf[100]; + size_t len = sizeof(buf); + rv = sysctl(mib, mib_len, buf, &len, NULL, 0); + assert(!rv); + + printf("sysctlgetmibinfo: '%s' size: '%zu'\n", buf, len); +} + +int main(void) { + printf("sysctlgetmibinfo\n"); + + test_sysctlgetmibinfo(); + + return 0; + + // CHECK: sysctlgetmibinfo + // CHECK: sysctlgetmibinfo: '{{.*}}' size: '{{.*}}' +} |