diff options
Diffstat (limited to 'test-chill/unit-tests')
33 files changed, 2554 insertions, 0 deletions
diff --git a/test-chill/unit-tests/__init__.py b/test-chill/unit-tests/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/test-chill/unit-tests/__init__.py @@ -0,0 +1 @@ + diff --git a/test-chill/unit-tests/cpp_validate_prog/mm_in.py b/test-chill/unit-tests/cpp_validate_prog/mm_in.py new file mode 100755 index 0000000..93eb080 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_in.py @@ -0,0 +1,9 @@ +#!/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 new file mode 100644 index 0000000..6131ae1 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one.cc @@ -0,0 +1,29 @@ +#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 new file mode 100644 index 0000000..a12a963 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one.testproc @@ -0,0 +1,6 @@ + +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 new file mode 100644 index 0000000..e35f189 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_defines.cc @@ -0,0 +1,25 @@ + +/* +<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 new file mode 100644 index 0000000..5b7e6c1 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_main.cc @@ -0,0 +1,93 @@ +#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 new file mode 100644 index 0000000..7d96248 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_longer_wrong_main.cc @@ -0,0 +1,93 @@ +#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 new file mode 100644 index 0000000..a03b505 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_main.cc @@ -0,0 +1,91 @@ +#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 new file mode 100644 index 0000000..6151301 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_out.cc @@ -0,0 +1,60 @@ +#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 new file mode 100644 index 0000000..9cb0ae4 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_with.cc @@ -0,0 +1,30 @@ +#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 new file mode 100644 index 0000000..80bc841 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_with.testproc @@ -0,0 +1,7 @@ + +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 new file mode 100644 index 0000000..77ce673 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_one_with_defines.cc @@ -0,0 +1,25 @@ + +/* +<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 new file mode 100644 index 0000000..49df049 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc @@ -0,0 +1,33 @@ +/* +<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 Binary files differnew file mode 100644 index 0000000..82c5ce6 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_three_basic.cc.data 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 new file mode 100644 index 0000000..dd8c7e7 --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/mm_three_slow.cc @@ -0,0 +1,35 @@ +/* +<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 new file mode 100755 index 0000000..fefbd2a --- /dev/null +++ b/test-chill/unit-tests/cpp_validate_prog/print_mm_out.py @@ -0,0 +1,10 @@ +#!/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 new file mode 100644 index 0000000..f5f2608 --- /dev/null +++ b/test-chill/unit-tests/cprog/Makefile @@ -0,0 +1,17 @@ +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 new file mode 100644 index 0000000..6e747a3 --- /dev/null +++ b/test-chill/unit-tests/cprog/MergeSorter.cc @@ -0,0 +1,77 @@ +#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 new file mode 100644 index 0000000..e2ed391 --- /dev/null +++ b/test-chill/unit-tests/cprog/MergeSorter.h @@ -0,0 +1,14 @@ +#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 new file mode 100644 index 0000000..3ade346 --- /dev/null +++ b/test-chill/unit-tests/cprog/QuickSorter.cc @@ -0,0 +1,83 @@ +#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 new file mode 100644 index 0000000..81919dd --- /dev/null +++ b/test-chill/unit-tests/cprog/QuickSorter.h @@ -0,0 +1,14 @@ +#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 new file mode 100644 index 0000000..a1ae5ec --- /dev/null +++ b/test-chill/unit-tests/cprog/Sorter.cc @@ -0,0 +1,8 @@ +#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 new file mode 100644 index 0000000..abf8f82 --- /dev/null +++ b/test-chill/unit-tests/cprog/Sorter.h @@ -0,0 +1,16 @@ +#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 new file mode 100644 index 0000000..3fe960b --- /dev/null +++ b/test-chill/unit-tests/cprog/main.cc @@ -0,0 +1,45 @@ +#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 new file mode 100644 index 0000000..7a79417 --- /dev/null +++ b/test-chill/unit-tests/test___main__.py @@ -0,0 +1,205 @@ +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 new file mode 100644 index 0000000..e0225cd --- /dev/null +++ b/test-chill/unit-tests/test__cpp_validate_env.py @@ -0,0 +1,377 @@ +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 new file mode 100644 index 0000000..72cba8a --- /dev/null +++ b/test-chill/unit-tests/test__extract.py @@ -0,0 +1,48 @@ +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 new file mode 100644 index 0000000..8aaebfe --- /dev/null +++ b/test-chill/unit-tests/test_chill.py @@ -0,0 +1,215 @@ +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 new file mode 100644 index 0000000..ed55c80 --- /dev/null +++ b/test-chill/unit-tests/test_cpp_validate.py @@ -0,0 +1,280 @@ +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 new file mode 100644 index 0000000..2720ef7 --- /dev/null +++ b/test-chill/unit-tests/test_gcov.py @@ -0,0 +1,98 @@ +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 new file mode 100644 index 0000000..91d6a13 --- /dev/null +++ b/test-chill/unit-tests/test_omega.py @@ -0,0 +1,23 @@ +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 new file mode 100644 index 0000000..9745358 --- /dev/null +++ b/test-chill/unit-tests/test_test.py @@ -0,0 +1,380 @@ +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 new file mode 100644 index 0000000..fbb0c79 --- /dev/null +++ b/test-chill/unit-tests/test_util.py @@ -0,0 +1,107 @@ +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) + + |