[t:4944] closes #4944. Remove all windows code and libraries.

We can resurrect this if necessary in the future and we want to support windows.
Right now it just gets in the way and makes checkouts larger."


git-svn-id: file:///svn/toku/tokudb@43969 c7de825b-a66e-492c-adef-691d508d4ae1

portability/tests/test-filesystem-sizes.c

-../../windows/tests/test-filesystem-sizes.c
\ No newline at end of file

portability/tests/test-filesystem-sizes.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#define _CRT_SECURE_NO_DEPRECATE
+#include <test.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <toku_stdint.h>
+#include <unistd.h>
+#include <toku_assert.h>
+#include "toku_os.h"
+
+int test_main(int argc, char *const argv[]) {
+    int verbose = 0;
+    int limit = 1;
+
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
+            verbose = 1;
+            continue;
+        }
+        if (strcmp(argv[i], "--timeit") == 0) {
+            limit = 100000;
+            continue;
+        }
+    }
+
+    int r;
+
+#if 0
+    r = toku_get_filesystem_sizes(NULL, NULL, NULL, NULL);
+    assert(r == EFAULT);
+#endif
+
+    r = toku_get_filesystem_sizes(".", NULL, NULL, NULL);
+    assert(r == 0);
+
+    uint64_t free_size = 0, avail_size = 0, total_size = 0;
+    for (int i = 0; i < limit; i++) {
+        r = toku_get_filesystem_sizes(".", &avail_size, &free_size, &total_size);
+        assert(r == 0);
+        assert(avail_size <= free_size && free_size <= total_size);
+    }
+    if (verbose) {
+        printf("avail=%"PRIu64"\n", avail_size);
+        printf("free=%"PRIu64"\n", free_size);
+        printf("total=%"PRIu64"\n", total_size);
+    }
+
+    return 0;
+}

portability/tests/test-fsync.c

-../../windows/tests/test-fsync.c
\ No newline at end of file

portability/tests/test-fsync.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#include "test.h"
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include "toku_time.h"
+
+
+int verbose = 0;
+static void
+create_files(int N, int fds[N]) {
+    int r;
+    int i;
+    char name[30];
+    for (i = 0; i < N; i++) {
+        snprintf(name, sizeof(name), "%d", i);
+        fds[i] = open(name, O_CREAT|O_WRONLY);
+        if (fds[i] < 0) {
+            r = errno;
+            CKERR(r);
+        }
+    }
+}
+
+static void
+write_to_files(int N, int bytes, int fds[N]) {
+    char junk[bytes];
+
+    int i;
+    for (i = 0; i < bytes; i++) {
+        junk[i] = random() & 0xFF;
+    }
+
+    int r;
+    for (i = 0; i < N; i++) {
+        r = toku_os_write(fds[i], junk, bytes);
+        CKERR(r);
+    }
+}
+
+static void
+time_many_fsyncs_one_file(int N, int bytes, int fds[N]) {
+    if (verbose>1) {
+        printf("Starting %s\n", __FUNCTION__);
+        fflush(stdout);
+    }
+    struct timeval begin;
+    struct timeval after_first;
+    struct timeval end;
+    write_to_files(1, bytes, fds);
+    if (verbose>1) {
+        printf("Done writing to os buffers\n");
+        fflush(stdout);
+    }
+    int i;
+    int r;
+
+    r = gettimeofday(&begin, NULL);
+    CKERR(r);
+    r = fsync(fds[0]);
+    CKERR(r);
+    r = gettimeofday(&after_first, NULL);
+    CKERR(r);
+    for (i = 0; i < N; i++) {
+        r = fsync(fds[0]);
+        CKERR(r);
+    }
+    r = gettimeofday(&end, NULL);
+    CKERR(r);
+
+    if (verbose) {
+        printf("Fsyncing one file %d times:\n"
+               "\tFirst fsync took: [%f] seconds\n"
+               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
+               "\tTotal time [%f] seconds\n",
+               N + 1,
+               toku_tdiff(&after_first, &begin),
+               N, 
+               toku_tdiff(&end, &after_first),
+               toku_tdiff(&end, &begin));
+        fflush(stdout);
+    }
+}
+
+static void
+time_fsyncs_many_files(int N, int bytes, int fds[N]) {
+    if (verbose>1) {
+        printf("Starting %s\n", __FUNCTION__);
+        fflush(stdout);
+    }
+    write_to_files(N, bytes, fds);
+    if (verbose>1) {
+        printf("Done writing to os buffers\n");
+        fflush(stdout);
+    }
+    struct timeval begin;
+    struct timeval after_first;
+    struct timeval end;
+    int i;
+    int r;
+
+    r = gettimeofday(&begin, NULL);
+    CKERR(r);
+    for (i = 0; i < N; i++) {
+        r = fsync(fds[i]);
+        CKERR(r);
+        if (i==0) {
+            r = gettimeofday(&after_first, NULL);
+            CKERR(r);
+        }
+        if (verbose>2) {
+            printf("Done fsyncing %d\n", i);
+            fflush(stdout);
+        }
+    }
+    r = gettimeofday(&end, NULL);
+    CKERR(r);
+    if (verbose) {
+        printf("Fsyncing %d files:\n"
+               "\tFirst fsync took: [%f] seconds\n"
+               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
+               "\tTotal time [%f] seconds\n",
+               N,
+               toku_tdiff(&after_first, &begin),
+               N-1,
+               toku_tdiff(&end, &after_first),
+               toku_tdiff(&end, &begin));
+        fflush(stdout);
+    }
+}
+
+#if !TOKU_WINDOWS
+//sync() does not appear to have an analogue on windows.
+static void
+time_sync_fsyncs_many_files(int N, int bytes, int fds[N]) {
+    if (verbose>1) {
+        printf("Starting %s\n", __FUNCTION__);
+        fflush(stdout);
+    }
+    //TODO: timing
+    write_to_files(N, bytes, fds);
+    if (verbose>1) {
+        printf("Done writing to os buffers\n");
+        fflush(stdout);
+    }
+    int i;
+    int r;
+    struct timeval begin;
+    struct timeval after_sync;
+    struct timeval end;
+
+    r = gettimeofday(&begin, NULL);
+    CKERR(r);
+
+    sync();
+
+    r = gettimeofday(&after_sync, NULL);
+    CKERR(r);
+    if (verbose>1) {
+        printf("Done with sync()\n");
+        fflush(stdout);
+    }
+
+    for (i = 0; i < N; i++) {
+        r = fsync(fds[i]);
+        CKERR(r);
+        if (verbose>2) {
+            printf("Done fsyncing %d\n", i);
+            fflush(stdout);
+        }
+    }
+    r = gettimeofday(&end, NULL);
+    CKERR(r);
+
+    if (verbose) {
+        printf("sync() then fsyncing %d files:\n"
+               "\tsync() took: [%f] seconds\n"
+               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
+               "\tTotal time [%f] seconds\n",
+               N,
+               toku_tdiff(&after_sync, &begin),
+               N,
+               toku_tdiff(&end, &after_sync),
+               toku_tdiff(&end, &begin));
+        fflush(stdout);
+    }
+}
+#endif
+
+int test_main(int argc, char *const argv[]) {
+    int i;
+    int r;
+    int N = 1000;
+    int bytes = 4096;
+    for (i=1; i<argc; i++) {
+        if (strcmp(argv[i], "-v") == 0) {
+            if (verbose < 0) verbose = 0;
+            verbose++;
+            continue;
+        }
+        if (strcmp(argv[i], "-q") == 0) {
+            verbose = 0;
+            continue;
+        }
+        if (strcmp(argv[i], "-b") == 0) {
+            i++;
+            if (i>=argc) exit(1);
+            bytes = atoi(argv[i]);
+            if (bytes <= 0)  exit(1);
+            continue;
+        }
+        if (strcmp(argv[i], "-n") == 0) {
+            i++;
+            if (i>=argc) exit(1);
+            N = atoi(argv[i]);
+            if (N <= 0)  exit(1);
+            continue;
+        }
+    }
+    r = system("rm -rf " ENVDIR);
+    CKERR(r);
+    r = toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
+    CKERR(r);
+    r = chdir(ENVDIR);
+    CKERR(r);
+
+    int fds[N];
+    create_files(N, fds);
+
+    time_many_fsyncs_one_file(N, bytes, fds);
+    time_fsyncs_many_files(N, bytes, fds);
+#if !TOKU_WINDOWS
+    time_sync_fsyncs_many_files(N, bytes, fds);
+#endif
+
+    return 0;
+}

portability/tests/test-pthread-rwlock-rdlock.c

-../../windows/tests/test-pthread-rwlock-rdlock.c
\ No newline at end of file

portability/tests/test-pthread-rwlock-rdlock.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#include <test.h>
+#include <toku_assert.h>
+#include <toku_pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int test_main(int argc __attribute__((__unused__)), char *const argv[] __attribute__((__unused__))) {
+    toku_pthread_rwlock_t rwlock;
+
+    toku_pthread_rwlock_init(&rwlock, NULL);
+    toku_pthread_rwlock_rdlock(&rwlock);
+    toku_pthread_rwlock_rdlock(&rwlock);
+    toku_pthread_rwlock_rdunlock(&rwlock);
+    toku_pthread_rwlock_rdunlock(&rwlock);
+    toku_pthread_rwlock_destroy(&rwlock);
+
+    return 0;
+}
+

portability/tests/test-pthread-rwlock-rwr.c

-../../windows/tests/test-pthread-rwlock-rwr.c
\ No newline at end of file

portability/tests/test-pthread-rwlock-rwr.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#include <test.h>
+#include <toku_assert.h>
+#include <toku_pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+// write a test see if things happen in the right order.
+
+volatile int state = 0;
+int verbose = 0;
+
+static void *f(void *arg) {
+    toku_pthread_rwlock_t *mylock = arg;
+    sleep(2);
+    assert(state==42); state = 16; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    toku_pthread_rwlock_wrlock(mylock);
+    assert(state==49); state = 17; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    toku_pthread_rwlock_wrunlock(mylock);
+    sleep(10);
+    assert(state==52); state = 20; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    return arg;
+}
+
+int test_main(int argc , char *const argv[] ) {
+    assert(argc==1 || argc==2);
+    if (argc==2) {
+	assert(strcmp(argv[1],"-v")==0);
+	verbose = 1;
+    }
+    int r;
+    toku_pthread_rwlock_t rwlock;
+    toku_pthread_t tid;
+    void *retptr;
+
+    toku_pthread_rwlock_init(&rwlock, NULL);
+    state = 37; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    toku_pthread_rwlock_rdlock(&rwlock);
+
+    r = toku_pthread_create(&tid, NULL, f, &rwlock); assert(r == 0);
+
+    assert(state==37); state = 42; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    sleep(4);
+    assert(state==16); state = 44; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    toku_pthread_rwlock_rdlock(&rwlock);
+    assert(state==44); state = 46; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+    toku_pthread_rwlock_rdunlock(&rwlock);
+    sleep(4);
+    assert(state==46); state=49; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__); // still have a read lock
+    toku_pthread_rwlock_rdunlock(&rwlock);
+    sleep(6);
+    assert(state==17); state=52; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
+
+    r = toku_pthread_join(tid, &retptr); assert(r == 0);
+
+    toku_pthread_rwlock_destroy(&rwlock);
+    
+    return 0;
+}

