[t:4871] make newbrt tests use temp files in the build directory, not the source directory

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

newbrt/tests/CMakeLists.txt

@@ -28,19 +28,12 @@ if(BUILD_TESTING)
       get_filename_component(base ${src} NAME_WE)
       add_executable(${base} ${src})
       target_link_libraries(${base} newbrt ${LIBTOKUPORTABILITY})
+      set_property(TARGET ${base} APPEND PROPERTY
+        COMPILE_DEFINITIONS "__SRCFILE__=\"${src}\"")
+      set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES "${src}.brt")
     endif()
   endforeach(src)
 
-  file(GLOB log_tests RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" log-test*.c)
-  foreach(src ${log_tests})
-    ## these tests use -Ddname=foo to decide where to put their data, if
-    ## we don't specify it, it defaults to "dir."__FILE__ which with cmake
-    ## is going to be an absolute path with "dir." in front, and that's
-    ## not a valid path
-    set_property(SOURCE ${src} APPEND PROPERTY
-      COMPILE_DEFINITIONS "dname=\"${src}\"")
-  endforeach(src)
-
   ## declare some tests that should be run with specific options
 
   declare_custom_tests(test-assert.c)

newbrt/tests/brt-bfe-query.c

@@ -289,7 +289,7 @@ test_prefetching(void) {
     const int nodesize = 1024;
     struct brtnode sn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 

newbrt/tests/brt-clock-test.c

@@ -230,7 +230,7 @@ test_serialize_nonleaf(void) {
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 
@@ -329,7 +329,7 @@ test_serialize_leaf(void) {
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 

newbrt/tests/brt-serialize-benchmark.c

@@ -56,7 +56,7 @@ test_serialize_leaf(int valsize, int nelts, double entropy) {
     const int nodesize = (1<<22);
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 
@@ -182,7 +182,7 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy) {
     const int nodesize = (1<<22);
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 

newbrt/tests/brt-serialize-sub-block-test.c

@@ -12,7 +12,7 @@
 static void test_sub_block(int n) {
     if (verbose) printf("%s:%d %d\n", __FUNCTION__, __LINE__, n);
 
-    const char fname[]= __FILE__ ".brt";
+    const char fname[]= __SRCFILE__ ".brt";
     const int nodesize = 4*1024*1024;
     const int basementnodesize = 128*1024;
     const enum toku_compression_method compression_method = TOKU_DEFAULT_COMPRESSION_METHOD;

newbrt/tests/brt-serialize-test.c

@@ -206,7 +206,7 @@ test_serialize_leaf_check_msn(enum brtnode_verify_type bft, BOOL do_clone) {
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 
@@ -353,7 +353,7 @@ test_serialize_leaf_with_large_pivots(enum brtnode_verify_type bft, BOOL do_clon
     struct brtnode sn, *dn;
     const int keylens = 256*1024, vallens = 0, nrows = 8;
     // assert(val_size > BN_MAX_SIZE);  // BN_MAX_SIZE isn't visible
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     sn.max_msn_applied_to_node_on_disk.msn = 0;
     sn.nodesize = 4*(1<<20);
@@ -496,7 +496,7 @@ test_serialize_leaf_with_many_rows(enum brtnode_verify_type bft, BOOL do_clone)
     struct brtnode sn, *dn;
     const int keylens = sizeof(int), vallens = sizeof(int), nrows = 196*1024;
     // assert(val_size > BN_MAX_SIZE);  // BN_MAX_SIZE isn't visible
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     sn.max_msn_applied_to_node_on_disk.msn = 0;
     sn.nodesize = 4*(1<<20);
@@ -636,7 +636,7 @@ test_serialize_leaf_with_large_rows(enum brtnode_verify_type bft, BOOL do_clone)
     const size_t key_size = 8;
     const size_t val_size = 512*1024;
     // assert(val_size > BN_MAX_SIZE);  // BN_MAX_SIZE isn't visible
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     sn.max_msn_applied_to_node_on_disk.msn = 0;
     sn.nodesize = 4*(1<<20);
@@ -782,7 +782,7 @@ test_serialize_leaf_with_empty_basement_nodes(enum brtnode_verify_type bft, BOOL
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 
@@ -931,7 +931,7 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum brtnode_verify_type
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 
@@ -1047,7 +1047,7 @@ test_serialize_leaf(enum brtnode_verify_type bft, BOOL do_clone) {
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
     BRTNODE_DISK_DATA src_ndd = NULL;
@@ -1187,7 +1187,7 @@ test_serialize_nonleaf(enum brtnode_verify_type bft, BOOL do_clone) {
     const int nodesize = 1024;
     struct brtnode sn, *dn;
 
-    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+    int fd = open(__SRCFILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
 

newbrt/tests/brt-test-cursor-2.c

@@ -5,7 +5,7 @@
 #include "includes.h"
 #include "test.h"
 
-static const char fname[]= __FILE__ ".brt";
+static const char fname[]= __SRCFILE__ ".brt";
 
 static TOKUTXN const null_txn = 0;
 

newbrt/tests/brt-test-cursor.c

@@ -5,7 +5,7 @@
 #include "includes.h"
 #include "test.h"
 
-static const char fname[]= __FILE__ ".brt";
+static const char fname[]= __SRCFILE__ ".brt";
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test-header.c

@@ -15,7 +15,7 @@ static void test_header (void) {
     BRT t;
     int r;
     CACHETABLE ct;
-    char fname[]= __FILE__ ".brt";
+    char fname[]= __SRCFILE__ ".brt";
 
     // First create dictionary
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);

newbrt/tests/brt-test.c

@@ -8,7 +8,7 @@
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;
 
-static char fname[] = __FILE__ ".brt";
+static char fname[] = __SRCFILE__ ".brt";
 
 static void test_dump_empty_db (void) {
     BRT t;
@@ -28,8 +28,8 @@ static void test_dump_empty_db (void) {
 
 /* Test running multiple trees in different files */
 static void test_multiple_files_of_size (int size) {
-    const char *n0 = __FILE__ "test0.brt";
-    const char *n1 = __FILE__ "test1.brt";
+    const char *n0 = __SRCFILE__ "test0.brt";
+    const char *n1 = __SRCFILE__ "test1.brt";
     CACHETABLE ct;
     BRT t0,t1;
     int r,i;
@@ -63,7 +63,7 @@ static void test_multiple_files_of_size (int size) {
     /* Now see if the data is all there. */
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);      assert(r==0);
     r = toku_open_brt(n0, 0, &t0, 1<<12, 1<<9, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun);
-    if (verbose) printf("%s:%d r=%d\n", __FILE__, __LINE__,r);
+    if (verbose) printf("%s:%d r=%d\n", __SRCFILE__, __LINE__,r);
     assert(r==0);
     r = toku_open_brt(n1, 0, &t1, 1<<12, 1<<9, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun); assert(r==0);
 
@@ -219,7 +219,7 @@ static void  test_read_what_was_written (void) {
     }
 
     r = toku_close_brt_nolsn(brt, 0); assert(r==0);
-    if (verbose) printf("%s:%d About to close %p\n", __FILE__, __LINE__, ct);
+    if (verbose) printf("%s:%d About to close %p\n", __SRCFILE__, __LINE__, ct);
     r = toku_cachetable_close(&ct); assert(r==0);
 
     
@@ -256,11 +256,11 @@ static void test_cursor_last_empty(void) {
     if (verbose) printf("%s", __FUNCTION__);
     unlink(fname);
     
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);       assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_open_brt(fname, 1, &brt, 1<<12, 1<<9, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun);  assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_brt_cursor(brt, &cursor, NULL, FALSE, FALSE);            assert(r==0);
     {
 	struct check_pair pair = {0,0,0,0,0};
@@ -277,9 +277,9 @@ static void test_cursor_last_empty(void) {
     r = toku_brt_cursor_close(cursor);
     assert_zero(r);
     r = toku_close_brt_nolsn(brt, 0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_cachetable_close(&ct); assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     
 }
 
@@ -293,23 +293,23 @@ static void test_cursor_next (void) {
     unlink(fname);
     
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);       assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_open_brt(fname, 1, &brt, 1<<12, 1<<9, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun);  assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_brt_insert(brt, toku_fill_dbt(&kbt, "hello", 6), toku_fill_dbt(&vbt, "there", 6), null_txn);
     r = toku_brt_insert(brt, toku_fill_dbt(&kbt, "byebye", 7), toku_fill_dbt(&vbt, "byenow", 7), null_txn);
-    if (verbose) printf("%s:%d calling toku_brt_cursor(...)\n", __FILE__, __LINE__);
+    if (verbose) printf("%s:%d calling toku_brt_cursor(...)\n", __SRCFILE__, __LINE__);
     r = toku_brt_cursor(brt, &cursor, NULL, FALSE, FALSE);            assert(r==0);
     toku_init_dbt(&kbt);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     toku_init_dbt(&vbt);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
 
-    if (verbose) printf("%s:%d calling toku_brt_cursor_get(...)\n", __FILE__, __LINE__);
+    if (verbose) printf("%s:%d calling toku_brt_cursor_get(...)\n", __SRCFILE__, __LINE__);
     {
 	struct check_pair pair = {7, "byebye", 7, "byenow", 0};
 	r = toku_brt_cursor_get(cursor, NULL, lookup_checkf, &pair, DB_NEXT);
-	if (verbose) printf("%s:%d called toku_brt_cursor_get(...)\n", __FILE__, __LINE__);
+	if (verbose) printf("%s:%d called toku_brt_cursor_get(...)\n", __SRCFILE__, __LINE__);
 	assert(r==0);
 	assert(pair.call_count==1);
     }
@@ -330,9 +330,9 @@ static void test_cursor_next (void) {
     r = toku_brt_cursor_close(cursor);
     assert_zero(r);
     r = toku_close_brt_nolsn(brt, 0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     r = toku_cachetable_close(&ct); assert(r==0);
-    //printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
+    //printf("%s:%d %d alloced\n", __SRCFILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
     
 
 }
@@ -370,7 +370,7 @@ static void test_wrongendian_compare (int wrong_p, unsigned int N) {
     }
 
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);       assert(r==0);
-    //printf("%s:%d WRONG=%d\n", __FILE__, __LINE__, wrong_p);
+    //printf("%s:%d WRONG=%d\n", __SRCFILE__, __LINE__, wrong_p);
 
     if (0) { // ???? Why is this commented out?
         r = toku_open_brt(fname, 1, &brt, 1<<20, 1<<17, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, wrong_p ? wrong_compare_fun : toku_builtin_compare_fun);  assert(r==0);
@@ -383,7 +383,7 @@ static void test_wrongendian_compare (int wrong_p, unsigned int N) {
 	DBT kbt = {.size=sizeof(a), .data=a};
 	DBT vbt = {.size=sizeof(b), .data=b};
 	if (verbose)
-	    printf("%s:%d insert: %02x%02x%02x%02x -> %02x%02x%02x%02x\n", __FILE__, __LINE__,
+	    printf("%s:%d insert: %02x%02x%02x%02x -> %02x%02x%02x%02x\n", __SRCFILE__, __LINE__,
 		   ((char*)kbt.data)[0], ((char*)kbt.data)[1], ((char*)kbt.data)[2], ((char*)kbt.data)[3],
 		   ((char*)vbt.data)[0], ((char*)vbt.data)[1], ((char*)vbt.data)[2], ((char*)vbt.data)[3]);
 	r = toku_brt_insert(brt, &kbt, &vbt, null_txn);
@@ -423,7 +423,7 @@ static void test_wrongendian_compare (int wrong_p, unsigned int N) {
 	    b[0] = a[3] = (unsigned char)((i>>24)&255);
 	    DBT kbt = {.size=sizeof(a), .data=a};
 	    DBT vbt = {.size=sizeof(b), .data=b};
-	    if (0) printf("%s:%d insert: %02x%02x%02x%02x -> %02x%02x%02x%02x\n", __FILE__, __LINE__,
+	    if (0) printf("%s:%d insert: %02x%02x%02x%02x -> %02x%02x%02x%02x\n", __SRCFILE__, __LINE__,
 			  ((unsigned char*)kbt.data)[0], ((unsigned char*)kbt.data)[1], ((unsigned char*)kbt.data)[2], ((unsigned char*)kbt.data)[3],
 			  ((unsigned char*)vbt.data)[0], ((unsigned char*)vbt.data)[1], ((unsigned char*)vbt.data)[2], ((unsigned char*)vbt.data)[3]);
 	    r = toku_brt_insert(brt, &kbt, &vbt, null_txn);

newbrt/tests/brt-test0.c

@@ -12,19 +12,19 @@ static void test0 (void) {
     BRT t;
     int r;
     CACHETABLE ct;
-    char fname[]= __FILE__ "0.brt";
-    if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__);
+    char fname[]= __SRCFILE__ ".brt";
+    if (verbose) printf("%s:%d test0\n", __SRCFILE__, __LINE__);
     
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
     assert(r==0);
-    if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__);
+    if (verbose) printf("%s:%d test0\n", __SRCFILE__, __LINE__);
     unlink(fname);
     r = toku_open_brt(fname, 1, &t, 1024, 256, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun);
     assert(r==0);
-    //printf("%s:%d test0\n", __FILE__, __LINE__);
-    //printf("%s:%d n_items_malloced=%lld\n", __FILE__, __LINE__, n_items_malloced);
+    //printf("%s:%d test0\n", __SRCFILE__, __LINE__);
+    //printf("%s:%d n_items_malloced=%lld\n", __SRCFILE__, __LINE__, n_items_malloced);
     r = toku_close_brt_nolsn(t, 0);     assert(r==0);
-    //printf("%s:%d n_items_malloced=%lld\n", __FILE__, __LINE__, n_items_malloced);
+    //printf("%s:%d n_items_malloced=%lld\n", __SRCFILE__, __LINE__, n_items_malloced);
     r = toku_cachetable_close(&ct);
     assert(r==0);
     

newbrt/tests/brt-test1.c

@@ -12,7 +12,7 @@ static void test1 (void) {
     BRT t;
     int r;
     CACHETABLE ct;
-    char fname[]= __FILE__ "1.brt";
+    char fname[]= __SRCFILE__ ".brt";
     DBT k,v;
     
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);

newbrt/tests/brt-test2.c

@@ -13,13 +13,13 @@ static void test2 (int limit) {
     int r;
     int i;
     CACHETABLE ct;
-    char fname[]= __FILE__ "2.brt";
-    if (verbose) printf("%s:%d checking\n", __FILE__, __LINE__);
+    char fname[]= __SRCFILE__ ".brt";
+    if (verbose) printf("%s:%d checking\n", __SRCFILE__, __LINE__);
     
     r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
     unlink(fname);
     r = toku_open_brt(fname, 1, &t, 1024, 256, TOKU_DEFAULT_COMPRESSION_METHOD, ct, null_txn, toku_builtin_compare_fun);
-    if (verbose) printf("%s:%d did setup\n", __FILE__, __LINE__);
+    if (verbose) printf("%s:%d did setup\n", __SRCFILE__, __LINE__);
     assert(r==0);
     for (i=0; i<limit; i++) { // 4096
 	DBT k,v;
@@ -29,9 +29,9 @@ static void test2 (int limit) {
 	r = toku_brt_insert(t, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v, val, 1+strlen(val)), null_txn);
 	assert(r==0);
 	r = toku_verify_brt(t); assert(r==0);
-	//printf("%s:%d did insert %d\n", __FILE__, __LINE__, i);
+	//printf("%s:%d did insert %d\n", __SRCFILE__, __LINE__, i);
     }
-    if (verbose) printf("%s:%d inserted\n", __FILE__, __LINE__);
+    if (verbose) printf("%s:%d inserted\n", __SRCFILE__, __LINE__);
     r = toku_verify_brt(t); assert(r==0);
     r = toku_close_brt_nolsn(t, 0);              assert(r==0);
     r = toku_cachetable_close(&ct);     assert(r==0);

newbrt/tests/brt-test3.c

@@ -6,7 +6,7 @@
 #include "test.h"
 #include <toku_time.h>
 
-static const char fname[]= __FILE__ ".brt";
+static const char fname[]= __SRCFILE__ ".brt";
 
 static const enum toku_compression_method compression_method = TOKU_DEFAULT_COMPRESSION_METHOD;
 

newbrt/tests/brt-test4.c

@@ -6,7 +6,7 @@
 #include "test.h"
 #include <toku_time.h>
 
-static const char fname[]= __FILE__ ".brt";
+static const char fname[]= __SRCFILE__ ".brt";
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test5.c

@@ -15,7 +15,7 @@ static void test5 (void) {
     int *values;
     int i;
     CACHETABLE ct;
-    char fname[]= __FILE__ ".brt";
+    char fname[]= __SRCFILE__ ".brt";
     
     MALLOC_N(limit,values);
     for (i=0; i<limit; i++) values[i]=-1;

newbrt/tests/brtloader-test-extractor.c

@@ -173,7 +173,7 @@ static char *merge(char **tempfiles, int ntempfiles, const char *testdir) {
         f[i].f = fopen(tname, "r"); 
 	if (f[i].f == NULL) {
 	    int error = errno;
-	    fprintf(stderr, "%s:%d errno=%d %s\n", __FILE__, __LINE__, error, strerror(error));
+	    fprintf(stderr, "%s:%d errno=%d %s\n", __SRCFILE__, __LINE__, error, strerror(error));
 	    if (error == EMFILE)
 		fprintf(stderr, "may need to increase the nofile ulimit\n");
 	}

newbrt/tests/brtloader-test-merge-files-dbufio.c

@@ -381,7 +381,7 @@ static void test (const char *directory, BOOL is_error) {
 	if (is_error && r!=0) {
 	    result = r;
 	} else {
-	    if (r!=0) printf("%s:%d r=%d (%s)\n", __FILE__, __LINE__, r, errorstr_static(r));
+	    if (r!=0) printf("%s:%d r=%d (%s)\n", __SRCFILE__, __LINE__, r, errorstr_static(r));
 	    assert(r==0);
 	}
         if (r)
@@ -414,7 +414,7 @@ static void test (const char *directory, BOOL is_error) {
 	    assert(cthunk.n_read == N_RECORDS);
 	}
     }
-    //printf("%s:%d Destroying\n", __FILE__, __LINE__);
+    //printf("%s:%d Destroying\n", __SRCFILE__, __LINE__);
     {
 	int r = queue_destroy(bl->primary_rowset_queue);
 	assert(r==0);

newbrt/tests/cachetable-3969.c

@@ -21,7 +21,7 @@ run_test (void) {
     int r;
     ct = NULL;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     f1 = NULL;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-4357.c

@@ -30,7 +30,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-4365.c

@@ -51,7 +51,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-4545.c

@@ -45,7 +45,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   CACHEFILE f1;
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-all-write.c

@@ -31,7 +31,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-checkpoint-pending.c

@@ -124,7 +124,7 @@ static void checkpoint_pending(void) {
     const int test_limit = N;
     int r;
     r = toku_create_cachetable(&ct, test_limit*sizeof(int), ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     r = unlink(fname1); if (r!=0) CKERR2(errno, ENOENT);
     r = toku_cachetable_openf(&cf, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
     toku_cachefile_set_userdata(cf, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

newbrt/tests/cachetable-checkpoint-pinned-nodes.c

@@ -65,7 +65,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   CACHEFILE f1;
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-checkpoint-prefetched-nodes.c

@@ -67,7 +67,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   CACHEFILE f1;
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-checkpoint-test.c

@@ -63,7 +63,7 @@ static void cachetable_checkpoint_test(int n, enum cachetable_dirty dirty) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-cleaner-checkpoint.c

@@ -61,7 +61,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-cleaner-checkpoint2.c

@@ -61,7 +61,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-cleaner-dev-null.c

@@ -50,7 +50,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-cleaner-thread-attrs-accumulate.c

@@ -61,7 +61,7 @@ run_test (void) {
     r = toku_pthread_mutex_init(&attr_mutex, NULL); resource_assert_zero(r);
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
 
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-cleaner-thread-empty-cachetable.c

@@ -15,7 +15,7 @@ cachetable_test (void) {
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
     r = toku_set_cleaner_period(ct, 1); assert(r == 0);
 
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-cleaner-thread-everything-pinned.c

@@ -28,7 +28,7 @@ run_test (void) {
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
     r = toku_set_cleaner_period(ct, 1); assert(r == 0);
 
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-cleaner-thread-nothing-needs-flushing.c

@@ -28,7 +28,7 @@ run_test (void) {
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
     r = toku_set_cleaner_period(ct, 1); assert(r == 0);
 
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-cleaner-thread-simple.c

@@ -37,7 +37,7 @@ run_test (void) {
     r = toku_set_cleaner_period(ct, 1); assert(r == 0);
     my_cleaner_callback_called = FALSE;
 
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
     

newbrt/tests/cachetable-clock-all-pinned.c

@@ -11,7 +11,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clock-eviction.c

@@ -56,7 +56,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clock-eviction2.c

@@ -95,7 +95,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clock-eviction3.c

@@ -110,7 +110,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clock-eviction4.c

@@ -93,7 +93,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clone-checkpoint.c

@@ -60,7 +60,7 @@ cachetable_test (void) {
     int r;
     ct = NULL;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clone-partial-fetch-pinned-node.c

@@ -52,7 +52,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clone-partial-fetch.c

@@ -56,7 +56,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clone-pin-nonblocking.c

@@ -37,7 +37,7 @@ cachetable_test (enum cachetable_dirty dirty, BOOL cloneable) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-clone-unpin-remove.c

@@ -50,7 +50,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-count-pinned-test.c

@@ -9,7 +9,7 @@ cachetable_count_pinned_test (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-debug-test.c

@@ -8,7 +8,7 @@ cachetable_debug_test (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-eviction-close-test.c

@@ -69,7 +69,7 @@ static void cachetable_eviction_full_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-eviction-close-test2.c

@@ -81,7 +81,7 @@ static void cachetable_eviction_full_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-eviction-getandpin-test.c

@@ -38,7 +38,7 @@ static void cachetable_predef_fetch_maybegetandpin_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-eviction-getandpin-test2.c

@@ -44,7 +44,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-fd-test.c

@@ -9,7 +9,7 @@ cachetable_fd_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE cf;
     r = toku_cachetable_openf(&cf, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
@@ -18,7 +18,7 @@ cachetable_fd_test (void) {
     toku_cachefile_unpin_fd(cf);
 
     // test set to good fd succeeds
-    char fname2[] = __FILE__ "test2.data";
+    char fname2[] = __SRCFILE__ "test2.data";
     unlink(fname2);
     int fd2 = open(fname2, O_RDWR | O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd2 >= 0 && fd1 != fd2);
     r = toku_cachefile_set_fd(cf, fd2, fname2); assert(r == 0);

newbrt/tests/cachetable-flush-during-cleaner.c

@@ -27,7 +27,7 @@ cachetable_test (void) {
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
   r = toku_set_cleaner_period(ct, 1); assert(r == 0);
 
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 

newbrt/tests/cachetable-flush-test.c

@@ -9,12 +9,12 @@ test_cachetable_def_flush (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
 
-    char fname2[] = __FILE__ "test2.dat";
+    char fname2[] = __SRCFILE__ "test2.dat";
     unlink(fname2);
     CACHEFILE f2;
     r = toku_cachetable_openf(&f2, ct, fname2, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-getandpin-test.c

@@ -46,7 +46,7 @@ cachetable_getandpin_test (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test_getandpin.dat";
+    char fname1[] = __SRCFILE__ "test_getandpin.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-kibbutz_and_flush_cachefile.c

@@ -25,7 +25,7 @@ run_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-partial-fetch.c

@@ -77,7 +77,7 @@ cachetable_test (void) {
     CACHETABLE ct;
     BOOL doing_prefetch = FALSE;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-pin-checkpoint.c

@@ -336,7 +336,7 @@ cachetable_test (void) {
     int r;
     
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
     

newbrt/tests/cachetable-pin-nonblocking-checkpoint-clean.c

@@ -14,7 +14,7 @@ run_test (void) {
     int r;
     ct = NULL;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     f1 = NULL;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-checkpoint-test.c

@@ -72,7 +72,7 @@ static void cachetable_prefetch_checkpoint_test(int n, enum cachetable_dirty dir
     CACHETABLE_WRITE_CALLBACK wc = def_write_callback(NULL);
     wc.flush_callback = flush;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-close-leak-test.c

@@ -53,7 +53,7 @@ static void cachetable_prefetch_close_leak_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-close-test.c

@@ -55,7 +55,7 @@ static void cachetable_prefetch_full_test (BOOL partial_fetch) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-flowcontrol-test.c

@@ -64,7 +64,7 @@ static void cachetable_prefetch_flowcontrol_test (int cachetable_size_limit) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, cachetable_size_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-getandpin-test.c

@@ -76,7 +76,7 @@ static void cachetable_prefetch_maybegetandpin_test (BOOL do_partial_fetch) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch-maybegetandpin-test.c

@@ -33,7 +33,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-prefetch2-test.c

@@ -36,7 +36,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-put-checkpoint.c

@@ -469,7 +469,7 @@ cachetable_test (void) {
     int r;
     
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test-put-checkpoint.dat";
+    char fname1[] = __SRCFILE__ "test-put-checkpoint.dat";
     unlink(fname1);
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
     

newbrt/tests/cachetable-put-test.c

@@ -8,7 +8,7 @@ cachetable_put_test (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-rename-test.c

@@ -91,7 +91,7 @@ static void test_rename (void) {
     int i;
     int r;
     test_mutex_init();
-    const char fname[] = __FILE__ "rename.dat";
+    const char fname[] = __SRCFILE__ "rename.dat";
     r=toku_create_cachetable(&t, KEYLIMIT, ZERO_LSN, NULL_LOGGER); assert(r==0);
     unlink(fname);
     r = toku_cachetable_openf(&f, t, fname, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO);

newbrt/tests/cachetable-reserve-filenum.c

@@ -17,7 +17,7 @@ cachetable_reserve_filenum_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE cf;
     r = toku_cachetable_openf(&cf, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
@@ -26,7 +26,7 @@ cachetable_reserve_filenum_test (void) {
     toku_cachefile_unpin_fd(cf);
 
     // test set to good fd succeeds
-    char fname2[] = __FILE__ "test2.data";
+    char fname2[] = __SRCFILE__ "test2.data";
     unlink(fname2);
     int fd2 = open(fname2, O_RDWR | O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd2 >= 0 && fd1 != fd2);
     r = toku_cachefile_set_fd(cf, fd2, fname2); assert(r == 0);

newbrt/tests/cachetable-scan.c

@@ -51,7 +51,7 @@ static int f_fetch (CACHEFILE f,
     return 0;
 }
 
-const char fname[] = __FILE__ ".dat";
+const char fname[] = __SRCFILE__ ".dat";
 
 CACHETABLE t;
 CACHEFILE f;

newbrt/tests/cachetable-simple-clone.c

@@ -62,7 +62,7 @@ test_clean (enum cachetable_dirty dirty, BOOL cloneable) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-clone2.c

@@ -49,7 +49,7 @@ test_clean (enum cachetable_dirty dirty, BOOL cloneable) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-maybe-get-pin.c

@@ -13,7 +13,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-pin-dep-nodes.c

@@ -69,7 +69,7 @@ cachetable_test (BOOL write_first, BOOL write_second, BOOL start_checkpoint) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-pin-nonblocking.c

@@ -60,7 +60,7 @@ run_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-pin.c

@@ -52,7 +52,7 @@ run_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-put-dep-nodes.c

@@ -76,7 +76,7 @@ cachetable_test (BOOL write_first, BOOL write_second, BOOL start_checkpoint) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-unpin-remove-checkpoint.c

@@ -27,7 +27,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   CACHEFILE f1;
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-simple-verify.c

@@ -9,7 +9,7 @@ cachetable_test (void) {
   int r;
   CACHETABLE ct;
   r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-  char fname1[] = __FILE__ "test1.dat";
+  char fname1[] = __SRCFILE__ "test1.dat";
   unlink(fname1);
   CACHEFILE f1;
   r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-test.c

@@ -158,7 +158,7 @@ static void test0 (void) {
     CACHETABLE t;
     CACHEFILE f;
     int r;
-    char fname[] = __FILE__ "test.dat";
+    char fname[] = __SRCFILE__ "test.dat";
 
     r=toku_create_cachetable(&t, 5, ZERO_LSN, NULL_LOGGER);
     assert(r==0);
@@ -325,7 +325,7 @@ static void test_nested_pin (void) {
     int i0, i1;
     int r;
     void *vv,*vv2;
-    char fname[] = __FILE__ "test_ct.dat";
+    char fname[] = __SRCFILE__ "test_ct.dat";
     if (verbose) printf("creating cachetable\n");
     r = toku_create_cachetable(&t, 1, ZERO_LSN, NULL_LOGGER);
     assert(r==0);
@@ -405,9 +405,9 @@ PAIR_ATTR *sizep __attribute__((__unused__)), int * dirtyp, void*extraargs) {
 static void test_multi_filehandles (void) {
     CACHETABLE t;
     CACHEFILE f1,f2,f3;
-    char fname1[]= __FILE__ "test_ct.dat";
-    char fname2[]= __FILE__ "test2_ct.dat";
-    char fname3[]= __FILE__ "test3_ct.dat";
+    char fname1[]= __SRCFILE__ "test_ct.dat";
+    char fname2[]= __SRCFILE__ "test2_ct.dat";
+    char fname3[]= __SRCFILE__ "test3_ct.dat";
     int r;
     void *v;
     unlink(fname1);
@@ -486,7 +486,7 @@ static void test_dirty(void) {
     r = toku_create_cachetable(&t, 4, ZERO_LSN, NULL_LOGGER);
     assert(r == 0);
 
-    char *fname = __FILE__ "test.dat";
+    char *fname = __SRCFILE__ "test.dat";
     unlink(fname);
     r = toku_cachetable_openf(&f, t, fname, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO);
     assert(r == 0);
@@ -619,7 +619,7 @@ static void test_size_resize(void) {
     r = toku_create_cachetable(&t, n*size, ZERO_LSN, NULL_LOGGER);
     assert(r == 0);
 
-    char *fname = __FILE__ "test.dat";
+    char *fname = __SRCFILE__ "test.dat";
     unlink(fname);
     r = toku_cachetable_openf(&f, t, fname, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO);
     assert(r == 0);
@@ -677,7 +677,7 @@ static void test_size_flush(void) {
     r = toku_create_cachetable(&t, n*size, ZERO_LSN, NULL_LOGGER);
     assert(r == 0);
 
-    char *fname = __FILE__ "test.dat";
+    char *fname = __SRCFILE__ "test.dat";
     unlink(fname);
     r = toku_cachetable_openf(&f, t, fname, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO);
     assert(r == 0);

newbrt/tests/cachetable-test2.c

@@ -159,14 +159,14 @@ static void test_chaining (void) {
     long i, trial;
     r = toku_create_cachetable(&ct, N_PRESENT_LIMIT, ZERO_LSN, NULL_LOGGER);    assert(r==0);
     for (i=0; i<N_FILES; i++) {
-	r = snprintf(fname[i], FILENAME_LEN, __FILE__ ".%ld.dat", i);
+	r = snprintf(fname[i], FILENAME_LEN, __SRCFILE__ ".%ld.dat", i);
 	assert(r>0 && r<FILENAME_LEN);
 	unlink(fname[i]);
 	r = toku_cachetable_openf(&f[i], ct, fname[i], O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO);   assert(r==0);
 	}
     for (i=0; i<N_PRESENT_LIMIT; i++) {
 	int fnum = i%N_FILES;
-	//printf("%s:%d Add %d\n", __FILE__, __LINE__, i);
+	//printf("%s:%d Add %d\n", __SRCFILE__, __LINE__, i);
 	u_int32_t fhash = toku_cachetable_hash(f[fnum], make_blocknum(i));
         CACHETABLE_WRITE_CALLBACK wc = def_write_callback((void *)i);
         wc.flush_callback = flush_forchain;
@@ -217,7 +217,7 @@ static void test_chaining (void) {
 	int fnum = i%N_FILES;
 	// i is always incrementing, so we need not worry about inserting a duplicate
         // if i is a duplicate, cachetable_put will return -1
-	// printf("%s:%d Add {%ld,%p}\n", __FILE__, __LINE__, i, f[fnum]);
+	// printf("%s:%d Add {%ld,%p}\n", __SRCFILE__, __LINE__, i, f[fnum]);
 	u_int32_t fhash = toku_cachetable_hash(f[fnum], make_blocknum(i));
         CACHETABLE_WRITE_CALLBACK wc = def_write_callback((void *)i);
         wc.flush_callback = flush_forchain;

newbrt/tests/cachetable-unpin-and-remove-test.c

@@ -29,7 +29,7 @@ cachetable_unpin_and_remove_test (int n) {
 
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, table_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, 0777); assert(r == 0);
@@ -71,7 +71,7 @@ cachetable_unpin_and_remove_test (int n) {
     for (i=0; i<n; i++) {
         r = toku_cachetable_unpin_and_remove(f1, keys[i], NULL, NULL);
         // assert(r != 0);
-        if (r == 0) printf("%s:%d warning %d\n", __FILE__, __LINE__, r);
+        if (r == 0) printf("%s:%d warning %d\n", __SRCFILE__, __LINE__, r);
     }
 
     // verify that the cachtable is empty
@@ -94,7 +94,7 @@ cachetable_put_evict_remove_test (int n) {
 
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, table_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, 0777); assert(r == 0);

newbrt/tests/cachetable-unpin-remove-and-checkpoint.c

@@ -29,7 +29,7 @@ run_test (void) {
     int r;
     ct = NULL;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-unpin-test.c

@@ -9,7 +9,7 @@ cachetable_unpin_test (int n) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/cachetable-writer-thread-limit.c

@@ -38,7 +38,7 @@ cachetable_test (void) {
     int r;
     CACHETABLE ct;
     r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
-    char fname1[] = __FILE__ "test1.dat";
+    char fname1[] = __SRCFILE__ "test1.dat";
     unlink(fname1);
     CACHEFILE f1;
     r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);

newbrt/tests/is_empty.c

@@ -9,7 +9,7 @@
 #include "checkpoint.h"
 
 
-#define TESTDIR __FILE__ ".dir"
+#define TESTDIR __SRCFILE__ ".dir"
 #define FILENAME "test0.brt"
 
 static void do_yield (voidfp f, void *fv, void *UU(v)) {

newbrt/tests/keyrange.c

@@ -12,7 +12,7 @@
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;
 
-static char fname[]= __FILE__ ".brt";
+static char fname[]= __SRCFILE__ ".brt";
 static CACHETABLE ct;
 static BRT t;
 

newbrt/tests/le-cursor-provdel.c

@@ -205,13 +205,13 @@ int
 test_main (int argc , const char *argv[]) {
     default_parse_args(argc, argv);
 
-    const char *logdir = __FILE__ ".dir";
+    const char *logdir = __SRCFILE__ ".dir";
     init_logdir(logdir);
     int error = chdir(logdir);
     assert(error == 0);
 
     const int n = 10;
-    const char *brtfile =  __FILE__ ".brt";
+    const char *brtfile =  __SRCFILE__ ".brt";
     create_populate_tree(".", brtfile, n);
     test_provdel(".", brtfile, n);
 

newbrt/tests/le-cursor-right.c

@@ -277,13 +277,13 @@ int
 test_main (int argc , const char *argv[]) {
     default_parse_args(argc, argv);
 
-    const char *logdir = __FILE__ ".dir";
+    const char *logdir = __SRCFILE__ ".dir";
     init_logdir(logdir);
     int error = chdir(logdir);
     assert(error == 0);
 
     const int n = 10;
-    const char *brtfile =  __FILE__ ".brt";
+    const char *brtfile =  __SRCFILE__ ".brt";
     create_populate_tree(".", brtfile, n);
     test_neg_infinity(brtfile, n);
     test_pos_infinity(brtfile, n);

newbrt/tests/le-cursor-walk.c

@@ -171,8 +171,8 @@ int
 test_main (int argc , const char *argv[]) {
     default_parse_args(argc, argv);
 
-    const char *logdir = __FILE__ ".dir";
-    const char *brtfile =  __FILE__ ".brt";
+    const char *logdir = __SRCFILE__ ".dir";
+    const char *brtfile =  __SRCFILE__ ".brt";
     char cmd[32+strlen(brtfile)];
     sprintf(cmd, "rm -rf %s", brtfile);
     int error = system(cmd);

newbrt/tests/log-test-maybe-trim.c

@@ -9,7 +9,7 @@
 #include "includes.h"
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test.c

@@ -13,7 +13,7 @@
 #endif
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test2.c

@@ -7,7 +7,7 @@
 #include "includes.h"
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test3.c

@@ -7,7 +7,7 @@
 #include "includes.h"
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test4.c

@@ -13,7 +13,7 @@
 #endif
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test5.c

@@ -7,7 +7,7 @@
 #include "includes.h"
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test6.c

@@ -13,7 +13,7 @@
 #endif
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "/"
 

newbrt/tests/log-test7.c

@@ -7,7 +7,7 @@
 #include "includes.h"
 
 #ifndef dname
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #endif
 #define rmrf "rm -rf " dname "_*/"
 

newbrt/tests/logcursor-bad-checksum.c

@@ -12,7 +12,7 @@
 # include <sys/syslimits.h>
 #endif
 
-#define dname __FILE__ ".dir"
+#define dname __SRCFILE__ ".dir"
 #define rmrf "rm -rf " dname "/"
 
 // log a couple of timestamp entries and verify the log by walking