12 files changed, 439 insertions, 288 deletions

diff --git a/tests/dirent/test_readdir.c b/tests/dirent/test_readdir.c
new file mode 100644
index 00000000..9f7b12e8
--- /dev/null
+++ b/tests/dirent/test_readdir.c
@@ -0,0 +1,132 @@
+#include <assert.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+static void create_file(const char *path, const char *buffer, int mode) {
+  int fd = open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
+  assert(fd >= 0);
+
+  int err = write(fd, buffer, sizeof(char) * strlen(buffer));
+  assert(err ==  (sizeof(char) * strlen(buffer)));
+
+  close(fd);
+}
+
+void setup() {
+  mkdir("nocanread", 0111);
+  mkdir("foobar", 0777);
+  create_file("foobar/file.txt", "ride into the danger zone", 0666);
+}
+
+void cleanup() {
+  rmdir("nocanread");
+  unlink("foobar/file.txt");
+  rmdir("foobar");
+}
+
+void test() {
+  int err;
+  int loc;
+  DIR *dir;
+  struct dirent *ent;
+  struct dirent ent_r;
+  struct dirent *result;
+
+  // check bad opendir input
+  dir = opendir("noexist");
+  assert(!dir);
+  assert(errno == ENOENT);
+  dir = opendir("nocanread");
+  assert(!dir);
+  assert(errno == EACCES);
+  dir = opendir("foobar/file.txt");
+  assert(!dir);
+  assert(errno == ENOTDIR);
+
+  // check bad readdir input
+  dir = opendir("foobar");
+  closedir(dir);
+  ent = readdir(dir);
+  assert(!ent);
+  assert(errno == EBADF);
+
+  // check bad readdir_r input
+  dir = opendir("foobar");
+  closedir(dir);
+  err = readdir_r(dir, NULL, &result);
+  assert(err == EBADF);
+  
+  //
+  // do a normal read with readdir
+  //
+  dir = opendir("foobar");
+  assert(dir);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, "."));
+  assert(ent->d_type & DT_DIR);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, ".."));
+  assert(ent->d_type & DT_DIR);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, "file.txt"));
+  assert(ent->d_type & DT_REG);
+  ent = readdir(dir);
+  assert(!ent);
+
+  // test rewinddir
+  rewinddir(dir);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, "."));
+
+  // test seek / tell
+  rewinddir(dir);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, "."));
+  loc = telldir(dir);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, ".."));
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, "file.txt"));
+  seekdir(dir, loc);
+  ent = readdir(dir);
+  assert(!strcmp(ent->d_name, ".."));
+
+  //
+  // do a normal read with readdir_r
+  //
+  rewinddir(dir);
+  err = readdir_r(dir, &ent_r, &result);
+  assert(!err);
+  assert(&ent_r == result);
+  assert(!strcmp(ent_r.d_name, "."));
+  err = readdir_r(dir, &ent_r, &result);
+  assert(!err);
+  assert(&ent_r == result);
+  assert(!strcmp(ent_r.d_name, ".."));
+  err = readdir_r(dir, &ent_r, &result);
+  assert(!err);
+  assert(&ent_r == result);
+  assert(!strcmp(ent_r.d_name, "file.txt"));
+  err = readdir_r(dir, &ent_r, &result);
+  assert(!err);
+  assert(!result);
+
+  err = closedir(dir);
+  assert(!err);
+
+  puts("success");
+}
+
+int main() {
+  atexit(cleanup);
+  signal(SIGABRT, cleanup);
+  setup();
+  test();
+  return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/tests/fcntl-misc/src.c b/tests/fcntl-misc/src.c
index 73734969..7cdbbcd6 100644
--- a/tests/fcntl-misc/src.c
+++ b/tests/fcntl-misc/src.c
@@ -6,7 +6,7 @@
 
 int main() {
   struct stat s;
-  int f = open("/test", O_RDONLY, 0777);
+  int f = open("/test", O_RDWR, 0777);
 
   printf("posix_fadvise: %d\n", posix_fadvise(f, 3, 2, POSIX_FADV_DONTNEED));
   printf("errno: %d\n", errno);
diff --git a/tests/fcntl-open/output.txt b/tests/fcntl-open/output.txt
index 314ae880..07b106ac 100644
--- a/tests/fcntl-open/output.txt
+++ b/tests/fcntl-open/output.txt
@@ -19,8 +19,8 @@ errno: 0
 st_mode: 0100000
 
 EXISTING FOLDER 0,1
-success: 0
-errno: 21
+success: 1
+errno: 0
 st_mode: 040000
 
 NON-EXISTING 0,1
@@ -139,8 +139,8 @@ errno: 0
 st_mode: 0100000
 
 EXISTING FOLDER 0,9
-success: 0
-errno: 21
+success: 1
+errno: 0
 st_mode: 040000
 
 NON-EXISTING 0,9
@@ -720,4 +720,4 @@ st_mode: 0100000
 
 CREAT
 success: 1
-errno: 0
+errno: 0
\ No newline at end of file
diff --git a/tests/fcntl-open/src.c b/tests/fcntl-open/src.c
index 52d2e7e4..bd52dd3f 100644
--- a/tests/fcntl-open/src.c
+++ b/tests/fcntl-open/src.c
@@ -1,13 +1,45 @@
-#include <stdio.h>
+#include <assert.h>
 #include <errno.h>
-#include <sys/stat.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
 
-int main() {
+char nonexistent_name[] = "noexist-##";
+
+void create_file(const char *path, const char *buffer, int mode) {
+  int fd = open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
+  assert(fd >= 0);
+
+  int err = write(fd, buffer, sizeof(char) * strlen(buffer));
+  assert(err ==  (sizeof(char) * strlen(buffer)));
+
+  close(fd);
+}
+
+void setup() {
+  create_file("test-file", "abcdef", 0777);
+  mkdir("test-folder", 0777);
+}
+
+void cleanup() {
+  unlink("test-file");
+  rmdir("test-folder");
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 16; j++) {
+      nonexistent_name[8] = 'a' + i;
+      nonexistent_name[9] = 'a' + j;
+      unlink(nonexistent_name);
+    }
+  }
+  unlink("creat-me");
+}
+
+void test() {
   struct stat s;
   int modes[] = {O_RDONLY, O_WRONLY, O_RDWR};
-  char nonexistent_name[] = "/noexist-##";
 
   for (int i = 0; i < 3; i++) {
     for (int j = 0; j < 16; j++) {
@@ -18,25 +50,25 @@ int main() {
       if (j & 0x8) flags |= O_APPEND;
 
       printf("EXISTING FILE %d,%d\n", i, j);
-      printf("success: %d\n", open("/test-file", flags, 0777) != -1);
+      printf("success: %d\n", open("test-file", flags, 0777) != -1);
       printf("errno: %d\n", errno);
-      stat("/test-file", &s);
+      stat("test-file", &s);
       printf("st_mode: 0%o\n", s.st_mode & 037777777000);
       memset(&s, 0, sizeof s);
       printf("\n");
       errno = 0;
 
       printf("EXISTING FOLDER %d,%d\n", i, j);
-      printf("success: %d\n", open("/test-folder", flags, 0777) != -1);
+      printf("success: %d\n", open("test-folder", flags, 0777) != -1);
       printf("errno: %d\n", errno);
-      stat("/test-folder", &s);
+      stat("test-folder", &s);
       printf("st_mode: 0%o\n", s.st_mode & 037777777000);
       memset(&s, 0, sizeof s);
       printf("\n");
       errno = 0;
 
-      nonexistent_name[9] = 'a' + i;
-      nonexistent_name[10] = 'a' + j;
+      nonexistent_name[8] = 'a' + i;
+      nonexistent_name[9] = 'a' + j;
       printf("NON-EXISTING %d,%d\n", i, j);
       printf("success: %d\n", open(nonexistent_name, flags, 0777) != -1);
       printf("errno: %d\n", errno);
@@ -49,8 +81,14 @@ int main() {
   }
 
   printf("CREAT\n");
-  printf("success: %d\n", creat("/creat-me", 0777) != -1);
+  printf("success: %d\n", creat("creat-me", 0777) != -1);
   printf("errno: %d\n", errno);
-
-  return 0;
 }
+
+int main() {
+  atexit(cleanup);
+  signal(SIGABRT, cleanup);
+  setup();
+  test();
+  return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/tests/runner.py b/tests/runner.py
index 18d5f4d1..c08434f5 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -1981,6 +1981,18 @@ Succeeded!
         self.do_run(src, "1.0 2.0 -1.0 -2.0 2.0 3.0 -2.0 -3.0 "
                          "1 2 -1 -2 2 2 -2 -2")
 
+    def test_llrint(self):
+      if Settings.USE_TYPED_ARRAYS != 2: return self.skip('requires ta2')
+      src = r'''
+        #include <stdio.h>
+        #include <math.h>
+        int main() {
+          printf("%lld\n%lld\n%lld\n%lld\n", llrint(0.1), llrint(0.6), llrint(1.25), llrint(1099511627776.667));
+          return 0;
+        }
+      '''
+      self.do_run(src, '0\n1\n1\n1099511627777\n')
+
     def test_getgep(self):
         # Generated code includes getelementptr (getelementptr, 0, 1), i.e., GEP as the first param to GEP
         src = '''
@@ -4958,6 +4970,130 @@ The current type of b is: 9
       '''
       self.do_run(src, 'time: ') # compilation check, mainly
 
+
+    def test_strptime_tm(self):
+      src=r'''
+        #include <time.h>
+        #include <stdio.h>
+        #include <string.h>
+
+        int main() {
+          struct tm tm;
+          char *ptr = strptime("17410105012000", "%H%M%S%d%m%Y", &tm);
+
+          printf("%s: %s, %d/%d/%d %d:%d:%d", 
+            (ptr != NULL && *ptr=='\0') ? "OK" : "ERR", 
+            tm.tm_wday == 0 ? "Sun" : (tm.tm_wday == 1 ? "Mon" : (tm.tm_wday == 2 ? "Tue" : (tm.tm_wday == 3 ? "Wed" : (tm.tm_wday == 4 ? "Thu" : (tm.tm_wday == 5 ? "Fri" : (tm.tm_wday == 6 ? "Sat" : "ERR")))))),
+            tm.tm_mon+1,
+            tm.tm_mday,
+            tm.tm_year+1900,
+            tm.tm_hour,
+            tm.tm_min,
+            tm.tm_sec            
+          );
+        }
+      ''' 
+      self.do_run(src, 'OK: Wed, 1/5/2000 17:41:1')
+
+    def test_strptime_days(self):
+      src = r'''
+        #include <time.h>
+        #include <stdio.h>
+        #include <string.h>
+
+        static const struct {
+          const char *input;
+          const char *format;
+        } day_tests[] = {
+          { "2000-01-01", "%Y-%m-%d"},
+          { "03/03/00", "%D"},
+          { "9/9/99", "%x"},
+          { "19990502123412", "%Y%m%d%H%M%S"},
+          { "2001 20 Mon", "%Y %U %a"},
+          { "2006 4 Fri", "%Y %U %a"},
+          { "2001 21 Mon", "%Y %W %a"},
+          { "2013 29 Wed", "%Y %W %a"},
+          { "2000-01-01 08:12:21 AM", "%Y-%m-%d %I:%M:%S %p"},
+          { "2000-01-01 08:12:21 PM", "%Y-%m-%d %I:%M:%S %p"},
+          { "2001 17 Tue", "%Y %U %a"},
+          { "2001 8 Thursday", "%Y %W %a"},
+        };
+
+        int main() {  
+          struct tm tm;
+
+          for (int i = 0; i < sizeof (day_tests) / sizeof (day_tests[0]); ++i) {
+            memset (&tm, '\0', sizeof (tm));
+            char *ptr = strptime(day_tests[i].input, day_tests[i].format, &tm);
+
+            printf("%s: %d/%d/%d (%dth DoW, %dth DoY)\n", (ptr != NULL && *ptr=='\0') ? "OK" : "ERR", tm.tm_mon+1, tm.tm_mday, 1900+tm.tm_year, tm.tm_wday, tm.tm_yday);
+          }
+        }
+      '''
+      self.do_run(src, 'OK: 1/1/2000 (6th DoW, 0th DoY)\n'\
+                       'OK: 3/3/2000 (5th DoW, 62th DoY)\n'\
+                       'OK: 9/9/1999 (4th DoW, 251th DoY)\n'\
+                       'OK: 5/2/1999 (0th DoW, 121th DoY)\n'\
+                       'OK: 5/21/2001 (1th DoW, 140th DoY)\n'\
+                       'OK: 1/27/2006 (5th DoW, 26th DoY)\n'\
+                       'OK: 5/21/2001 (1th DoW, 140th DoY)\n'\
+                       'OK: 7/24/2013 (3th DoW, 204th DoY)\n'\
+                       'OK: 1/1/2000 (6th DoW, 0th DoY)\n'\
+                       'OK: 1/1/2000 (6th DoW, 0th DoY)\n'\
+                       'OK: 5/1/2001 (2th DoW, 120th DoY)\n'\
+                       'OK: 2/22/2001 (4th DoW, 52th DoY)\n'\
+      )
+
+    def test_strptime_reentrant(self):
+      src=r'''
+        #include <time.h>
+        #include <stdio.h>
+        #include <string.h>
+        #include <stdlib.h>
+
+        int main () {
+          int result = 0;
+          struct tm tm;
+
+          memset (&tm, 0xaa, sizeof (tm));
+
+          /* Test we don't crash on uninitialized struct tm.
+             Some fields might contain bogus values until everything
+             needed is initialized, but we shouldn't crash.  */
+          if (strptime ("2007", "%Y", &tm) == NULL
+              || strptime ("12", "%d", &tm) == NULL
+              || strptime ("Feb", "%b", &tm) == NULL
+              || strptime ("13", "%M", &tm) == NULL
+              || strptime ("21", "%S", &tm) == NULL
+              || strptime ("16", "%H", &tm) == NULL) {
+            printf("ERR: returned NULL");
+            exit(EXIT_FAILURE);
+          }
+
+          if (tm.tm_sec != 21 || tm.tm_min != 13 || tm.tm_hour != 16
+              || tm.tm_mday != 12 || tm.tm_mon != 1 || tm.tm_year != 107
+              || tm.tm_wday != 1 || tm.tm_yday != 42) {
+            printf("ERR: unexpected tm content (1) - %d/%d/%d %d:%d:%d", tm.tm_mon+1, tm.tm_mday, tm.tm_year+1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
+            exit(EXIT_FAILURE);
+          }
+
+          if (strptime ("8", "%d", &tm) == NULL) {
+            printf("ERR: strptime failed");
+            exit(EXIT_FAILURE);
+          }
+
+          if (tm.tm_sec != 21 || tm.tm_min != 13 || tm.tm_hour != 16
+              || tm.tm_mday != 8 || tm.tm_mon != 1 || tm.tm_year != 107
+              || tm.tm_wday != 4 || tm.tm_yday != 38) {
+            printf("ERR: unexpected tm content (2) - %d/%d/%d %d:%d:%d", tm.tm_mon+1, tm.tm_mday, tm.tm_year+1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
+            exit(EXIT_FAILURE);
+          }
+
+          printf("OK");
+        }
+      '''
+      self.do_run(src, 'OK')
+
     def test_intentional_fault(self):
       # Some programs intentionally segfault themselves, we should compile that into a throw
       src = r'''
@@ -6838,84 +6974,9 @@ def process(filename):
       self.emcc_args += ['--embed-file', 'three_numbers.txt']
       self.do_run(src, 'match = 3\nx = -1.0, y = 0.1, z = -0.1\n')
 
-    def test_folders(self):
-      add_pre_run = '''
-def process(filename):
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    \'\'\'
-      FS.createFolder('/', 'test', true, false);
-      FS.createPath('/', 'test/hello/world/', true, false);
-      FS.createPath('/test', 'goodbye/world/', true, false);
-      FS.createPath('/test/goodbye', 'noentry', false, false);
-      FS.createDataFile('/test', 'freeforall.ext', 'abc', true, true);
-      FS.createDataFile('/test', 'restricted.ext', 'def', false, false);
-    \'\'\'
-  )
-  open(filename, 'w').write(src)
-'''
-      src = r'''
-        #include <stdio.h>
-        #include <dirent.h>
-        #include <errno.h>
-
-        int main() {
-          struct dirent *e;
-
-          // Basic correct behaviour.
-          DIR* d = opendir("/test");
-          printf("--E: %d\n", errno);
-          while ((e = readdir(d))) puts(e->d_name);
-          printf("--E: %d\n", errno);
-
-          // Empty folder; tell/seek.
-          puts("****");
-          d = opendir("/test/hello/world/");
-          e = readdir(d);
-          puts(e->d_name);
-          int pos = telldir(d);
-          e = readdir(d);
-          puts(e->d_name);
-          seekdir(d, pos);
-          e = readdir(d);
-          puts(e->d_name);
-
-          // Errors.
-          puts("****");
-          printf("--E: %d\n", errno);
-          d = opendir("/test/goodbye/noentry");
-          printf("--E: %d, D: %d\n", errno, d);
-          d = opendir("/i/dont/exist");
-          printf("--E: %d, D: %d\n", errno, d);
-          d = opendir("/test/freeforall.ext");
-          printf("--E: %d, D: %d\n", errno, d);
-          while ((e = readdir(d))) puts(e->d_name);
-          printf("--E: %d\n", errno);
-
-          return 0;
-        }
-        '''
-      expected = '''
-        --E: 0
-        .
-        ..
-        hello
-        goodbye
-        freeforall.ext
-        restricted.ext
-        --E: 0
-        ****
-        .
-        ..
-        ..
-        ****
-        --E: 0
-        --E: 13, D: 0
-        --E: 2, D: 0
-        --E: 20, D: 0
-        --E: 9
-      '''
-      self.do_run(src, re.sub('(^|\n)\s+', '\\1', expected), post_build=add_pre_run)
+    def test_readdir(self):
+      src = open(path_from_root('tests', 'dirent', 'test_readdir.c'), 'r').read()
+      self.do_run(src, 'success', force_c=True)
 
     def test_stat(self):
       add_pre_run = '''
@@ -6950,20 +7011,9 @@ def process(filename):
       self.do_run(src, expected, post_build=add_pre_run, extra_emscripten_args=['-H', 'libc/fcntl.h'])
 
     def test_fcntl_open(self):
-      add_pre_run = '''
-def process(filename):
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    \'\'\'
-      FS.createDataFile('/', 'test-file', 'abcdef', true, true);
-      FS.createFolder('/', 'test-folder', true, true);
-    \'\'\'
-  )
-  open(filename, 'w').write(src)
-'''
       src = open(path_from_root('tests', 'fcntl-open', 'src.c'), 'r').read()
       expected = open(path_from_root('tests', 'fcntl-open', 'output.txt'), 'r').read()
-      self.do_run(src, expected, post_build=add_pre_run, extra_emscripten_args=['-H', 'libc/fcntl.h'])
+      self.do_run(src, expected, force_c=True, extra_emscripten_args=['-H', 'libc/fcntl.h'])
 
     def test_fcntl_misc(self):
       add_pre_run = '''
@@ -7131,49 +7181,8 @@ def process(filename):
       self.do_run(src, re.sub('(^|\n)\s+', '\\1', expected))
 
     def test_utime(self):
-      add_pre_run_and_checks = '''
-def process(filename):
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    \'\'\'
-      var TEST_F1 = FS.createFolder('/', 'writeable', true, true);
-      var TEST_F2 = FS.createFolder('/', 'unwriteable', true, false);
-    \'\'\'
-  ).replace(
-    '// {{POST_RUN_ADDITIONS}}',
-    \'\'\'
-      Module.print('first changed: ' + (TEST_F1.timestamp == 1200000000000));
-      Module.print('second changed: ' + (TEST_F2.timestamp == 1200000000000));
-    \'\'\'
-  )
-  open(filename, 'w').write(src)
-'''
-      src = r'''
-        #include <stdio.h>
-        #include <errno.h>
-        #include <utime.h>
-
-        int main() {
-          struct utimbuf t = {1000000000, 1200000000};
-          char* writeable = "/writeable";
-          char* unwriteable = "/unwriteable";
-
-          utime(writeable, &t);
-          printf("writeable errno: %d\n", errno);
-
-          utime(unwriteable, &t);
-          printf("unwriteable errno: %d\n", errno);
-
-          return 0;
-        }
-        '''
-      expected = '''
-        writeable errno: 0
-        unwriteable errno: 1
-        first changed: true
-        second changed: false
-      '''
-      self.do_run(src, re.sub('(^|\n)\s+', '\\1', expected), post_build=add_pre_run_and_checks)
+      src = open(path_from_root('tests', 'utime', 'test_utime.c'), 'r').read()
+      self.do_run(src, 'success', force_c=True)
 
     def test_utf(self):
       self.banned_js_engines = [SPIDERMONKEY_ENGINE] # only node handles utf well
@@ -7265,38 +7274,6 @@ def process(filename):
         Settings.LINKABLE = linkable # regression check for issue #273
         self.do_run(src, "1 2 3")
 
-    def test_readdir(self):
-      add_pre_run = '''
-def process(filename):
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    "FS.createFolder('', 'test', true, true);\\nFS.createLazyFile( 'test', 'some_file', 'http://localhost/some_file', true, false);\\nFS.createFolder('test', 'some_directory', true, true);"
-  )
-  open(filename, 'w').write(src)
-'''
-
-      src = '''
-        #include <dirent.h>
-        #include <stdio.h>
-
-        int main()
-        {
-            DIR * dir;
-            dirent * entity;
-
-            dir = opendir( "test" );
-
-            while( ( entity = readdir( dir ) ) )
-            {
-                printf( "%s is a %s\\n", entity->d_name, entity->d_type & DT_DIR ? "directory" : "file" );
-            }
-
-            return 0;
-        }
-
-      '''
-      self.do_run(src, ". is a directory\n.. is a directory\nsome_file is a file\nsome_directory is a directory", post_build=add_pre_run)
-
     def test_fs_base(self):
       Settings.INCLUDE_FULL_LIBRARY = 1
       try:
@@ -7353,18 +7330,8 @@ def process(filename):
       self.do_run(src, expected, extra_emscripten_args=['-H', 'libc/unistd.h'])
 
     def test_unistd_ttyname(self):
-      add_pre_run = '''
-def process(filename):
-  import tools.shared as shared
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    open(shared.path_from_root('tests', 'unistd', 'ttyname.js'), 'r').read()
-  )
-  open(filename, 'w').write(src)
-'''
       src = open(path_from_root('tests', 'unistd', 'ttyname.c'), 'r').read()
-      expected = open(path_from_root('tests', 'unistd', 'ttyname.out'), 'r').read()
-      self.do_run(src, expected, post_build=add_pre_run)
+      self.do_run(src, 'success', force_c=True)
 
     def test_unistd_dup(self):
       src = open(path_from_root('tests', 'unistd', 'dup.c'), 'r').read()
@@ -7396,18 +7363,8 @@ def process(filename):
       self.do_run(src, expected)
 
     def test_unistd_isatty(self):
-      add_pre_run = '''
-def process(filename):
-  import tools.shared as shared
-  src = open(filename, 'r').read().replace(
-    '// {{PRE_RUN_ADDITIONS}}',
-    open(shared.path_from_root('tests', 'unistd', 'isatty.js'), 'r').read()
-  )
-  open(filename, 'w').write(src)
-'''
       src = open(path_from_root('tests', 'unistd', 'isatty.c'), 'r').read()
-      expected = open(path_from_root('tests', 'unistd', 'isatty.out'), 'r').read()
-      self.do_run(src, expected, post_build=add_pre_run)
+      self.do_run(src, 'success', force_c=True)
 
     def test_unistd_sysconf(self):
       src = open(path_from_root('tests', 'unistd', 'sysconf.c'), 'r').read()
diff --git a/tests/unistd/isatty.c b/tests/unistd/isatty.c
index cc1ff641..191036e9 100644
--- a/tests/unistd/isatty.c
+++ b/tests/unistd/isatty.c
@@ -1,28 +1,28 @@
-#include <stdio.h>
+#include <assert.h>
 #include <errno.h>
-#include <unistd.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 int main() {
-  printf("read: %d\n", isatty(open("/read", O_RDONLY)));
-  printf("errno: %d\n", errno);
-  errno = 0;
+  int err;
+
+  err = isatty(-1);
+  assert(!err);
+  assert(errno == EBADF);
 
-  printf("write: %d\n", isatty(open("/write", O_WRONLY)));
-  printf("errno: %d\n", errno);
-  errno = 0;
+  err = isatty(open("/dev/stdin", O_RDONLY));
+  assert(err == 1);
 
-  printf("all: %d\n", isatty(open("/all", O_RDONLY)));
-  printf("errno: %d\n", errno);
-  errno = 0;
+  err = isatty(open("/dev/null", O_RDONLY));
+  assert(!err);
 
-  printf("folder: %d\n", isatty(open("/folder", O_RDONLY)));
-  printf("errno: %d\n", errno);
-  errno = 0;
+  err = isatty(open("/dev", O_RDONLY));
+  assert(!err);
 
-  printf("file: %d\n", isatty(open("/file", O_RDONLY)));
-  printf("errno: %d\n", errno);
-  errno = 0;
+  puts("success");
 
-  return 0;
-}
+  return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/tests/unistd/isatty.js b/tests/unistd/isatty.js
deleted file mode 100644
index d88bd2be..00000000
--- a/tests/unistd/isatty.js
+++ /dev/null
@@ -1,5 +0,0 @@
-FS.createDevice('/', 'read', function() {}, null);
-FS.createDevice('/', 'write', null, function() {});
-FS.createDevice('/', 'all', function() {}, function() {});
-FS.createFolder('/', 'folder', true, true);
-FS.createDataFile('/', 'file', 'test', true, true);
diff --git a/tests/unistd/isatty.out b/tests/unistd/isatty.out
deleted file mode 100644
index 6823c1f0..00000000
--- a/tests/unistd/isatty.out
+++ /dev/null
@@ -1,10 +0,0 @@
-read: 0
-errno: 25
-write: 0
-errno: 25
-all: 0
-errno: 25
-folder: 0
-errno: 25
-file: 0
-errno: 25
diff --git a/tests/unistd/ttyname.c b/tests/unistd/ttyname.c
index 7080be5d..b7cc27bd 100644
--- a/tests/unistd/ttyname.c
+++ b/tests/unistd/ttyname.c
@@ -1,51 +1,43 @@
-#include <stdio.h>
+#include <assert.h>
 #include <errno.h>
-#include <unistd.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 int main() {
+  int err;
+  int stdin, null, dev;
   char buffer[256];
-  int d = open("/device", O_RDWR);
-  int f = open("/", O_RDONLY);
   char* result;
 
+  stdin = open("/dev/stdin", O_RDONLY);
+  null = open("/dev/null", O_RDONLY);
+  dev = open("/dev", O_RDONLY);
+
   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;
+  assert(!strcmp(result, "/dev/tty"));
+
+  // strstr instead of strcmp as native code may
+  // be using a virtual console (e.g. /dev/tty02)
+  err = ttyname_r(stdin, buffer, 256);
+  assert(!err);
+  assert(strstr(buffer, "/dev/tty"));
+
+  err = ttyname_r(stdin, buffer, 2);
+  assert(err == ERANGE);
+
+  result = ttyname(stdin);
+  assert(strstr(result, "/dev/tty"));
+
+  result = ttyname(null);
+  assert(!result);
+
+  result = ttyname(dev);
+  assert(!result);
+
+  puts("success");
+
+  return EXIT_SUCCESS;
 }
diff --git a/tests/unistd/ttyname.js b/tests/unistd/ttyname.js
deleted file mode 100644
index a21f417f..00000000
--- a/tests/unistd/ttyname.js
+++ /dev/null
@@ -1 +0,0 @@
-FS.createDevice('/', 'device', function() {}, function() {});
diff --git a/tests/unistd/ttyname.out b/tests/unistd/ttyname.out
deleted file mode 100644
index b47cbf75..00000000
--- a/tests/unistd/ttyname.out
+++ /dev/null
@@ -1,5 +0,0 @@
-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/utime/test_utime.c b/tests/utime/test_utime.c
new file mode 100644
index 00000000..1793f4a5
--- /dev/null
+++ b/tests/utime/test_utime.c
@@ -0,0 +1,53 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <utime.h>
+#include <sys/stat.h>
+
+void setup() {
+  mkdir("writeable", 0777);
+  mkdir("unwriteable", 0111);
+}
+
+void cleanup() {
+  rmdir("writeable");
+  rmdir("unwriteable");
+}
+
+void test() {
+  struct stat s;
+  // currently, the most recent timestamp is shared for atime,
+  // ctime and mtime. using unique values for each in the test
+  // will fail
+  struct utimbuf t = {1000000000, 1000000000};
+
+  utime("writeable", &t);
+  assert(!errno);
+  memset(&s, 0, sizeof s);
+  stat("writeable", &s);
+  assert(s.st_atime == t.actime);
+  assert(s.st_mtime == t.modtime);
+
+  // write permissions aren't checked when setting node
+  // attributes unless the user uid isn't the owner (so
+  // therefor, this should work fine)
+  utime("unwriteable", &t);
+  assert(!errno);
+  memset(&s, 0, sizeof s);
+  stat("unwriteable", &s);
+  assert(s.st_atime == t.actime);
+  assert(s.st_mtime == t.modtime);
+
+  puts("success");
+}
+
+int main() {
+  atexit(cleanup);
+  signal(SIGABRT, cleanup);
+  setup();
+  test();
+  return EXIT_SUCCESS;
+}
\ No newline at end of file