portability/tests/test-pwrite4g.c

-../../windows/tests/test-pwrite4g.c
\ No newline at end of file

portability/tests/test-pwrite4g.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+/* Verify that toku_os_full_pwrite does the right thing when writing beyond 4GB.  */
+#include <test.h>
+#include <fcntl.h>
+#include <toku_assert.h>
+#include <string.h>
+#include <stdio.h>
+
+static int iszero(char *cp, size_t n) {
+    size_t i;
+    for (i=0; i<n; i++)
+        if (cp[i] != 0) 
+	    return 0;
+    return 1;
+}
+
+int test_main(int argc, char *const argv[]) {
+    assert(argc==2); // first arg is the directory to put the data file into.
+    char short_fname[] = "pwrite4g.data";
+    int fname_len = strlen(short_fname) + strlen(argv[1]) + 5;
+    char fname[fname_len];
+    snprintf(fname, fname_len, "%s/%s", argv[1], short_fname);
+    int r;
+    unlink(fname);
+    int fd = open(fname, O_RDWR | O_CREAT | O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO);
+    assert(fd>=0);
+    char buf[] = "hello";
+    int64_t offset = (1LL<<32) + 100;
+    toku_os_full_pwrite(fd, buf, sizeof buf, offset);
+    char newbuf[sizeof buf];
+    r = pread(fd, newbuf, sizeof newbuf, 100);
+    assert(r==sizeof newbuf);
+    assert(iszero(newbuf, sizeof newbuf));
+    r = pread(fd, newbuf, sizeof newbuf, offset);
+    assert(r==sizeof newbuf);
+    assert(memcmp(newbuf, buf, sizeof newbuf) == 0);
+    int64_t fsize;
+    r = toku_os_get_file_size(fd, &fsize);
+    assert(r == 0);
+    assert(fsize > 100 + (signed)sizeof(buf));
+    r = close(fd);
+    assert(r==0);
+    return 0;
+}

portability/tests/test-snprintf.c

-../../windows/tests/test-snprintf.c
\ No newline at end of file

portability/tests/test-snprintf.c

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
+
+#include <test.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <toku_portability.h>
+#include <toku_assert.h>
+#include <toku_os.h>
+
+static void
+check_snprintf(int i) {
+    char buf_before[8];
+    char target[5];
+    char buf_after[8];
+    memset(target, 0xFF, sizeof(target));
+    memset(buf_before, 0xFF, sizeof(buf_before));
+    memset(buf_after, 0xFF, sizeof(buf_after));
+    int64_t n = 1;
+    
+    int j;
+    for (j = 0; j < i; j++) n *= 10;
+
+    int bytes = snprintf(target, sizeof target, "%"PRId64, n);
+    assert(bytes==i+1 ||
+           (i+1>=(int)(sizeof target) && bytes>=(int)(sizeof target)));
+    if (bytes>=(int)(sizeof target)) {
+        //Overflow prevented by snprintf
+        assert(target[sizeof target - 1] == '\0');
+        assert(strlen(target)==sizeof target-1);
+    }
+    else {
+        assert(target[bytes] == '\0');
+        assert(strlen(target)==(size_t)bytes);
+    }
+}
+
+
+int test_main(int argc __attribute__((__unused__)), char *const argv[] __attribute__((__unused__))) {
+    int i;
+    for (i = 0; i < 8; i++) {
+        check_snprintf(i);
+    }
+    return 0;
+}
+

portability/tests/test.h

-../../windows/tests/test.h
\ No newline at end of file

portability/tests/test.h

+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: expandtab:ts=8:sw=4:softtabstop=4:
+#include <toku_portability.h>
+#include <toku_assert.h>
+
+#define CKERR(r) ({ int __r = r; if (__r!=0) fprintf(stderr, "%s:%d error %d %s\n", __FILE__, __LINE__, __r, strerror(r)); assert(__r==0); })
+#define CKERR2(r,r2) do { if (r!=r2) fprintf(stderr, "%s:%d error %d %s, expected %d\n", __FILE__, __LINE__, r, strerror(r), r2); assert(r==r2); } while (0)
+#define CKERR2s(r,r2,r3) do { if (r!=r2 && r!=r3) fprintf(stderr, "%s:%d error %d %s, expected %d or %d\n", __FILE__, __LINE__, r, strerror(r), r2,r3); assert(r==r2||r==r3); } while (0)
+
+#define DEBUG_LINE do { \
+    fprintf(stderr, "%s() %s:%d\n", __FUNCTION__, __FILE__, __LINE__); \
+    fflush(stderr); \
+} while (0)
+
+int test_main(int argc, char *const argv[]);
+
+int
+main(int argc, char *const argv[]) {
+    int ri = toku_portability_init();
+    assert(ri==0);
+    int r = test_main(argc, argv);
+    int rd = toku_portability_destroy();
+    assert(rd==0);
+    return r;
+}
+

windows/Makefile

-# -*- Mode: Makefile -*-
-
-.DEFAULT_GOAL=install
-TOKUROOT=../
-INCLUDEDIRS=-I. -I$(TOKUROOT)ft
-SKIP_LIBPORTABILITYRULE=1
-include $(TOKUROOT)toku_include/Makefile.include
-
-OPT_AROPT=-qnoipo #Disable ipo for lib creation even when optimization is on.
-
-SRCS = $(wildcard *.c)
-OBJS = $(patsubst %.c,%.$(OEXT),$(SRCS))
-TARGET = libtokuportability.$(AEXT)
-
-build install: $(LIBPORTABILITY) $(PTHREAD_LIB)
-
-PTHREAD_LIB_CRUNTIME=$(TOKUROOT)windows/lib/$(CRUNTIME)/pthreadVC2.dll
-$(PTHREAD_LIB): $(PTHREAD_LIB_CRUNTIME)
-	cp -u $< $@
-
-$(LIBPORTABILITY): $(TARGET)
-	cp -u $< $@
-
-$(TARGET): $(OBJS)
-
-check: $(TARGET)
-	cd tests && $(MAKE) check
-
-$(OBJS): CPPFLAGS += -DTOKU_WINDOWS_ALLOW_DEPRECATED
-file.obj: CPPFLAGS += -DDONT_DEPRECATE_WRITES
-
-clean:
-	rm -rf $(TARGET) $(LIBPORTABILITY) $(PTHREAD_LIB)
-	cd tests && $(MAKE) clean

windows/dirent.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef _TOKU_DIRENT_H
-#define _TOKU_DIRENT_H
-
-#include "toku_os_types.h"
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-//The DIR functions do not exist in windows, but the Linux API ends up
-//just using a wrapper.  We might convert these into an toku_os_* type api.
-
-enum {
-    DT_UNKNOWN = 0,
-    DT_DIR     = 4,
-    DT_REG     = 8
-};
-
-struct dirent {
-    char          d_name[_MAX_PATH];
-    unsigned char d_type;
-};
-
-struct __toku_windir;
-typedef struct __toku_windir DIR;
-
-
-DIR *opendir(const char *name);
-
-struct dirent *readdir(DIR *dir);
-
-int closedir(DIR *dir);
-
-#ifndef NAME_MAX
-#define NAME_MAX 255
-#endif
-
-#if defined(__cplusplus)
-};
-#endif
-
-#endif
-

windows/dirs.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <toku_portability.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <toku_assert.h>
-#include <errno.h>
-#include <direct.h>
-#include <dirent.h>
-#include <io.h>
-#include <sys/stat.h>
-#include <windows.h>
-
-struct __toku_windir {
-    struct dirent         ent;
-    struct _finddatai64_t data;
-    intptr_t              handle;
-    BOOL                  finished;
-};
-
-DIR*
-opendir(const char *name) {
-    char *format = NULL;
-    DIR *result = malloc(sizeof(*result));
-    int r;
-    if (!result) {
-        r = ENOMEM;
-        goto cleanup;
-    }
-    format = malloc(strlen(name)+2+1); //2 for /*, 1 for '\0'
-    if (!format) {
-        r = ENOMEM;
-        goto cleanup;
-    }
-    strcpy(format, name);
-    if (format[strlen(format)-1]=='/') format[strlen(format)-1]='\0';
-    strcat(format, "/*");
-    result->handle = _findfirsti64(format, &result->data);
-    // printf("%s:%d %p %d\n", __FILE__, __LINE__, result->handle, errno); fflush(stdout);
-    if (result->handle==-1L) {
-        if (errno==ENOENT) {
-            int64_t r_stat;
-            //ENOENT can mean a good directory with no files, OR
-            //a directory that does not exist.
-            struct _stat64 buffer;
-            format[strlen(format)-3] = '\0'; //Strip the "/*"
-            r_stat = _stati64(format, &buffer);
-            if (r_stat==0) {
-                //Empty directory.
-                result->finished = TRUE;
-                r = 0;
-                goto cleanup;
-            }
-        }
-        r = errno;
-        assert(r!=0);
-        goto cleanup;
-    }
-    result->finished = FALSE;
-    r = 0;
-cleanup:
-    if (r!=0) {
-        if (result) free(result);
-        result = NULL;
-    }
-    if (format) free(format);
-    return result;
-}
-
-struct dirent*
-readdir(DIR *dir) {
-    struct dirent *result;
-    int r;
-    if (dir->finished) {
-        errno = ENOENT;
-        result = NULL;
-        goto cleanup;
-    }
-    assert(dir->handle!=-1L);
-    strcpy(dir->ent.d_name, dir->data.name);
-    if (dir->data.attrib&_A_SUBDIR) dir->ent.d_type=DT_DIR;
-    else                            dir->ent.d_type=DT_REG;
-    r = _findnexti64(dir->handle, &dir->data);
-    if (r==-1L) dir->finished = TRUE;
-    result = &dir->ent;
-cleanup:
-    return result;
-}
-
-int
-closedir(DIR *dir) {
-    int r;
-    if (dir->handle==-1L) r = 0;
-    else r = _findclose(dir->handle);
-    free(dir);
-    return r;
-}
-
-#define SUPPORT_CYGWIN_STYLE_STAT 0
-#define CYGWIN_ROOT_DIR_PREFIX "c:/cygwin"
-#define CYGDRIVE_PREFIX        "/cygdrive/"
-
-int
-toku_stat(const char *name, toku_struct_stat *statbuf) {
-    char new_name[strlen(name) + sizeof(CYGWIN_ROOT_DIR_PREFIX)];
-    int bytes;
-#if SUPPORT_CYGWIN_STYLE_STAT
-    if (name[0] == '/') {
-        char *cygdrive = strstr(name, CYGDRIVE_PREFIX);
-        if (cygdrive==name && isalpha(name[strlen(CYGDRIVE_PREFIX)]))
-             bytes = snprintf(new_name, sizeof(new_name), "%c:%s", name[strlen(CYGDRIVE_PREFIX)], name+strlen(CYGDRIVE_PREFIX)+1); //handle /cygdrive/DRIVELETTER
-        else bytes = snprintf(new_name, sizeof(new_name), "%s%s", CYGWIN_ROOT_DIR_PREFIX, name);                  //handle /usr/local (for example)
-    }
-    else
-#endif
-             bytes = snprintf(new_name, sizeof(new_name), "%s", name);                                            //default
-    //Verify no overflow
-    assert(bytes>=0);
-    assert((size_t)bytes < sizeof(new_name));
-    int needdir = 0;
-    if (bytes>1 && new_name[bytes-1]=='/') {
-        //Strip trailing '/', but this implies it is a directory.
-        new_name[bytes-1] = '\0';
-        needdir = 1;
-    }
-    toku_struct_stat temp;
-    int r = _stati64(new_name, &temp);
-    if (r==0 && needdir && !(temp.st_mode&_S_IFDIR)) {
-        r = -1;
-        errno = ENOENT;
-    }
-    if (r==0) *statbuf = temp;
-    return r;
-}
-
-int
-toku_fstat(int fd, toku_struct_stat *statbuf) {
-    int r = _fstati64(fd, statbuf);
-    return r;
-}
-
-int
-toku_fsync_dirfd_without_accounting(DIR *dirp) {
-    //Believed to not be supported in windows.
-    //Possibly not needed
-    return 0;
-}
-
-int
-toku_fsync_directory(const char *UU(fname)) {
-    return 0; // toku_fsync_dirfd
-}
-
-int
-toku_fsync_dir_by_name_without_accounting(const char *dir_name) {
-    //Believed to not be supported in windows.
-    //Possibly not needed
-    return 0;
-}
-

