v0.2.1

33 files changed, 0 insertions, 2554 deletions

diff --git a/test-chill/unit-tests/__init__.py b/test-chill/unit-tests/__init__.py
deleted file mode 100644
index 8b13789..0000000
--- a/test-chill/unit-tests/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_in.py b/test-chill/unit-tests/cpp_validate_prog/mm_in.py
deleted file mode 100755
index 93eb080..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_in.py
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/usr/bin/python
-
-import struct
-
-data = list(range(15)) + list(range(10)) + [0]*6
-bindata = ''.join([struct.pack('f',n) for n in data])
-with open('mm.in.data','wb') as f:
-    f.write(bindata)
-
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one.cc
deleted file mode 100644
index 6131ae1..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-#define AN 3
-#define BM 2
-#define AMBN 5
-
-/*
-
-<test name='mm_small'>
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one.testproc b/test-chill/unit-tests/cpp_validate_prog/mm_one.testproc
deleted file mode 100644
index a12a963..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one.testproc
+++ /dev/null
@@ -1,6 +0,0 @@
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_defines.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_defines.cc
deleted file mode 100644
index e35f189..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_defines.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-
-/*
-<test name='mm_small' define="{'AN':3, 'BM':2, 'AMBN':5}">
-
-procedure void mm(
-    in  float[AN][AMBN] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[AMBN][BM] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[AN][BM]   C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_main.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_main.cc
deleted file mode 100644
index 5b7e6c1..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_main.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-#define AN 3
-#define BM 2
-#define AMBN 5
-//#define PRINT
-
-#include <time.h>
-#include <fstream>
-#include <cstdio>
-
-/*
-
-<test name='mm_small'>
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            C[i][j] = 0;
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
-
-int main(int argc, char** argv) {
-    float A[3][5] = {{0,1,2,3,4},{5,6,7,8,9},{10,11,12,13,14}};
-    float B[5][2] = {{0,1},{2,3},{4,5},{6,7},{8,9}};
-    float C[3][2] = {{0,0},{0,0},{0,0}};
-    timespec start_time;
-    timespec end_time;
-    
-    if (argc == 3) {
-        std::ifstream is(argv[1], std::ifstream::in | std::ifstream::binary);
-        is.read((char*)A, 15*sizeof(float));
-        is.read((char*)B, 10*sizeof(float));
-        is.close();
-    }
-    
-    clock_gettime(CLOCK_REALTIME, &start_time);
-    for(int i = 0; i < 10000; i++) {
-        mm(A,B,C);
-    }
-    clock_gettime(CLOCK_REALTIME, &end_time);
-    
-    if (argc == 3) {
-        std::ofstream os(argv[2], std::ofstream::out | std::ofstream::binary);
-        os.write((char*)C, 6*sizeof(float));
-        os.close();
-    }
-    
-    #ifdef PRINT
-    std::printf("A:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 5; j++) {
-            std::printf("%f,",A[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("B:\n");
-    for(int i = 0; i < 5; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",B[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("C:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",C[i][j]);
-        }
-        std::printf("]\n");
-    }
-    #else
-    double time_diff = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec)/1000000000.0;
-    std::printf("(%f,)", time_diff);
-    #endif
-    return 0;
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_wrong_main.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_wrong_main.cc
deleted file mode 100644
index 7d96248..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_wrong_main.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-#define AN 3
-#define BM 2
-#define AMBN 5
-//#define PRINT
-
-#include <time.h>
-#include <fstream>
-#include <cstdio>
-
-/*
-
-<test name='mm_small'>
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            C[i][j] = 0;
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] + B[k][j];
-            }
-        }
-    }
-}
-
-int main(int argc, char** argv) {
-    float A[3][5] = {{0,1,2,3,4},{5,6,7,8,9},{10,11,12,13,14}};
-    float B[5][2] = {{0,1},{2,3},{4,5},{6,7},{8,9}};
-    float C[3][2] = {{0,0},{0,0},{0,0}};
-    timespec start_time;
-    timespec end_time;
-    
-    if (argc == 3) {
-        std::ifstream is(argv[1], std::ifstream::in | std::ifstream::binary);
-        is.read((char*)A, 15*sizeof(float));
-        is.read((char*)B, 10*sizeof(float));
-        is.close();
-    }
-    
-    clock_gettime(CLOCK_REALTIME, &start_time);
-    for(int i = 0; i < 1000000; i++) {
-        mm(A,B,C);
-    }
-    clock_gettime(CLOCK_REALTIME, &end_time);
-    
-    if (argc == 3) {
-        std::ofstream os(argv[2], std::ofstream::out | std::ofstream::binary);
-        os.write((char*)C, 6*sizeof(float));
-        os.close();
-    }
-    
-    #ifdef PRINT
-    std::printf("A:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 5; j++) {
-            std::printf("%f,",A[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("B:\n");
-    for(int i = 0; i < 5; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",B[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("C:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",C[i][j]);
-        }
-        std::printf("]\n");
-    }
-    #else
-    double time_diff = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec)/1000000000.0;
-    std::printf("(%f,)", time_diff);
-    #endif
-    return 0;
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_main.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_main.cc
deleted file mode 100644
index a03b505..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_main.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-#define AN 3
-#define BM 2
-#define AMBN 5
-//#define PRINT
-
-#include <time.h>
-#include <fstream>
-#include <cstdio>
-
-/*
-
-<test name='mm_small'>
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            C[i][j] = 0;
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
-
-int main(int argc, char** argv) {
-    float A[3][5] = {{0,1,2,3,4},{5,6,7,8,9},{10,11,12,13,14}};
-    float B[5][2] = {{0,1},{2,3},{4,5},{6,7},{8,9}};
-    float C[3][2] = {{0,0},{0,0},{0,0}};
-    timespec start_time;
-    timespec end_time;
-    
-    if (argc == 3) {
-        std::ifstream is(argv[1], std::ifstream::in | std::ifstream::binary);
-        is.read((char*)A, 15*sizeof(float));
-        is.read((char*)B, 10*sizeof(float));
-        is.close();
-    }
-    
-    clock_gettime(CLOCK_REALTIME, &start_time);
-    mm(A,B,C);
-    clock_gettime(CLOCK_REALTIME, &end_time);
-    
-    if (argc == 3) {
-        std::ofstream os(argv[2], std::ofstream::out | std::ofstream::binary);
-        os.write((char*)C, 6*sizeof(float));
-        os.close();
-    }
-    
-    #ifdef PRINT
-    std::printf("A:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 5; j++) {
-            std::printf("%f,",A[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("B:\n");
-    for(int i = 0; i < 5; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",B[i][j]);
-        }
-        std::printf("]\n");
-    }
-    std::printf("C:\n");
-    for(int i = 0; i < 3; i++) {
-        std::printf("[");
-        for(int j = 0; j < 2; j++) {
-            std::printf("%f,",C[i][j]);
-        }
-        std::printf("]\n");
-    }
-    #else
-    double time_diff = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec)/1000000000.0;
-    std::printf("(%f,)", time_diff);
-    #endif
-    return 0;
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_out.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_out.cc
deleted file mode 100644
index 6151301..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_out.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <time.h>
-#include <fstream>
-#include <cstdio>
-
-
-#define AN 3
-#define BM 2
-#define AMBN 5
-
-/*
-
-<test name='mm_small'>
-
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],lambda i,j: random(-8,8)),
-    in  float[5][2] B = matrix([*,*],lambda i,j: random(-8,8)),
-    out float[3][2] C = matrix([*,*],lambda i,j: 0))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
-
-int main(int argc, char** argv) {
-    float A[3][5];
-    float B[5][2];
-    float C[3][2];
-    timespec start_time;
-    timespec end_time;
-    
-    std::ifstream datafile_initialize(argv[1]);
-    datafile_initialize.read((char*)A, 15*sizeof(float));
-    datafile_initialize.read((char*)B, 10*sizeof(float));
-    datafile_initialize.read((char*)C, 6*sizeof(float));
-    datafile_initialize.close();
-    
-    clock_gettime(CLOCK_REALTIME, &start_time);
-    mm(A,B,C);
-    clock_gettime(CLOCK_REALTIME, &end_time);
-    
-    std::ofstream datafile_out(argv[2]);
-    datafile_out.write((char*)C, 6*sizeof(float));
-    datafile_out.close();
-    
-    double time_diff = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec)/1000000000.0;
-    std::printf("(%f,)", time_diff);
-    return 0;
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_with.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_with.cc
deleted file mode 100644
index 9cb0ae4..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_with.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-#define AN 3
-#define BM 2
-#define AMBN 5
-
-/*
-
-<test name='mm_small'>
-
-with {evendist2:lambda i,j: random(-8,8), zero2:lambda i,j: 0}
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],evendist2),
-    in  float[5][2] B = matrix([*,*],evendist2),
-    out float[3][2] C = matrix([*,*],zero2))
-
-</test>
-
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_with.testproc b/test-chill/unit-tests/cpp_validate_prog/mm_one_with.testproc
deleted file mode 100644
index 80bc841..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_with.testproc
+++ /dev/null
@@ -1,7 +0,0 @@
-
-with {evendist2:lambda i,j: random(-8,8), zero2:lambda i,j: 0}
-procedure void mm(
-    in  float[3][5] A = matrix([*,*],evendist2),
-    in  float[5][2] B = matrix([*,*],evendist2),
-    out float[3][2] C = matrix([*,*],zero2))
-
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_one_with_defines.cc b/test-chill/unit-tests/cpp_validate_prog/mm_one_with_defines.cc
deleted file mode 100644
index 77ce673..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_one_with_defines.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-
-/*
-<test name='mm_small' define="{'AN':3, 'BM':2, 'AMBN':5}">
-
-with {evendist2:lambda i,j: random(-8,8), zero2:lambda i,j: 0}
-procedure void mm(
-    in  float[AN][AMBN] A = matrix([*,*],evendist2),
-    in  float[AMBN][BM] B = matrix([*,*],evendist2),
-    out float[AN][BM]   C = matrix([*,*],zero2))
-
-</test>
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    int i;
-    int j;
-    int k;
-    for(i = 0; i < AN; i++) {
-        for(j = 0; j < BM; j++) {
-            for(k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc b/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc
deleted file mode 100644
index 49df049..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-<test name=small define="{'AN':2, 'AMBN':5, 'BM':3}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-
-<test name=medium define="{'AN':20, 'AMBN':50, 'BM':30}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-
-<test name=big define="{'AN':200, 'AMBN':500, 'BM':300}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    for(int i = 0; i < AN; i++) {
-        for(int j = 0; j < BM; j++) {
-            C[i][j] = 0;
-            for(int k = 0; k < AMBN; k++) {
-                C[i][j] += A[i][k] * B[k][j];
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc.data b/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc.data
deleted file mode 100644
index 82c5ce6..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc.data
+++ /dev/null
diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_three_slow.cc b/test-chill/unit-tests/cpp_validate_prog/mm_three_slow.cc
deleted file mode 100644
index dd8c7e7..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/mm_three_slow.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-<test name=small define="{'AN':2, 'AMBN':5, 'BM':3}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-
-<test name=medium define="{'AN':20, 'AMBN':50, 'BM':30}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-
-<test name=big define="{'AN':200, 'AMBN':500, 'BM':300}">
-    procedure void mm(
-        in  float[AN][AMBN] A = matrix([,],lambda i,j: i*AMBN + j),
-        in  float[AMBN][BM] B = matrix([,],lambda i,j: i*BM + j),
-        out float[AN][BM]   C = matrix([,],lambda i,j: 0))
-</test>
-*/
-
-void mm(float A[AN][AMBN], float B[AMBN][BM], float C[AN][BM]) {
-    for(int w = 0; w < 100; w++) {
-        for(int i = 0; i < AN; i++) {
-            for(int j = 0; j < BM; j++) {
-                C[i][j] = 0;
-                for(int k = 0; k < AMBN; k++) {
-                    C[i][j] += A[i][k] * B[k][j];
-                }
-            }
-        }
-    }
-}
diff --git a/test-chill/unit-tests/cpp_validate_prog/print_mm_out.py b/test-chill/unit-tests/cpp_validate_prog/print_mm_out.py
deleted file mode 100755
index fefbd2a..0000000
--- a/test-chill/unit-tests/cpp_validate_prog/print_mm_out.py
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/python
-
-import struct
-import numpy as np
-
-with open('mm.out.data','rb') as f:
-    data = f.read()
-
-mat = np.array([struct.unpack_from('f',data,n*4) for n in range(len(data)/4)]).reshape((3,2))
-print(mat)
diff --git a/test-chill/unit-tests/cprog/Makefile b/test-chill/unit-tests/cprog/Makefile
deleted file mode 100644
index f5f2608..0000000
--- a/test-chill/unit-tests/cprog/Makefile
+++ /dev/null
@@ -1,17 +0,0 @@
-OBJS = $(patsubst %.cc, %.o, $(wildcard *.cc))
-
-.PHONY: all
-all: sorter
-
-$(OBJS): %.o: %.cc
-	g++ -g -fprofile-arcs -ftest-coverage -c $< -o $@
-
-.PHONY: sorter
-sorter: $(OBJS)
-	g++ -g -fprofile-arcs -ftest-coverage -o bin/sorter $(OBJS)
-
-.PHONY: clean
-clean:
-	rm -f *.o
-	rm -f *.gcno *.gcda *.gcov
-	rm -f bin/sorter
diff --git a/test-chill/unit-tests/cprog/MergeSorter.cc b/test-chill/unit-tests/cprog/MergeSorter.cc
deleted file mode 100644
index 6e747a3..0000000
--- a/test-chill/unit-tests/cprog/MergeSorter.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "MergeSorter.h"
-
-/* Python
-def msort(lst, start, end, pindent = 0):
-    if start == end:
-        return
-    center = start + ((end - start) // 2)
-    print(' '*pindent + "SPLIT {}|{}".format(lst[start:center+1], lst[center+1:end+1]))
-    msort(lst, start, center, pindent+1)
-    msort(lst, center+1, end, pindent+1)
-    left = list(lst[start:center+1])
-    right = list(lst[center+1:end+1])
-    print(' '*pindent + "MERGE {}|{}".format(lst[start:center+1], lst[center+1:end+1]))
-    i,j = 0, 0
-    for k in range(start, end+1):
-        if i >= len(left):
-            lst[k] = right[j]
-            j += 1
-            print(' '*(pindent+1) + 'pull j: {} {} {}'.format(lst[start:k+1], left[i:], right[j:]))
-        elif j >= len(right):
-            lst[k] = left[i]
-            i += 1
-            print(' '*(pindent+1) + 'pull i: {} {} {}'.format(lst[start:k+1], left[i:], right[j:]))
-        elif left[i] > right[j]:
-            lst[k] = right[j]
-            j += 1
-            print(' '*(pindent+1) + 'pull j: {} {} {}'.format(lst[start:k+1], left[i:], right[j:]))
-        else:
-            lst[k] = left[i]
-            i += 1
-            print(' '*(pindent+1) + 'pull i: {} {} {}'.format(lst[start:k+1], left[i:], right[j:]))
-    print(' '*pindent + "-- {}".format(lst[start:end+1]))
-        
-
-if __name__ == '__main__':
-    import random as r
-    x = [int(r.random()*12) for i in range(7)]
-    print(x)
-    msort(x, 0, len(x)-1)
-    print(x)
-*/
-
-static void mergesort(std::vector<int>& lst, int start, int end) {
-    if(start == end) return;
-    int center = start + (end-start)/2;
-    mergesort(lst, start, center);
-    mergesort(lst, center+1, end);
-    std::vector<int> left = std::vector<int>(lst.begin()+start, lst.begin()+(center+1));
-    std::vector<int> right = std::vector<int>(lst.begin()+(center+1),lst.begin()+(end+1));
-    int i = 0;
-    int j = 0;
-    for(int k = start; k < (end+1); k++) {
-        if (i >= left.size()) {
-            lst[k] = right[j++];
-        }
-        else if(j >= right.size()) {
-            lst[k] = left[i++];
-        }
-        else if(left[i] > right[j]) {
-            lst[k] = right[j++];
-        }
-        else {
-            lst[k] = left[i++];
-        }
-    }
-}
-
-MergeSorter::MergeSorter() {
-    this->name = std::string("mergesort");
-}
-
-MergeSorter::~MergeSorter() {
-}
-
-void MergeSorter::sort(std::vector<int>& list) const {
-    mergesort(list, 0, list.size()-1);
-}
diff --git a/test-chill/unit-tests/cprog/MergeSorter.h b/test-chill/unit-tests/cprog/MergeSorter.h
deleted file mode 100644
index e2ed391..0000000
--- a/test-chill/unit-tests/cprog/MergeSorter.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef MERGE_SORTER_H
-#define MERGE_SORTER_H
-
-#include <vector>
-#include "Sorter.h"
-
-class MergeSorter : public Sorter {
-public:
-    MergeSorter();
-    virtual ~MergeSorter();
-    virtual void sort(std::vector<int>& list) const;
-};
-
-#endif
diff --git a/test-chill/unit-tests/cprog/QuickSorter.cc b/test-chill/unit-tests/cprog/QuickSorter.cc
deleted file mode 100644
index 3ade346..0000000
--- a/test-chill/unit-tests/cprog/QuickSorter.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "QuickSorter.h"
-
-/* Python
-
-def swap(l, i, k):
-    v = l[i]
-    l[i] = l[k]
-    l[k] = v
-    print(str(l))
-
-def partition(l, start, end):
-    print("PARTITION {} [{}:{}]".format(l, start, end))
-    p_value = l[end]
-    p_index = end-1
-    
-    for i in range(start, end):
-        while(i < p_index and l[i] >= p_value):
-            swap(l, i, p_index)
-            p_index -= 1
-        while(i >= p_index and l[i] < p_value):
-            swap(l, i, p_index)
-            p_index += 1
-    swap(l, p_index, end)
-    print("DONE {}|[{}]|{}:{}".format(l[start:p_index], l[p_index], l[p_index+1:end+1], p_value))
-    return p_index
-
-def qsort(l, i, k):
-    if i < k:
-        p = partition(l, i, k)
-        qsort(l,i,p-1)
-        qsort(l,p+1,k)
-
-if __name__ == "__main__":
-    import random as r
-    x = [int(r.random()*12) for i in range(12)]
-    print(x)
-    qsort(x, 0, len(x)-1)
-    print(x)
-    
-*/
-
-static void swap(std::vector<int>& list, int i, int k) {
-    int v = list[i];
-    list[i] = list[k];
-    list[k] = v;
-}
-
-static int partition(std::vector<int>& list, int i, int k) {
-    int pivot_value = list[k];
-    int pivot_index = k - 1;
-    
-    for(int index = i; index < k; index++) {
-        while((index < pivot_index) && (list[index] >= pivot_value)) {
-            swap(list, index, pivot_index);
-            pivot_index--;
-        }
-        while((index >= pivot_index) && (list[index] < pivot_value)) {
-            swap(list, index, pivot_index);
-            pivot_index++;
-        }
-    }
-    swap(list, pivot_index, k);
-    return pivot_index;
-}
-
-static void quicksort(std::vector<int>& list, int i, int k) {
-    if(i < k) {
-        int p = partition(list, i, k);
-        quicksort(list, i, p-1);
-        quicksort(list, p+1, k);
-    }
-}
-
-QuickSorter::QuickSorter() {
-    this->name = std::string("quicksort");
-}
-
-QuickSorter::~QuickSorter() {
-}
-
-void QuickSorter::sort(std::vector<int>& list) const {
-    quicksort(list, 0, list.size()-1);
-}
diff --git a/test-chill/unit-tests/cprog/QuickSorter.h b/test-chill/unit-tests/cprog/QuickSorter.h
deleted file mode 100644
index 81919dd..0000000
--- a/test-chill/unit-tests/cprog/QuickSorter.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef QUICK_SORTER_H
-#define QUICK_SORTER_H
-
-#include <vector>
-#include "Sorter.h"
-
-class QuickSorter : public Sorter {
-public:
-    QuickSorter();
-    virtual ~QuickSorter();
-    virtual void sort(std::vector<int>& list) const;
-};
-
-#endif
diff --git a/test-chill/unit-tests/cprog/Sorter.cc b/test-chill/unit-tests/cprog/Sorter.cc
deleted file mode 100644
index a1ae5ec..0000000
--- a/test-chill/unit-tests/cprog/Sorter.cc
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "Sorter.h"
-
-Sorter::Sorter() {
-}
-
-Sorter::~Sorter() {
-}
-
diff --git a/test-chill/unit-tests/cprog/Sorter.h b/test-chill/unit-tests/cprog/Sorter.h
deleted file mode 100644
index abf8f82..0000000
--- a/test-chill/unit-tests/cprog/Sorter.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef SORTER_H
-#define SORTER_H
-
-#include <string>
-#include <vector>
-
-class Sorter {
-public:
-    Sorter();
-    virtual ~Sorter();
-    
-    std::string name;
-    virtual void sort(std::vector<int>& list) const = 0;
-};
-
-#endif
diff --git a/test-chill/unit-tests/cprog/main.cc b/test-chill/unit-tests/cprog/main.cc
deleted file mode 100644
index 3fe960b..0000000
--- a/test-chill/unit-tests/cprog/main.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <cstdio>
-#include <cstdlib>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "Sorter.h"
-#include "QuickSorter.h"
-#include "MergeSorter.h"
-//#include "InsertionSorter.h"
-//#include "ShellSorter.h"
-
-void read_vector(std::vector<int>& vec, int start, int stop, char** argv) {
-    for(int i = start; i < stop; i++) {
-        vec.push_back((int)strtol(argv[i],NULL,0));
-    }
-}
-
-void print_vector(std::vector<int>& vec) {
-    printf("[");
-    for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); iter++) {
-        printf(" %d ", *iter);
-    }
-    printf("]\n");
-}
-
-void addsorter(std::map<std::string, Sorter*>& m, Sorter* s) {
-    m[s->name] = s;
-}
-
-int main(int argc, char** argv) {
-    std::map<std::string, Sorter*> sorter_map;
-    std::vector<int> vec;
-    
-    read_vector(vec, 2, argc, argv);
-    print_vector(vec);
-    
-    addsorter(sorter_map, new QuickSorter());
-    addsorter(sorter_map, new MergeSorter());
-    //addsorter(sorter_map, new InsertionSorter());
-    //addsorter(sorter_map, new ShellSorter());
-    sorter_map[std::string(argv[1])]->sort(vec);
-    print_vector(vec);
-}
-
diff --git a/test-chill/unit-tests/test___main__.py b/test-chill/unit-tests/test___main__.py
deleted file mode 100644
index 7a79417..0000000
--- a/test-chill/unit-tests/test___main__.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import os
-import unittest
-
-import testchill.gcov as gcov
-import testchill.__main__ as main
-
-
-def runtest(tc):
-    tc.setUp()
-    tc.run()
-    tc.tearDown()
-
-class TestMain(unittest.TestCase):
-    def setUp(self):
-        self.chill_dev_src = os.getenv('CHILL_DEV_SRC')
-        self.chill_release_src = os.getenv('CHILL_RELEASE_SRC')
-        self.omega_dev_src = os.getenv('OMEGA_DEV_SRC')
-        self.omega_release_src = os.getenv('OMEGA_RELEASE_SRC')
-        self.staging_dir_bin = os.getenv('STAGING_DIR_BIN')
-        self.staging_dir_wd = os.getenv('STAGING_DIR_WD')
-    
-    def test_main_parse_chillbuild(self):
-        pass
-    
-    def test_main_parse_chill_dev(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase path/to/somescript.script path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        
-        self.assertEqual(tc.config.chill_dir, None)
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.build_cuda, False)
-        self.assertEqual(tc.config.version, 'dev')
-        self.assertEqual(tc.config.script_lang, 'script')
-        
-        self.assertEqual(tc.name, 'chill:somescript.script')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'chill'))
-        self.assertEqual(tc.chill_script, 'somescript.script')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.script'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.c')
-    
-    def test_main_parse_chill_lua_dev(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase path/to/somescript.lua path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        
-        self.assertEqual(tc.config.chill_dir, None)
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.build_cuda, False)
-        self.assertEqual(tc.config.version, 'dev')
-        self.assertEqual(tc.config.script_lang, 'lua')
-        
-        self.assertEqual(tc.name, 'chill-lua:somescript.lua')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'chill-lua'))
-        self.assertEqual(tc.chill_script, 'somescript.lua')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.lua'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.c')
-    
-    def test_main_parse_chill_python_dev(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase path/to/somescript.py path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        
-        self.assertEqual(tc.config.chill_dir, None)
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.build_cuda, False)
-        self.assertEqual(tc.config.version, 'dev')
-        self.assertEqual(tc.config.script_lang, 'python')
-        
-        self.assertEqual(tc.name, 'chill-python:somescript.py')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'chill-python'))
-        self.assertEqual(tc.chill_script, 'somescript.py')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.py'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.c')
-    
-    def test_main_parse_cudachill_dev(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase -u path/to/somescript.lua path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        
-        self.assertEqual(tc.config.chill_dir, None)
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.build_cuda, True)
-        self.assertEqual(tc.config.version, 'dev')
-        self.assertEqual(tc.config.script_lang, 'lua')
-        
-        self.assertEqual(tc.name, 'cuda-chill:somescript.lua')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'cuda-chill'))
-        self.assertEqual(tc.chill_script, 'somescript.lua')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.lua'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.cu')
-    
-    def test_main_parse_cudachill_python_dev(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase -u path/to/somescript.py path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        
-        self.assertEqual(tc.config.chill_dir, None)
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.build_cuda, True)
-        self.assertEqual(tc.config.version, 'dev')
-        self.assertEqual(tc.config.script_lang, 'python')
-        
-        self.assertEqual(tc.name, 'cuda-chill-python:somescript.py')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'cuda-chill-python'))
-        self.assertEqual(tc.chill_script, 'somescript.py')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.py'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.cu')
-    
-    def test_main_parse_chill_release(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase -v release path/to/somescript.script path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'chill-release:somescript.script')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'chill-release'))
-        self.assertEqual(tc.chill_script, 'somescript.script')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.script'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.c')
-    
-    def test_main_parse_chill_release(self):
-        tclist = main.args_to_tclist('-b {} chill-testcase -uv release path/to/somescript.lua path/to/somesrc.c'.format(self.staging_dir_bin).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'cuda-chill-release:somescript.lua')
-        self.assertEqual(tc.wd, os.getcwd())
-        self.assertEqual(tc.chill_bin, os.path.join(self.staging_dir_bin, 'cuda-chill-release'))
-        self.assertEqual(tc.chill_script, 'somescript.lua')
-        self.assertEqual(tc.chill_src, 'somesrc.c')
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'path/to/somescript.lua'))
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'path/to/somesrc.c'))
-        self.assertEqual(tc.chill_gensrc, 'rose_somesrc.cu')
-    
-    def test_main_parse_chillbuild_dev(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'chill')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'script')
-    
-    def test_main_parse_chillbuild_lua_dev(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -i lua'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'chill-lua')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'lua')
-    
-    def test_main_parse_chillbuild_python_dev(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -i python'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'chill-python')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'python')
-    
-    def test_main_parse_chillbuild_cuda_dev(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -u'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'cuda-chill')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'lua')
-    
-    def test_main_parse_chillbuild_cuda_python_dev(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -u -i python'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'cuda-chill-python')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'python')
-    
-    def test_main_parse_chillbuild_release(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -v release'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'chill-release')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'script')
-    
-    def test_main_parse_chillbuild_cuda_release(self):
-        tclist = main.args_to_tclist('-b {} -C {} build-chill-testcase -u -v release'.format(self.staging_dir_bin, self.chill_dev_src).split(), coverage_set=gcov.GcovSet())
-        tc = tclist[0]
-        self.assertEqual(tc.name, 'cuda-chill-release')
-        self.assertEqual(tc.config.bin_dir, self.staging_dir_bin)
-        self.assertEqual(tc.config.chill_dir, self.chill_dev_src)
-        self.assertEqual(tc.config.script_lang, 'lua')
-    
-    def test_main_tctree(self):
-        tclist = main.args_to_tclist('batch test-cases/unit/chill-basic.tclist'.split(), coverage_set=gcov.GcovSet())
-        for tc in tclist:
-            runtest(tc)
-
-    
diff --git a/test-chill/unit-tests/test__cpp_validate_env.py b/test-chill/unit-tests/test__cpp_validate_env.py
deleted file mode 100644
index e0225cd..0000000
--- a/test-chill/unit-tests/test__cpp_validate_env.py
+++ /dev/null
@@ -1,377 +0,0 @@
-import ast
-import functools
-import itertools
-import pylang.debug
-import random
-import struct
-import unittest
-
-import testchill
-import testchill._cpp_validate_env as validate_env
-import testchill.cpp_validate
-import testchill.util
-
-## Support functions ##
-class Point(object):
-    def __init__(self, x, y):
-        self.x = x
-        self.y = y
-
-def _compile_and_run(expr, target_type, bindings):
-    t = ast.fix_missing_locations(ast.Expression(expr.compile_expr(target_type)))
-    return eval(compile(t, '<string>', 'eval'), bindings)
-
-def _compile_and_invoke(expr, target_type, bindings, args):
-    t = ast.fix_missing_locations(ast.Expression(expr.compile_expr(target_type)))
-    return (eval(compile(t, '<string>', 'eval'), bindings))(*args)
-
-def _expr_test(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value):
-    freevars = expr.getfreevars(fv_bindings)
-    value = _compile_and_run(expr, target_type, rt_bindings)
-    tc.assertEqual(exp_freevars, freevars)
-    tc.assertEqual(exp_value, value)
-    tc.assertEqual(target_type, type(value))
-
-def _expr_test_list(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value):
-    freevars = expr.getfreevars(fv_bindings)
-    value = _compile_and_run(expr, target_type, rt_bindings)
-    tc.assertEqual(exp_freevars, freevars)
-    tc.assertEqual(exp_value, value)
-    tc.assertEqual(list, type(value))
-
-def _expr_test_invoke(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value):
-    freevars = expr.getfreevars(fv_bindings)
-    value = _compile_and_invoke(expr, target_type, rt_bindings, invoke_args)
-    tc.assertEqual(exp_freevars, freevars)
-    tc.assertEqual(exp_value, value)
-    tc.assertEqual(target_type.exprtype, type(value))
-
-def lambdatype(param_types, etype):
-    return validate_env._pylambdatype(param_types, etype)
-
-def arraytype(dims, etype):
-    return validate_env._pyarraytype(dims, etype)
-
-
-## Test case class ##
-class Test_CppValidateEnv(unittest.TestCase):
-    def setUp(self):
-        ### data for the abstract syntax tree ###
-        _const_4 = validate_env._ConstantExpr('4')
-        _const_3 = validate_env._ConstantExpr('3')
-        _const_2 = validate_env._ConstantExpr('2')
-        _const_0 = validate_env._ConstantExpr('0')
-        _name_x = validate_env._NameExpr('x')
-        _name_y = validate_env._NameExpr('y')
-        _name_p = validate_env._NameExpr('p')
-        _name_pow = validate_env._NameExpr('pow')
-        _attr_px = validate_env._AttributeExpr(_name_p, 'x')
-        _attr_py = validate_env._AttributeExpr(_name_p, 'y')
-        _add_3_2 = validate_env._BinExpr(_const_3, '+', _const_2)
-        _add_x_2 = validate_env._BinExpr(_name_x, '+', _const_2)
-        _pow_x_2 = validate_env._BinExpr(_name_x, '**', _const_2)
-        
-        _name_i = validate_env._NameExpr('i')
-        _lambda_i = validate_env._LambdaExpr(['i'],_name_i)
-        
-        _name_j = validate_env._NameExpr('j')
-        _const_10 = validate_env._ConstantExpr('10')
-        _mul_i_10 = validate_env._BinExpr(_name_i, '*', _const_10)
-        _add_mul_i_10_j = validate_env._BinExpr(_mul_i_10, '+', _name_j)
-        _lambda_ij = validate_env._LambdaExpr(['i','j'],_add_mul_i_10_j)
-        
-        self._ConstantExpr_test_data = [
-                (('3',), set(), dict(), int, set(), int(3)),
-                (('3',), set(), dict(), float, set(), float(3))
-            ]
-        self._NameExpr_test_data = [
-                (('x',), set(), {'x':3}, int, {'x'}, int(3)),
-                (('x',), {'x'}, {'x':3}, int, set(), int(3))
-            ]
-        self._AttributeExpr_test_data = [
-                ((validate_env._NameExpr('p'),'x'), set(), {'p':Point(3,0)}, int, {'p'}, int(3)),
-                ((validate_env._NameExpr('p'),'x'), {'p'}, {'p':Point(3,0)}, int, set(), int(3))
-            ]
-        self._BinExpr_test_data = [
-                ((_const_3, '+', _const_2), set(), dict(), int, set(), int(5)),
-                ((_const_3, '+', _const_2), set(), dict(), float, set(), float(5)),
-                ((_name_x, '+', _const_2), set(), {'x':3}, int, {'x'}, int(5)),
-                ((_name_x, '+', _const_2), {'x'}, {'x':3}, int, set(), int(5)),
-                ((_const_3, '+', _name_x), set(), {'x':2}, int, {'x'}, int(5)),
-                ((_const_3, '+', _name_x), {'x'}, {'x':2}, int, set(), int(5)),
-                ((_const_3, '-', _const_2), set(), dict(), int, set(), int(1)),
-                ((_const_3, '*', _const_2), set(), dict(), int, set(), int(6)),
-                ((_const_3, '/', _const_2), set(), dict(), int, set(), int(1)),
-                ((_const_3, '**', _const_2), set(), dict(), int, set(), int(9))
-            ]
-        self._UnaryExpr_test_data = [
-                (('-', _const_3), set(), dict(), int, set(), int(-3)),
-                (('-', _add_3_2), set(), dict(), int, set(), int(-5)),
-                (('-', _add_x_2), set(), {'x':3}, int, {'x'}, int(-5)),
-                (('-', _add_x_2), {'x'}, {'x':3}, int, set(), int(-5))
-            ]
-        self._LambdaExpr_test_data = [
-                (([],_const_3), set(), dict(), lambdatype([],int), set(), tuple(), int(3)),
-                (([],_name_x), set(), {'x':3}, lambdatype([],int), {'x'}, tuple(), int(3)),
-                ((['x'],_pow_x_2), set(), dict(), lambdatype([int],int), set(), (int(4),), int(16))
-            ]
-        self._InvokeExpr_test_data = [
-                ((_name_pow,[_const_3, _const_2]), set(), dict(), int, {'pow'}, int(9)),
-            ]
-        self._MatrixGenerator_test_data = [
-                (([_const_2],_lambda_i), set(), {'_pyitertools': itertools}, arraytype([None],int), set(), [0, 1]),
-                (([None],_lambda_i), set(), {'_pyitertools': itertools}, arraytype([_const_2],int), set(), [0, 1]),
-                (([_const_2,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,_const_3], int), set(), [0, 1, 2, 10, 11, 12]),
-                (([_const_2,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([None,None], int), set(), [0, 1, 2, 10, 11, 12]),
-                (([_const_2,None],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([None,_const_3], int), set(), [0, 1, 2, 10, 11, 12]),
-                (([None,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,None], int), set(), [0, 1, 2, 10, 11, 12]),
-                (([None,None],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,_const_3], int), set(), [0, 1, 2, 10, 11, 12]),
-                (([_name_x],_lambda_i), set(), {'_pyitertools': itertools, 'x':2}, arraytype([None],int), {'x'}, [0, 1]),
-                (([None],_lambda_i), set(), {'_pyitertools': itertools, 'x':2}, arraytype([_name_x],int), set(), [0, 1]),
-            ]
-        self._RandomExpr_test_state = random.getstate()
-        self._RandomExpr_test_data = [
-                ((_const_0,_const_4), set(), {'_pyrandom': random}, int, set(), int(random.random()*4)),
-                ((_const_0,_name_x), set(), {'_pyrandom': random, 'x':4}, int, {'x'}, int(random.random()*4)),
-                ((_name_x,_const_4), set(), {'_pyrandom': random, 'x':0}, int, {'x'}, int(random.random()*4)),
-            ]
-        ### data for data generating ###
-        _name_ambn = validate_env._NameExpr('ambn')
-        _name_an   = validate_env._NameExpr('an')
-        _name_bm   = validate_env._NameExpr('bm')
-        _name_even2 = validate_env._NameExpr('evendist2')
-        _lambda_ij_0 = validate_env._LambdaExpr(['i','j'],_const_0)
-        _matrix_2_an_ambn_even2 = validate_env._MatrixGenerator([_name_an,_name_ambn],_name_even2)
-        _matrix_2_ambn_bm_even2 = validate_env._MatrixGenerator([_name_ambn,_name_bm],_name_even2)
-        _matrix_2_an_bm_lambda_ij_0 = validate_env._MatrixGenerator([_name_an,_name_bm],_lambda_ij_0)
-        _add_an_bm = validate_env._BinExpr(_name_an, '+', _name_bm)
-        _int_type = validate_env._CppPrimitiveType.get_from_cppname('int')
-        _float_type = validate_env._CppPrimitiveType.get_from_cppname('float')
-        _float_ptr_type = validate_env._CppPointerType(_float_type)
-        _param_A    = validate_env._Parameter('A',   _float_ptr_type,'in', _matrix_2_an_ambn_even2)
-        _param_B    = validate_env._Parameter('B',   _float_ptr_type,'in', _matrix_2_ambn_bm_even2)
-        _param_C    = validate_env._Parameter('C',   _float_ptr_type,'out',_matrix_2_an_bm_lambda_ij_0)
-        _param_ambn = validate_env._Parameter('ambn',_int_type,      'in', _add_an_bm)
-        _param_an   = validate_env._Parameter('an',  _int_type,      'in', _const_2)
-        _param_bm   = validate_env._Parameter('bm',  _int_type,      'in', _const_3)
-        self._Parameter_order_by_freevars_test_data = [
-                ([_param_A, _param_B, _param_C, _param_ambn, _param_an, _param_bm], ['an','bm','C','ambn','A','B'])
-            ]
-        _float_3_type = validate_env._CppArrayType(_float_type, [_const_3])
-        _float_3_2_type = validate_env._CppArrayType(_float_type, [_const_3,_const_2])
-        _name_N = validate_env._NameExpr('N')
-        _float_N_type = validate_env._CppArrayType(_float_type, [_name_N])
-        _float_N_2_type = validate_env._CppArrayType(_float_type, [_name_N,_const_2])
-        self._CppType_statictype_test_data = [
-                ((_int_type, dict()), 'int'),
-                ((_float_ptr_type, dict()), 'float*'),
-                ((_float_3_type, dict()), 'float[3]'),
-                ((_float_N_type, {'N': 3}), 'float[3]'),
-                ((_float_N_2_type, {'N': 3}), 'float[3][2]')
-            ]
-        _int_ptr_type = validate_env._CppPointerType(_int_type)
-        _int_ptr_ptr_type = validate_env._CppPointerType(_int_ptr_type)
-        _int_3_type = validate_env._CppArrayType(_int_type, [_const_3])
-        _int_N_type = validate_env._CppArrayType(_int_type, [_name_N])
-        _int_3_2_type = validate_env._CppArrayType(_int_type, [_const_3, _const_2])
-        joinbytes = lambda b: functools.reduce(lambda a,v: a+v,b)
-        self._CppType_formatdata_test_data = [
-                ((_int_type,         dict(), 3),                 ([1],     struct.pack('i',3))),
-                ((_float_type,       dict(), float(3)),          ([1],     struct.pack('f',float(3)))),
-                ((_int_3_type,       dict(), list(range(3))),    ([3],     joinbytes([struct.pack('i',i) for i in range(3)]))),
-                ((_int_3_2_type,     dict(), list(range(6))),    ([3,2],   joinbytes([struct.pack('i',i) for i in range(6)]))),
-                ((_int_ptr_type,     dict(), 3),                 ([1,1],   struct.pack('i',3))),
-                ((_int_ptr_type,     dict(), list(range(3))),    ([3,1],   joinbytes([struct.pack('i',i) for i in range(3)]))),
-                ((_int_ptr_ptr_type, dict(), list(range(3))),    ([3,1,1], joinbytes([struct.pack('i',i) for i in range(3)]))),
-                ((_int_ptr_ptr_type, dict(), [[0,1,2],[3,4,5]]), ([2,3,1], joinbytes([struct.pack('i',i) for i in range(6)]))),
-            ]
-        evendist2 = lambda i,j: random.random()
-        random.seed(0)
-        self._Parameter_generatedata_test_state = random.getstate()
-        if testchill.util.python_version_major == 2:
-            self._Parameter_generatedata_test_data = [
-                    ((_param_A,    {'an':2, 'ambn':5,'evendist2':evendist2}), ('A', 'float*', [10, 1], '\x08,X?M\tB?)U\xd7>\xbc\x90\x84>\xe6\xe2\x02?\x87S\xcf>\x06\xa7H?\xceK\x9b>\x84\x04\xf4>\x86X\x15?')),
-                    ((_param_B,    {'ambn':5, 'bm':3,'evendist2':evendist2}), ('B', 'float*', [15, 1], '\x16zh?(3\x01?\rM\x90>b|A?nM\x1e?^B\x80>!\xe5h?\xd4\x97{?fjO?Y\xf4f?\xaa\xcb\x9e>A\xd6:?D\x1af?\x92\x19/?\xb1\xbc\xf1>')),
-                    ((_param_C,    {'an':2, 'bm':3, 'evendist2':evendist2}),  ('C', 'float*', [6, 1], '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')),
-                    ((_param_ambn, {'an':2, 'bm':3}),                         ('ambn', 'int', [1], '\x05\x00\x00\x00')),
-                    ((_param_an,   dict()),                                   ('an', 'int', [1], '\x02\x00\x00\x00')),
-                    ((_param_bm,   dict()),                                   ('bm', 'int', [1], '\x03\x00\x00\x00'))
-                ]
-        else:
-            self._Parameter_generatedata_test_data = [
-                    ((_param_A,    {'an':2, 'ambn':5,'evendist2':evendist2}), ('A', 'float*', [10, 1], b'\x08,X?M\tB?)U\xd7>\xbc\x90\x84>\xe6\xe2\x02?\x87S\xcf>\x06\xa7H?\xceK\x9b>\x84\x04\xf4>\x86X\x15?')),
-                    ((_param_B,    {'ambn':5, 'bm':3,'evendist2':evendist2}), ('B', 'float*', [15, 1], b'\x16zh?(3\x01?\rM\x90>b|A?nM\x1e?^B\x80>!\xe5h?\xd4\x97{?fjO?Y\xf4f?\xaa\xcb\x9e>A\xd6:?D\x1af?\x92\x19/?\xb1\xbc\xf1>')),
-                    ((_param_C,    {'an':2, 'bm':3, 'evendist2':evendist2}),  ('C', 'float*', [6, 1], b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')),
-                    ((_param_ambn, {'an':2, 'bm':3}),                         ('ambn', 'int', [1], b'\x05\x00\x00\x00')),
-                    ((_param_an,   dict()),                                   ('an', 'int', [1], b'\x02\x00\x00\x00')),
-                    ((_param_bm,   dict()),                                   ('bm', 'int', [1], b'\x03\x00\x00\x00'))
-                ]
-        ### data for parsing ###
-        self.parse_procedure_test_data = [
-                (('procedure void q()',), ('void', 'q', 0)),
-                (('procedure int q()',), ('int', 'q', 0)),
-                (('procedure float q()',), ('float', 'q', 0)),
-                (('procedure unsigned int q()',), ('unsigned int', 'q', 0)),
-                (('procedure void q(in int x)',), ('void', 'q', 1)),
-                (('procedure void q(in int x, in int y)',), ('void', 'q', 2)),
-            ]
-        _mm_proc_expr = '''
-            procedure void mm(
-                in  float* A    = matrix([an,ambn],evendist2),
-                in  float* B    = matrix([ambn,bm],evendist2),
-                out float* C    = matrix([an,bm],lambda i,j: 0),
-                in  int    ambn = an + bm,
-                in  int    an   = 2,
-                in  int    bm   = 3)
-            '''
-        self.parse_parameter_test_data = [
-                (('procedure void mm(in int x)',), [(0, 'x', 'int', 'in', False, set())]),
-                (('procedure void mm(out int* x = 10)',), [(0, 'x', 'int*', 'out', True, set())]),
-                ((_mm_proc_expr,),[
-                        (0, 'A', 'float*', 'in', True, set(['an','ambn','evendist2'])),
-                        (1, 'B', 'float*', 'in', True, set(['ambn','bm','evendist2'])),
-                        (2, 'C', 'float*', 'out', True, set(['an','bm'])),
-                        (3, 'ambn', 'int', 'in', True, set(['an','bm'])),
-                        (4, 'an', 'int', 'in', True, set([])),
-                        (5, 'bm', 'int', 'in', True, set([]))
-                    ]),
-            ]
-        ### data for code generation ###
-        _float_2d_type = validate_env._CppArrayType(_float_type, [_name_an,_name_ambn])
-        self._CppType_statictype_test_data = [
-                ((_float_2d_type, {'an':2,'ambn':5}), 'float[2][5]')
-            ]
-        self._CppType_get_cdecl_stmt_test_data = [
-                ((_float_2d_type, 'A', {'an':2,'ambn':5}), 'float A[2][5];')
-            ]
-        self._CppType_get_cread_stmt_test_data = [
-                ((_float_2d_type, 'A', {'an':2,'ambn':5}, 'datafile_initialize', [10,1]), 'datafile_initialize.read((char*)A, 10*sizeof(float));')
-            ]
-        self._CppType_get_cwrite_stmt_test_data = [
-                ((_float_2d_type, 'A', {'an':2,'ambn':5}, 'datafile_out', [10,1]), 'datafile_out.write((char*)A, 10*sizeof(float));')
-            ]
-    
-    def run_expr_test_data(self, ctor, test_data):
-        for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value in test_data:
-            expr = ctor(*ctor_args)
-            _expr_test(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value)
-    
-    def run_expr_test_data_list(self, ctor, test_data):
-        for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value in test_data:
-            expr = ctor(*ctor_args)
-            _expr_test_list(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value)
-    
-    def run_expr_test_data_invoke(self, ctor, test_data):
-        for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value in test_data:
-            expr = ctor(*ctor_args)
-            _expr_test_invoke(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value)
-    
-    def test__ConstantExpr(self):
-        self.run_expr_test_data(validate_env._ConstantExpr, self._ConstantExpr_test_data)
-    
-    def test__NameExpr(self):
-        self.run_expr_test_data(validate_env._NameExpr, self._NameExpr_test_data)
-    
-    def test__AttributeExpr(self):
-        self.run_expr_test_data(validate_env._AttributeExpr, self._AttributeExpr_test_data)
-    
-    def test__UnaryExpr(self):
-        self.run_expr_test_data(validate_env._UnaryExpr, self._UnaryExpr_test_data)
-    
-    def test__LambdaExpr(self):
-        self.run_expr_test_data_invoke(validate_env._LambdaExpr, self._LambdaExpr_test_data)
-    
-    def test__InvokeExpr(self):
-        self.run_expr_test_data(validate_env._InvokeExpr, self._InvokeExpr_test_data)
-    
-    def test__MatrixGenerator(self):
-        self.run_expr_test_data_list(validate_env._MatrixGenerator, self._MatrixGenerator_test_data)
-    
-    def test__RandomExpr(self):
-        random.setstate(self._RandomExpr_test_state)
-        self.run_expr_test_data(validate_env._RandomExpr, self._RandomExpr_test_data)
-    
-    def test_parse_procedure(self):
-        parse_func = testchill.cpp_validate._parse_testproc_script
-        for args, expected in self.parse_procedure_test_data:
-            rtype_exp, name_exp, param_count_exp = expected
-            proc = parse_func(*args)
-            self.assertEqual(str(proc.rtype), rtype_exp)
-            self.assertEqual(proc.name, name_exp)
-            self.assertEqual(len(proc.parameters), param_count_exp)
-    
-    def test_parse_parameter(self):
-        #pylang.debug.enable(['pylang.parser.BaseTextParser.parse'])
-        parse_func = testchill.cpp_validate._parse_testproc_script
-        for args, expected in self.parse_parameter_test_data:
-            proc = parse_func(*args)
-            for param_exp in expected:
-                index, name_exp, ctype_exp, direction_exp, has_init_exp, freevars_exp = param_exp
-                param = proc.parameters[index]
-                self.assertEqual(param.name, name_exp)
-                self.assertEqual(str(param.cpptype), ctype_exp)
-                self.assertEqual(param.direction, direction_exp)
-                self.assertEqual(param.init_expr is not None, has_init_exp)
-                self.assertEqual(param.getfreevars(), freevars_exp)
-        #pylang.debug.enable(['pylang.parser.BaseTextParser.parse'], False)
-    
-    def test__Parameter_order_by_freevars(self):
-        def testfunc(param_list):
-            return [p.name for p in validate_env._Parameter.order_by_freevars(param_list)]
-        for arg, expected in self._Parameter_order_by_freevars_test_data:
-            self.assertEqual(testfunc(arg),expected)
-    
-    def test__CppType_statictype(self):
-        def testfunc(ctype, glbls):
-            return str(ctype.statictype(glbls))
-        for args, expected in self._CppType_statictype_test_data:
-            self.assertEqual(testfunc(*args), expected)
-    
-    def test__CppType_formatdata(self):
-        def testfunc(ctype, glbls, data):
-            return ctype.statictype(glbls).formatdata(data)
-        for args, expected in self._CppType_formatdata_test_data:
-            dim_exp, bytes_exp = expected
-            dim_val, bytes_val = testfunc(*args)
-            self.assertEqual(dim_val, dim_exp)
-            self.assertEqual(bytes_val, bytes_exp)
-    
-    def test__CppType_statictype(self):
-        def testfunc(t, bindings):
-            return str(t.statictype(bindings))
-        for args, typename in self._CppType_statictype_test_data:
-            self.assertEqual(testfunc(*args), typename)
-    
-    def test__CppType_get_cdecl_stmt(self):
-        def testfunc(t, param_name, bindings):
-            return t.statictype(bindings).get_cdecl_stmt(param_name)
-        for args, decl_exp in self._CppType_get_cdecl_stmt_test_data:
-            decl_val = testfunc(*args)
-            self.assertEqual(decl_val, decl_exp)
-    
-    def test__CppType_get_cread_stmt(self):
-        def testfunc(t, param_name, bindings, stream, dims):
-            return t.statictype(bindings).get_cread_stmt(param_name, stream, dims)
-        for args, decl_exp in self._CppType_get_cread_stmt_test_data:
-            decl_val = testfunc(*args)
-            self.assertEqual(decl_val, decl_exp)
-    
-    def test__CppType_get_cwrite_stmt(self):
-        def testfunc(t, param_name, bindings, stream, dims):
-            return t.statictype(bindings).get_cwrite_stmt(param_name, stream, dims)
-        for args, decl_exp in self._CppType_get_cwrite_stmt_test_data:
-            decl_val = testfunc(*args)
-            self.assertEqual(decl_val, decl_exp)
-    
-    def test__Parameter_generatedata(self):
-        def testfunc(param, glbls):
-            return param.generatedata(glbls)
-        for args, expected in self._Parameter_generatedata_test_data:
-            name_val, type_val, dims_val, data_val = testfunc(*args)
-            name_exp, type_exp, dims_exp, data_exp = expected
-            #print((name_val,type_val,dims_val,data_val))
-            self.assertEqual(name_val, name_exp)
-            self.assertEqual(str(type_val), type_exp)
-            self.assertEqual(dims_val, dims_exp)
-            self.assertEqual(data_val, data_exp)
-    
diff --git a/test-chill/unit-tests/test__extract.py b/test-chill/unit-tests/test__extract.py
deleted file mode 100644
index 72cba8a..0000000
--- a/test-chill/unit-tests/test__extract.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import ast
-import unittest
-
-import testchill._extract as _extract
-import testchill.util as util
-
-class TestExtraction(unittest.TestCase):
-    def setUp(self):
-        self._TagExtractor_parse_test_data = [
-                (('a',''),                      []),
-                (('a','x<a>yy</a>z'),           [('yy', {})]),
-                (('a','x<a>yy</a>z<a>ww</a>g'), [('yy', {}), ('ww',{})]),
-                (('a','x<a>yy</a>z<b>ww</b>g'), [('yy', {})])
-            ]
-        self._commented_test_data = [
-                (('no comment here','cc'), []),
-                (('one comment //xxx\n','cc'), ['xxx']),
-                (('two comments //xxx\nunrelated//yyy\n', 'cc'), ['xxx','yyy']),
-                (('two comments //xxx\nunrelated//yyy', 'cc'), ['xxx','yyy']),
-                (('ss/*x\ny\n*/z','cc'),['x\ny\n']),
-                (('ss/*x\ny\n*/z//q\nc','cc'),['x\ny\n','q']),
-                (('ss###x#\n','py'),['x#']),
-                (('ss"""x"""\n','py'),['x'])
-            ]
-    
-    def test__commented(self):
-        def run(txt, ext):
-            return list(_extract._TagExtractor._commented(txt, ext))
-        for args, res in self._commented_test_data:
-            self.assertEqual(run(*args), res)
-    
-    #def test_extract(self):
-    #    def testfunc(tag, txt):
-    #        temp = util.mktemp()
-    #        with open(temp, 'w') as f:
-    #            f.write(txt)
-    #        extracted = _extract._TagExtractor.extract_tag(tag, temp)
-    #        util.rmtemp()
-    #        return extracted
-    #        
-    #    for args, res in self.test_extract_data:
-    #        self.assertEqual(testfunc(*args), res)
-    
-    def test__TagExtractor_parse(self):
-        def testfunc(tag, txt):
-            return _extract._TagExtractor._parse(tag, txt)
-        for args, exp in self._TagExtractor_parse_test_data:
-            self.assertEqual(testfunc(*args), exp)
diff --git a/test-chill/unit-tests/test_chill.py b/test-chill/unit-tests/test_chill.py
deleted file mode 100644
index 8aaebfe..0000000
--- a/test-chill/unit-tests/test_chill.py
+++ /dev/null
@@ -1,215 +0,0 @@
-import logging
-import os
-import unittest
-
-import testchill.chill
-import testchill.gcov
-import testchill.test
-import testchill.util
-
-
-_runbuild=True
-
-def runtest(tclist):
-    if _runbuild:
-        for tc in tclist:
-            tc.setUp()
-            tc.setresult(tc.run())
-            tc.tearDown()
-
-def runchilltest(tclist, runvalidate=False, runstdout=False):
-    for tc in tclist:
-        tc.setUp()
-        tc.compile_src(tc)
-        tc.run_script(tc)
-        tc.compile_gensrc(tc)
-        if runvalidate:
-            tc.check_run_script_validate(tc)
-        if runstdout:
-            tc.check_run_script_stdout(tc)
-        tc.tearDown()
-
-class TestChillTestCases(unittest.TestCase):
-    def config(self, **kwargs):
-        cargs = {
-                'omega_dir': self.omega_dev_dir,
-                'chill_dir': self.chill_dev_dir,
-                'bin_dir': self.bin_dir,
-                'build_cuda': False,
-                'script_lang': None,
-                'version': 'dev'
-            }
-        cargs.update(kwargs)
-        return testchill.chill.ChillConfig(**cargs)
-    
-    def config_rel(self, **kwargs):
-        kwargs['version'] = 'release'
-        kwargs['omega_dir'] = self.omega_rel_dir
-        kwargs['chill_dir'] = self.chill_rel_dir
-        return self.config(**kwargs)
-    
-    def setUp(self):
-        self.chill_dev_dir = os.getenv('CHILL_DEV_SRC')
-        self.chill_rel_dir = os.getenv('CHILL_RELEASE_SRC')
-        self.omega_dev_dir = os.getenv('OMEGA_DEV_SRC')
-        self.omega_rel_dir = os.getenv('OMEGA_RELEASE_SRC')
-        self.bin_dir = os.getenv('STAGING_DIR_BIN')
-        self.wd = os.getenv('STAGING_DIR_WD')
-        self.build_options = {'coverage':False}
-        
-        testchill.util.shell('cp', [os.path.join(self.chill_dev_dir, 'examples/cuda-chill/cudaize.lua'), self.wd])
-        testchill.util.shell('cp', [os.path.join(self.chill_dev_dir, 'examples/cuda-chill/cudaize.py'), self.wd])
-        
-        self.config_test_func = {
-                0: lambda conf: conf.default_script_lang(),
-                1: lambda conf: conf.name(),
-                2: lambda conf: conf.make_depend_target(),
-                3: lambda conf: conf.make_target(),
-                4: lambda conf: conf.make_args()
-            }
-        self.config_test_data = [
-                ((self.omega_dev_dir, self.chill_dev_dir, self.bin_dir, False, None,     'dev'),     ('script', 'chill',              'depend-chill',      'chill')),
-                ((self.omega_dev_dir, self.chill_dev_dir, self.bin_dir, False, 'lua',    'dev'),     ('script', 'chill-lua',          'depend-chill',      'chill')),
-                ((self.omega_dev_dir, self.chill_dev_dir, self.bin_dir, False, 'python', 'dev'),     ('script', 'chill-python',       'depend-chill',      'chill')),
-                ((self.omega_dev_dir, self.chill_dev_dir, self.bin_dir, True,  None,     'dev'),     ('lua',    'cuda-chill',         'depend-cuda-chill', 'cuda-chill')),
-                ((self.omega_dev_dir, self.chill_dev_dir, self.bin_dir, True,  'python', 'dev'),     ('lua',    'cuda-chill-python',  'depend-cuda-chill', 'cuda-chill')),
-                ((self.omega_rel_dir, self.chill_rel_dir, self.bin_dir, False, None,     'release'), ('script', 'chill-release',      'depend',            'chill')),
-                ((self.omega_rel_dir, self.chill_rel_dir, self.bin_dir, True,  None,     'release'), ('lua',    'cuda-chill-release', 'depend-cuda-chill', 'cuda-chill'))
-            ]
-    
-    def tearDown(self):
-        pass
-    
-    def _run_ChillConfig_test(self, n):
-        for args, expected in self.config_test_data:
-            val = self.config_test_func[n](testchill.chill.ChillConfig(*args))
-            exp = expected[n]
-            self.assertEqual(val, exp)
-    
-    def test_ChillConfig_default_script_lang(self):
-        self._run_ChillConfig_test(0)
-    
-    def test_ChillConfig_name(self):
-        self._run_ChillConfig_test(1)
-    
-    def test_ChillConfig_make_depend_target(self):
-        self._run_ChillConfig_test(2)
-    
-    def test_ChillConfig_make_target(self):
-        self._run_ChillConfig_test(3)
-    
-    #def test_ChillConfig_make_args(self):
-    #    self._run_ChillConfig_test(4)
-    
-    def test_chill_dev(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(), self.build_options)
-        self.assertEqual(tc.config.name(), 'chill')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-chill')
-        self.assertEqual(tc.config.make_target(), 'chill')
-        self.assertEqual(tc.name, 'chill')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_chill_dev_lua(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(script_lang='lua'), self.build_options)
-        self.assertEqual(tc.config.name(), 'chill-lua')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-chill')
-        self.assertEqual(tc.config.make_target(), 'chill')
-        self.assertEqual(tc.config.make_args(), 'SCRIPT_LANG=lua')
-        self.assertEqual(tc.name, 'chill-lua')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_chill_dev_python(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(script_lang='python'), self.build_options)
-        self.assertEqual(tc.config.name(), 'chill-python')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-chill')
-        self.assertEqual(tc.config.make_target(), 'chill')
-        self.assertEqual(tc.config.make_args(), 'SCRIPT_LANG=python')
-        self.assertEqual(tc.name, 'chill-python')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_cudachill_dev(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(build_cuda=True), self.build_options)
-        self.assertEqual(tc.config.name(), 'cuda-chill')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-cuda-chill')
-        self.assertEqual(tc.config.make_target(), 'cuda-chill')
-        self.assertEqual(tc.name, 'cuda-chill')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_cudachill_dev(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(build_cuda=True, script_lang='python'), self.build_options)
-        self.assertEqual(tc.config.name(), 'cuda-chill-python')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-cuda-chill')
-        self.assertEqual(tc.config.make_target(), 'cuda-chill')
-        self.assertEqual(tc.name, 'cuda-chill-python')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-
-    def test_chill_release(self):
-        tc = testchill.chill.BuildChillTestCase(self.config_rel(), self.build_options)
-        self.assertEqual(tc.config.name(), 'chill-release')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_rel_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend')
-        self.assertEqual(tc.config.make_target(), 'chill')
-        self.assertEqual(tc.name, 'chill-release')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_cudachill_release(self):
-        tc = testchill.chill.BuildChillTestCase(self.config_rel(build_cuda=True), self.build_options)
-        self.assertEqual(tc.config.name(), 'cuda-chill-release')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_rel_dir)
-        self.assertEqual(tc.config.env()['CUDACHILL'], 'true')
-        self.assertEqual(tc.config.make_depend_target(), 'depend-cuda-chill')
-        self.assertEqual(tc.config.make_target(), 'cuda-chill')
-        self.assertEqual(tc.name, 'cuda-chill-release')
-        logging.info('Building ' + tc.name)
-        runtest([tc])
-    
-    def test_run_chill(self):
-        config = self.config()
-        btc = testchill.chill.BuildChillTestCase(config, self.build_options)
-        runtest([btc])
-        tc = testchill.chill.RunChillTestCase(config, 'test-cases/chill/test_scale.script', 'test-cases/chill/mm.c', wd=self.wd)
-        self.assertEqual(tc.chill_src, 'mm.c')
-        self.assertEqual(tc.chill_script, 'test_scale.script')
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'test-cases/chill/mm.c'))
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'test-cases/chill/test_scale.script'))
-        self.assertEqual(tc.chill_gensrc, 'rose_mm.c')
-        self.assertEqual(tc.name, 'chill:test_scale.script')
-        runchilltest([tc])
-    
-    def test_run_cudachill(self):
-        config = self.config(build_cuda=True)
-        btc = testchill.chill.BuildChillTestCase(config, self.build_options)
-        runtest([btc])
-        tc = testchill.chill.RunChillTestCase(config, 'test-cases/examples/cuda-chill/mm.lua', 'test-cases/examples/cuda-chill/mm.c', wd=self.wd)
-        self.assertEqual(tc.chill_src, 'mm.c')
-        self.assertEqual(tc.chill_script, 'mm.lua')
-        self.assertEqual(tc.chill_src_path, os.path.join(os.getcwd(), 'test-cases/examples/cuda-chill/mm.c'))
-        self.assertEqual(tc.chill_script_path, os.path.join(os.getcwd(), 'test-cases/examples/cuda-chill/mm.lua'))
-        self.assertEqual(tc.chill_gensrc, 'rose_mm.cu')
-        self.assertEqual(tc.name, 'cuda-chill:mm.lua')
-        runchilltest([tc])
-    
-    def test_chill_coverage(self):
-        tc = testchill.chill.BuildChillTestCase(self.config(), options={'coverage':True}, coverage_set=testchill.gcov.GcovSet())
-        self.assertEqual(tc.config.name(), 'chill')
-        self.assertEqual(tc.config.env()['OMEGAHOME'], self.omega_dev_dir)
-        self.assertEqual(tc.config.make_depend_target(), 'depend-chill')
-        self.assertEqual(tc.config.make_target(), 'chill')
-        self.assertEqual(tc.name, 'chill')
-        self.assertTrue(tc.options['coverage'])
-        logging.info('Building ' + tc.name)
-        if _runbuild:
-            runtest([tc])
-            self.assertTrue(os.path.exists(os.path.join(self.chill_dev_dir, 'ir_rose.gcno')))
-
diff --git a/test-chill/unit-tests/test_cpp_validate.py b/test-chill/unit-tests/test_cpp_validate.py
deleted file mode 100644
index ed55c80..0000000
--- a/test-chill/unit-tests/test_cpp_validate.py
+++ /dev/null
@@ -1,280 +0,0 @@
-import functools
-import os
-import pprint
-import struct
-import unittest
-
-import testchill
-import testchill.util as util
-import testchill._cpp_validate_env as cpp_validate_env
-import testchill.cpp_validate as cpp_validate
-
-
-def listtodata(flist):
-    data = [struct.pack('f',n) for n in flist]
-    return functools.reduce(lambda a,v: a+v, data)
-
-class TestCppValidate(unittest.TestCase):
-    def setUp(self):
-        self.staging_dir_wd = os.getenv("STAGING_DIR_WD")
-        self.cpp_validate_dir = os.path.join(os.getcwd(),'unit-tests/cpp_validate_prog/')
-        self._parse_testproc_script_test_data = [
-                (('mm_one.testproc',),      None),
-                (('mm_one_with.testproc',), None)
-            ]
-        self._parse_testproc_python_test_data = [
-            ]
-        #self._generate_data_test_data = [
-        #        (('mm_one.cc','in'),               None),
-        #        (('mm_one.cc','out'),              None),
-        #        (('mm_one_with.cc','in'),          None),
-        #        (('mm_one_with.cc','out'),         None),
-        #        (('mm_one_defines.cc','in'),       None),
-        #        (('mm_one_defines.cc','out'),      None),
-        #        (('mm_one_with_defines.cc','in'),  None),
-        #        (('mm_one_with_defines.cc','out'), None),
-        #    ]
-        self._parse_testproc_iter_test_data = [
-                (('mm_one.cc',),
-                    [({'lang': 'script', 'name': 'mm_small', 'define':'dict()'},)]),
-                (('mm_one_with.cc',),
-                    [({'lang': 'script', 'name': 'mm_small', 'define':'dict()'},)]),
-                (('mm_one_defines.cc',),
-                    [({'lang': 'script', 'name': 'mm_small', 'define': "{'AN':3, 'BM':2, 'AMBN':5}"},)]),
-                (('mm_one_with_defines.cc',),
-                    [({'lang': 'script', 'name': 'mm_small', 'define': "{'AN':3, 'BM':2, 'AMBN':5}"},)])
-            ]
-        self._compile_gpp_test_data = [
-                ('mm_one_main.cc', 'mm_one')
-            ]
-        self._test_time_test_data = [
-                ((0.0034, 0.0025), True),
-                ((0.0025, 0.0034), False)
-            ]
-        self._test_validate_test_data = [
-                (('asdf', 'asdf'), True),
-                (('asdf', 'sdfg'), False)
-            ]
-        self._run_test_validate_time_test_data = [
-                (('mm_one_main.cc', 'mm_control', 'mm_one_longer_main.cc', 'mm_test', list(range(15)) + list(range(10))), (True, False)),
-                (('mm_one_longer_main.cc', 'mm_control', 'mm_one_main.cc', 'mm_test', list(range(15)) + list(range(10))), (True, True)),
-                (('mm_one_main.cc', 'mm_control', 'mm_one_longer_wrong_main.cc', 'mm_test', list(range(15)) + list(range(10))), (False, False))
-            ]
-        self._compile_run_test_validate_time_test_data = [
-                (('mm_one_main.cc', 'mm_one_longer_main.cc', list(range(15)) + list(range(10))), (True, False)),
-                (('mm_one_longer_main.cc', 'mm_one_main.cc', list(range(15)) + list(range(10))), (True, True)),
-                (('mm_one_main.cc', 'mm_one_longer_wrong_main.cc', list(range(15)) + list(range(10))), (False, False))
-            ]
-        self._generate_initial_data_test_data = [
-                (('mm_one.testproc', 'mm.cc', {}),      listtodata(list(range(15)) + list(range(10)) + [0]*6)),
-                (('mm_one_with.testproc', 'mm.cc', {}), listtodata(list(range(15)) + list(range(10)) + [0]*6)),
-            ]
-        self._format_insertion_dict_test_data = [
-                (('mm_one.testproc', 'mm_one.cc', {}),
-                    {
-                        'run': 'mm(A,B,C);',
-                        'read-out': 'datafile_initialize.read((char*)C, 6*sizeof(float));',
-                        'declarations': 'float A[3][5];\nfloat B[5][2];\nfloat C[3][2];',
-                        'write-out': 'datafile_out.write((char*)C, 6*sizeof(float));',
-                        'defines': '',
-                        'read-in': 'datafile_initialize.read((char*)A, 15*sizeof(float));\ndatafile_initialize.read((char*)B, 10*sizeof(float));'
-                    }),
-                (('mm_one_with.testproc', 'mm_one.cc', {}),
-                    {
-                        'run': 'mm(A,B,C);',
-                        'read-out': 'datafile_initialize.read((char*)C, 6*sizeof(float));',
-                        'declarations': 'float A[3][5];\nfloat B[5][2];\nfloat C[3][2];',
-                        'write-out': 'datafile_out.write((char*)C, 6*sizeof(float));',
-                        'defines': '',
-                        'read-in': 'datafile_initialize.read((char*)A, 15*sizeof(float));\ndatafile_initialize.read((char*)B, 10*sizeof(float));'
-                    }),
-            ]
-        self._write_generated_code_test_data = [
-                (('mm_one.testproc', 'mm_one.cc', 'control.cc', {}), 'mm_one_out.cc')
-            ]
-        self.run_from_src_test_data = [
-                (('mm_three_basic.cc', 'mm_three_slow.cc', self.staging_dir_wd), [('small', (True, False)), ('medium', (True, False)), ('big', (True, False))]),
-                (('mm_three_slow.cc', 'mm_three_basic.cc', self.staging_dir_wd), [('small', (True, True)), ('medium', (True, True)), ('big', (True, True))]),
-            ]
-    
-    def tearDown(self):
-        util.rmtemp()
-    
-    def test__get_script_parser(self):
-        cpp_validate._script_parser = None
-        self.assertIsNotNone(cpp_validate._get_script_parser())
-        self.assertIsNotNone(cpp_validate._get_script_parser())
-    
-    def _test_parse_src(self, parsefunc, test_data):
-        def parse_file(filename):
-            path = os.path.join(self.cpp_validate_dir, filename)
-            with open(path, 'r') as f:
-                src = f.read()
-            return parsefunc(src)
-        for args, expected in test_data:
-            srcfile, = args
-            val = parse_file(srcfile)
-            #TODO: make some assertions
-    
-    def test__parse_testproc_script(self):
-        self._test_parse_src(
-                cpp_validate._parse_testproc_script,
-                self._parse_testproc_script_test_data)
-    
-    @unittest.skip("not yet supported")
-    def test__parse_testproc_python(self):
-        self._test_parse_src(
-                cpp_validate._parse_testproc_python,
-                self._parse_testproc_python_test_data)
-    
-    def test__parse_testproc_iter(self):
-        def testfunc(filename):
-            path = os.path.join(self.cpp_validate_dir, filename)
-            util.shell('cp', [path, '.'], wd=self.staging_dir_wd)
-            return list(cpp_validate._parse_testproc_iter(filename, wd=self.staging_dir_wd))
-        for args, expected_list in self._parse_testproc_iter_test_data:
-            val_list = testfunc(*args)
-            for val, expected in zip(val_list, expected_list):
-                _, attr_val = val
-                attr_exp, = expected
-                self.assertEqual(attr_val, attr_exp)
-            #TODO: make some more assertions
-    
-    #def test__generate_data(self):
-    #    def testfunc(filename, direction):
-    #        path = os.path.join(self.cpp_validate_dir, filename)
-    #        util.shell('cp', [path, '.'], wd=self.staging_dir_wd)
-    #        for proc, attrs in cpp_validate._parse_testproc_iter(filename, wd=self.staging_dir_wd):
-    #            defines = eval(attrs['define'])
-    #            yield cpp_validate._generate_initial_data(proc, direction, filename, defines, wd=self.staging_dir_wd)
-    #        
-    #    for args, expected in self._generate_data_test_data:
-    #        for filename in testfunc(*args):
-    #            self.assertTrue(os.path.exists(filename))
-    #        #TODO: make some more assertions
-    
-    def test__compile_gpp(self):
-        def testfunc(src, obj):
-            src = os.path.join(self.cpp_validate_dir, src)
-            obj = os.path.join(self.staging_dir_wd, obj)
-            cpp_validate._compile_gpp(src, obj)
-        
-        for src, obj in self._compile_gpp_test_data:
-            testfunc(src, obj)
-            obj_path = os.path.join(self.staging_dir_wd, obj)
-            self.assertTrue(os.path.exists(obj_path))
-    
-    def test__test_time(self):
-        def testfunc(control_time, test_time):
-            return cpp_validate._test_time(control_time, test_time)
-        
-        for args, exp in self._test_time_test_data:
-            val = testfunc(*args)
-            self.assertEqual(val, exp)
-    
-    def test__test_validate(self):
-        def testfunc(control_data, test_data):
-            if util.python_version_major == 3:
-                control_data = bytes(map(ord,control_data))
-                test_data = bytes(map(ord,test_data))
-            control_file, control_path = util.mktemp('wb')
-            control_file.write(control_data)
-            control_file.close()
-            test_file, test_path = util.mktemp('wb')
-            test_file.write(test_data)
-            test_file.close()
-            return cpp_validate._test_validate(control_path, test_path)
-        
-        for args, exp in self._test_validate_test_data:
-            val = testfunc(*args)
-            self.assertEqual(val, exp)
-    
-    def test__run_test_validate_time(self):
-        def makeobj(src, obj):
-            src_path = os.path.join(self.cpp_validate_dir, src)
-            obj_path = os.path.join(self.staging_dir_wd, obj)
-            util.shell('g++', ['-o', obj_path, src_path, '-lrt'])
-            util.set_tempfile(obj_path)
-            return src_path, obj_path
-        
-        def testfunc(control_src, control_obj, test_src, test_obj, in_data):
-            control_src, control_obj = makeobj(control_src, control_obj)
-            test_src, test_obj = makeobj(test_src, test_obj)
-            inpath = os.path.join(self.staging_dir_wd, 'test.in.data')
-            with open(inpath, 'wb') as infile:
-                infile.write(listtodata(in_data))
-            util.set_tempfile(inpath)
-            return cpp_validate._run_test_validate_time(control_obj, test_obj, inpath)
-        
-        for args, expected in self._run_test_validate_time_test_data:
-            validate_val, time_val = testfunc(*args)
-            validate_exp, time_exp = expected
-            self.assertEqual(validate_val, validate_exp)
-            self.assertEqual(time_val, time_exp)
-    
-    def test__compile_run_test_validate_time(self):
-        def testfunc(control_src, test_src, in_data):
-            control_src = os.path.join(self.cpp_validate_dir, control_src)
-            test_src = os.path.join(self.cpp_validate_dir, test_src)
-            inpath = os.path.join(self.staging_dir_wd, 'test.in.data')
-            with open(inpath, 'wb') as infile:
-                infile.write(listtodata(in_data))
-            util.set_tempfile(inpath)
-            return cpp_validate._compile_run_test_validate_time(control_src, test_src, inpath)
-        
-        for args, expected in self._compile_run_test_validate_time_test_data:
-            validate_val, time_val = testfunc(*args)
-            validate_exp, time_exp = expected
-            self.assertEqual(validate_val, validate_exp)
-            self.assertEqual(time_val, time_exp)
-    
-    def test__generate_initial_data(self):
-        def testfunc(testprocfile, srcfile, defines):
-            testprocpath = os.path.join(self.cpp_validate_dir, testprocfile)
-            with open(testprocpath, 'r') as f:
-                srcpath = os.path.join(self.cpp_validate_dir, srcfile)
-                testproc = cpp_validate._parse_testproc_script(f.read())
-                return cpp_validate._generate_initial_data(testproc, srcpath, defines, wd=self.staging_dir_wd)
-        
-        for args, expected in self._generate_initial_data_test_data:
-            datafile = testfunc(*args)
-            with open(datafile, 'rb') as f:
-                self.assertEqual(len(f.read()), len(expected))
-    
-    def test__format_insertion_dict(self):
-        def testfunc(testprocfile, srcfile, defines):
-            testprocpath = os.path.join(self.cpp_validate_dir, testprocfile)
-            srcpath = os.path.join(self.cpp_validate_dir, srcfile)
-            with open(testprocpath, 'r') as f:
-                testproc = cpp_validate._parse_testproc_script(f.read())
-                #testproc.generatedata('in', defines)
-                #testproc.generatedata('out', defines)
-            return cpp_validate._format_insertion_dict(testproc, srcpath, defines)
-                
-        for args, exp in self._format_insertion_dict_test_data:
-            val = testfunc(*args)
-            for k,v in exp.items():
-                self.assertEqual(val[k], v)
-    
-    def test__write_generated_code(self):
-        def testfunc(testprocfile, srcname, destname, defines):
-            srcpath = os.path.join(self.cpp_validate_dir, srcname)
-            with open(os.path.join(self.cpp_validate_dir, testprocfile),'r') as f:
-                testproc = cpp_validate._parse_testproc_script(f.read())
-            return cpp_validate._write_generated_code(testproc, srcpath, defines, destname, self.staging_dir_wd)
-        for args, exp_path in self._write_generated_code_test_data:
-            val_path = testfunc(*args)
-            util.set_tempfile(val_path)
-            exp_path = os.path.join(self.cpp_validate_dir, exp_path)
-            with open(val_path, 'r') as valfile:
-                with open(exp_path, 'r') as expfile:
-                    self.assertEqual(valfile.read().splitlines(), expfile.read().splitlines())
-    
-    def test_run_from_src(self):
-        for args, expected in self.run_from_src_test_data:
-            control_src, test_src, wd = args
-            control_src = os.path.join(self.cpp_validate_dir, control_src)
-            test_src = os.path.join(self.cpp_validate_dir, test_src)
-            val = list(cpp_validate.run_from_src(control_src,test_src,wd))
-            self.assertEqual(val, expected)
-            
diff --git a/test-chill/unit-tests/test_gcov.py b/test-chill/unit-tests/test_gcov.py
deleted file mode 100644
index 2720ef7..0000000
--- a/test-chill/unit-tests/test_gcov.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import itertools
-import pprint
-import os
-import textwrap
-import unittest
-
-import testchill.util as util
-import testchill.gcov as gcov
-
-
-class TestGCov(unittest.TestCase):
-    def setUp(self):
-        self.cprog_dir = os.path.join(os.getcwd(), 'unit-tests/cprog')
-        self.cprog_bin = os.path.join(self.cprog_dir, 'bin/sorter')
-    
-    def build_prog(self):
-        self.clean_prog()
-        util.shell('make', [], wd=self.cprog_dir)
-    
-    def clean_prog(self):
-        util.shell('make', ['clean'], wd=self.cprog_dir)
-    
-    def run_prog(self, alg, lst):
-        util.shell(self.cprog_bin, [alg] + list(map(str,lst)))
-    
-    def test_GcovLine_mrege_lines(self):
-        '''
-           56:   14:        while((index < pivot_index) && (list[index] >= pivot_value)) {
-            6:   15:            swap(list, index, pivot_index);
-            6:   16:            pivot_index--;
-            -:   17:        }
-        And
-            78:   14:        while((index < pivot_index) && (list[index] >= pivot_value)) {
-            18:   15:            swap(list, index, pivot_index);
-            18:   16:            pivot_index--;
-            -:   17:        }
-        '''
-        lines_proc_one = list(itertools.starmap(gcov.GcovLine,[ 
-                (14, {'proc_one':   56},'        while((index < pivot_index) && (list[index] >= pivot_value)) {'),
-                (15, {'proc_one':    6},'            swap(list, index, pivot_index);'),
-                (16, {'proc_one':    6},'            pivot_index--;'),
-                (17, {'proc_one': None},'        }')]))
-        lines_proc_two = list(itertools.starmap(gcov.GcovLine,[
-                (14, {'proc_two':   78},'        while((index < pivot_index) && (list[index] >= pivot_value)) {'),
-                (15, {'proc_two':   18},'            swap(list, index, pivot_index);'),
-                (16, {'proc_two':   18},'            pivot_index--;'),
-                (17, {'proc_two': None},'        }')]))
-        gcov.GcovLine.merge_lines(lines_proc_one, lines_proc_two)
-        self.assertEqual(lines_proc_one[0].lineno, 14)
-        self.assertEqual(lines_proc_one[1].lineno, 15)
-        self.assertEqual(lines_proc_one[2].lineno, 16)
-        self.assertEqual(lines_proc_one[3].lineno, 17)
-    
-    def test_GcovLine_merge_and_count(self):
-        lines_proc_one = list(itertools.starmap(gcov.GcovLine,[ 
-                (14, {'proc_one':   56},'        while((index < pivot_index) && (list[index] >= pivot_value)) {'),
-                (15, {'proc_one':    6},'            swap(list, index, pivot_index);'),
-                (16, {'proc_one':    6},'            pivot_index--;'),
-                (17, {'proc_one': None},'        }')]))
-        lines_proc_two = list(itertools.starmap(gcov.GcovLine,[
-                (14, {'proc_two':   78},'        while((index < pivot_index) && (list[index] >= pivot_value)) {'),
-                (15, {'proc_two':   18},'            swap(list, index, pivot_index);'),
-                (16, {'proc_two':   18},'            pivot_index--;'),
-                (17, {'proc_two': None},'        }')]))
-        gcov.GcovLine.merge_lines(lines_proc_one, lines_proc_two)
-        self.assertEqual(lines_proc_one[0].count(), 134)
-        self.assertEqual(lines_proc_one[1].count(), 24)
-        self.assertEqual(lines_proc_one[2].count(), 24)
-        self.assertEqual(lines_proc_one[3].count(), None)
-    
-    def test_GcovFile_parse_lines(self):
-        lines = textwrap.dedent(
-            '''-:0:SomeProperty:SomeValue
-               56:   14:        while((index < pivot_index) && (list[index] >= pivot_value)) {
-                6:   15:            swap(list, index, pivot_index);
-                6:   16:            pivot_index--;
-                -:   17:        }''').splitlines()
-        lines, properties = gcov.GcovFile.parse_lines(lines, 'proc')
-        self.assertEqual(lines[0].lineno, 14)
-        self.assertEqual(lines[0].count_by_process, {'proc': 56})
-        self.assertEqual(lines[0].code, '        while((index < pivot_index) && (list[index] >= pivot_value)) {')
-        self.assertEqual(lines[3].count_by_process, dict())
-    
-    def test_Gcov_parse(self):
-        self.build_prog()
-        self.run_prog('quicksort', [9, 4, 10, 6, 11, 0, 3, 7, 2, 1, 8, 5])
-        cov = gcov.Gcov.parse(self.cprog_dir, 'unsorted')
-        self.build_prog()
-        self.run_prog('quicksort', [5, 4, 3, 2, 1])
-        #pprint.pprint(vars(cov.files['QuickSorter.cc']))
-        cov.merge(gcov.Gcov.parse(self.cprog_dir, 'reverse'))
-        #pprint.pprint(vars(cov.files['QuickSorter.cc']))
-        #TODO: assert something
-        #cov.pretty_print()
-    
-    def tearDown(self):
-        self.clean_prog()
-        
diff --git a/test-chill/unit-tests/test_omega.py b/test-chill/unit-tests/test_omega.py
deleted file mode 100644
index 91d6a13..0000000
--- a/test-chill/unit-tests/test_omega.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import os
-import unittest
-
-import testchill.omega
-import testchill.util
-
-
-class TestOmegaTestCases(unittest.TestCase):
-    def setUp(self):
-        self.omega_dev_dir = os.getenv('OMEGA_DEV_SRC')
-        self.omega_rel_dir = os.getenv('OMEGA_RELEASE_SRC')
-    
-    def tearDown(self):
-        pass
-    
-    def test_omega_dev(self):
-        tc = testchill.omega.BuildOmegaTestCase(self.omega_dev_dir)
-        tc.run()
-        
-    def test_omega_release(self):
-        tc = testchill.omega.BuildOmegaTestCase(self.omega_rel_dir, 'release')
-        tc.run()
-    
diff --git a/test-chill/unit-tests/test_test.py b/test-chill/unit-tests/test_test.py
deleted file mode 100644
index 9745358..0000000
--- a/test-chill/unit-tests/test_test.py
+++ /dev/null
@@ -1,380 +0,0 @@
-import io
-import pickle
-import pprint
-import unittest
-import textwrap
-
-import testchill.test as test
-import testchill.util as util
-
-
-class Named(object):
-    def __init__(self, name):
-        self.name = name
-    
-    def setresult(self, res):
-        pass
-
-def make_tc(rfunc=None, sufunc=None, tdfunc=None, name=None):
-    class SomeTestCase(test.TestCase):
-        def setUp(self):
-            if sufunc:
-                sufunc(self)
-            
-        def run(self):
-            if rfunc != None:
-                return rfunc(self)
-            
-        def tearDown(self):
-            if tdfunc:
-                tdfunc(self)
-    
-    return SomeTestCase(name)
-
-def make_seqtc(subtests, sufunc=None, tdfunc=None, name=None):
-    class SomeSeqTestCase(test.SequencialTestCase):
-        def __init__(self, name):
-            test.SequencialTestCase.__init__(self, name)
-            for fn_name, func in subtests:
-                self.add_subtest(fn_name, func)
-        
-        def setUp(self):
-            if sufunc:
-                sufunc(self)
-                
-        def tearDown(self):
-            if tdfunc:
-                tdfunc(self)
-        
-    return SomeSeqTestCase(name)
-
-
-class TestTest(unittest.TestCase):
-    
-    def flip_n_switch(self, n, value=True):
-        '''
-        Return a function that sets switches[n] to value (True by default)
-        '''
-        def flipswitch(tc):
-            self.switches[n] = value
-        return flipswitch
-    
-    def flip_n_switch_if_m(self, n, m, value=True):
-        '''
-        Returns a function that sets switches[n] to value (True by default) if switches[m] is True
-        '''
-        def flipswitch(tc):
-            if self.switches[m]:
-                self.switches[n] = value
-        return flipswitch
-    
-    def allways_raise(self, exc=Exception('Expected exception')):
-        '''
-        Returns a function that raises an exception
-        '''
-        def throwexc(tc):
-            raise exc
-        return throwexc
-    
-    def allways_fail(self):
-        '''
-        Returns a function that returns an explicit failure
-        '''
-        def fail(tc):
-            return test.TestResult.make_fail(test.TestResult, tc)
-        return fail
-    
-    def allways_skip(self):
-        '''
-        Returns a function that skips
-        '''
-        def skip(tc):
-            return test.TestResult.make_skipped(test.TestResult, tc)
-        return skip
-    
-    def allways_pass(self):
-        '''
-        Returns a function that passes
-        '''
-        def notfail(tc):
-            return test.TestResult.make_pass(test.TestResult, tc)
-        return notfail
-    
-    def donothing(self):
-        '''
-        Returns a function that does nothing
-        '''
-        def foo(tc):
-            pass
-        return foo
-    
-    def setUp(self):
-        self.switches = dict((n, False) for n in range(3))
-    
-    def test_TestResult_make_pass(self):
-        self.assertTrue(test.TestResult.make_pass(test.TestResult, Named('i-pass')).passed())
-        self.assertFalse(test.TestResult.make_pass(test.TestResult, Named('i-pass')).errored())
-        self.assertFalse(test.TestResult.make_pass(test.TestResult, Named('i-pass')).failed())
-        self.assertFalse(test.TestResult.make_pass(test.TestResult, Named('i-pass')).skipped())
-    
-    def test_TestResult_make_error(self):
-        self.assertFalse(test.TestResult.make_error(test.TestResult, Named('i-error')).passed())
-        self.assertTrue(test.TestResult.make_error(test.TestResult, Named('i-error')).errored())
-        self.assertFalse(test.TestResult.make_error(test.TestResult, Named('i-error')).failed())
-        self.assertFalse(test.TestResult.make_error(test.TestResult, Named('i-error')).skipped())
-    
-    def test_TestResult_make_fail(self):
-        self.assertFalse(test.TestResult.make_fail(test.TestResult, Named('i-fail')).passed())
-        self.assertFalse(test.TestResult.make_fail(test.TestResult, Named('i-fail')).errored())
-        self.assertTrue(test.TestResult.make_fail(test.TestResult, Named('i-fail')).failed())
-        self.assertFalse(test.TestResult.make_fail(test.TestResult, Named('i-fail')).skipped())
-    
-    def test_TestResult_make_skipped(self):
-        self.assertFalse(test.TestResult.make_skipped(test.TestResult, Named('i-skip')).passed())
-        self.assertFalse(test.TestResult.make_skipped(test.TestResult, Named('i-skip')).errored())
-        self.assertFalse(test.TestResult.make_skipped(test.TestResult, Named('i-skip')).failed())
-        self.assertTrue(test.TestResult.make_skipped(test.TestResult, Named('i-skip')).skipped())
-    
-    def test__result(self):
-        result_passed = test.TestResult.make_pass(test.TestResult, Named('i-pass'))
-        result_failed = test.TestResult.make_fail(test.TestResult, Named('i-fail'))
-        self.assertTrue(result_passed is test._result(result_passed, Named('i-pass')))
-        self.assertTrue(test._result(result_failed, Named('i-fail')).failed())
-        self.assertTrue(test._result(Exception(), Named('i-error')).errored())
-    
-    def test_run_empty(self):
-        test.run([])
-    
-    def test_run_run(self):
-        test.run([make_tc(
-            rfunc=self.flip_n_switch(0))])
-        self.assertTrue(self.switches[0])
-    
-    def test_run_setupfirst(self):
-        test.run([make_tc(
-                rfunc = self.flip_n_switch_if_m(0,1),
-                sufunc = self.flip_n_switch(1))])
-        self.assertTrue(self.switches[0])
-    
-    def test_run_teardownlast(self):
-        test.run([make_tc(
-                rfunc = self.flip_n_switch(1),
-                tdfunc = self.flip_n_switch_if_m(0,1))])
-        self.assertTrue(self.switches[0])
-    
-    def test_run_teardown_allways(self):
-        test.run([make_tc(
-                rfunc = self.allways_raise(),
-                tdfunc = self.flip_n_switch(0))])
-        self.assertTrue(self.switches[0])
-    
-    def test_run_pass_result(self):
-        result_set = test.run([make_tc(
-                rfunc = self.donothing(),
-                name='pass')])
-        result = result_set[0]
-        self.assertTrue(result.passed())
-        self.assertFalse(result.errored())
-        self.assertFalse(result.failed())
-        self.assertFalse(result.skipped())
-    
-    def test_run_error_result(self):
-        result_set = test.run([make_tc(
-                rfunc = self.allways_raise(),
-                name='error')])
-        result = result_set[0]
-        self.assertFalse(result.passed())
-        self.assertTrue(result.errored())
-        self.assertFalse(result.failed())
-        self.assertFalse(result.skipped())
-    
-    def test_run_fail_result(self):
-        result_set = test.run([make_tc(
-                rfunc = self.allways_fail(),
-                name='fail')])
-        result = result_set[0]
-        self.assertFalse(result.passed())
-        self.assertFalse(result.errored())
-        self.assertTrue(result.failed())
-        self.assertFalse(result.skipped())
-
-    def test_run_skipped_result(self):
-        result_set = test.run([make_tc(
-                rfunc = self.allways_skip(),
-                name='skipped')])
-        result = result_set[0]
-        self.assertFalse(result.passed())
-        self.assertFalse(result.errored())
-        self.assertFalse(result.failed())
-        self.assertTrue(result.skipped())
-    
-    def test_run_seq_empty(self):
-        test.run([make_seqtc([])])
-    
-    def test_run_seq_allrun(self):
-        result_set = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', self.flip_n_switch(1)),
-                ('three', self.flip_n_switch(2))],
-                name='seq')])
-        self.assertTrue(result_set[0].passed())
-        self.assertTrue(self.switches[0])
-        self.assertTrue(self.switches[1])
-        self.assertTrue(self.switches[2])
-    
-    def test_run_seq_until_fail(self):
-        result_set = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', self.allways_fail()),
-                ('trhee', self.flip_n_switch(1))],
-                name='seq')])
-        self.assertTrue(result_set[0].failed())
-        self.assertTrue(self.switches[0])
-        self.assertFalse(self.switches[1])
-    
-    def test_run_seq_until_error(self):
-        result_set = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', self.allways_raise()),
-                ('trhee', self.flip_n_switch(1))],
-                name='seq')])
-        self.assertTrue(result_set[0].errored())
-        self.assertTrue(self.switches[0])
-        self.assertFalse(self.switches[1])
-    
-    def test_persistance_one_pass(self):
-        result_set = test.run([make_tc(self.allways_pass(), name='tc-name')])
-        read_result_set = util.withtmp(
-            lambda f: pickle.dump(result_set, f),
-            lambda f: pickle.load(f))
-        self.assertEqual(list(map(vars,result_set)), list(map(vars,read_result_set)))
-    
-    def test_persistance_seq(self):
-        result_set = test.run([make_seqtc([
-            ('one', self.flip_n_switch(0)),
-            ('two', self.flip_n_switch(1))],
-            name = 'seq')])
-        read_result_set = util.withtmp(
-            lambda f: pickle.dump(result_set, f),
-            lambda f: pickle.load(f))
-        
-        for i in range(len(result_set)):
-            self.assertEqual(result_set[i].status, read_result_set[i].status)
-            self.assertEqual(result_set[i].testcase_name, read_result_set[i].testcase_name)
-            for j in range(len(result_set[i].sub_results)):
-                self.assertEqual(result_set[i].sub_results[j].status, read_result_set[i].sub_results[j].status)
-                self.assertEqual(result_set[i].sub_results[j].testcase_name, read_result_set[i].sub_results[j].testcase_name)
-    
-    def test_persistance_seq_error(self):
-        result_set = test.run([make_seqtc([
-            ('one', self.flip_n_switch(0)),
-            ('two', self.allways_raise())],
-            name = 'seq')])
-        read_result_set = util.withtmp(
-            lambda f: pickle.dump(result_set, f),
-            lambda f: pickle.load(f))
-        
-        for i in range(len(result_set)):
-            self.assertEqual(result_set[i].status, read_result_set[i].status)
-            self.assertEqual(result_set[i].testcase_name, read_result_set[i].testcase_name)
-            for j in range(len(result_set[i].sub_results)):
-                self.assertEqual(result_set[i].sub_results[j].status, read_result_set[i].sub_results[j].status)
-                self.assertEqual(result_set[i].sub_results[j].testcase_name, read_result_set[i].sub_results[j].testcase_name)
-        
-    def test_FailedTestResult_init(self):
-        result = test.TestResult.make_fail(test.FailedTestResult, Named('i-fail'), reason='testing')
-        self.assertFalse(result.passed())
-        self.assertTrue(result.failed())
-        self.assertFalse(result.errored())
-        self.assertFalse(result.skipped())
-        self.assertEqual(result.testcase_name, 'i-fail')
-        self.assertEqual(result.reason, 'testing')
-    
-    def test_pretty_print(self):
-        def pretty_print_to_string(results_iter):
-            sio = util.StringIO()
-            test.pretty_print_results(results_iter, outfile=sio)
-            return sio.getvalue()
-            
-        results_iter = iter([
-                test.TestResult.make_pass(test.TestResult, Named('i-pass')),
-                test.TestResult.make_error(test.UnhandledExceptionTestResult, Named('i-error'), Exception, Exception(), None),
-                test.TestResult.make_fail(test.FailedTestResult, Named('i-fail'), reason='Oops'),
-                test.TestResult.make_skipped(test.TestResult, Named('i-skip'))
-            ])
-        
-        self.assertEqual(pretty_print_to_string(results_iter), textwrap.dedent('''\
-            Passed: 1
-            Errors: 1
-            Failed: 1
-            Skipped: 1
-            ============================================================
-            error: i-error
-            ------------------------------------------------------------
-            <class 'Exception'>: 
-            ------------------------------------------------------------
-            ============================================================
-            fail: i-fail
-            ------------------------------------------------------------
-            Oops
-            ------------------------------------------------------------
-            '''))
-        result_set = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', self.flip_n_switch(1)),
-                ('three', self.flip_n_switch(2))],
-                name='seq')])
-        result_set_fail = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', lambda s: test.TestResult.make_fail(test.FailedTestResult, s, 'Oops')),
-                ('trhee', self.flip_n_switch(1))],
-                name='seq')])
-        result_set_error = test.run([make_seqtc([
-                ('one', self.flip_n_switch(0)),
-                ('two', lambda s: test.TestResult.make_error(test.UnhandledExceptionTestResult, s, Exception, Exception(), None))],
-                name = 'seq')])
-        
-        
-        
-        compound_set = pretty_print_to_string(result_set)
-        compound_set_fail = pretty_print_to_string(result_set_fail)
-        compound_set_error = pretty_print_to_string(result_set_error)
-        
-        self.assertEqual(compound_set, textwrap.dedent('''\
-            Passed: 1
-            Errors: 0
-            Failed: 0
-            Skipped: 0
-            '''))
-        self.assertEqual(compound_set_fail, textwrap.dedent('''\
-            Passed: 0
-            Errors: 0
-            Failed: 1
-            Skipped: 0
-            ============================================================
-            fail: seq
-            ------------------------------------------------------------
-            pass: one
-            fail: two
-            Oops
-            ------------------------------------------------------------
-            '''))
-        self.assertEqual(compound_set_error, textwrap.dedent('''\
-            Passed: 0
-            Errors: 1
-            Failed: 0
-            Skipped: 0
-            ============================================================
-            error: seq
-            ------------------------------------------------------------
-            pass: one
-            error: two
-            <class 'Exception'>: 
-            ------------------------------------------------------------
-            '''))
-    
-    def tearDown(self):
-        util.rmtemp()
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/test-chill/unit-tests/test_util.py b/test-chill/unit-tests/test_util.py
deleted file mode 100644
index fbb0c79..0000000
--- a/test-chill/unit-tests/test_util.py
+++ /dev/null
@@ -1,107 +0,0 @@
-import os
-import subprocess
-import tempfile
-import unittest
-
-import testchill.util as util
-
-### Most of these are sanity checks. ###
-
-class TestUtil(unittest.TestCase):
-    def setUp(self):
-        self.tempfiles = []
-    
-    def maketempfiles(self, n=1):
-        files = tuple([tempfile.mkstemp(text=True) for i in range(n)])
-        self.tempfiles += list(map(lambda f: f[1], files))
-        return files
-        
-    def test_shell(self):
-        sbla = subprocess.check_output(['ls', '-la', 'test-cases/chill'])
-        
-        if util.python_version_major == 3:
-            sbla = sbla.decode()
-        
-        shla = util.shell('ls', ['-la', 'test-cases/chill'])
-        self.assertEqual(sbla, shla)
-    
-    def test_shell_env(self):
-        env = {'STRING_VAR':'string','NUMBER_VAR':3,'DEFINED_VAR':1}
-        
-        self.assertEqual(util.shell('echo', ['$STRING_VAR'], env=env), env['STRING_VAR'] + '\n')
-        self.assertEqual(util.shell('echo', ['$NUMBER_VAR'], env=env), str(env['NUMBER_VAR']) + '\n')
-        self.assertEqual(util.shell('echo', ['$DEFINED_VAR'], env=env), str(env['DEFINED_VAR']) + '\n')
-    
-    def test_shell_tofile(self):
-        tfile = self.maketempfiles(1)
-        fname = tfile[0][1]
-        
-        with open(fname, 'w') as f:
-            util.shell('ls', ['-la', 'test-cases/chill'], stdout=f)
-        with open(fname, 'r') as f:
-            self.assertEqual(util.shell('ls', ['-la', 'test-cases/chill']), f.read())
-    
-    def test_copy(self):
-        class C(object):
-            pass
-        c = C()
-        c.x = 'x'
-        a = util.copy(c)
-        b = util.copy(c)
-        a.x = 'y'
-        self.assertEqual(c.x,'x')
-        self.assertEqual(b.x,'x')
-        self.assertEqual(a.x,'y')
-    
-    def test_callonce(self):
-        def foo():
-            return 3
-        foo_once = util.callonce(foo)
-        self.assertEqual(foo_once(), 3)
-        self.assertRaises(Exception, foo_once)
-    
-    def test_isdiff(self):
-        testdata = [
-                (('aaa','aaa'),(False,'  aaa')),
-                (('aab','aaa'),(True, '- aab\n+ aaa')),
-                (('a\nb','a\nb\nc'),(True, '  a\n  b\n+ c')),
-                (('a\na\nc','a\nb\nc'),(True, '  a\n- a\n+ b\n  c'))
-            ]
-        for args, expected in testdata:
-            isdiff_exp, diff_exp = expected
-            isdiff_val, diff_val = util.isdiff(*args)
-            self.assertEqual(isdiff_val, isdiff_exp)
-            self.assertEqual(diff_val, diff_exp)
-    
-    def test_filterext(self):
-        testdata = [
-                ((['.c','.py'],['a.c','b.txt','c.py']),['a.c','c.py'])
-            ]
-        for args, expected in testdata:
-            self.assertEqual(list(util.filterext(*args)), expected)
-    
-    #TODO:
-    #def test_extract_tag(self):
-    #    testdata = [
-    #            (('a', 'abc<a>def</a>ghi<b>jkl</b>mno<c>pqr</c>stu<b>zwx</b>yz'), ['def']),
-    #            (('b', 'abc<a>def</a>ghi<b>jkl</b>mno<c>pqr</c>stu<b>zwx</b>yz'), ['jkl','zwx']),
-    #            (('c', 'abc<a>def</a>ghi<b>jkl</b>mno<c>pqr</c>stu<b>zwx</b>yz'), ['pqr']),
-    #            (('d', 'abc<a>def</a>ghi<b>jkl</b>mno<c>pqr</c>stu<b>zwx</b>yz'), []),
-    #        ]
-    #    for args, expected in testdata:
-    #        self.assertEqual(list(util.extract_tag(*args)), expected)
-    
-    def test_textstream(self):
-        testdata = [
-                (('asdf',),'asdf')
-            ]
-        for args, expected in testdata:
-            stream = util.textstream(*args)
-            self.assertTrue(hasattr(stream,'read'))
-            self.assertEqual(stream.read(), expected)
-    
-    def tearDown(self):
-        for f in self.tempfiles:
-            os.remove(f)
-    
-