END_TEST
START_TEST (test_selector)
{
set_fail_freq(1000000);
freesasa_parameters p = freesasa_default_parameters;
p.shrake_rupley_n_points = 10;
FILE *file = fopen(DATADIR "1ubq.pdb", "r");
freesasa_structure *s = freesasa_structure_from_pdb(file, NULL, 0);
freesasa_result *result = freesasa_calc_structure(s, NULL);
double area;
char name[FREESASA_MAX_SELECTION_NAME];
freesasa_set_verbosity(FREESASA_V_SILENT);
for (int i = 1; i < 17; ++i) {
/* This is a pretty short expression. Have not verified that
it's actually exactly 17 memory allocations, but we have
success with a frequencey of 18, and 17 seems about right. */
set_fail_freq(i);
ck_assert_int_eq(freesasa_select_area("s, resn ALA and not resi 1-20", name, &area, s, result),
FREESASA_FAIL); // this expression should come across most allocations
}
freesasa_set_verbosity(FREESASA_V_NORMAL);
fclose(file);
freesasa_result_free(result);
freesasa_structure_free(s);
}
END_TEST
START_TEST (test_api)
{
freesasa_parameters p = freesasa_default_parameters;
p.shrake_rupley_n_points = 20; // so the loop below will be fast
freesasa_set_verbosity(FREESASA_V_SILENT);
for (int i = 1; i < 50; ++i) {
p.alg = FREESASA_SHRAKE_RUPLEY;
set_fail_freq(i);
ck_assert_int_eq(freesasa_calc(&coord, r, &p), NULL);
p.alg = FREESASA_LEE_RICHARDS;
set_fail_freq(i);
ck_assert_int_eq(freesasa_calc(&coord, r, &p), NULL);
}
FILE *file = fopen(DATADIR "1ubq.pdb","r");
set_fail_freq(10000);
freesasa_structure *s=freesasa_structure_from_pdb(file, NULL, 0);
ck_assert_ptr_ne(s,NULL);
for (int i = 1; i < 256; i *= 2) { //try to spread it out without doing too many calculations
set_fail_freq(i);
ck_assert_ptr_eq(freesasa_calc_structure(s, NULL), NULL);
set_fail_freq(i);
ck_assert_ptr_eq(freesasa_structure_get_chains(s, "A"), NULL);
}
set_fail_freq(1);
freesasa_structure_free(s);
fclose(file);
freesasa_set_verbosity(FREESASA_V_NORMAL);
}
END_TEST
START_TEST (test_structure)
{
FILE *file = fopen(DATADIR "1ubq.pdb","r");
int n;
freesasa_set_verbosity(FREESASA_V_SILENT);
ck_assert_ptr_ne(file, NULL);
ck_assert_ptr_eq(freesasa_structure_new(), NULL);
ck_assert_ptr_eq(from_pdb_impl(file,interval, NULL, 0), NULL);
for (int i = 1; i < 100; ++i) {
set_fail_freq(i);
rewind(file);
ck_assert_ptr_eq(freesasa_structure_from_pdb(file, NULL, 0), NULL);
}
fclose(file);
file = fopen(DATADIR "2jo4.pdb", "r");
ck_assert_ptr_ne(file,NULL);
for (int i = 1; i < 50; ++i) {
set_fail_freq(i);
rewind(file);
ck_assert_ptr_eq(freesasa_structure_array(file, &n, NULL, FREESASA_SEPARATE_MODELS),NULL);
rewind(file);
ck_assert_ptr_eq(freesasa_structure_array(file, &n, NULL, FREESASA_SEPARATE_MODELS | FREESASA_SEPARATE_CHAINS),NULL);
}
set_fail_freq(1);
fclose(file);
freesasa_set_verbosity(FREESASA_V_NORMAL);
}
END_TEST
START_TEST (test_syntax_error)
{
double a;
char s[FREESASA_MAX_SELECTION_NAME+1];
const char *err[] = {"","a","a,","a,b",
// no selection arg
"a,resi","a,resn","a,name","a,symbol","a,chain",
// no name of selection
",resn ala",",resi 1",",name ca",", symbol c",",chain a",
"resn ala","resi 1","name ca","symbol c","chain a",
// comma wrong place, no name
"resn, ala","resi, 1","name, ca","symbol, c","chain, a",
// ranges (-) used where not allowed
"a, resn ala-arg", "a, name ca-cb","a, symbol c-o",
"a, resi 1-2-3",
// trailing +-
"a, resn ala+", "a, resn ala+arg+", "a, resi 1-",
"a, resi 1-", "a, resi 1-2+","a, resi 1+2-5+",
// boolean operators
"a, (resn ala) AND","a,(resn ala) OR","a,(resn ala) OR NOT",
"a, (resn ala) AND arg","a,(resn ala) OR arg",
"a, (resn ala) OR NOT arg",
"a, ala OR resn arg",
};
int n = sizeof(err)/sizeof(char*);
freesasa_set_verbosity(FREESASA_V_SILENT);
for (int i = 0; i < n; ++i) {
ck_assert_int_eq(freesasa_select_area(err[i],s,&a,structure,result),FREESASA_FAIL);
}
freesasa_set_verbosity(FREESASA_V_NORMAL);
} END_TEST
END_TEST
START_TEST (test_resi)
{
const char *commands[] = {"c1, resi 1+2-4",
"c2, resi 2-4",
"c3, resi 1",
"c4, resi 1 AND resi 2-4",
"c5, resi 1 OR resi 2-4",
"c6, resi 1-2+2-4",
"c7, resi 1+2-4+3",
"c8, resi 1-2+7+9+3-5+100",
"c9, resi 1-4 AND NOT resi 2-4"};
freesasa_set_verbosity(FREESASA_V_SILENT);
test_select(commands,9);
freesasa_set_verbosity(FREESASA_V_NORMAL);
ck_assert(value[0] > 5);
ck_assert(float_eq(value[0], addup(resi_1,result) + addup(resi_2r4,result), 1e-10));
ck_assert(float_eq(value[1], addup(resi_2r4,result), 1e-10));
ck_assert(float_eq(value[2], addup(resi_1,result), 1e-10));
ck_assert(float_eq(value[3], 0, 1e-10));
ck_assert(float_eq(value[4], value[0], 1e-10));
ck_assert(float_eq(value[5], value[0], 1e-10));
ck_assert(float_eq(value[6], value[0], 1e-10));
ck_assert(float_eq(value[7], value[0], 1e-10));
ck_assert(float_eq(value[8], value[2], 1e-10));
}
END_TEST
START_TEST (test_nb)
{
freesasa_set_verbosity(FREESASA_V_SILENT);
ck_assert_ptr_eq(cell_list_new(1,&coord),NULL);
ck_assert_int_eq(fill_cells(&a_cell_list,&coord),FREESASA_FAIL);
ck_assert_ptr_eq(freesasa_nb_alloc(10),NULL);
for (int i = 1; i < 50; ++i) {
set_fail_freq(i);
ck_assert_ptr_eq(freesasa_nb_alloc(2*i),NULL);
set_fail_freq(i);
ck_assert_ptr_eq(freesasa_nb_new(&coord,r),NULL);
}
set_fail_freq(1);
freesasa_set_verbosity(FREESASA_V_NORMAL);
}
} END_TEST
// check that some complex constructs don't cause errors, but no checks for valid selection
START_TEST (test_complex_syntax)
{
double a;
char s[FREESASA_MAX_SELECTION_NAME+1];
const char *stmt[] = {"a, (resn ala AND resi 1-3) OR (NOT chain A+B AND (symbol C OR symbol O))",
"a, NOT symbol SE+C AND NOT resi 5-7+1+6-8+100+200+10-11"
};
int n = sizeof(stmt)/sizeof(char*);
freesasa_set_verbosity(FREESASA_V_SILENT);
for (int i = 0; i < n; ++i) {
ck_assert_int_eq(freesasa_select_area(stmt[i],s,&a,structure,result),FREESASA_SUCCESS);
}
freesasa_set_verbosity(FREESASA_V_NORMAL);
} END_TEST
END_TEST
START_TEST (test_classifier)
{
freesasa_set_verbosity(FREESASA_V_SILENT);
set_fail_freq(1);
ck_assert_ptr_eq(classifier_types_new(),NULL);
ck_assert_ptr_eq(classifier_residue_new("A"),NULL);
ck_assert_ptr_eq(classifier_config_new(),NULL);
for (int i = 1; i < 5; ++i) {
set_fail_freq(10000);
struct classifier_types *types = classifier_types_new();
struct classifier_residue *res = classifier_residue_new("ALA");
struct classifier_config *cfg = classifier_config_new();
if (i < 3) {
set_fail_freq(i);
ck_assert_int_eq(add_class(types,"A"),FREESASA_FAIL);
set_fail_freq(i);
ck_assert_int_eq(add_type(types,"a","A",1.0),FREESASA_FAIL);
}
set_fail_freq(i);
ck_assert_int_eq(add_atom(res,"A",1.0,0),FREESASA_FAIL);
set_fail_freq(i);
ck_assert_int_eq(add_residue(cfg,"A"),FREESASA_FAIL);
classifier_types_free(types);
classifier_residue_free(res);
classifier_config_free(cfg);
}
// don't test all levels, but make sure errors in low level
// allocation propagates to the interface
FILE *config = fopen(SHAREDIR "naccess.config","r");
ck_assert_ptr_ne(config, NULL);
for (int i = 1; i < 50; ++i) {
set_fail_freq(i);
ck_assert_ptr_eq(freesasa_classifier_from_file(config),NULL);
rewind(config);
}
fclose(config);
freesasa_set_verbosity(FREESASA_V_NORMAL);
}
END_TEST
START_TEST (test_alg)
{
// First check that the input actually gives a valid calculation
set_fail_freq(10000);
ck_assert_int_eq(freesasa_lee_richards(dummy,&coord,r,1.4,20,1),FREESASA_SUCCESS);
ck_assert_int_eq(freesasa_shrake_rupley(dummy,&coord,r,1.4,100,1),FREESASA_SUCCESS);
freesasa_set_verbosity(FREESASA_V_SILENT);
for (int i = 1; i < 50; ++i) {
set_fail_freq(i);
ck_assert_int_eq(freesasa_lee_richards(dummy,&coord,r,1.4,0.1,1),FREESASA_FAIL);
set_fail_freq(i);
ck_assert_int_eq(freesasa_shrake_rupley(dummy,&coord,r,1.4,100,1),FREESASA_FAIL);
}
set_fail_freq(1);
freesasa_set_verbosity(FREESASA_V_NORMAL);
}
END_TEST
START_TEST (test_memerr) {
FILE *file = fopen(DATADIR "1ubq.pdb","r");
freesasa_structure *structure = freesasa_structure_from_pdb(file, NULL, 0);
freesasa_result *result = freesasa_calc_structure(structure, NULL);
freesasa_node *rn;
freesasa_set_verbosity(FREESASA_V_SILENT);
rn = freesasa_tree_new();
for (int i = 1; i < 200; ++i) {
int ret;
set_fail_after(i);
ret = freesasa_tree_add_result(rn, result, structure, "test");
set_fail_after(0);
ck_assert_int_eq(ret, FREESASA_FAIL);
}
freesasa_set_verbosity(FREESASA_V_NORMAL);
freesasa_structure_free(structure);
freesasa_result_free(result);
fclose(file);
} END_TEST