windows/endian.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
-#ifndef ENDIAN_H
-#define ENDIAN_H
-
-#if defined(__BYTE_ORDER) || defined(__LITTLE_ENDIAN) || defined(__BIG_ENDIAN)
-#error Standards are defined for some reason
-#endif
-
-//Windows does not exist for big endian machines, only little endian
-#define __LITTLE_ENDIAN (0x01020304)
-#define __BIG_ENDIAN    (0x04030201)
-#define __BYTE_ORDER    (__LITTLE_ENDIAN)
-
-
-#endif
-

windows/env.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <toku_portability.h>
-#include <windows.h>
-#include <toku_stdlib.h>
-#include <toku_assert.h>
-
-int
-setenv(const char *name, const char *value, int overwrite) {
-    char * current = getenv(name);
-    BOOL exists = current!=NULL;
-
-    int r;
-    if (overwrite || !exists) {
-        char setstring[sizeof("=") + strlen(name) + strlen(value)];
-        int bytes = snprintf(setstring, sizeof(setstring), "%s=%s", name, value);
-        assert(bytes>=0);
-        assert((size_t)bytes < sizeof(setstring));
-        r = _putenv(setstring);
-        if (r==-1) {
-            errno = GetLastError();
-            goto cleanup;
-        }
-    }
-    r = 0;
-cleanup:
-    return r;
-}
-
-int
-unsetenv(const char *name) {
-    int r = setenv(name, "", 1);
-    return r;
-}
-

windows/getopt.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <toku_portability.h>
-#include <stdio.h>
-#include <unistd.h>
-
-char *optarg;
-int optind;
-
-static const char *match(char c, const char *optstring) {
-    int i;
-    for (i=0;optstring[i]; i++)
-        if (c == optstring[i])
-            return &optstring[i];
-    return 0;
-}
-
-int getopt(int argc, char * const argv[], const char *optstring) {
-    static int nextargc = 0;
-    static int nextchar = 0;
-    char *arg;
-    const char *theopt;
-
-    // first time initialization
-    if (nextargc == 0) {
-        nextargc = 1;
-        optind = 1;
-        nextchar = 0;
-    }
-
-again:
-    optarg = 0;
-    optind = nextargc;
-    // last arg
-    if (nextargc >= argc)
-        return -1;
-
-    arg = argv[nextargc];
-    if (!arg[nextchar]) {
-        nextargc++;
-        nextchar = 0;
-        goto again;
-    }
-    if (!nextchar) {
-        // not an option
-        if (arg[0] != '-')
-            return -1;
-        // end of options "--"
-        if (arg[1] == '-') {
-            nextargc++;
-            optind = nextargc;
-            return -1;
-        }
-        nextchar = 1;
-    }
-    // try to match the arg with the options
-    theopt = match(arg[nextchar++], optstring);
-    if (!theopt)
-        return '?';
-
-    if (theopt[1] == ':') {
-        if (arg[nextchar]) {
-            optarg = &arg[nextchar];
-            nextargc++;
-            nextchar = 0;
-        } else if (nextargc >= argc) {
-            nextargc++;
-            nextchar = 0;
-            return -1;
-        } else {
-            nextargc++;
-            nextchar = 0;
-            optarg = argv[nextargc++];
-        }
-    }
-    return theopt[0];
-}
-
-    

windows/getopt.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef _TOKUWIN_GETOPT_H
-#define _TOKUWIN_GETOPT_H
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-int
-getopt(int argc, char *const argv[], const char *optstring);
-
-extern char *optarg;
-extern int  optind;
-
-#if defined(__cplusplus)
-};
-#endif
-
-#endif
-

windows/inttypes.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef _INTTYPES_H
-#define _INTTYPES_H
-
-#include <stdint.h>
-
-//Define printf types.
-#define SCNd64 "I64d"
-#define SCNu64 "I64u"
-#define SCNd32 "d"
-#define SCNu32 "u"
-
-#define PRId64 "I64d"
-#define PRIu64 "I64u"
-#define PRIx64 "I64x"
-#define PRIX64 "I64X"
-#define PRId32 "d"
-#define PRIu32 "u"
-#define PRIx32 "x"
-#define PRIX32 "X"
-
-#endif

windows/memory.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ident "Copyright (c) 2007-2011 Tokutek Inc.  All rights reserved."
-
-#include <toku_portability.h>
-#include "memory.h"
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-#include "toku_assert.h"
-#include "toku_pthread.h"
-
-static malloc_fun_t  t_malloc  = 0;
-static malloc_fun_t  t_xmalloc = 0;
-static free_fun_t    t_free    = 0;
-static realloc_fun_t t_realloc = 0;
-static realloc_fun_t t_xrealloc = 0;
-
-static MEMORY_STATUS_S status;
-
-static size_t
-my_malloc_usable_size(void *p) {
-    return p == NULL ? 0 : malloc_usable_size(p);
-}
-
-void 
-toku_memory_get_status(MEMORY_STATUS s) {
-    *s = status;
-}
-
-// max_in_use may be slightly off because use of max_in_use is not thread-safe.
-// It is not worth the overhead to make it completely accurate.
-static inline void 
-set_max(uint64_t sum_used, uint64_t sum_freed) {
-    uint64_t in_use = (sum_used - sum_freed);
-    if ((!(in_use & 0x8000000000000000)) // if wrap due to another thread, ignore bogus "negative" value
-	&& (in_use > status.max_in_use)) {
-	status.max_in_use = in_use;
-    }
-}
-
-void *toku_malloc(size_t size) {
-    void *p = t_malloc ? t_malloc(size) : os_malloc(size);
-    if (p) {
-        size_t used = my_malloc_usable_size(p);
-        __sync_add_and_fetch(&status.malloc_count, 1);
-        __sync_add_and_fetch(&status.requested,size);
-        __sync_add_and_fetch(&status.used, used);
-        set_max(status.used, status.freed);
-    } else {
-        __sync_add_and_fetch(&status.malloc_fail, 1);
-    }
-    return p;
-}
-
-void *
-toku_calloc(size_t nmemb, size_t size) {
-    size_t newsize = nmemb * size;
-    void *p = toku_malloc(newsize);
-    if (p) memset(p, 0, newsize);
-    return p;
-}
-
-void *
-toku_realloc(void *p, size_t size) {
-    size_t used_orig = p ? my_malloc_usable_size(p) : 0;
-    void *q = t_realloc ? t_realloc(p, size) : os_realloc(p, size);
-    if (q) {
-	size_t used = my_malloc_usable_size(q);
-	__sync_add_and_fetch(&status.realloc_count, 1);
-	__sync_add_and_fetch(&status.requested, size);
-	__sync_add_and_fetch(&status.used, used);
-	__sync_add_and_fetch(&status.freed, used_orig);
-	set_max(status.used, status.freed);
-    } else {
-	__sync_add_and_fetch(&status.realloc_fail, 1);
-    }
-    return q;
-}
-
-void *
-toku_memdup(const void *v, size_t len) {
-    void *p = toku_malloc(len);
-    if (p) memcpy(p, v,len);
-    return p;
-}
-
-char *
-toku_strdup(const char *s) {
-    return toku_memdup(s, strlen(s)+1);
-}
-
-void
-toku_free(void *p) {
-    if (p) {
-	size_t used = my_malloc_usable_size(p);
-	__sync_add_and_fetch(&status.free_count, 1);
-	__sync_add_and_fetch(&status.freed, used);
-	if (t_free)
-	    t_free(p);
-	else
-	    os_free(p);
-    }
-}
-
-void
-toku_free_n(void* p, size_t size __attribute__((unused))) {
-    toku_free(p);
-}
-
-void *
-toku_xmalloc(size_t size) {
-    void *p = t_xmalloc ? t_xmalloc(size) : os_malloc(size);
-    if (p == NULL)  // avoid function call in common case
-        resource_assert(p);
-    size_t used = my_malloc_usable_size(p);
-    __sync_add_and_fetch(&status.malloc_count, 1);
-    __sync_add_and_fetch(&status.requested, size);
-    __sync_add_and_fetch(&status.used, used);
-    set_max(status.used, status.freed);
-    return p;
-}
-
-void *
-toku_xcalloc(size_t nmemb, size_t size) {
-    size_t newsize = nmemb * size;
-    void *vp = toku_xmalloc(newsize);
-    if (vp) memset(vp, 0, newsize);
-    return vp;
-}
-
-void *
-toku_xrealloc(void *v, size_t size) {
-    size_t used_orig = v ? my_malloc_usable_size(v) : 0;
-    void *p = t_xrealloc ? t_xrealloc(v, size) : os_realloc(v, size);
-    if (p == 0)  // avoid function call in common case
-        resource_assert(p);
-    size_t used = my_malloc_usable_size(p);
-    __sync_add_and_fetch(&status.realloc_count, 1);
-    __sync_add_and_fetch(&status.requested, size);
-    __sync_add_and_fetch(&status.used, used);
-    __sync_add_and_fetch(&status.freed, used_orig);
-    set_max(status.used, status.freed);
-    return p;
-}
-
-size_t 
-toku_malloc_usable_size(void *p) {
-    return p == NULL ? 0 : malloc_usable_size(p);
-}
-
-void *
-toku_xmemdup (const void *v, size_t len) {
-    void *p = toku_xmalloc(len);
-    memcpy(p, v, len);
-    return p;
-}
-
-char *
-toku_xstrdup (const char *s) {
-    return toku_xmemdup(s, strlen(s)+1);
-}
-
-void
-toku_set_func_malloc(malloc_fun_t f) {
-    t_malloc = f;
-    t_xmalloc = f;
-}
-
-void
-toku_set_func_xmalloc_only(malloc_fun_t f) {
-    t_xmalloc = f;
-}
-
-void
-toku_set_func_malloc_only(malloc_fun_t f) {
-    t_malloc = f;
-}
-
-void
-toku_set_func_realloc(realloc_fun_t f) {
-    t_realloc = f;
-    t_xrealloc = f;
-}
-
-void
-toku_set_func_xrealloc_only(realloc_fun_t f) {
-    t_xrealloc = f;
-}
-
-void
-toku_set_func_realloc_only(realloc_fun_t f) {
-    t_realloc = f;
-
-}
-
-void
-toku_set_func_free(free_fun_t f) {
-    t_free = f;
-}
-
-#include <valgrind/drd.h>
-void __attribute__((constructor)) toku_memory_drd_ignore(void);
-void
-toku_memory_drd_ignore(void) {
-    DRD_IGNORE_VAR(status);
-}

