diff options
Diffstat (limited to 'tests/unistd')
42 files changed, 2059 insertions, 0 deletions
diff --git a/tests/unistd/access.c b/tests/unistd/access.c new file mode 100644 index 00000000..89428610 --- /dev/null +++ b/tests/unistd/access.c @@ -0,0 +1,24 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + char* files[] = {"/readable", "/writeable", + "/allaccess", "/forbidden", "/nonexistent"}; + for (int i = 0; i < sizeof files / sizeof files[0]; i++) { + printf("F_OK(%s): %d\n", files[i], access(files[i], F_OK)); + printf("errno: %d\n", errno); + errno = 0; + printf("R_OK(%s): %d\n", files[i], access(files[i], R_OK)); + printf("errno: %d\n", errno); + errno = 0; + printf("X_OK(%s): %d\n", files[i], access(files[i], X_OK)); + printf("errno: %d\n", errno); + errno = 0; + printf("W_OK(%s): %d\n", files[i], access(files[i], W_OK)); + printf("errno: %d\n", errno); + errno = 0; + printf("\n"); + } + return 0; +} diff --git a/tests/unistd/access.js b/tests/unistd/access.js new file mode 100644 index 00000000..ea9e6359 --- /dev/null +++ b/tests/unistd/access.js @@ -0,0 +1,4 @@ +FS.createDataFile('/', 'forbidden', '', false, false); +FS.createDataFile('/', 'readable', '', true, false); +FS.createDataFile('/', 'writeable', '', false, true); +FS.createDataFile('/', 'allaccess', '', true, true); diff --git a/tests/unistd/access.out b/tests/unistd/access.out new file mode 100644 index 00000000..dffe0b9e --- /dev/null +++ b/tests/unistd/access.out @@ -0,0 +1,45 @@ +F_OK(/readable): 0 +errno: 0 +R_OK(/readable): 0 +errno: 0 +X_OK(/readable): 0 +errno: 0 +W_OK(/readable): -1 +errno: 13 + +F_OK(/writeable): 0 +errno: 0 +R_OK(/writeable): -1 +errno: 13 +X_OK(/writeable): -1 +errno: 13 +W_OK(/writeable): 0 +errno: 0 + +F_OK(/allaccess): 0 +errno: 0 +R_OK(/allaccess): 0 +errno: 0 +X_OK(/allaccess): 0 +errno: 0 +W_OK(/allaccess): 0 +errno: 0 + +F_OK(/forbidden): 0 +errno: 0 +R_OK(/forbidden): -1 +errno: 13 +X_OK(/forbidden): -1 +errno: 13 +W_OK(/forbidden): -1 +errno: 13 + +F_OK(/nonexistent): -1 +errno: 2 +R_OK(/nonexistent): -1 +errno: 2 +X_OK(/nonexistent): -1 +errno: 2 +W_OK(/nonexistent): -1 +errno: 2 + diff --git a/tests/unistd/close.c b/tests/unistd/close.c new file mode 100644 index 00000000..7110d18a --- /dev/null +++ b/tests/unistd/close.c @@ -0,0 +1,26 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + int f = open("/", O_RDONLY); + + printf("fsync(opened): %d\n", fsync(f)); + printf("errno: %d\n", errno); + errno = 0; + + printf("close(opened): %d\n", close(f)); + printf("errno: %d\n", errno); + errno = 0; + + printf("fsync(closed): %d\n", fsync(f)); + printf("errno: %d\n", errno); + errno = 0; + + printf("close(closed): %d\n", close(f)); + printf("errno: %d\n", errno); + errno = 0; + + return 0; +} diff --git a/tests/unistd/close.out b/tests/unistd/close.out new file mode 100644 index 00000000..66e47927 --- /dev/null +++ b/tests/unistd/close.out @@ -0,0 +1,8 @@ +fsync(opened): 0 +errno: 0 +close(opened): 0 +errno: 0 +fsync(closed): -1 +errno: 9 +close(closed): -1 +errno: 9 diff --git a/tests/unistd/confstr.c b/tests/unistd/confstr.c new file mode 100644 index 00000000..5c96c89c --- /dev/null +++ b/tests/unistd/confstr.c @@ -0,0 +1,55 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + int vals[] = { + _CS_PATH, + _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS, + _CS_GNU_LIBC_VERSION, + _CS_GNU_LIBPTHREAD_VERSION, + _CS_POSIX_V6_ILP32_OFF32_LIBS, + _CS_POSIX_V6_ILP32_OFFBIG_LIBS, + _CS_POSIX_V6_LP64_OFF64_CFLAGS, + _CS_POSIX_V6_LP64_OFF64_LDFLAGS, + _CS_POSIX_V6_LP64_OFF64_LIBS, + _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, + _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, + _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, + _CS_POSIX_V6_ILP32_OFF32_CFLAGS, + _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, + _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, + _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS + }; + char* names[] = { + "_CS_PATH", + "_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS", + "_CS_GNU_LIBC_VERSION", + "_CS_GNU_LIBPTHREAD_VERSION", + "_CS_POSIX_V6_ILP32_OFF32_LIBS", + "_CS_POSIX_V6_ILP32_OFFBIG_LIBS", + "_CS_POSIX_V6_LP64_OFF64_CFLAGS", + "_CS_POSIX_V6_LP64_OFF64_LDFLAGS", + "_CS_POSIX_V6_LP64_OFF64_LIBS", + "_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS", + "_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS", + "_CS_POSIX_V6_LPBIG_OFFBIG_LIBS", + "_CS_POSIX_V6_ILP32_OFF32_CFLAGS", + "_CS_POSIX_V6_ILP32_OFF32_LDFLAGS", + "_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS", + "_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS" + }; + char buffer[256]; + + for (int i = 0; i < sizeof vals / sizeof vals[0]; i++) { + printf("ret: %d\n", confstr(vals[i], buffer, 256)); + printf("%s: %s\n", names[i], buffer); + printf("errno: %d\n\n", errno); + errno = 0; + } + + printf("(invalid) ret: %d\n", confstr(-123, buffer, 256)); + printf("errno: %d\n", errno); + + return 0; +} diff --git a/tests/unistd/confstr.out b/tests/unistd/confstr.out new file mode 100644 index 00000000..c6019319 --- /dev/null +++ b/tests/unistd/confstr.out @@ -0,0 +1,67 @@ +ret: 2 +_CS_PATH: / +errno: 0 + +ret: 43 +_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS: POSIX_V6_ILP32_OFF32 +POSIX_V6_ILP32_OFFBIG +errno: 0 + +ret: 11 +_CS_GNU_LIBC_VERSION: glibc 2.14 +errno: 0 + +ret: 1 +_CS_GNU_LIBPTHREAD_VERSION: +errno: 0 + +ret: 1 +_CS_POSIX_V6_ILP32_OFF32_LIBS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_ILP32_OFFBIG_LIBS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LP64_OFF64_CFLAGS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LP64_OFF64_LDFLAGS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LP64_OFF64_LIBS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: +errno: 0 + +ret: 1 +_CS_POSIX_V6_LPBIG_OFFBIG_LIBS: +errno: 0 + +ret: 5 +_CS_POSIX_V6_ILP32_OFF32_CFLAGS: -m32 +errno: 0 + +ret: 5 +_CS_POSIX_V6_ILP32_OFF32_LDFLAGS: -m32 +errno: 0 + +ret: 5 +_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: -m32 +errno: 0 + +ret: 48 +_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: -m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 +errno: 0 + +(invalid) ret: 0 +errno: 22 diff --git a/tests/unistd/curdir.c b/tests/unistd/curdir.c new file mode 100644 index 00000000..63b9c7fe --- /dev/null +++ b/tests/unistd/curdir.c @@ -0,0 +1,95 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + char buffer[256]; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + errno = 0; + printf("\n"); + + printf("chdir(file): %d\n", chdir("/file")); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + } + errno = 0; + printf("\n"); + + printf("chdir(device): %d\n", chdir("/device")); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + } + errno = 0; + printf("\n"); + + printf("chdir(folder): %d\n", chdir("/folder")); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + } + errno = 0; + printf("\n"); + + printf("chdir(nonexistent): %d\n", chdir("/nonexistent")); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + } + errno = 0; + printf("\n"); + + printf("chdir(link): %d\n", chdir("/link")); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + } + errno = 0; + printf("\n"); + + errno = 0; + printf("fchdir(/): %d\n", fchdir(open("/", O_RDONLY, 0777))); + printf("errno: %d\n", errno); + if (!errno) { + errno = 0; + printf("getwd: %s\n", getwd(buffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("getcwd: %s\n", getcwd(buffer, 256)); + printf("errno: %d\n", errno); + errno = 0; + } + + return 0; +} diff --git a/tests/unistd/curdir.js b/tests/unistd/curdir.js new file mode 100644 index 00000000..e271b9da --- /dev/null +++ b/tests/unistd/curdir.js @@ -0,0 +1,4 @@ +FS.createDataFile('/', 'file', '', true, true); +FS.createFolder('/', 'folder', true, true); +FS.createDevice('/', 'device', function() {}, function() {}); +FS.createLink('/', 'link', 'folder', true, true); diff --git a/tests/unistd/curdir.out b/tests/unistd/curdir.out new file mode 100644 index 00000000..e353f1c4 --- /dev/null +++ b/tests/unistd/curdir.out @@ -0,0 +1,34 @@ +getwd: / +errno: 0 +getcwd: / +errno: 0 + +chdir(file): -1 +errno: 20 + +chdir(device): -1 +errno: 20 + +chdir(folder): 0 +errno: 0 +getwd: /folder +errno: 0 +getcwd: /folder +errno: 0 + +chdir(nonexistent): -1 +errno: 2 + +chdir(link): 0 +errno: 0 +getwd: /folder +errno: 0 +getcwd: /folder +errno: 0 + +fchdir(/): 0 +errno: 0 +getwd: / +errno: 0 +getcwd: / +errno: 0 diff --git a/tests/unistd/dup.c b/tests/unistd/dup.c new file mode 100644 index 00000000..8b4dca34 --- /dev/null +++ b/tests/unistd/dup.c @@ -0,0 +1,38 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + int f, f2, f3; + + printf("DUP\n"); + f = open("/", O_RDONLY); + f2 = open("/", O_RDONLY); + f3 = dup(f); + printf("errno: %d\n", errno); + printf("f: %d\n", f); + printf("f2: %d\n", f2); + printf("f3: %d\n", f3); + printf("close(f1): %d\n", close(f)); + printf("close(f2): %d\n", close(f2)); + printf("close(f3): %d\n", close(f3)); + printf("\n"); + errno = 0; + + printf("DUP2\n"); + f = open("/", O_RDONLY); + f2 = open("/", O_RDONLY); + f3 = dup2(f, f2); + printf("errno: %d\n", errno); + printf("f: %d\n", f); + printf("f2: %d\n", f2); + printf("f3: %d\n", f3); + printf("close(f1): %d\n", close(f)); + printf("close(f2): %d\n", close(f2)); + printf("close(f3): %d\n", close(f3)); + printf("\n"); + errno = 0; + + return 0; +} diff --git a/tests/unistd/dup.out b/tests/unistd/dup.out new file mode 100644 index 00000000..439c6fd5 --- /dev/null +++ b/tests/unistd/dup.out @@ -0,0 +1,17 @@ +DUP +errno: 0 +f: 1 +f2: 2 +f3: 3 +close(f1): 0 +close(f2): 0 +close(f3): 0 + +DUP2 +errno: 0 +f: 4 +f2: 5 +f3: 5 +close(f1): 0 +close(f2): 0 +close(f3): -1 diff --git a/tests/unistd/io.c b/tests/unistd/io.c new file mode 100644 index 00000000..eeb80373 --- /dev/null +++ b/tests/unistd/io.c @@ -0,0 +1,101 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <string.h> + +int main() { + char readBuffer[256] = {0}; + char writeBuffer[] = "writeme"; + + int fl = open("/folder", O_RDWR); + printf("read from folder: %d\n", read(fl, readBuffer, sizeof readBuffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("write to folder: %d\n", write(fl, writeBuffer, sizeof writeBuffer)); + printf("errno: %d\n\n", errno); + errno = 0; + + int bd = open("/broken-device", O_RDWR); + printf("read from broken device: %d\n", read(bd, readBuffer, sizeof readBuffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("write to broken device: %d\n", write(bd, writeBuffer, sizeof writeBuffer)); + printf("errno: %d\n\n", errno); + errno = 0; + + int d = open("/device", O_RDWR); + printf("read from device: %d\n", read(d, readBuffer, sizeof readBuffer)); + printf("data: %s\n", readBuffer); + memset(readBuffer, 0, sizeof readBuffer); + printf("errno: %d\n", errno); + errno = 0; + printf("write to device: %d\n", write(d, writeBuffer, sizeof writeBuffer)); + printf("errno: %d\n\n", errno); + errno = 0; + + int f = open("/file", O_RDWR); + printf("read from file: %d\n", read(f, readBuffer, sizeof readBuffer)); + printf("data: %s\n", readBuffer); + memset(readBuffer, 0, sizeof readBuffer); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, 3, SEEK_SET)); + printf("errno: %d\n\n", errno); + printf("partial read from file: %d\n", read(f, readBuffer, 3)); + printf("data: %s\n", readBuffer); + memset(readBuffer, 0, sizeof readBuffer); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, -2, SEEK_END)); + printf("errno: %d\n", errno); + errno = 0; + printf("partial read from end of file: %d\n", read(f, readBuffer, 3)); + printf("data: %s\n", readBuffer); + memset(readBuffer, 0, sizeof readBuffer); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, -15, SEEK_CUR)); + printf("errno: %d\n", errno); + errno = 0; + printf("partial read from before start of file: %d\n", read(f, readBuffer, 3)); + printf("data: %s\n", readBuffer); + memset(readBuffer, 0, sizeof readBuffer); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, 0, SEEK_SET)); + printf("write to start of file: %d\n", write(f, writeBuffer, 3)); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, 0, SEEK_END)); + printf("write to end of file: %d\n", write(f, writeBuffer, 3)); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("seek: %d\n", lseek(f, 10, SEEK_END)); + printf("write after end of file: %d\n", write(f, writeBuffer, sizeof writeBuffer)); + printf("errno: %d\n\n", errno); + errno = 0; + + int bytesRead; + printf("seek: %d\n", lseek(f, 0, SEEK_SET)); + printf("read after write: %d\n", bytesRead = read(f, readBuffer, sizeof readBuffer)); + printf("errno: %d\n", errno); + errno = 0; + printf("final: "); + for (int i = 0; i < bytesRead; i++) { + if (readBuffer[i] == 0) { + printf("\\0"); + } else { + printf("%c", readBuffer[i]); + } + } + printf("\n"); + + return 0; +} diff --git a/tests/unistd/io.js b/tests/unistd/io.js new file mode 100644 index 00000000..b129af44 --- /dev/null +++ b/tests/unistd/io.js @@ -0,0 +1,19 @@ +(function() { + var devicePayload = [65, 66, 67, 68]; + FS.createDevice('/', 'device', function() { + if (devicePayload.length) { + return devicePayload.shift(); + } else { + return null; + } + }, function(arg) { + print("TO DEVICE: " + arg); + }); + FS.createDevice('/', 'broken-device', function() { + throw new Error('Broken device input.'); + }, function(arg) { + throw new Error('Broken device output.'); + }); + FS.createDataFile('/', 'file', '1234567890', true, true); + FS.createFolder('/', 'folder', true, true); +})(); diff --git a/tests/unistd/io.out b/tests/unistd/io.out new file mode 100644 index 00000000..3061b94e --- /dev/null +++ b/tests/unistd/io.out @@ -0,0 +1,63 @@ +read from folder: -1 +errno: 9 +write to folder: -1 +errno: 9 + +read from broken device: -1 +errno: 5 +write to broken device: -1 +errno: 5 + +read from device: 4 +data: ABCD +errno: 0 +TO DEVICE: 119 +TO DEVICE: 114 +TO DEVICE: 105 +TO DEVICE: 116 +TO DEVICE: 101 +TO DEVICE: 109 +TO DEVICE: 101 +TO DEVICE: 0 +write to device: 8 +errno: 0 + +read from file: 10 +data: 1234567890 +errno: 0 + +seek: 3 +errno: 0 + +partial read from file: 3 +data: 456 +errno: 0 + +seek: 8 +errno: 0 +partial read from end of file: 2 +data: 90 +errno: 0 + +seek: -1 +errno: 22 +partial read from before start of file: 0 +data: +errno: 0 + +seek: 0 +write to start of file: 3 +errno: 0 + +seek: 10 +write to end of file: 3 +errno: 0 + +seek: 23 +write after end of file: 8 +errno: 0 + +seek: 0 +read after write: 31 +errno: 0 +final: wri4567890wri\0\0\0\0\0\0\0\0\0\0writeme\0 diff --git a/tests/unistd/isatty.c b/tests/unistd/isatty.c new file mode 100644 index 00000000..cc1ff641 --- /dev/null +++ b/tests/unistd/isatty.c @@ -0,0 +1,28 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + printf("read: %d\n", isatty(open("/read", O_RDONLY))); + printf("errno: %d\n", errno); + errno = 0; + + printf("write: %d\n", isatty(open("/write", O_WRONLY))); + printf("errno: %d\n", errno); + errno = 0; + + printf("all: %d\n", isatty(open("/all", O_RDONLY))); + printf("errno: %d\n", errno); + errno = 0; + + printf("folder: %d\n", isatty(open("/folder", O_RDONLY))); + printf("errno: %d\n", errno); + errno = 0; + + printf("file: %d\n", isatty(open("/file", O_RDONLY))); + printf("errno: %d\n", errno); + errno = 0; + + return 0; +} diff --git a/tests/unistd/isatty.js b/tests/unistd/isatty.js new file mode 100644 index 00000000..6399f9e9 --- /dev/null +++ b/tests/unistd/isatty.js @@ -0,0 +1,5 @@ +FS.createDevice('/', 'read', function() {}, null); +FS.createDevice('/', 'write', null, function() {}); +FS.createDevice('/', 'all', function() {}, function() {}); +FS.createFolder('/', 'folder', true, true); +FS.createDataFile('/', 'file', true, true); diff --git a/tests/unistd/isatty.out b/tests/unistd/isatty.out new file mode 100644 index 00000000..3c138c0e --- /dev/null +++ b/tests/unistd/isatty.out @@ -0,0 +1,10 @@ +read: -1 +errno: 25 +write: -1 +errno: 25 +all: 0 +errno: 0 +folder: -1 +errno: 25 +file: -1 +errno: 25 diff --git a/tests/unistd/links.c b/tests/unistd/links.c new file mode 100644 index 00000000..c6da83b9 --- /dev/null +++ b/tests/unistd/links.c @@ -0,0 +1,40 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + char* files[] = {"/link", "/file", "/folder"}; + char buffer[256] = {0}; + + for (int i = 0; i < sizeof files / sizeof files[0]; i++) { + printf("readlink(%s)\n", files[i]); + printf("ret: %d\n", readlink(files[i], buffer, 256)); + printf("errno: %d\n", errno); + printf("result: %s\n\n", buffer); + errno = 0; + } + + printf("symlink/overwrite\n"); + printf("ret: %d\n", symlink("new-nonexistent-path", "/link")); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("symlink/normal\n"); + printf("ret: %d\n", symlink("new-nonexistent-path", "/folder/link")); + printf("errno: %d\n", errno); + errno = 0; + + printf("readlink(created link)\n"); + printf("ret: %d\n", readlink("/folder/link", buffer, 256)); + printf("errno: %d\n", errno); + printf("result: %s\n\n", buffer); + errno = 0; + + printf("readlink(short buffer)\n"); + printf("ret: %d\n", readlink("/link", buffer, 4)); + printf("errno: %d\n", errno); + printf("result: %s\n", buffer); + errno = 0; + + return 0; +} diff --git a/tests/unistd/links.js b/tests/unistd/links.js new file mode 100644 index 00000000..5e58a729 --- /dev/null +++ b/tests/unistd/links.js @@ -0,0 +1,3 @@ +FS.createLink('/', 'link', '../test/../there!', true, true); +FS.createDataFile('/', 'file', 'test', true, true); +FS.createFolder('/', 'folder', true, true); diff --git a/tests/unistd/links.out b/tests/unistd/links.out new file mode 100644 index 00000000..75e410cb --- /dev/null +++ b/tests/unistd/links.out @@ -0,0 +1,31 @@ +readlink(/link) +ret: 17 +errno: 0 +result: ../test/../there! + +readlink(/file) +ret: -1 +errno: 22 +result: ../test/../there! + +readlink(/folder) +ret: -1 +errno: 22 +result: ../test/../there! + +symlink/overwrite +ret: -1 +errno: 17 + +symlink/normal +ret: 0 +errno: 0 +readlink(created link) +ret: 20 +errno: 0 +result: new-nonexistent-path + +readlink(short buffer) +ret: 3 +errno: 0 +result: ../-nonexistent-path diff --git a/tests/unistd/login.c b/tests/unistd/login.c new file mode 100644 index 00000000..2e4e1515 --- /dev/null +++ b/tests/unistd/login.c @@ -0,0 +1,39 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + char host[256] = "--------------------------"; + + printf("gethostid: %d\n", gethostid()); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("gethostname/2 ret: %d\n", gethostname(host, 2)); + printf("gethostname/2: %s\n", host); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("gethostname/256 ret: %d\n", gethostname(host, 256)); + printf("gethostname/256: %s\n", host); + printf("errno: %d\n\n", errno); + errno = 0; + + char login[256] = "--------------------------"; + + printf("login: %s\n", getlogin()); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("login_r/2 ret: %d\n", getlogin_r(login, 2)); + printf("login_r/2: %s\n", login); + printf("errno: %d\n\n", errno); + errno = 0; + + printf("login_r/256 ret: %d\n", getlogin_r(login, 256)); + printf("login_r/256: %s\n", login); + printf("errno: %d\n", errno); + errno = 0; + + return 0; +} diff --git a/tests/unistd/login.out b/tests/unistd/login.out new file mode 100644 index 00000000..c1919c3c --- /dev/null +++ b/tests/unistd/login.out @@ -0,0 +1,21 @@ +gethostid: 42 +errno: 0 + +gethostname/2 ret: -1 +gethostname/2: em------------------------ +errno: 36 + +gethostname/256 ret: 0 +gethostname/256: emscripten +errno: 0 + +login: root +errno: 0 + +login_r/2 ret: 34 +login_r/2: -------------------------- +errno: 34 + +login_r/256 ret: 0 +login_r/256: root +errno: 0 diff --git a/tests/unistd/misc.c b/tests/unistd/misc.c new file mode 100644 index 00000000..4e7ac216 --- /dev/null +++ b/tests/unistd/misc.c @@ -0,0 +1,196 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + int f = open("/", O_RDONLY); + + sync(); + + printf("fsync(good): %d", fsync(f)); + printf(", errno: %d\n", errno); + errno = 0; + printf("fsync(bad): %d", fsync(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("fdatasync(good): %d", fdatasync(f)); + printf(", errno: %d\n", errno); + errno = 0; + printf("fdatasync(bad): %d", fdatasync(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("tcgetpgrp(good): %d", tcgetpgrp(f)); + printf(", errno: %d\n", errno); + errno = 0; + printf("tcgetpgrp(bad): %d", tcgetpgrp(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("tcsetpgrp(good): %d", tcsetpgrp(f, 123)); + printf(", errno: %d\n", errno); + errno = 0; + printf("tcsetpgrp(bad): %d", tcsetpgrp(42, 123)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("link: %d", link("/here", "/there")); + printf(", errno: %d\n", errno); + errno = 0; + + printf("lockf(good): %d", lockf(f, 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("lockf(bad): %d", lockf(42, 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("nice: %d", nice(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("pause: %d", pause()); + printf(", errno: %d\n", errno); + errno = 0; + + int pipe_arg[2]; + printf("pipe(good): %d", pipe(pipe_arg)); + printf(", errno: %d\n", errno); + errno = 0; + printf("pipe(bad): %d", pipe(0)); + printf(", errno: %d\n", errno); + errno = 0; + + char* exec_argv[] = {"arg", 0}; + char* exec_env[] = {"a=b", 0}; + printf("execl: %d", execl("/program", "arg", 0)); + printf(", errno: %d\n", errno); + errno = 0; + printf("execle: %d", execle("/program", "arg", 0, exec_env)); + printf(", errno: %d\n", errno); + errno = 0; + printf("execlp: %d", execlp("program", "arg", 0)); + printf(", errno: %d\n", errno); + errno = 0; + printf("execv: %d", execv("program", exec_argv)); + printf(", errno: %d\n", errno); + errno = 0; + printf("execve: %d", execve("program", exec_argv, exec_env)); + printf(", errno: %d\n", errno); + errno = 0; + printf("execvp: %d", execvp("program", exec_argv)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("chown(good): %d", chown("/", 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("chown(bad): %d", chown("/noexist", 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("lchown(good): %d", lchown("/", 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("lchown(bad): %d", lchown("/noexist", 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("fchown(good): %d", fchown(f, 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("fchown(bad): %d", fchown(42, 123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("alarm: %d", alarm(42)); + printf(", errno: %d\n", errno); + errno = 0; + printf("ualarm: %d", ualarm(123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("fork: %d", fork()); + printf(", errno: %d\n", errno); + errno = 0; + printf("vfork: %d", vfork()); + printf(", errno: %d\n", errno); + errno = 0; + + printf("crypt: %d", crypt("foo", "bar")); + printf(", errno: %d\n", errno); + errno = 0; + char encrypt_block[64] = {0}; + printf("encrypt"); + encrypt(encrypt_block, 42); + printf(", errno: %d\n", errno); + errno = 0; + + printf("getgid: %d", getgid()); + printf(", errno: %d\n", errno); + errno = 0; + printf("getegid: %d", getegid()); + printf(", errno: %d\n", errno); + errno = 0; + printf("getuid: %d", getuid()); + printf(", errno: %d\n", errno); + errno = 0; + printf("geteuid: %d", geteuid()); + printf(", errno: %d\n", errno); + errno = 0; + + printf("getpgrp: %d", getpgrp()); + printf(", errno: %d\n", errno); + errno = 0; + printf("getpid: %d", getpid()); + printf(", errno: %d\n", errno); + errno = 0; + printf("getppid: %d", getppid()); + printf(", errno: %d\n", errno); + errno = 0; + + printf("getpgid: %d", getpgid(42)); + printf(", errno: %d\n", errno); + errno = 0; + printf("getsid: %d", getsid(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("setgid: %d", setgid(42)); + printf(", errno: %d\n", errno); + errno = 0; + printf("setegid: %d", setegid(42)); + printf(", errno: %d\n", errno); + errno = 0; + printf("setuid: %d", setuid(42)); + printf(", errno: %d\n", errno); + errno = 0; + printf("seteuid: %d", seteuid(42)); + printf(", errno: %d\n", errno); + errno = 0; + + printf("setpgrp: %d", setpgrp()); + printf(", errno: %d\n", errno); + errno = 0; + printf("setsid: %d", setsid()); + printf(", errno: %d\n", errno); + errno = 0; + + printf("setpgid: %d", setpgid(123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("setregid: %d", setregid(123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + printf("setreuid: %d", setreuid(123, 456)); + printf(", errno: %d\n", errno); + errno = 0; + + gid_t groups[10] = {42}; + printf("getgroups: %d", getgroups(10, groups)); + printf(", result: %d", groups[0]); + printf(", errno: %d\n", errno); + errno = 0; + + return 0; +} diff --git a/tests/unistd/misc.out b/tests/unistd/misc.out new file mode 100644 index 00000000..810da215 --- /dev/null +++ b/tests/unistd/misc.out @@ -0,0 +1,46 @@ +fsync(good): 0, errno: 0 +fsync(bad): -1, errno: 9 +fdatasync(good): 0, errno: 0 +fdatasync(bad): -1, errno: 9 +tcgetpgrp(good): 0, errno: 0 +tcgetpgrp(bad): 0, errno: 0 +tcsetpgrp(good): -1, errno: 22 +tcsetpgrp(bad): -1, errno: 22 +link: -1, errno: 31 +lockf(good): 0, errno: 0 +lockf(bad): -1, errno: 9 +nice: 0, errno: 1 +pause: -1, errno: 4 +pipe(good): -1, errno: 38 +pipe(bad): -1, errno: 38 +execl: -1, errno: 8 +execle: -1, errno: 8 +execlp: -1, errno: 8 +execv: -1, errno: 8 +execve: -1, errno: 8 +execvp: -1, errno: 8 +chown(good): 0, errno: 0 +chown(bad): -1, errno: 2 +lchown(good): 0, errno: 0 +lchown(bad): -1, errno: 2 +fchown(good): 0, errno: 0 +fchown(bad): -1, errno: 9 +alarm: 0, errno: 0 +ualarm: 0, errno: 0 +fork: -1, errno: 11 +vfork: -1, errno: 11 +crypt: 0, errno: 38 +encrypt, errno: 38 +getgid: 0, errno: 0 +getegid: 0, errno: 0 +getuid: 0, errno: 0 +geteuid: 0, errno: 0 +getpgrp: 0, errno: 0 +getpid: 0, errno: 0 +getppid: 0, errno: 0 +getpgid: 0, errno: 0 +getsid: 0, errno: 0 +setgid: -1, errno: 1 +setegid: -1, errno: 1 +setuid: -1, errno: 1 +seteuid: -1, errno: 1 diff --git a/tests/unistd/pathconf.c b/tests/unistd/pathconf.c new file mode 100644 index 00000000..4fac852b --- /dev/null +++ b/tests/unistd/pathconf.c @@ -0,0 +1,63 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + int vals[] = { + _PC_LINK_MAX, + _PC_MAX_CANON, + _PC_MAX_INPUT, + _PC_NAME_MAX, + _PC_PATH_MAX, + _PC_PIPE_BUF, + _PC_REC_MIN_XFER_SIZE, + _PC_REC_XFER_ALIGN, + _PC_ALLOC_SIZE_MIN, + _PC_CHOWN_RESTRICTED, + _PC_NO_TRUNC, + _PC_2_SYMLINKS, + _PC_VDISABLE, + _PC_SYNC_IO, + _PC_ASYNC_IO, + _PC_PRIO_IO, + _PC_SOCK_MAXBUF, + _PC_REC_INCR_XFER_SIZE, + _PC_REC_MAX_XFER_SIZE, + _PC_SYMLINK_MAX, + _PC_FILESIZEBITS + }; + char* names[] = { + "_PC_LINK_MAX", + "_PC_MAX_CANON", + "_PC_MAX_INPUT", + "_PC_NAME_MAX", + "_PC_PATH_MAX", + "_PC_PIPE_BUF", + "_PC_REC_MIN_XFER_SIZE", + "_PC_REC_XFER_ALIGN", + "_PC_ALLOC_SIZE_MIN", + "_PC_CHOWN_RESTRICTED", + "_PC_NO_TRUNC", + "_PC_2_SYMLINKS", + "_PC_VDISABLE", + "_PC_SYNC_IO", + "_PC_ASYNC_IO", + "_PC_PRIO_IO", + "_PC_SOCK_MAXBUF", + "_PC_REC_INCR_XFER_SIZE", + "_PC_REC_MAX_XFER_SIZE", + "_PC_SYMLINK_MAX", + "_PC_FILESIZEBITS" + }; + + for (int i = 0; i < sizeof vals / sizeof vals[0]; i++) { + printf("%s: %ld\n", names[i], pathconf("/", vals[i])); + printf("errno: %d\n\n", errno); + errno = 0; + } + + printf("(invalid): %ld\n", pathconf("/", -123)); + printf("errno: %d\n", errno); + + return 0; +} diff --git a/tests/unistd/pathconf.out b/tests/unistd/pathconf.out new file mode 100644 index 00000000..1daf04a9 --- /dev/null +++ b/tests/unistd/pathconf.out @@ -0,0 +1,65 @@ +_PC_LINK_MAX: 32000 +errno: 0 + +_PC_MAX_CANON: 255 +errno: 0 + +_PC_MAX_INPUT: 255 +errno: 0 + +_PC_NAME_MAX: 255 +errno: 0 + +_PC_PATH_MAX: 4096 +errno: 0 + +_PC_PIPE_BUF: 4096 +errno: 0 + +_PC_REC_MIN_XFER_SIZE: 4096 +errno: 0 + +_PC_REC_XFER_ALIGN: 4096 +errno: 0 + +_PC_ALLOC_SIZE_MIN: 4096 +errno: 0 + +_PC_CHOWN_RESTRICTED: 1 +errno: 0 + +_PC_NO_TRUNC: 1 +errno: 0 + +_PC_2_SYMLINKS: 1 +errno: 0 + +_PC_VDISABLE: 0 +errno: 0 + +_PC_SYNC_IO: -1 +errno: 0 + +_PC_ASYNC_IO: -1 +errno: 0 + +_PC_PRIO_IO: -1 +errno: 0 + +_PC_SOCK_MAXBUF: -1 +errno: 0 + +_PC_REC_INCR_XFER_SIZE: -1 +errno: 0 + +_PC_REC_MAX_XFER_SIZE: -1 +errno: 0 + +_PC_SYMLINK_MAX: -1 +errno: 0 + +_PC_FILESIZEBITS: 64 +errno: 0 + +(invalid): -1 +errno: 22 diff --git a/tests/unistd/sleep.c b/tests/unistd/sleep.c new file mode 100644 index 00000000..5a0302e2 --- /dev/null +++ b/tests/unistd/sleep.c @@ -0,0 +1,21 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <time.h> + +int main() { + time_t start; + + start = time(0); + printf("sleep(2) ret: %d\n", sleep(2)); + printf("after sleep(2): %d\n", time(0) - start); + printf("errno: %d\n", errno); + errno = 0; + + start = time(0); + printf("usleep(3000000) ret: %d\n", usleep(3100000)); + printf("after usleep(3000000): %d\n", time(0) - start); + printf("errno: %d\n", errno); + + return 0; +} diff --git a/tests/unistd/sleep.out b/tests/unistd/sleep.out new file mode 100644 index 00000000..9a668e91 --- /dev/null +++ b/tests/unistd/sleep.out @@ -0,0 +1,6 @@ +sleep(2) ret: 0 +after sleep(2): 2 +errno: 0 +usleep(3000000) ret: 0 +after usleep(3000000): 3 +errno: 0 diff --git a/tests/unistd/swab.c b/tests/unistd/swab.c new file mode 100644 index 00000000..d5c9ec27 --- /dev/null +++ b/tests/unistd/swab.c @@ -0,0 +1,13 @@ +#include <stdio.h> +#include <unistd.h> + +int main() { + char src[] = "abcdefg"; + char dst[10] = {0}; + swab(src, dst, 5); + + printf("before: %s\n", src); + printf("after: %s\n", dst); + + return 0; +} diff --git a/tests/unistd/swab.out b/tests/unistd/swab.out new file mode 100644 index 00000000..fe2c0f5c --- /dev/null +++ b/tests/unistd/swab.out @@ -0,0 +1,2 @@ +before: abcdefg +after: badc diff --git a/tests/unistd/sysconf.c b/tests/unistd/sysconf.c new file mode 100644 index 00000000..3211608e --- /dev/null +++ b/tests/unistd/sysconf.c @@ -0,0 +1,266 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + int vals[] = { + _SC_PAGE_SIZE, + _SC_PAGESIZE, + _SC_ADVISORY_INFO, + _SC_BARRIERS, + _SC_ASYNCHRONOUS_IO, + _SC_CLOCK_SELECTION, + _SC_CPUTIME, + _SC_FSYNC, + _SC_IPV6, + _SC_MAPPED_FILES, + _SC_MEMLOCK, + _SC_MEMLOCK_RANGE, + _SC_MEMORY_PROTECTION, + _SC_MESSAGE_PASSING, + _SC_MONOTONIC_CLOCK, + _SC_PRIORITIZED_IO, + _SC_PRIORITY_SCHEDULING, + _SC_RAW_SOCKETS, + _SC_READER_WRITER_LOCKS, + _SC_REALTIME_SIGNALS, + _SC_SEMAPHORES, + _SC_SHARED_MEMORY_OBJECTS, + _SC_SPAWN, + _SC_SPIN_LOCKS, + _SC_SYNCHRONIZED_IO, + _SC_THREAD_ATTR_STACKADDR, + _SC_THREAD_ATTR_STACKSIZE, + _SC_THREAD_CPUTIME, + _SC_THREAD_PRIO_INHERIT, + _SC_THREAD_PRIO_PROTECT, + _SC_THREAD_PRIORITY_SCHEDULING, + _SC_THREAD_PROCESS_SHARED, + _SC_THREAD_SAFE_FUNCTIONS, + _SC_THREADS, + _SC_TIMEOUTS, + _SC_TIMERS, + _SC_VERSION, + _SC_2_C_BIND, + _SC_2_C_DEV, + _SC_2_CHAR_TERM, + _SC_2_LOCALEDEF, + _SC_2_SW_DEV, + _SC_2_VERSION, + _SC_MQ_OPEN_MAX, + _SC_XOPEN_STREAMS, + _SC_XBS5_LP64_OFF64, + _SC_XBS5_LPBIG_OFFBIG, + _SC_AIO_LISTIO_MAX, + _SC_AIO_MAX, + _SC_SPORADIC_SERVER, + _SC_THREAD_SPORADIC_SERVER, + _SC_TRACE, + _SC_TRACE_EVENT_FILTER, + _SC_TRACE_EVENT_NAME_MAX, + _SC_TRACE_INHERIT, + _SC_TRACE_LOG, + _SC_TRACE_NAME_MAX, + _SC_TRACE_SYS_MAX, + _SC_TRACE_USER_EVENT_MAX, + _SC_TYPED_MEMORY_OBJECTS, + _SC_V6_LP64_OFF64, + _SC_V6_LPBIG_OFFBIG, + _SC_2_FORT_DEV, + _SC_2_FORT_RUN, + _SC_2_PBS, + _SC_2_PBS_ACCOUNTING, + _SC_2_PBS_CHECKPOINT, + _SC_2_PBS_LOCATE, + _SC_2_PBS_MESSAGE, + _SC_2_PBS_TRACK, + _SC_2_UPE, + _SC_THREAD_THREADS_MAX, + _SC_SEM_NSEMS_MAX, + _SC_SYMLOOP_MAX, + _SC_TIMER_MAX, + _SC_V6_ILP32_OFF32, + _SC_V6_ILP32_OFFBIG, + _SC_JOB_CONTROL, + _SC_REGEXP, + _SC_SAVED_IDS, + _SC_SHELL, + _SC_XBS5_ILP32_OFF32, + _SC_XBS5_ILP32_OFFBIG, + _SC_XOPEN_CRYPT, + _SC_XOPEN_ENH_I18N, + _SC_XOPEN_LEGACY, + _SC_XOPEN_REALTIME, + _SC_XOPEN_REALTIME_THREADS, + _SC_XOPEN_SHM, + _SC_XOPEN_UNIX, + _SC_THREAD_KEYS_MAX, + _SC_IOV_MAX, + _SC_GETGR_R_SIZE_MAX, + _SC_GETPW_R_SIZE_MAX, + _SC_OPEN_MAX, + _SC_RTSIG_MAX, + _SC_EXPR_NEST_MAX, + _SC_TTY_NAME_MAX, + _SC_ATEXIT_MAX, + _SC_DELAYTIMER_MAX, + _SC_SEM_VALUE_MAX, + _SC_SIGQUEUE_MAX, + _SC_CHILD_MAX, + _SC_BC_SCALE_MAX, + _SC_BC_BASE_MAX, + _SC_LINE_MAX, + _SC_BC_DIM_MAX, + _SC_ARG_MAX, + _SC_NGROUPS_MAX, + _SC_MQ_PRIO_MAX, + _SC_RE_DUP_MAX, + _SC_THREAD_STACK_MIN, + _SC_BC_STRING_MAX, + _SC_XOPEN_VERSION, + _SC_LOGIN_NAME_MAX, + _SC_COLL_WEIGHTS_MAX, + _SC_CLK_TCK, + _SC_HOST_NAME_MAX, + _SC_AIO_PRIO_DELTA_MAX, + _SC_STREAM_MAX, + _SC_TZNAME_MAX, + _SC_THREAD_DESTRUCTOR_ITERATIONS + }; + char* names[] = { + "_SC_PAGE_SIZE", + "_SC_PAGESIZE", + "_SC_ADVISORY_INFO", + "_SC_BARRIERS", + "_SC_ASYNCHRONOUS_IO", + "_SC_CLOCK_SELECTION", + "_SC_CPUTIME", + "_SC_FSYNC", + "_SC_IPV6", + "_SC_MAPPED_FILES", + "_SC_MEMLOCK", + "_SC_MEMLOCK_RANGE", + "_SC_MEMORY_PROTECTION", + "_SC_MESSAGE_PASSING", + "_SC_MONOTONIC_CLOCK", + "_SC_PRIORITIZED_IO", + "_SC_PRIORITY_SCHEDULING", + "_SC_RAW_SOCKETS", + "_SC_READER_WRITER_LOCKS", + "_SC_REALTIME_SIGNALS", + "_SC_SEMAPHORES", + "_SC_SHARED_MEMORY_OBJECTS", + "_SC_SPAWN", + "_SC_SPIN_LOCKS", + "_SC_SYNCHRONIZED_IO", + "_SC_THREAD_ATTR_STACKADDR", + "_SC_THREAD_ATTR_STACKSIZE", + "_SC_THREAD_CPUTIME", + "_SC_THREAD_PRIO_INHERIT", + "_SC_THREAD_PRIO_PROTECT", + "_SC_THREAD_PRIORITY_SCHEDULING", + "_SC_THREAD_PROCESS_SHARED", + "_SC_THREAD_SAFE_FUNCTIONS", + "_SC_THREADS", + "_SC_TIMEOUTS", + "_SC_TIMERS", + "_SC_VERSION", + "_SC_2_C_BIND", + "_SC_2_C_DEV", + "_SC_2_CHAR_TERM", + "_SC_2_LOCALEDEF", + "_SC_2_SW_DEV", + "_SC_2_VERSION", + "_SC_MQ_OPEN_MAX", + "_SC_XOPEN_STREAMS", + "_SC_XBS5_LP64_OFF64", + "_SC_XBS5_LPBIG_OFFBIG", + "_SC_AIO_LISTIO_MAX", + "_SC_AIO_MAX", + "_SC_SPORADIC_SERVER", + "_SC_THREAD_SPORADIC_SERVER", + "_SC_TRACE", + "_SC_TRACE_EVENT_FILTER", + "_SC_TRACE_EVENT_NAME_MAX", + "_SC_TRACE_INHERIT", + "_SC_TRACE_LOG", + "_SC_TRACE_NAME_MAX", + "_SC_TRACE_SYS_MAX", + "_SC_TRACE_USER_EVENT_MAX", + "_SC_TYPED_MEMORY_OBJECTS", + "_SC_V6_LP64_OFF64", + "_SC_V6_LPBIG_OFFBIG", + "_SC_2_FORT_DEV", + "_SC_2_FORT_RUN", + "_SC_2_PBS", + "_SC_2_PBS_ACCOUNTING", + "_SC_2_PBS_CHECKPOINT", + "_SC_2_PBS_LOCATE", + "_SC_2_PBS_MESSAGE", + "_SC_2_PBS_TRACK", + "_SC_2_UPE", + "_SC_THREAD_THREADS_MAX", + "_SC_SEM_NSEMS_MAX", + "_SC_SYMLOOP_MAX", + "_SC_TIMER_MAX", + "_SC_V6_ILP32_OFF32", + "_SC_V6_ILP32_OFFBIG", + "_SC_JOB_CONTROL", + "_SC_REGEXP", + "_SC_SAVED_IDS", + "_SC_SHELL", + "_SC_XBS5_ILP32_OFF32", + "_SC_XBS5_ILP32_OFFBIG", + "_SC_XOPEN_CRYPT", + "_SC_XOPEN_ENH_I18N", + "_SC_XOPEN_LEGACY", + "_SC_XOPEN_REALTIME", + "_SC_XOPEN_REALTIME_THREADS", + "_SC_XOPEN_SHM", + "_SC_XOPEN_UNIX", + "_SC_THREAD_KEYS_MAX", + "_SC_IOV_MAX", + "_SC_GETGR_R_SIZE_MAX", + "_SC_GETPW_R_SIZE_MAX", + "_SC_OPEN_MAX", + "_SC_RTSIG_MAX", + "_SC_EXPR_NEST_MAX", + "_SC_TTY_NAME_MAX", + "_SC_ATEXIT_MAX", + "_SC_DELAYTIMER_MAX", + "_SC_SEM_VALUE_MAX", + "_SC_SIGQUEUE_MAX", + "_SC_CHILD_MAX", + "_SC_BC_SCALE_MAX", + "_SC_BC_BASE_MAX", + "_SC_LINE_MAX", + "_SC_BC_DIM_MAX", + "_SC_ARG_MAX", + "_SC_NGROUPS_MAX", + "_SC_MQ_PRIO_MAX", + "_SC_RE_DUP_MAX", + "_SC_THREAD_STACK_MIN", + "_SC_BC_STRING_MAX", + "_SC_XOPEN_VERSION", + "_SC_LOGIN_NAME_MAX", + "_SC_COLL_WEIGHTS_MAX", + "_SC_CLK_TCK", + "_SC_HOST_NAME_MAX", + "_SC_AIO_PRIO_DELTA_MAX", + "_SC_STREAM_MAX", + "_SC_TZNAME_MAX", + "_SC_THREAD_DESTRUCTOR_ITERATIONS" + }; + char buffer[256]; + + for (int i = 0; i < sizeof vals / sizeof vals[0]; i++) { + printf("%s: %ld\n", names[i], sysconf(vals[i])); + printf("errno: %d\n\n", errno); + errno = 0; + } + + printf("(invalid): %ld\n", sysconf(-123)); + printf("errno: %d\n", errno); + + return 0; +} diff --git a/tests/unistd/sysconf.out b/tests/unistd/sysconf.out new file mode 100644 index 00000000..5cb78bdb --- /dev/null +++ b/tests/unistd/sysconf.out @@ -0,0 +1,368 @@ +_SC_PAGE_SIZE: 4096 +errno: 0 + +_SC_PAGESIZE: 4096 +errno: 0 + +_SC_ADVISORY_INFO: 200809 +errno: 0 + +_SC_BARRIERS: 200809 +errno: 0 + +_SC_ASYNCHRONOUS_IO: 200809 +errno: 0 + +_SC_CLOCK_SELECTION: 200809 +errno: 0 + +_SC_CPUTIME: 200809 +errno: 0 + +_SC_FSYNC: 200809 +errno: 0 + +_SC_IPV6: 200809 +errno: 0 + +_SC_MAPPED_FILES: 200809 +errno: 0 + +_SC_MEMLOCK: 200809 +errno: 0 + +_SC_MEMLOCK_RANGE: 200809 +errno: 0 + +_SC_MEMORY_PROTECTION: 200809 +errno: 0 + +_SC_MESSAGE_PASSING: 200809 +errno: 0 + +_SC_MONOTONIC_CLOCK: 200809 +errno: 0 + +_SC_PRIORITIZED_IO: 200809 +errno: 0 + +_SC_PRIORITY_SCHEDULING: 200809 +errno: 0 + +_SC_RAW_SOCKETS: 200809 +errno: 0 + +_SC_READER_WRITER_LOCKS: 200809 +errno: 0 + +_SC_REALTIME_SIGNALS: 200809 +errno: 0 + +_SC_SEMAPHORES: 200809 +errno: 0 + +_SC_SHARED_MEMORY_OBJECTS: 200809 +errno: 0 + +_SC_SPAWN: 200809 +errno: 0 + +_SC_SPIN_LOCKS: 200809 +errno: 0 + +_SC_SYNCHRONIZED_IO: 200809 +errno: 0 + +_SC_THREAD_ATTR_STACKADDR: 200809 +errno: 0 + +_SC_THREAD_ATTR_STACKSIZE: 200809 +errno: 0 + +_SC_THREAD_CPUTIME: 200809 +errno: 0 + +_SC_THREAD_PRIO_INHERIT: 200809 +errno: 0 + +_SC_THREAD_PRIO_PROTECT: 200809 +errno: 0 + +_SC_THREAD_PRIORITY_SCHEDULING: 200809 +errno: 0 + +_SC_THREAD_PROCESS_SHARED: 200809 +errno: 0 + +_SC_THREAD_SAFE_FUNCTIONS: 200809 +errno: 0 + +_SC_THREADS: 200809 +errno: 0 + +_SC_TIMEOUTS: 200809 +errno: 0 + +_SC_TIMERS: 200809 +errno: 0 + +_SC_VERSION: 200809 +errno: 0 + +_SC_2_C_BIND: 200809 +errno: 0 + +_SC_2_C_DEV: 200809 +errno: 0 + +_SC_2_CHAR_TERM: 200809 +errno: 0 + +_SC_2_LOCALEDEF: 200809 +errno: 0 + +_SC_2_SW_DEV: 200809 +errno: 0 + +_SC_2_VERSION: 200809 +errno: 0 + +_SC_MQ_OPEN_MAX: -1 +errno: 0 + +_SC_XOPEN_STREAMS: -1 +errno: 0 + +_SC_XBS5_LP64_OFF64: -1 +errno: 0 + +_SC_XBS5_LPBIG_OFFBIG: -1 +errno: 0 + +_SC_AIO_LISTIO_MAX: -1 +errno: 0 + +_SC_AIO_MAX: -1 +errno: 0 + +_SC_SPORADIC_SERVER: -1 +errno: 0 + +_SC_THREAD_SPORADIC_SERVER: -1 +errno: 0 + +_SC_TRACE: -1 +errno: 0 + +_SC_TRACE_EVENT_FILTER: -1 +errno: 0 + +_SC_TRACE_EVENT_NAME_MAX: -1 +errno: 0 + +_SC_TRACE_INHERIT: -1 +errno: 0 + +_SC_TRACE_LOG: -1 +errno: 0 + +_SC_TRACE_NAME_MAX: -1 +errno: 0 + +_SC_TRACE_SYS_MAX: -1 +errno: 0 + +_SC_TRACE_USER_EVENT_MAX: -1 +errno: 0 + +_SC_TYPED_MEMORY_OBJECTS: -1 +errno: 0 + +_SC_V6_LP64_OFF64: -1 +errno: 0 + +_SC_V6_LPBIG_OFFBIG: -1 +errno: 0 + +_SC_2_FORT_DEV: -1 +errno: 0 + +_SC_2_FORT_RUN: -1 +errno: 0 + +_SC_2_PBS: -1 +errno: 0 + +_SC_2_PBS_ACCOUNTING: -1 +errno: 0 + +_SC_2_PBS_CHECKPOINT: -1 +errno: 0 + +_SC_2_PBS_LOCATE: -1 +errno: 0 + +_SC_2_PBS_MESSAGE: -1 +errno: 0 + +_SC_2_PBS_TRACK: -1 +errno: 0 + +_SC_2_UPE: -1 +errno: 0 + +_SC_THREAD_THREADS_MAX: -1 +errno: 0 + +_SC_SEM_NSEMS_MAX: -1 +errno: 0 + +_SC_SYMLOOP_MAX: -1 +errno: 0 + +_SC_TIMER_MAX: -1 +errno: 0 + +_SC_V6_ILP32_OFF32: 1 +errno: 0 + +_SC_V6_ILP32_OFFBIG: 1 +errno: 0 + +_SC_JOB_CONTROL: 1 +errno: 0 + +_SC_REGEXP: 1 +errno: 0 + +_SC_SAVED_IDS: 1 +errno: 0 + +_SC_SHELL: 1 +errno: 0 + +_SC_XBS5_ILP32_OFF32: 1 +errno: 0 + +_SC_XBS5_ILP32_OFFBIG: 1 +errno: 0 + +_SC_XOPEN_CRYPT: 1 +errno: 0 + +_SC_XOPEN_ENH_I18N: 1 +errno: 0 + +_SC_XOPEN_LEGACY: 1 +errno: 0 + +_SC_XOPEN_REALTIME: 1 +errno: 0 + +_SC_XOPEN_REALTIME_THREADS: 1 +errno: 0 + +_SC_XOPEN_SHM: 1 +errno: 0 + +_SC_XOPEN_UNIX: 1 +errno: 0 + +_SC_THREAD_KEYS_MAX: 1024 +errno: 0 + +_SC_IOV_MAX: 1024 +errno: 0 + +_SC_GETGR_R_SIZE_MAX: 1024 +errno: 0 + +_SC_GETPW_R_SIZE_MAX: 1024 +errno: 0 + +_SC_OPEN_MAX: 1024 +errno: 0 + +_SC_RTSIG_MAX: 32 +errno: 0 + +_SC_EXPR_NEST_MAX: 32 +errno: 0 + +_SC_TTY_NAME_MAX: 32 +errno: 0 + +_SC_ATEXIT_MAX: 2147483647 +errno: 0 + +_SC_DELAYTIMER_MAX: 2147483647 +errno: 0 + +_SC_SEM_VALUE_MAX: 2147483647 +errno: 0 + +_SC_SIGQUEUE_MAX: 47839 +errno: 0 + +_SC_CHILD_MAX: 47839 +errno: 0 + +_SC_BC_SCALE_MAX: 99 +errno: 0 + +_SC_BC_BASE_MAX: 99 +errno: 0 + +_SC_LINE_MAX: 2048 +errno: 0 + +_SC_BC_DIM_MAX: 2048 +errno: 0 + +_SC_ARG_MAX: 2097152 +errno: 0 + +_SC_NGROUPS_MAX: 65536 +errno: 0 + +_SC_MQ_PRIO_MAX: 32768 +errno: 0 + +_SC_RE_DUP_MAX: 32767 +errno: 0 + +_SC_THREAD_STACK_MIN: 16384 +errno: 0 + +_SC_BC_STRING_MAX: 1000 +errno: 0 + +_SC_XOPEN_VERSION: 700 +errno: 0 + +_SC_LOGIN_NAME_MAX: 256 +errno: 0 + +_SC_COLL_WEIGHTS_MAX: 255 +errno: 0 + +_SC_CLK_TCK: 100 +errno: 0 + +_SC_HOST_NAME_MAX: 64 +errno: 0 + +_SC_AIO_PRIO_DELTA_MAX: 20 +errno: 0 + +_SC_STREAM_MAX: 16 +errno: 0 + +_SC_TZNAME_MAX: 6 +errno: 0 + +_SC_THREAD_DESTRUCTOR_ITERATIONS: 4 +errno: 0 + +(invalid): -1 +errno: 22 diff --git a/tests/unistd/truncate.c b/tests/unistd/truncate.c new file mode 100644 index 00000000..18920976 --- /dev/null +++ b/tests/unistd/truncate.c @@ -0,0 +1,68 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <string.h> + +int main() { + struct stat s; + int f = open("/towrite", O_WRONLY); + int f2 = open("/toread", O_RDONLY); + printf("f2: %d\n", f2); + + fstat(f, &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("ftruncate(10): %d\n", ftruncate(f, 10)); + printf("errno: %d\n", errno); + fstat(f, &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("ftruncate(4): %d\n", ftruncate(f, 4)); + printf("errno: %d\n", errno); + fstat(f, &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("ftruncate(-1): %d\n", ftruncate(f, -1)); + printf("errno: %d\n", errno); + fstat(f, &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("truncate(2): %d\n", truncate("/towrite", 2)); + printf("errno: %d\n", errno); + stat("/towrite", &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("truncate(readonly, 2): %d\n", truncate("/toread", 2)); + printf("errno: %d\n", errno); + stat("/toread", &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + printf("\n"); + + printf("ftruncate(readonly, 4): %d\n", ftruncate(f2, 4)); + printf("errno: %d\n", errno); + fstat(f2, &s); + printf("st_size: %d\n", s.st_size); + memset(&s, 0, sizeof s); + errno = 0; + + return 0; +} diff --git a/tests/unistd/truncate.js b/tests/unistd/truncate.js new file mode 100644 index 00000000..6a4c6868 --- /dev/null +++ b/tests/unistd/truncate.js @@ -0,0 +1,2 @@ +FS.createDataFile('/', 'towrite', 'abcdef', true, true); +FS.createDataFile('/', 'toread', 'abcdef', true, false); diff --git a/tests/unistd/truncate.out b/tests/unistd/truncate.out new file mode 100644 index 00000000..2ab0f305 --- /dev/null +++ b/tests/unistd/truncate.out @@ -0,0 +1,25 @@ +st_size: 6 + +ftruncate(10): 0 +errno: 0 +st_size: 10 + +ftruncate(4): 0 +errno: 0 +st_size: 4 + +ftruncate(-1): -1 +errno: 22 +st_size: 4 + +truncate(2): 0 +errno: 0 +st_size: 2 + +truncate(readonly, 2): -1 +errno: 13 +st_size: 6 + +ftruncate(readonly, 4): -1 +errno: 22 +st_size: 6 diff --git a/tests/unistd/ttyname.c b/tests/unistd/ttyname.c new file mode 100644 index 00000000..7080be5d --- /dev/null +++ b/tests/unistd/ttyname.c @@ -0,0 +1,51 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> + +int main() { + char buffer[256]; + int d = open("/device", O_RDWR); + int f = open("/", O_RDONLY); + char* result; + + result = ctermid(buffer); + if (result) { + printf("ctermid: %s\n", result); + } else { + printf("ctermid errno: %d\n", errno); + errno = 0; + } + + if (ttyname_r(d, buffer, 256) == 0) { + printf("ttyname_r(d, ..., 256): %s\n", buffer); + } else { + printf("ttyname_r(d, ..., 256) errno: %d\n", errno); + errno = 0; + } + + if (ttyname_r(d, buffer, 2) == 0) { + printf("ttyname_r(d, ..., 2): %s\n", buffer); + } else { + printf("ttyname_r(d, ..., 2) errno: %d\n", errno); + errno = 0; + } + + result = ttyname(d); + if (result) { + printf("ttyname(d): %s\n", result); + } else { + printf("ttyname(d) errno: %d\n", errno); + errno = 0; + } + + result = ttyname(f); + if (result) { + printf("ttyname(f): %s\n", result); + } else { + printf("ttyname(f) errno: %d\n", errno); + errno = 0; + } + + return 0; +} diff --git a/tests/unistd/ttyname.js b/tests/unistd/ttyname.js new file mode 100644 index 00000000..a21f417f --- /dev/null +++ b/tests/unistd/ttyname.js @@ -0,0 +1 @@ +FS.createDevice('/', 'device', function() {}, function() {}); diff --git a/tests/unistd/ttyname.out b/tests/unistd/ttyname.out new file mode 100644 index 00000000..b47cbf75 --- /dev/null +++ b/tests/unistd/ttyname.out @@ -0,0 +1,5 @@ +ctermid: /dev/tty +ttyname_r(d, ..., 256): /device +ttyname_r(d, ..., 2) errno: 34 +ttyname(d): /device +ttyname(f) errno: 25 diff --git a/tests/unistd/unlink.c b/tests/unistd/unlink.c new file mode 100644 index 00000000..3f7d84b6 --- /dev/null +++ b/tests/unistd/unlink.c @@ -0,0 +1,35 @@ +#include <stdio.h> +#include <errno.h> +#include <unistd.h> + +int main() { + char* files[] = {"/device", "/file", "/file-forbidden", "/noexist"}; + char* folders[] = {"/empty", "/empty-forbidden", "/full"}; + int i; + + for (i = 0; i < sizeof files / sizeof files[0]; i++) { + printf("access(%s) before: %d\n", files[i], access(files[i], F_OK)); + rmdir(files[i]); + printf("errno: %d\n", errno); + errno = 0; + printf("access(%s) after rmdir: %d\n", files[i], access(files[i], F_OK)); + unlink(files[i]); + printf("errno: %d\n", errno); + errno = 0; + printf("access(%s) after unlink: %d\n\n", files[i], access(files[i], F_OK)); + } + + for (i = 0; i < sizeof folders / sizeof folders[0]; i++) { + printf("access(%s) before: %d\n", folders[i], access(folders[i], F_OK)); + unlink(folders[i]); + printf("errno: %d\n", errno); + errno = 0; + printf("access(%s) after unlink: %d\n", folders[i], access(folders[i], F_OK)); + rmdir(folders[i]); + printf("errno: %d\n", errno); + errno = 0; + printf("access(%s) after rmdir: %d\n\n", folders[i], access(folders[i], F_OK)); + } + + return 0; +} diff --git a/tests/unistd/unlink.js b/tests/unistd/unlink.js new file mode 100644 index 00000000..c2366080 --- /dev/null +++ b/tests/unistd/unlink.js @@ -0,0 +1,7 @@ +FS.createDevice('/', 'device', function() {}, function() {}); +FS.createDataFile('/', 'file', 'test', true, true); +FS.createDataFile('/', 'file-forbidden', 'test', true, false); +FS.createFolder('/', 'empty', true, true); +FS.createFolder('/', 'empty-forbidden', true, false); +FS.createFolder('/', 'full', true, true); +FS.createFolder('/full', 'junk', true, true); diff --git a/tests/unistd/unlink.out b/tests/unistd/unlink.out new file mode 100644 index 00000000..1dcec761 --- /dev/null +++ b/tests/unistd/unlink.out @@ -0,0 +1,42 @@ +access(/device) before: 0 +errno: 20 +access(/device) after rmdir: 0 +errno: 0 +access(/device) after unlink: -1 + +access(/file) before: 0 +errno: 20 +access(/file) after rmdir: 0 +errno: 0 +access(/file) after unlink: -1 + +access(/file-forbidden) before: 0 +errno: 13 +access(/file-forbidden) after rmdir: 0 +errno: 13 +access(/file-forbidden) after unlink: 0 + +access(/noexist) before: -1 +errno: 2 +access(/noexist) after rmdir: -1 +errno: 2 +access(/noexist) after unlink: -1 + +access(/empty) before: 0 +errno: 21 +access(/empty) after unlink: 0 +errno: 0 +access(/empty) after rmdir: -1 + +access(/empty-forbidden) before: 0 +errno: 21 +access(/empty-forbidden) after unlink: 0 +errno: 13 +access(/empty-forbidden) after rmdir: 0 + +access(/full) before: 0 +errno: 21 +access(/full) after unlink: 0 +errno: 39 +access(/full) after rmdir: 0 + |