windows/misc.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef _MISC_H
-#define _MISC_H
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#include "toku_os.h"
-#include <sys/stat.h>
-#include <stddef.h>
-
-//These are functions that really exist in windows but are named
-//something else.
-//TODO: Sort these into some .h file that makes sense.
-
-int fsync(int fildes);
-int toku_fsync_init(void);
-int toku_fsync_destroy(void);
-int toku_mkstemp_init(void);
-int toku_mkstemp_destroy(void);
-
-int gettimeofday(struct timeval *tv, struct timezone *tz);
-
-long long int strtoll(const char *nptr, char **endptr, int base);
-
-
-//TODO: Enforce use of these macros. Otherwise, open, creat, and chmod may fail
-//toku_os_mkdir actually ignores the permissions, so it won't fail.
-
-//Permissions
-//User permissions translate to global
-//Execute bit does not exist
-//TODO: Determine if we need to use BINARY mode for opening.
-#define S_IRWXU     S_IRUSR | S_IWUSR | S_IXUSR
-#define S_IRUSR     S_IREAD
-#define S_IWUSR     S_IWRITE
-//Execute bit does not exist
-#define S_IXUSR     (0)
-
-//Group permissions thrown away.
-#define S_IRWXG     S_IRGRP | S_IWGRP | S_IXGRP
-#define S_IRGRP     (0)
-#define S_IWGRP     (0)
-#define S_IXGRP     (0)
-
-//Other permissions thrown away. (Except for read)
-//MySQL defines S_IROTH as S_IREAD.  Avoid the warning.
-#if defined(S_IROTH)
-#undef S_IROTH
-#endif
-#define S_IRWXO     S_IROTH | S_IWOTH | S_IXOTH
-#define S_IROTH     S_IREAD
-#define S_IWOTH     (0)
-#define S_IXOTH     (0)
-
-long int random(void);
-void srandom(unsigned int seed);
-
-//strtoll has a different name in windows.
-#define strtoll     _strtoi64
-#define strtoull    _strtoui64
-
-//rmdir has a different name in windows.
-#define rmdir       _rmdir
-
-#ifndef PATH_MAX
-#define PATH_MAX _MAX_PATH
-#endif
-
-char *realpath(const char *path, char *resolved_path);
-
-
-int unsetenv(const char *name);
-int setenv(const char *name, const char *value, int overwrite);
-
-int vsnprintf(char *str, size_t size, const char *format, va_list ap);
-
-int snprintf(char *str, size_t size, const char *format, ...);
-
-int usleep(unsigned int useconds);
-
-int mkstemp(char * ttemplate);
-
-toku_off_t ftello(FILE *stream);
-
-int strerror_r(int errnum, char *buf, size_t buflen);
-
-#define __builtin_offsetof(type, member) offsetof(type, member)
-
-
-#if defined(__cplusplus)
-};
-#endif
-
-#endif
-

windows/os_malloc.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
-
-#include <toku_portability.h>
-#include <stdlib.h>
-
-#include <string.h>
-#include <malloc.h>
-#include <errno.h>
-
-static inline size_t resize(size_t n) {
-    if (n >= 1*1024*1024) 
-        n = (n+7) & ~7; // round up to make windbg !heap happy
-#define DO_PAD_64K 0
-#if DO_PAD_64K
-    else if (64*1024 <= n && n < 1*1024*1024)
-	n = 1*1024*1024; // map anything >= 64K to 1M
-#endif
-#define DO_ROUND_POW2 1
-#if DO_ROUND_POW2
-    else {
-        // make all buffers a power of 2 in size including the windows overhead
-        size_t r = 0;
-        size_t newn = 1<<r;
-        size_t overhead = 0x24;
-        n += overhead;
-        while (n > newn) {
-            r++;
-            newn = 1<<r;
-        }
-        n = newn - overhead;
-    }
-#endif
-    return n;
-}
-
-void *
-os_malloc(size_t size)
-{
-    return malloc(resize(size));
-}
-
-void *
-os_realloc(void *p, size_t size)
-{
-    return realloc(p, resize(size));
-}
-
-void
-os_free(void* p)
-{
-    free(p);
-}

windows/random.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-//rand_s requires _CRT_RAND_S be defined before including stdlib
-#define _CRT_RAND_S
-
-#include <toku_portability.h>
-#include <stdio.h>
-#include <toku_assert.h>
-#include <stdint.h>
-#include <toku_stdlib.h>
-#include <windows.h>
-
-static int used_srand = 0;
-
-long int
-random(void) {
-    u_int32_t r;
-    if (used_srand) {
-        //rand is a relatively poor number generator, but can be seeded
-        //rand generates 15 bits.  We need 3 calls to generate 31 bits.
-        u_int32_t r1 = rand() & ((1<<15)-1);
-        u_int32_t r2 = rand() & ((1<<15)-1);;
-        u_int32_t r3 = rand() & 0x1;
-        r = r1 | (r2<<15) | (r3<<30);
-    }
-    else {
-        //rand_s is a good number generator, but cannot be seeded (for
-        //repeatability).
-        errno_t r_error = rand_s(&r);
-        assert(r_error==0);
-        //Should return 0 to 2**31-1 instead of 2**32-1
-        r >>= 1;
-    }
-    return r;
-}
-
-//TODO: Implement srandom to modify the way rand_s works (IF POSSIBLE).. or
-//reimplement random.
-void
-srandom(unsigned int seed) {
-    srand(seed);
-    used_srand = 1;
-}
-

windows/rss.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <toku_portability.h>
-#include <windows.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <toku_os.h>
-
-#define DO_MEMORY_INFO 1
-
-#if DO_MEMORY_INFO
-#include <psapi.h>
-
-static int
-get_memory_info(PROCESS_MEMORY_COUNTERS *meminfo) {
-    int r;
-
-    r = GetProcessMemoryInfo(GetCurrentProcess(), meminfo, sizeof *meminfo);
-    if (r == 0)
-        return GetLastError();
-    return 0;
-}
-
-#endif
-
-int
-toku_os_get_rss(int64_t *rss) {
-    int r;
-#if DO_MEMORY_INFO
-    PROCESS_MEMORY_COUNTERS meminfo;
-
-    r = get_memory_info(&meminfo);
-    if (r == 0)
-        *rss = meminfo.WorkingSetSize;
-#else
-    r = 0;
-    *rss = 0;
-#endif
-    return r;
-}
-
-int
-toku_os_get_max_rss(int64_t *maxrss) {
-    int r;
-#if DO_MEMORY_INFO
-    PROCESS_MEMORY_COUNTERS meminfo;
-
-    r = get_memory_info(&meminfo);
-    if (r == 0)
-        *maxrss = meminfo.PeakWorkingSetSize;
-#else
-    r = 0;
-    *maxrss = 0;
-#endif
-    return r;
-}
-

windows/sched.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-/*
- * Module: sched.h
- *
- * Purpose:
- *      Provides an implementation of POSIX realtime extensions
- *      as defined in 
- *
- *              POSIX 1003.1b-1993      (POSIX.1b)
- *
- * --------------------------------------------------------------------------
- *
- *      Pthreads-win32 - POSIX Threads Library for Win32
- *      Copyright(C) 1998 John E. Bossom
- *      Copyright(C) 1999,2005 Pthreads-win32 contributors
- * 
- *      Contact Email: rpj@callisto.canberra.edu.au
- * 
- *      The current list of contributors is contained
- *      in the file CONTRIBUTORS included with the source
- *      code distribution. The list can also be seen at the
- *      following World Wide Web location:
- *      http://sources.redhat.com/pthreads-win32/contributors.html
- * 
- *      This library is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU Lesser General Public
- *      License as published by the Free Software Foundation; either
- *      version 2 of the License, or (at your option) any later version.
- * 
- *      This library is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *      Lesser General Public License for more details.
- * 
- *      You should have received a copy of the GNU Lesser General Public
- *      License along with this library in the file COPYING.LIB;
- *      if not, write to the Free Software Foundation, Inc.,
- *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-#ifndef _SCHED_H
-#define _SCHED_H
-
-#undef PTW32_LEVEL
-
-#if defined(_POSIX_SOURCE)
-#define PTW32_LEVEL 0
-/* Early POSIX */
-#endif
-
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
-#undef PTW32_LEVEL
-#define PTW32_LEVEL 1
-/* Include 1b, 1c and 1d */
-#endif
-
-#if defined(INCLUDE_NP)
-#undef PTW32_LEVEL
-#define PTW32_LEVEL 2
-/* Include Non-Portable extensions */
-#endif
-
-#define PTW32_LEVEL_MAX 3
-
-#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 )  || !defined(PTW32_LEVEL)
-#define PTW32_LEVEL PTW32_LEVEL_MAX
-/* Include everything */
-#endif
-
-
-#if __GNUC__ && ! defined (__declspec)
-# error Please upgrade your GNU compiler to one that supports __declspec.
-#endif
-
-/*
- * When building the DLL code, you should define PTW32_BUILD so that
- * the variables/functions are exported correctly. When using the DLL,
- * do NOT define PTW32_BUILD, and then the variables/functions will
- * be imported correctly.
- */
-#ifndef PTW32_STATIC_LIB
-#  ifdef PTW32_BUILD
-#    define PTW32_DLLPORT __declspec (dllexport)
-#  else
-#    define PTW32_DLLPORT __declspec (dllimport)
-#  endif
-#else
-#  define PTW32_DLLPORT
-#endif
-
-/*
- * This is a duplicate of what is in the autoconf config.h,
- * which is only used when building the pthread-win32 libraries.
- */
-
-#ifndef PTW32_CONFIG_H
-#  if defined(WINCE)
-#    define NEED_ERRNO
-#    define NEED_SEM
-#  endif
-#  if defined(_UWIN) || defined(__MINGW32__)
-#    define HAVE_MODE_T
-#  endif
-#endif
-
-/*
- *
- */
-
-#if PTW32_LEVEL >= PTW32_LEVEL_MAX
-#ifdef NEED_ERRNO
-#include "need_errno.h"
-#else
-#include <errno.h>
-#endif
-#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
-
-#if defined(__MINGW32__) || defined(_UWIN)
-# if PTW32_LEVEL >= PTW32_LEVEL_MAX
-/* For pid_t */
-#  include <sys/types.h>
-/* Required by Unix 98 */
-#  include <time.h>
-# else
-  typedef int pid_t;
-# endif
-#else
-typedef int pid_t;
-#endif
-
-/* Thread scheduling policies */
-
-enum {
-  SCHED_OTHER = 0,
-  SCHED_FIFO,
-  SCHED_RR,
-  SCHED_MIN   = SCHED_OTHER,
-  SCHED_MAX   = SCHED_RR
-};
-
-struct sched_param {
-  int sched_priority;
-};
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif                          /* __cplusplus */
-
-PTW32_DLLPORT int __cdecl sched_yield (void);
-
-PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy);
-
-PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy);
-
-PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy);
-
-PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid);
-
-/*
- * Note that this macro returns ENOTSUP rather than
- * ENOSYS as might be expected. However, returning ENOSYS
- * should mean that sched_get_priority_{min,max} are
- * not implemented as well as sched_rr_get_interval.
- * This is not the case, since we just don't support
- * round-robin scheduling. Therefore I have chosen to
- * return the same value as sched_setscheduler when
- * SCHED_RR is passed to it.
- */
-#define sched_rr_get_interval(_pid, _interval) \
-  ( errno = ENOTSUP, (int) -1 )
-
-
-#ifdef __cplusplus
-}                               /* End of extern "C" */
-#endif                          /* __cplusplus */
-
-#undef PTW32_LEVEL
-#undef PTW32_LEVEL_MAX
-
-#endif                          /* !_SCHED_H */
-

windows/scripts/amd64/Cygwin.bat

-@echo off
-
-call "C:\Program Files (x86)\Intel\Compiler\C++\10.1.032\EM64T\Bin\ICLVars.bat"
-C:
-chdir C:\cygwin\bin
-
-bash --login -i %*
-

windows/scripts/install_amd64.sh

-#!/usr/bin/bash
-
-#Install BDB
-echo Installing BDB  if necessary ...
-if ! test -d /usr/local/BerkeleyDB.4.6 ; then
-    (
-        echo "BDB is missing.  Downloading from svn" &&
-        cd /usr/local &&
-        svn co -q https://svn.tokutek.com/tokudb/berkeleydb/windows/amd64/BerkeleyDB.4.6
-    ) || { echo Failed; exit 1; }
-fi
-if ! grep 'export BDB=' ~/.bashrc > /dev/null; then
-    echo "Adding 'export BDB=/usr/local/BerkeleyDB.4.6' to ~/.bashrc"
-    echo 'export BDB=/usr/local/BerkeleyDB.4.6' >> ~/.bashrc
-fi
-if ! grep 'export BDBDIR=' ~/.bashrc > /dev/null; then
-    echo "Adding 'export BDBDIR=C:/cygwin/usr/local/BerkeleyDB.4.6'' to ~/.bashrc"
-    echo 'export BDBDIR=C:/cygwin/usr/local/BerkeleyDB.4.6' >> ~/.bashrc
-fi
-echo Done installing BDB.
-echo 
-
-
-#Install licenses.
-if ! test -e ../licenses/install_licenses_amd64.bat; then
-    echo Missing ../licenses directory.
-    exit 1
-fi
-echo Installing licenses...
-(cd ../licenses && cmd /c install_licenses_amd64.bat) > /dev/null
-echo Done installing licenses.
-echo
-
-
-#install icc integration
-(
-    cd amd64 &&
-    if ! diff -q Cygwin.bat /cygdrive/c/cygwin/Cygwin.bat > /dev/null; then
-        cp Cygwin.bat /cygdrive/c/cygwin/ || { echo Failed Cygwin.bat; exit 1; }
-    fi
-)
-if ! grep 'export CC=' ~/.bashrc > /dev/null; then
-    echo "Adding 'export CC=icc' to ~/.bashrc"
-    echo 'export CC=icc' >> ~/.bashrc
-fi
-if ! grep 'export CYGWIN=' ~/.bashrc > /dev/null; then
-    echo "Adding 'export CYGWIN=CYGWIN' to ~/.bashrc"
-    echo 'export CYGWIN=CYGWIN' >> ~/.bashrc
-fi
-
-#cygwin link is in the way
-if test -e /usr/bin/link; then
-    mv /usr/bin/link /usr/bin/link_DISABLED || { echo Failed changing link; exit 1; }
-fi
-#cygwin cmake is in the way
-if test -e /usr/bin/cmake; then
-    mv /usr/bin/cmake /usr/bin/cmake_DISABLED || { echo Failed changing link; exit 1; }
-fi
-
-#Set up aliases
-( cd amd64/symlinks && cp -d * /usr/local/bin/  || { echo Failed copying link; exit 1; } )
-
-#Copy nightly script.
-cp -u nightly.sh ~/ || { echo Failed copying nightly.sh; exit 1; }
-
-
-echo You can now install the intel compiler.
-echo You must restart cygwin after intel compiler is installed.
-echo If the intel compiler is already installed, just restart cygwin.
-
-echo
-
-

windows/scripts/nightly.sh

-#!/bin/bash
-
-SVN_USER="tokubuild"
-SVN_PASS="Tb091638"
-
-
-if ! [ -d $HOME/svn.build ] ; then
-    mkdir -p $HOME/svn.build || exit 1
-fi
-
-cd $HOME/svn.build
-if ! [ -d tokudb.build ] ; then
-    svn --username $SVN_USER --password $SVN_PASS co -q --depth=empty https://svn.tokutek.com/tokudb/tokudb.build || exit 1
-fi
-if ! [ -d scripts ] ; then
-    svn --username $SVN_USER --password $SVN_PASS co -q --depth=empty https://svn.tokutek.com/toku/tokudb/scripts || exit 1
-fi
-
-cd scripts
-svn --username $SVN_USER --password $SVN_PASS up || exit 1
-
-cd bin
-
-./build.check.bash --windows=1 "$@" || exit 1
-

windows/sleep.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <toku_portability.h>
-#include <windows.h>
-#include <unistd.h>
-
-unsigned int
-sleep(unsigned int seconds) {
-    unsigned int m = seconds / 1000000;
-    unsigned int n = seconds % 1000000;
-    unsigned int i;
-    for (i=0; i<m; i++)
-        Sleep(1000000*1000);
-    Sleep(n*1000);
-    return 0;
-}
-
-int
-usleep(unsigned int useconds) {
-    unsigned int m = useconds / 1000;
-    unsigned int n = useconds % 1000;
-    if (m == 0 && n > 0)
-        m = 1;
-    Sleep(m);
-    return 0;
-}
-

windows/stdint.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef _STDINT_H
-#define _STDINT_H
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#include <basetsd.h>
-#include <sys/types.h>
-
-//Define standard integer types.
-typedef __int8                 int8_t;
-typedef unsigned __int8       uint8_t;
-typedef unsigned __int8      u_int8_t;
-typedef __int16               int16_t;
-typedef unsigned __int16     uint16_t;
-typedef unsigned __int16    u_int16_t;
-typedef __int32               int32_t;
-typedef unsigned __int32     uint32_t;
-typedef unsigned __int32    u_int32_t;
-typedef __int64               int64_t;
-typedef unsigned __int64     uint64_t;
-typedef unsigned __int64    u_int64_t;
-
-typedef SSIZE_T ssize_t;
-
-//Limits
-#define INT8_MIN   _I8_MIN
-#define INT8_MAX   _I8_MAX
-#define UINT8_MAX  _UI8_MAX
-#define INT16_MIN  _I16_MIN
-#define INT16_MAX  _I16_MAX
-#define UINT16_MAX _UI16_MAX
-#define INT32_MIN  _I32_MIN
-#define INT32_MAX  _I32_MAX
-#define UINT32_MAX _UI32_MAX
-#define INT64_MIN  _I64_MIN
-#define INT64_MAX  _I64_MAX
-#define UINT64_MAX _UI64_MAX
-
-#if defined(__cplusplus)
-};
-#endif
-
-#endif
-

windows/tests/Makefile

-# -*- Mode: Makefile -*-
-
-.DEFAULT_GOAL=all
-TOKUROOT=../../
-INCLUDEDIRS=-I$(TOKUROOT)include/windows -I$(TOKUROOT)ft -I$(TOKUROOT)windows/tests
-include $(TOKUROOT)toku_include/Makefile.include
-
-SKIP_WARNING += $(ICC_NOWARN)1418 #Non static functions do not need prototypes.
-
-SRCS=$(sort $(filter-out dir.%.c,$(wildcard *.c)))
-BINS_RAW = $(patsubst %.c,%,$(SRCS))
-#Bins will be generated.
-$(BINS): $(LIBPORTABILITY)
-$(BINS): CFLAGS+=-DTESTDIR=\"dir.$<.dir\"
-
-RUNTARGETS = $(patsubst %$(BINSUF),%.tdbrun,$(BINS))
-VGRIND = 
-
-all: $(BINS)
-
-.PHONY: check
-check: $(BINS) $(RUNTARGETS);
-
-test-pwrite4g.tdbrun: TEST_EXTRA_ARGS=.
-test-pwrite4g.tdbrun: VERBVERBOSE=
-%.tdbrun: %$(BINSUF) $(PTHREAD_LOCAL)
-	mkdir -p dir.$*
-ifeq ($(VGRIND),)
-	cd dir.$* && ../$< $(TEST_EXTRA_ARGS) $(VERBVERBOSE) $(SUMMARIZE_CMD)
-else
-	cd dir.$* && .$(VGRIND) --log-file=$<.valgrind ../$< $(TEST_EXTRA_ARGS) $(VERBVERBOSE); \
-	if [ $$? = 0 ] ; then \
-		grep "LEAK SUMMARY" dir.$*/$<.valgrind >/dev/null 2>&1; \
-		if [ $$? = 0 ] ; then cat dir.$*/$<.valgrind; test 0 = 1; fi \
-	fi \
-	$(SUMMARIZE_CMD)
-endif
-
-clean:
-	rm -rf $(TARGETS) *.valgrind dir.*
-

windows/tests/test-dirs.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#define _CRT_SECURE_NO_DEPRECATE
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <toku_assert.h>
-#include <fcntl.h>
-#include "toku_os.h"
-#include <dirent.h>
-
-int verbose;
-
-static int walk(const char *dirname) {
-    DIR *d;
-    struct dirent *dirent;
-    int dotfound = 0, dotdotfound = 0, otherfound = 0;
-
-    d = opendir(dirname);
-    if (d == NULL)
-        return -1;
-    while ((dirent = readdir(d))) {
-        if (verbose)
-            printf("%p %s\n", dirent, dirent->d_name);
-        if (strcmp(dirent->d_name, ".") == 0)
-            dotfound++;
-        else if (strcmp(dirent->d_name, "..") == 0)
-            dotdotfound++;
-        else
-            otherfound++;
-    }
-    closedir(d);
-    assert(dotfound == 1 && dotdotfound == 1);
-    return otherfound;
-}
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-    int found;
-    int fd;
-    int r;
-
-    for (i=1; i<argc; i++) {
-        char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0)
-            verbose++;
-    }
-
-    system("rm -rf " TESTDIR);
-
-    // try to walk a directory that does not exist
-    found = walk(TESTDIR);
-    assert(found == -1);
-
-    // try to walk an empty directory
-    r = toku_os_mkdir(TESTDIR, 0777); assert(r==0);
-    found = walk(TESTDIR);
-    assert(found == 0);
-    //Try to delete the empty directory
-    system("rm -rf " TESTDIR);
-    
-    r = toku_os_mkdir(TESTDIR, 0777); assert(r==0);
-    // walk a directory with a bunch of files in it
-#define N 100
-    for (i=0; i<N; i++) {
-        char fname[256];
-        sprintf(fname, TESTDIR "/%d", i);
-        if (verbose)
-            printf("%s\n", fname);
-        // fd = creat(fname, 0777);
-        fd = open(fname, O_CREAT+O_RDWR, 0777);
-        assert(fd >= 0);
-        close(fd);
-    }
-    found = walk(TESTDIR);
-    assert(found == N);
-
-    // walk and remove files
-    
-    return 0;
-}
-

windows/tests/test-fileid.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <fcntl.h>
-#include "toku_os.h"
-
-int verbose=0;
-enum {NUM_IDS=4};
-struct fileid old_ids[NUM_IDS];
-BOOL valid[NUM_IDS];
-
-//TODO: Test that different files are different,
-//      other stuff
-static void test_handles(const char *fname, unsigned which) {
-    unlink(fname);
-    int fd = open(fname,  O_RDWR | O_CREAT | O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO);
-    assert(fd!=-1);
-    int i;
-    struct fileid id_base;
-    struct fileid id;
-    int r = toku_os_get_unique_file_id(fd, &id_base);
-    CKERR(r);
-    assert(which < NUM_IDS);
-    for (i = 0; i < NUM_IDS; i++) {
-        if (valid[i]) {
-            if (which==i) {
-                //Assert same
-                assert(memcmp(&id_base, &old_ids[i], sizeof(id_base))==0);
-            }
-            else {
-                //Assert different
-                assert(memcmp(&id_base, &old_ids[i], sizeof(id_base))!=0);
-            }
-        }
-    }
-    memcpy(&old_ids[which], &id_base, sizeof(id_base));
-    valid[which] = TRUE;
-
-    if (verbose) printf("[%s] : r=[%d] errno=[%d] id=[0x%"PRIx32"/0x%"PRIx64"]\n", fname, r, errno, id_base.st_dev, id_base.st_ino);
-    for (i=0; i < 1<<16; i++) {
-        r = toku_os_get_unique_file_id(fd, &id);
-        CKERR(r);
-        assert(memcmp(&id, &id_base, sizeof(id))==0);
-    }
-    r = close(fd);
-    CKERR(r);
-}
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-
-    for (i=1; i<argc; i++) {
-        char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0)
-            verbose++;
-    }
-
-    test_handles("junk1", 0);
-    test_handles("junk2", 1);
-    test_handles("junk3", 2);
-    test_handles("NUL", 3);
-    test_handles(".\\NUL", 3);
-    test_handles("\\NUL", 3);
-    test_handles("C:\\NUL", 3);
-
-    return 0;
-}

windows/tests/test-filesystem-sizes.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#define _CRT_SECURE_NO_DEPRECATE
-#include <test.h>
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <toku_stdint.h>
-#include <unistd.h>
-#include <toku_assert.h>
-#include "toku_os.h"
-
-int test_main(int argc, char *const argv[]) {
-    int verbose = 0;
-    int limit = 1;
-
-    for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
-            verbose = 1;
-            continue;
-        }
-        if (strcmp(argv[i], "--timeit") == 0) {
-            limit = 100000;
-            continue;
-        }
-    }
-
-    int r;
-
-#if 0
-    r = toku_get_filesystem_sizes(NULL, NULL, NULL, NULL);
-    assert(r == EFAULT);
-#endif
-
-    r = toku_get_filesystem_sizes(".", NULL, NULL, NULL);
-    assert(r == 0);
-
-    uint64_t free_size = 0, avail_size = 0, total_size = 0;
-    for (int i = 0; i < limit; i++) {
-        r = toku_get_filesystem_sizes(".", &avail_size, &free_size, &total_size);
-        assert(r == 0);
-        assert(avail_size <= free_size && free_size <= total_size);
-    }
-    if (verbose) {
-        printf("avail=%"PRIu64"\n", avail_size);
-        printf("free=%"PRIu64"\n", free_size);
-        printf("total=%"PRIu64"\n", total_size);
-    }
-
-    return 0;
-}

windows/tests/test-fsync.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include "test.h"
-#include <stdio.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-#include "toku_time.h"
-
-
-int verbose = 0;
-static void
-create_files(int N, int fds[N]) {
-    int r;
-    int i;
-    char name[30];
-    for (i = 0; i < N; i++) {
-        snprintf(name, sizeof(name), "%d", i);
-        fds[i] = open(name, O_CREAT|O_WRONLY);
-        if (fds[i] < 0) {
-            r = errno;
-            CKERR(r);
-        }
-    }
-}
-
-static void
-write_to_files(int N, int bytes, int fds[N]) {
-    char junk[bytes];
-
-    int i;
-    for (i = 0; i < bytes; i++) {
-        junk[i] = random() & 0xFF;
-    }
-
-    int r;
-    for (i = 0; i < N; i++) {
-        r = toku_os_write(fds[i], junk, bytes);
-        CKERR(r);
-    }
-}
-
-static void
-time_many_fsyncs_one_file(int N, int bytes, int fds[N]) {
-    if (verbose>1) {
-        printf("Starting %s\n", __FUNCTION__);
-        fflush(stdout);
-    }
-    struct timeval begin;
-    struct timeval after_first;
-    struct timeval end;
-    write_to_files(1, bytes, fds);
-    if (verbose>1) {
-        printf("Done writing to os buffers\n");
-        fflush(stdout);
-    }
-    int i;
-    int r;
-
-    r = gettimeofday(&begin, NULL);
-    CKERR(r);
-    r = fsync(fds[0]);
-    CKERR(r);
-    r = gettimeofday(&after_first, NULL);
-    CKERR(r);
-    for (i = 0; i < N; i++) {
-        r = fsync(fds[0]);
-        CKERR(r);
-    }
-    r = gettimeofday(&end, NULL);
-    CKERR(r);
-
-    if (verbose) {
-        printf("Fsyncing one file %d times:\n"
-               "\tFirst fsync took: [%f] seconds\n"
-               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
-               "\tTotal time [%f] seconds\n",
-               N + 1,
-               toku_tdiff(&after_first, &begin),
-               N, 
-               toku_tdiff(&end, &after_first),
-               toku_tdiff(&end, &begin));
-        fflush(stdout);
-    }
-}
-
-static void
-time_fsyncs_many_files(int N, int bytes, int fds[N]) {
-    if (verbose>1) {
-        printf("Starting %s\n", __FUNCTION__);
-        fflush(stdout);
-    }
-    write_to_files(N, bytes, fds);
-    if (verbose>1) {
-        printf("Done writing to os buffers\n");
-        fflush(stdout);
-    }
-    struct timeval begin;
-    struct timeval after_first;
-    struct timeval end;
-    int i;
-    int r;
-
-    r = gettimeofday(&begin, NULL);
-    CKERR(r);
-    for (i = 0; i < N; i++) {
-        r = fsync(fds[i]);
-        CKERR(r);
-        if (i==0) {
-            r = gettimeofday(&after_first, NULL);
-            CKERR(r);
-        }
-        if (verbose>2) {
-            printf("Done fsyncing %d\n", i);
-            fflush(stdout);
-        }
-    }
-    r = gettimeofday(&end, NULL);
-    CKERR(r);
-    if (verbose) {
-        printf("Fsyncing %d files:\n"
-               "\tFirst fsync took: [%f] seconds\n"
-               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
-               "\tTotal time [%f] seconds\n",
-               N,
-               toku_tdiff(&after_first, &begin),
-               N-1,
-               toku_tdiff(&end, &after_first),
-               toku_tdiff(&end, &begin));
-        fflush(stdout);
-    }
-}
-
-#if !TOKU_WINDOWS
-//sync() does not appear to have an analogue on windows.
-static void
-time_sync_fsyncs_many_files(int N, int bytes, int fds[N]) {
-    if (verbose>1) {
-        printf("Starting %s\n", __FUNCTION__);
-        fflush(stdout);
-    }
-    //TODO: timing
-    write_to_files(N, bytes, fds);
-    if (verbose>1) {
-        printf("Done writing to os buffers\n");
-        fflush(stdout);
-    }
-    int i;
-    int r;
-    struct timeval begin;
-    struct timeval after_sync;
-    struct timeval end;
-
-    r = gettimeofday(&begin, NULL);
-    CKERR(r);
-
-    sync();
-
-    r = gettimeofday(&after_sync, NULL);
-    CKERR(r);
-    if (verbose>1) {
-        printf("Done with sync()\n");
-        fflush(stdout);
-    }
-
-    for (i = 0; i < N; i++) {
-        r = fsync(fds[i]);
-        CKERR(r);
-        if (verbose>2) {
-            printf("Done fsyncing %d\n", i);
-            fflush(stdout);
-        }
-    }
-    r = gettimeofday(&end, NULL);
-    CKERR(r);
-
-    if (verbose) {
-        printf("sync() then fsyncing %d files:\n"
-               "\tsync() took: [%f] seconds\n"
-               "\tRemaining %d fsyncs took additional: [%f] seconds\n"
-               "\tTotal time [%f] seconds\n",
-               N,
-               toku_tdiff(&after_sync, &begin),
-               N,
-               toku_tdiff(&end, &after_sync),
-               toku_tdiff(&end, &begin));
-        fflush(stdout);
-    }
-}
-#endif
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-    int r;
-    int N = 1000;
-    int bytes = 4096;
-    for (i=1; i<argc; i++) {
-        if (strcmp(argv[i], "-v") == 0) {
-            if (verbose < 0) verbose = 0;
-            verbose++;
-            continue;
-        }
-        if (strcmp(argv[i], "-q") == 0) {
-            verbose = 0;
-            continue;
-        }
-        if (strcmp(argv[i], "-b") == 0) {
-            i++;
-            if (i>=argc) exit(1);
-            bytes = atoi(argv[i]);
-            if (bytes <= 0)  exit(1);
-            continue;
-        }
-        if (strcmp(argv[i], "-n") == 0) {
-            i++;
-            if (i>=argc) exit(1);
-            N = atoi(argv[i]);
-            if (N <= 0)  exit(1);
-            continue;
-        }
-    }
-    r = system("rm -rf " ENVDIR);
-    CKERR(r);
-    r = toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
-    CKERR(r);
-    r = chdir(ENVDIR);
-    CKERR(r);
-
-    int fds[N];
-    create_files(N, fds);
-
-    time_many_fsyncs_one_file(N, bytes, fds);
-    time_fsyncs_many_files(N, bytes, fds);
-#if !TOKU_WINDOWS
-    time_sync_fsyncs_many_files(N, bytes, fds);
-#endif
-
-    return 0;
-}

windows/tests/test-ftruncate.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <toku_assert.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/stat.h>
-
-#if 0 && TOKU_WINDOWS
-#include <windows.h>
-static int ftruncate(int fd, uint64_t offset) {
-    HANDLE h = (HANDLE) _get_osfhandle(fd);
-    printf("%s:%d %p\n", __FILE__, __LINE__, h); fflush(stdout);
-    if (h == INVALID_HANDLE_VALUE)
-        return -1;
-    int r = _lseeki64(fd, 0, SEEK_SET);
-    printf("%s:%d %d\n", __FILE__, __LINE__, r); fflush(stdout);
-    if (r != 0)
-        return -2;
-    BOOL b = SetEndOfFile(h);
-    printf("%s:%d %d\n", __FILE__, __LINE__, b); fflush(stdout);
-    if (!b)
-        return -3;
-    return 0;
-}
-#endif
-
-int test_main(int argc, char *const argv[]) {
-    int r;
-    int fd;
-
-    fd = open("test-file-truncate", O_CREAT+O_RDWR+O_TRUNC, S_IREAD+S_IWRITE);
-    assert(fd != -1);
-
-    int i;
-    for (i=0; i<32; i++) {
-        char junk[4096];
-        memset(junk, 0, sizeof junk);
-        toku_os_full_write(fd, junk, sizeof junk);
-    }
-    
-    toku_struct_stat filestat;
-    r = toku_fstat(fd, &filestat);
-    assert(r == 0);
-
-    printf("orig size %lu\n", (unsigned long) filestat.st_size); fflush(stdout);
-
-    r = ftruncate(fd, 0);
-    assert(r == 0);
-
-    r = toku_fstat(fd, &filestat);
-    assert(r == 0);
-
-    printf("truncated size %lu\n", (unsigned long) filestat.st_size); fflush(stdout);
-    assert(filestat.st_size == 0);
-
-    return 0;
-}

windows/tests/test-gettimeofday.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <toku_assert.h>
-#include <toku_time.h>
-
-int test_main(int argc, char *const argv[]) {
-    int r;
-    struct timeval tv;
-    struct timezone tz;
-
-    r = gettimeofday(&tv, 0);
-    assert(r == 0);
-    
-    return 0;
-}

windows/tests/test-max-data.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#define _GNU_SOURCE
-#include <test.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <unistd.h>
-#include <toku_assert.h>
-#include <toku_os.h>
-
-int test_main(int argc, char *const argv[]) {
-    uint64_t maxdata;
-    int r = toku_os_get_max_process_data_size(&maxdata);
-    assert(r == 0);
-    printf("maxdata=%"PRIu64"\n", maxdata);
-    return 0;
-}

windows/tests/test-open-dir.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-    for (i=1; i<argc; i++) {
-        int fd = open(argv[i], O_RDONLY);
-        printf("%s: %d %d\n", argv[i], fd, errno);
-        if (fd >= 0) close(fd);
-    }
-    return 0;
-}

windows/tests/test-open-rename.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#if TOKU_WINDOWS
-#include <io.h>
-#endif
-#include <sys/stat.h>
-
-#ifndef S_IRUSR
-#define S_IRUSR S_IREAD
-#endif
-#ifndef S_IWUSR
-#define S_IWUSR S_IWRITE
-#endif
-
-#define TESTFILE "test-open-unlink-file"
-#define NEWNAME TESTFILE ".junk"
-
-int test_main(int argc, char *const argv[]) {
-    int r;
-    int fd;
-
-    r = system("rm -rf " TESTFILE); assert(r==0);
-    r = system("rm -rf " NEWNAME); assert(r==0);
-    
-    fd = open(TESTFILE, O_CREAT+O_RDWR, S_IRUSR+S_IWUSR);
-    assert(fd != -1);
-
-    r = rename(TESTFILE, NEWNAME);
-    printf("%s:%d rename %d %d\n", __FILE__, __LINE__, r, errno); fflush(stdout);
-#if defined(__linux__)
-    assert(r == 0);
-
-    r = close(fd);
-    assert(r == 0);
-#endif
-#if TOKU_WINDOWS
-    assert(r == -1);
-    
-    r = close(fd);
-    assert(r == 0);
-    
-    r = rename(TESTFILE, NEWNAME);
-    printf("%s:%d rename %d %d\n", __FILE__, __LINE__, r, errno); fflush(stdout);
-    assert(r == 0);
-#endif
-
-    return 0;
-}

windows/tests/test-open-unlink.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#if TOKU_WINDOWS
-#include <io.h>
-#endif
-#include <sys/stat.h>
-
-#ifndef S_IRUSR
-#define S_IRUSR S_IREAD
-#endif
-#ifndef S_IWUSR
-#define S_IWUSR S_IWRITE
-#endif
-
-const char TESTFILE[] = "test-open-unlink-file";
-
-int test_main(int argc, char *const argv[]) {
-    int r;
-    int fd;
-
-    system("rm -rf test-open-unlink-file");
-    
-    fd = open(TESTFILE, O_CREAT+O_RDWR, S_IRUSR+S_IWUSR);
-    assert(fd != -1);
-
-    r = unlink(TESTFILE);
-    printf("%s:%d unlink %d %d\n", __FILE__, __LINE__, r, errno); fflush(stdout);
-#if defined(__linux__)
-    assert(r == 0);
-
-    r = close(fd);
-    assert(r == 0);
-#endif
-#if TOKU_WINDOWS
-    assert(r == -1);
-    
-    r = close(fd);
-    assert(r == 0);
-    
-    r = unlink(TESTFILE);
-    printf("%s:%d unlink %d %d\n", __FILE__, __LINE__, r, errno); fflush(stdout);
-    assert(r == 0);
-#endif
-
-    return 0;
-}

windows/tests/test-pread.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <fcntl.h>
-#include "toku_os.h"
-
-int verbose;
-
-static void test_pread_empty(const char *fname) {
-    int fd;
-    char c[12];
-    uint64_t r;
-
-    unlink(fname);
-    fd = open(fname,  O_RDWR | O_CREAT | O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO);
-    if (verbose)
-        printf("open %s fd %d\n", fname, fd);
-    assert(fd != -1);
-    r = pread(fd, c, sizeof c, 0);
-    assert(r == 0);
-    r = close(fd);
-    if (verbose)
-        printf("close %s %"PRIu64"\n", fname, r);
-}
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-
-    for (i=1; i<argc; i++) {
-        char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0)
-            verbose++;
-    }
-
-    test_pread_empty("junk");
-
-    return 0;
-}

windows/tests/test-pthread-cond.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <toku_assert.h>
-#include <toku_pthread.h>
-
-struct q {
-    toku_pthread_mutex_t m;
-    toku_pthread_cond_t r;
-    toku_pthread_cond_t w;
-    void *item;
-};
-
-static void q_init(struct q *q) {
-    toku_pthread_mutex_init(&q->m, NULL);
-    toku_pthread_cond_init(&q->r, NULL);
-    toku_pthread_cond_init(&q->w, NULL);
-    q->item = NULL;
-}
-
-static void q_destroy(struct q *q) {
-    toku_pthread_cond_destroy(&q->w);
-    toku_pthread_cond_destroy(&q->r);
-    toku_pthread_mutex_destroy(&q->m);
-}
-
-static void *q_get(struct q *q) {
-    void *item;
-    toku_pthread_mutex_lock(&q->m);
-    while (q->item == NULL)
-        toku_pthread_cond_wait(&q->r, &q->m);
-    item = q->item; q->item = NULL;
-    toku_pthread_mutex_unlock(&q->m);
-    toku_pthread_cond_signal(&q->w);
-    return item;
-}
-
-static void q_put(struct q *q, void *item) {
-    toku_pthread_mutex_lock(&q->m);
-    while (q->item != NULL) 
-        toku_pthread_cond_wait(&q->w, &q->m);
-    q->item = item;
-    toku_pthread_mutex_unlock(&q->m);
-    toku_pthread_cond_signal(&q->r);
-}
-    
-static void *writer(void *arg) {
-    struct q *q = arg;
-    int i;
-
-    printf("%s %p %lu\n", __FUNCTION__, arg, GetCurrentThreadId());
-    for (i=0; i<100; i++) 
-        q_put(q, (void*)(i+1));
-    return arg;
-}
-
-static void *reader(void *arg) {
-    struct q *q = arg;
-    int i;
-
-    printf("%s %p %lu\n", __FUNCTION__, arg, GetCurrentThreadId());
-    for (i=0; i<100; i++) {
-        void *item = q_get(q);
-        printf("%p\n", item); fflush(stdout);
-        Sleep(i);
-    }
-    return arg;
-}
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-    void *ret;
-    toku_pthread_t t[2];
-    struct q q;
-
-    q_init(&q);
-    toku_pthread_create(&t[0], NULL, reader, &q);
-    toku_pthread_create(&t[1], NULL, writer, &q);
-    for (i=0; i<2; i++)
-        toku_pthread_join(t[i], &ret);
-    q_destroy(&q);
-    return 0;
-}
-

windows/tests/test-pthread-create.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <toku_assert.h>
-#include <unistd.h>
-#include <toku_pthread.h>
-
-static void *myfunc1(void *arg) {
-    printf("%s %p %lu\n", __FUNCTION__, arg, GetCurrentThreadId());
-    fflush(stdout);
-    sleep(10);
-    return arg;
-}
-
-static void *myfunc2(void *arg) {
-    printf("%s %p %lu\n", __FUNCTION__, arg, GetCurrentThreadId());
-    fflush(stdout);
-    sleep(10);
-    return arg;
-}
-
-int test_main(int argc, char *const argv[]) {
-#define N 10
-    toku_pthread_t t[N];
-    int i;
-
-    for (i=0; i<N; i++) {
-        toku_pthread_create(&t[i], NULL, i & 1 ? myfunc1 : myfunc2, (void *)i);
-    }
-    for (i=0; i<N; i++) {
-        void *ret;
-        toku_pthread_join(t[i], &ret);
-        assert(ret == (void*)i);
-    }
-    return 0;
-}
-

windows/tests/test-pthread-handle-leak.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-// test for a pthread handle leak
-
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <toku_assert.h>
-#include <unistd.h>
-#include <toku_pthread.h>
-
-static void *mythreadfunc(void *arg) {
-    return arg;
-}
-
-int test_main(int argc, char *const argv[]) {
-#define N 1000000
-
-    int i;
-    for (i=0; i<N; i++) {
-	int r;
-	toku_pthread_t tid;
-        r = toku_pthread_create(&tid, NULL, mythreadfunc, (void *)i);
-	assert(r == 0);
-        void *ret;
-        r = toku_pthread_join(tid, &ret);
-        assert(r == 0 && ret == (void*)i);
-    }
-    printf("ok\n"); fflush(stdout);
-    return 0;
-}
-

windows/tests/test-pthread-rwlock-rdlock.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <toku_assert.h>
-#include <toku_pthread.h>
-#include <stdio.h>
-#include <unistd.h>
-
-int test_main(int argc __attribute__((__unused__)), char *const argv[] __attribute__((__unused__))) {
-    toku_pthread_rwlock_t rwlock;
-
-    toku_pthread_rwlock_init(&rwlock, NULL);
-    toku_pthread_rwlock_rdlock(&rwlock);
-    toku_pthread_rwlock_rdlock(&rwlock);
-    toku_pthread_rwlock_rdunlock(&rwlock);
-    toku_pthread_rwlock_rdunlock(&rwlock);
-    toku_pthread_rwlock_destroy(&rwlock);
-
-    return 0;
-}
-

windows/tests/test-pthread-rwlock-rwr.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <toku_assert.h>
-#include <toku_pthread.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-// write a test see if things happen in the right order.
-
-volatile int state = 0;
-int verbose = 0;
-
-static void *f(void *arg) {
-    toku_pthread_rwlock_t *mylock = arg;
-    sleep(2);
-    assert(state==42); state = 16; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    toku_pthread_rwlock_wrlock(mylock);
-    assert(state==49); state = 17; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    toku_pthread_rwlock_wrunlock(mylock);
-    sleep(10);
-    assert(state==52); state = 20; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    return arg;
-}
-
-int test_main(int argc , char *const argv[] ) {
-    assert(argc==1 || argc==2);
-    if (argc==2) {
-	assert(strcmp(argv[1],"-v")==0);
-	verbose = 1;
-    }
-    int r;
-    toku_pthread_rwlock_t rwlock;
-    toku_pthread_t tid;
-    void *retptr;
-
-    toku_pthread_rwlock_init(&rwlock, NULL);
-    state = 37; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    toku_pthread_rwlock_rdlock(&rwlock);
-
-    r = toku_pthread_create(&tid, NULL, f, &rwlock); assert(r == 0);
-
-    assert(state==37); state = 42; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    sleep(4);
-    assert(state==16); state = 44; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    toku_pthread_rwlock_rdlock(&rwlock);
-    assert(state==44); state = 46; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-    toku_pthread_rwlock_rdunlock(&rwlock);
-    sleep(4);
-    assert(state==46); state=49; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__); // still have a read lock
-    toku_pthread_rwlock_rdunlock(&rwlock);
-    sleep(6);
-    assert(state==17); state=52; if (verbose) printf("%s:%d\n", __FUNCTION__, __LINE__);
-
-    r = toku_pthread_join(tid, &retptr); assert(r == 0);
-
-    toku_pthread_rwlock_destroy(&rwlock);
-    
-    return 0;
-}

windows/tests/test-pwrite4g.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-/* Verify that toku_os_full_pwrite does the right thing when writing beyond 4GB.  */
-#include <test.h>
-#include <fcntl.h>
-#include <toku_assert.h>
-#include <string.h>
-#include <stdio.h>
-
-static int iszero(char *cp, size_t n) {
-    size_t i;
-    for (i=0; i<n; i++)
-        if (cp[i] != 0) 
-	    return 0;
-    return 1;
-}
-
-int test_main(int argc, char *const argv[]) {
-    assert(argc==2); // first arg is the directory to put the data file into.
-    char short_fname[] = "pwrite4g.data";
-    int fname_len = strlen(short_fname) + strlen(argv[1]) + 5;
-    char fname[fname_len];
-    snprintf(fname, fname_len, "%s/%s", argv[1], short_fname);
-    int r;
-    unlink(fname);
-    int fd = open(fname, O_RDWR | O_CREAT | O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO);
-    assert(fd>=0);
-    char buf[] = "hello";
-    int64_t offset = (1LL<<32) + 100;
-    toku_os_full_pwrite(fd, buf, sizeof buf, offset);
-    char newbuf[sizeof buf];
-    r = pread(fd, newbuf, sizeof newbuf, 100);
-    assert(r==sizeof newbuf);
-    assert(iszero(newbuf, sizeof newbuf));
-    r = pread(fd, newbuf, sizeof newbuf, offset);
-    assert(r==sizeof newbuf);
-    assert(memcmp(newbuf, buf, sizeof newbuf) == 0);
-    int64_t fsize;
-    r = toku_os_get_file_size(fd, &fsize);
-    assert(r == 0);
-    assert(fsize > 100 + (signed)sizeof(buf));
-    r = close(fd);
-    assert(r==0);
-    return 0;
-}

windows/tests/test-rss.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <toku_os.h>
-
-static void do_mallocs(void) {
-    int i;
-    for (i=0; i<1000; i++) {
-        int nbytes = 1024*1024;
-        void *vp = malloc(nbytes);
-        memset(vp, 0, nbytes);
-    }
-}
-
-int test_main(int argc, char *const argv[]) {
-    int64_t rss;
-
-    toku_os_get_max_rss(&rss);
-    printf("%I64d\n", rss);
-    do_mallocs();
-    toku_os_get_max_rss(&rss);
-    printf("%I64d\n", rss);
-
-    return 0;
-}
-
-    

windows/tests/test-sleep.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include <unistd.h>
-#include <string.h>
-
-int verbose;
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-
-    for (i=1; i<argc; i++) {
-        char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0)
-            verbose++;
-    }
-
-    for (i=0; i<10; i++) {
-        if (verbose) {
-            printf("sleep %d\n", i); fflush(stdout);
-        }
-        sleep(i);
-    }
-
-    for (i=0; i<10*1000000; i += 1000000) {
-        if (verbose) {
-            printf("usleep %d\n", i); fflush(stdout);
-        }
-        usleep(i);
-    }
-
-    return 0;
-}

windows/tests/test-snprintf.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
-
-#include <test.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <toku_portability.h>
-#include <toku_assert.h>
-#include <toku_os.h>
-
-static void
-check_snprintf(int i) {
-    char buf_before[8];
-    char target[5];
-    char buf_after[8];
-    memset(target, 0xFF, sizeof(target));
-    memset(buf_before, 0xFF, sizeof(buf_before));
-    memset(buf_after, 0xFF, sizeof(buf_after));
-    int64_t n = 1;
-    
-    int j;
-    for (j = 0; j < i; j++) n *= 10;
-
-    int bytes = snprintf(target, sizeof target, "%"PRId64, n);
-    assert(bytes==i+1 ||
-           (i+1>=(int)(sizeof target) && bytes>=(int)(sizeof target)));
-    if (bytes>=(int)(sizeof target)) {
-        //Overflow prevented by snprintf
-        assert(target[sizeof target - 1] == '\0');
-        assert(strlen(target)==sizeof target-1);
-    }
-    else {
-        assert(target[bytes] == '\0');
-        assert(strlen(target)==(size_t)bytes);
-    }
-}
-
-
-int test_main(int argc __attribute__((__unused__)), char *const argv[] __attribute__((__unused__))) {
-    int i;
-    for (i = 0; i < 8; i++) {
-        check_snprintf(i);
-    }
-    return 0;
-}
-

windows/tests/test-stat.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <toku_assert.h>
-#include <sys/stat.h>
-#include <errno.h>
-
-void test_stat(char *dirname, int result, int ex_errno) {
-    int r;
-    toku_struct_stat buf;
-    r = toku_stat(dirname, &buf);
-    printf("stat %s %d %d\n", dirname, r, errno); fflush(stdout);
-    assert(r==result);
-    if (r!=0) assert(errno == ex_errno);
-}
-
-int test_main(int argc, char *const argv[]) {
-    int r;
-
-    test_stat(".", 0, 0);
-    test_stat("./", 0, 0);
-
-    r = system("rm -rf testdir"); assert(r==0);
-    test_stat("testdir", -1, ENOENT);
-    test_stat("testdir/", -1, ENOENT);
-    test_stat("testdir/foo", -1, ENOENT);
-    test_stat("testdir/foo/", -1, ENOENT);
-    r = toku_os_mkdir("testdir", S_IRWXU);
-    assert(r == 0);
-    test_stat("testdir/foo", -1, ENOENT);
-    test_stat("testdir/foo/", -1, ENOENT);
-    r = system("touch testdir/foo"); assert(r==0);
-    test_stat("testdir/foo", 0, 0);
-    test_stat("testdir/foo/", -1, ENOENT);
-
-    test_stat("testdir", 0, 0);
-
-    test_stat("./testdir", 0, 0);
-
-    test_stat("./testdir/", 0, 0);
-
-    return 0;
-}

windows/tests/test-strtoll.c

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#include <test.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <toku_assert.h>
-#include "toku_os.h"
-
-int verbose;
-
-void testit(int64_t i, int base) {
-    int64_t o;
-#define SN 32
-    char s[SN];
-    sprintf(s, "%I64d", i);
-    o = strtoll(s, NULL, base);
-    if (verbose) 
-        printf("%s: %I64d %I64d %s\n", __FUNCTION__, i, o, s);
-    assert(i == o);
-}
-
-int test_main(int argc, char *const argv[]) {
-    int i;
-    int64_t n;
-    int64_t o;
-#define SN 32
-    char s[SN];
-
-    for (i=1; i<argc; i++) {
-        char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0)
-            verbose++;
-    }
-
-    for (n=0; n<1000; n++) {
-        testit(n, 10);
-    }
-
-    testit(1I64 << 31, 10);
-    testit((1I64 << 32) - 1, 10);
-    testit(1I64 << 32, 10);
-
-    return 0;
-}

windows/toku_stdint.h

-/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef TOKU_STDINT_H
-#define TOKU_STDINT_H
-
-#include <stdint.h>
-#include <inttypes.h>
-
-#endif
-