int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; raptor_sequence* row_seq = NULL; raptor_sequence* expr_args_seq = NULL; int failures = 0; rasqal_variables_table* vt; rasqal_rowsource *input_rs = NULL; raptor_sequence* vars_seq = NULL; raptor_sequence* exprs_seq = NULL; int test_id; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } query = rasqal_new_query(world, "sparql", NULL); vt = query->vars_table; for(test_id = 0; test_id < AGGREGATION_TESTS_COUNT; test_id++) { int input_vars_count = test_data[test_id].input_vars; int output_rows_count = test_data[test_id].output_rows; int output_vars_count = test_data[test_id].output_vars; const int* input_group_ids = test_data[test_id].group_ids; const int* result_int_data = test_data[test_id].result_data; const char* const* result_string_data = test_data[test_id].result_string_data; rasqal_op op = test_data[test_id].op; raptor_sequence* seq = NULL; int count; int size; int i; char* output_var_name; rasqal_variable* output_var; rasqal_expression* expr; int output_row_size = (input_vars_count + output_vars_count); if(output_vars_count != 1) { fprintf(stderr, "%s: test %d expects %d variables which is not supported. Test skipped\n", program, test_id, output_vars_count); failures++; goto tidy; } row_seq = rasqal_new_row_sequence(world, vt, test_data[test_id].data, test_data[test_id].input_vars, &vars_seq); if(row_seq) { for(i = 0; i < test_data[test_id].input_rows; i++) { rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(row_seq, i); row->group_id = input_group_ids[i]; } input_rs = rasqal_new_rowsequence_rowsource(world, query, vt, row_seq, vars_seq); /* vars_seq and row_seq are now owned by input_rs */ vars_seq = row_seq = NULL; } if(!input_rs) { fprintf(stderr, "%s: failed to create rowsequence rowsource\n", program); failures++; goto tidy; } expr_args_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression, (raptor_data_print_handler)rasqal_expression_print); if(test_data[test_id].expr_agg_vars[0] != NULL) { int vindex; const unsigned char* var_name; for(vindex = 0; (var_name = (const unsigned char*)test_data[test_id].expr_agg_vars[vindex] ); vindex++) { rasqal_variable* v; rasqal_literal *l = NULL; rasqal_expression* e = NULL; v = rasqal_variables_table_get_by_name(vt, var_name); if(v) l = rasqal_new_variable_literal(world, v); if(l) e = rasqal_new_literal_expression(world, l); if(e) raptor_sequence_push(expr_args_seq, e); else { fprintf(stderr, "%s: failed to create variable %s\n", program, (const char*)var_name); failures++; goto tidy; } } } /* if vars */ output_var_name = (char*)RASQAL_MALLOC(cstring, 5); memcpy(output_var_name, "fake", 5); output_var = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_ANONYMOUS, (const unsigned char*)output_var_name, NULL); expr = make_test_expr(world, expr_args_seq, op); /* expr_args_seq is now owned by expr */ expr_args_seq = NULL; exprs_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression, (raptor_data_print_handler)rasqal_expression_print); raptor_sequence_push(exprs_seq, expr); /* expr is now owned by exprs_seq */ expr = NULL; vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable, (raptor_data_print_handler)rasqal_variable_print); output_var = rasqal_new_variable_from_variable(output_var); raptor_sequence_push(vars_seq, output_var); rowsource = rasqal_new_aggregation_rowsource(world, query, input_rs, exprs_seq, vars_seq); /* exprs_seq, vars_seq and input_rs are now owned by rowsource */ exprs_seq = NULL; vars_seq = NULL; input_rs = NULL; if(!rowsource) { fprintf(stderr, "%s: failed to create aggregation rowsource\n", program); failures++; goto tidy; } /* Test the rowsource */ seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: test %d rasqal_rowsource_read_all_rows() returned a NULL seq for a aggregation rowsource\n", program, test_id); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != output_rows_count) { fprintf(stderr, "%s: test %d rasqal_rowsource_read_all_rows() returned %d rows for a aggregation rowsource, expected %d\n", program, test_id, count, output_rows_count); failures++; goto tidy; } size = rasqal_rowsource_get_size(rowsource); if(size != output_row_size) { fprintf(stderr, "%s: test %d rasqal_rowsource_get_size() returned %d columns (variables) for a aggregation rowsource, expected %d\n", program, test_id, size, output_row_size); failures++; goto tidy; } if(result_int_data) { for(i = 0; i < output_rows_count; i++) { rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i); rasqal_literal* value; int integer; int expected_integer = result_int_data[i]; int vc; if(row->size != output_row_size) { fprintf(stderr, "%s: test %d row #%d is size %d expected %d\n", program, test_id, i, row->size, output_row_size); failures++; goto tidy; } /* Expected variable ordering in output row is: * {input vars} {output_vars} */ for(vc = 0; vc < output_vars_count; vc++) { rasqal_variable* row_var; int offset = input_vars_count + vc; row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset); value = row->values[offset]; if(!value) { fprintf(stderr, "%s: test %d row #%d %s value #%d result is NULL\n", program, test_id, i, row_var->name, vc); failures++; goto tidy; } if(value->type != RASQAL_LITERAL_INTEGER) { fprintf(stderr, "%s: test %d row #%d %s value #%d result is type %s expected integer\n", program, test_id, i, row_var->name, vc, rasqal_literal_type_label(value->type)); failures++; goto tidy; } integer = rasqal_literal_as_integer(value, NULL); if(integer != expected_integer) { fprintf(stderr, "%s: test %d row #%d %s value #%d result is %d expected %d\n", program, test_id, i, row_var->name, vc, integer, expected_integer); failures++; goto tidy; } } } } if(result_string_data) { for(i = 0; i < output_rows_count; i++) { rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i); rasqal_literal* value; const unsigned char* str; const char* expected_string = result_string_data[i]; int vc; if(row->size != output_row_size) { fprintf(stderr, "%s: test %d row #%d is size %d expected %d\n", program, test_id, i, row->size, output_row_size); failures++; goto tidy; } /* Expected variable ordering in output row is: * {input vars} {output_vars} */ for(vc = 0; vc < output_vars_count; vc++) { rasqal_variable* row_var; int offset = input_vars_count + vc; row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset); value = row->values[offset]; if(!value) { fprintf(stderr, "%s: test %d row #%d %s value #%d result is NULL\n", program, test_id, i, row_var->name, vc); failures++; goto tidy; } if(value->type != RASQAL_LITERAL_STRING) { fprintf(stderr, "%s: test %d row #%d %s value #%d is type %s expected integer\n", program, test_id, i, row_var->name, vc, rasqal_literal_type_label(value->type)); failures++; goto tidy; } str = rasqal_literal_as_string(value); if(strcmp((const char*)str, expected_string)) { fprintf(stderr, "%s: test %d row #%d %s value #%d is %s expected %s\n", program, test_id, i, row_var->name, vc, str, expected_string); failures++; goto tidy; } } } } #ifdef RASQAL_DEBUG rasqal_rowsource_print_row_sequence(rowsource, seq, stderr); #endif raptor_free_sequence(seq); seq = NULL; rasqal_free_rowsource(rowsource); rowsource = NULL; if(expr_args_seq) raptor_free_sequence(expr_args_seq); expr_args_seq = NULL; } tidy: if(exprs_seq) raptor_free_sequence(exprs_seq); if(vars_seq) raptor_free_sequence(vars_seq); if(expr_args_seq) raptor_free_sequence(expr_args_seq); if(rowsource) rasqal_free_rowsource(rowsource); if(input_rs) rasqal_free_rowsource(input_rs); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_rowsource *left_rs = NULL; rasqal_rowsource *right_rs = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; raptor_sequence* seq = NULL; int failures = 0; int vars_count; rasqal_variables_table* vt; raptor_sequence* vars_seq = NULL; rasqal_row_compatible* rc_map = NULL; int i; world = rasqal_new_world(); rasqal_world_open(world); query = rasqal_new_query(world, "sparql", NULL); vt = query->vars_table; /* 3 variables and 4 rows */ vars_count = 3; seq = rasqal_new_row_sequence(world, vt, compatible_data_abc_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create left sequence of %d vars\n", program, vars_count); failures++; goto tidy; } left_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!left_rs) { fprintf(stderr, "%s: failed to create left rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by left_rs */ vars_seq = seq = NULL; /* 3 variables and 4 rows */ vars_count = 3; seq = rasqal_new_row_sequence(world, vt, compatible_data_abcd_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create right sequence of %d rows\n", program, vars_count); failures++; goto tidy; } right_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!right_rs) { fprintf(stderr, "%s: failed to create right rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by right_rs */ vars_seq = seq = NULL; rc_map = rasqal_new_row_compatible(vt, left_rs, right_rs); if(!rc_map) { fprintf(stderr, "%s: failed to create row compatible\n", program); failures++; goto tidy; } rasqal_print_row_compatible(stderr, rc_map); #ifdef RASQAL_DEBUG fputs("\n", stderr); #endif for(i = 0; i < EXPECTED_ROWS_COUNT; i++) { rasqal_row *left_row = rasqal_rowsource_read_row(left_rs); rasqal_row *right_row = rasqal_rowsource_read_row(right_rs); int expected = expected_compatible_results[i]; int compatible; if(!left_row) { fprintf(stderr, "%s: FAILED left rowsource ended early at row #%d\n", program, i); failures++; goto tidy; } if(!right_row) { fprintf(stderr, "%s: FAILED right rowsource ended early at row #%d\n", program, i); failures++; goto tidy; } compatible = rasqal_row_compatible_check(rc_map, left_row, right_row); RASQAL_DEBUG4("%s: compatible check for row #%d returned %d\n", program, i, compatible); if(compatible != expected) { fprintf(stderr, "%s: FAILED compatible check for row #%d returned %d expected %d\n", program, i, compatible, expected); failures++; } #ifdef RASQAL_DEBUG fputs("\n", stderr); #endif if(left_row) rasqal_free_row(left_row); if(right_row) rasqal_free_row(right_row); } tidy: if(rc_map) rasqal_free_row_compatible(rc_map); if(seq) raptor_free_sequence(seq); if(left_rs) rasqal_free_rowsource(left_rs); if(right_rs) rasqal_free_rowsource(right_rs); if(rowsource) rasqal_free_rowsource(rowsource); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_world* world = NULL; rasqal_variables_table* vt = NULL; #define NUM_VARS 3 const char* var_names[NUM_VARS] = {"normal-null", "normal-value", "anon"}; unsigned char* names[NUM_VARS]; rasqal_variable* vars[NUM_VARS]; rasqal_literal *value = NULL; int i; int rc = 0; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); rc = 1; goto tidy; } vt = rasqal_new_variables_table(world); if(!vt) { fprintf(stderr, "%s: Failed to make variables table\n", program); rc = 1; goto tidy; } for(i = 0; i < NUM_VARS; i++) { size_t len = strlen(var_names[i]); names[i] = (unsigned char*)malloc(len+1); memcpy(names[i], var_names[i], len + 1); } vars[0] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL, names[0], NULL); if(!vars[0]) { fprintf(stderr, "%s: Failed to make normal variable with NULL value\n", program); rc = 1; goto tidy; } else { /* now owned by vars[0] owned by vt */ names[0] = NULL; } /* vars[0] now owned by vt */ value = rasqal_new_double_literal(world, 42.0); if(!value) { fprintf(stderr, "%s: Failed to make double literal\n", program); rc = 1; goto tidy; } vars[1] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL, names[1], value); if(!vars[1]) { fprintf(stderr, "%s: Failed to make normal variable with literal value\n", program); rc = 1; goto tidy; } else { /* now owned by vars[1] owned by vt */ names[1] = NULL; value = NULL; } /* vars[1] now owned by vt */ vars[2] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_ANONYMOUS, names[2], NULL); if(!vars[2]) { fprintf(stderr, "%s: Failed to make anonymous variable with NULL value\n", program); rc = 1; goto tidy; } else { /* now owned by vars[2] owned by vt */ names[2] = NULL; } /* vars[2] now owned by vt */ tidy: for(i = 0; i < NUM_VARS; i++) { if(names[i]) free(names[i]); } if(value) rasqal_free_literal(value); if(vt) rasqal_free_variables_table(vt); if(world) rasqal_free_world(world); return 0; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_rowsource *left_rs = NULL; rasqal_rowsource *right_rs = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; int count; raptor_sequence* seq = NULL; int failures = 0; rasqal_variables_table* vt; int size; int expected_size = EXPECTED_COLUMNS_COUNT; int i; raptor_sequence* vars_seq = NULL; int test_count; world = rasqal_new_world(); rasqal_world_open(world); query = rasqal_new_query(world, "sparql", NULL); vt = query->vars_table; for(test_count = 0; test_count < JOIN_TESTS_COUNT; test_count++) { rasqal_join_type join_type = join_test_config[test_count].join_type; int expected_count = join_test_config[test_count].expected; int vars_count; fprintf(stderr, "%s: test #%d join type %d\n", program, test_count, RASQAL_GOOD_CAST(int, join_type)); /* 2 variables and 3 rows */ vars_count = 2; seq = rasqal_new_row_sequence(world, vt, join_1_data_2x3_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create left sequence of %d vars\n", program, vars_count); failures++; goto tidy; } left_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!left_rs) { fprintf(stderr, "%s: failed to create left rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by left_rs */ vars_seq = seq = NULL; /* 3 variables and 2 rows */ vars_count = 3; seq = rasqal_new_row_sequence(world, vt, join_2_data_3x2_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create right sequence of %d rows\n", program, vars_count); failures++; goto tidy; } right_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!right_rs) { fprintf(stderr, "%s: failed to create right rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by right_rs */ vars_seq = seq = NULL; rowsource = rasqal_new_join_rowsource(world, query, left_rs, right_rs, join_type, NULL); if(!rowsource) { fprintf(stderr, "%s: failed to create join rowsource\n", program); failures++; goto tidy; } /* left_rs and right_rs are now owned by rowsource */ left_rs = right_rs = NULL; seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: read_rows returned a NULL seq for a join rowsource\n", program); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != expected_count) { fprintf(stderr, "%s: read_rows returned %d rows for a join rowsource, expected %d\n", program, count, expected_count); failures++; goto tidy; } size = rasqal_rowsource_get_size(rowsource); if(size != expected_size) { fprintf(stderr, "%s: read_rows returned %d columns (variables) for a join rowsource, expected %d\n", program, size, expected_size); failures++; goto tidy; } for(i = 0; i < expected_size; i++) { rasqal_variable* v; const char* name = NULL; const char *expected_name = join_result_vars[i]; v = rasqal_rowsource_get_variable_by_offset(rowsource, i); if(!v) { fprintf(stderr, "%s: read_rows had NULL column (variable) #%d expected %s\n", program, i, expected_name); failures++; goto tidy; } name = RASQAL_GOOD_CAST(const char*, v->name); if(strcmp(name, expected_name)) { fprintf(stderr, "%s: read_rows returned column (variable) #%d %s but expected %s\n", program, i, name, expected_name); failures++; goto tidy; } } #ifdef RASQAL_DEBUG rasqal_rowsource_print_row_sequence(rowsource, seq, DEBUG_FH); #endif raptor_free_sequence(seq); seq = NULL; rasqal_free_rowsource(rowsource); rowsource = NULL; /* end test_count loop */ } tidy: if(seq) raptor_free_sequence(seq); if(left_rs) rasqal_free_rowsource(left_rs); if(right_rs) rasqal_free_rowsource(right_rs); if(rowsource) rasqal_free_rowsource(rowsource); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; rasqal_row* row = NULL; int count; raptor_sequence* seq = NULL; int failures = 0; raptor_uri* service_uri; const unsigned char* query_string; raptor_sequence* data_graphs = NULL; unsigned int rs_flags = 0; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } query = rasqal_new_query(world, "sparql", NULL); service_uri = raptor_new_uri(world->raptor_world_ptr, (const unsigned char *)"http://example.org/service"); query_string = (const unsigned char*)"SELECT * WHERE { ?s ?p ?o }"; rowsource = rasqal_new_service_rowsource(world, query, service_uri, query_string, data_graphs, rs_flags); if(!rowsource) { fprintf(stderr, "%s: failed to create service rowsource\n", program); failures++; goto tidy; } row = rasqal_rowsource_read_row(rowsource); if(!row) { fprintf(stderr, "%s: read_row failed to return a row for an service rowsource\n", program); failures++; goto tidy; } if(row->size) { fprintf(stderr, "%s: read_row returned an non-service row size %d for a service stream\n", program, row->size); failures++; goto tidy; } count = rasqal_rowsource_get_rows_count(rowsource); if(count != 1) { fprintf(stderr, "%s: read_rows returned count %d for a service stream\n", program, count); failures++; goto tidy; } rasqal_free_rowsource(rowsource); /* re-init rowsource */ rowsource = rasqal_new_service_rowsource(world, query, service_uri, query_string, data_graphs, rs_flags); seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: read_rows returned a NULL seq for a service stream\n", program); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != 1) { fprintf(stderr, "%s: read_rows returned size %d seq for a service stream\n", program, count); failures++; goto tidy; } tidy: if(seq) raptor_free_sequence(seq); if(rowsource) rasqal_free_rowsource(rowsource); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); #define TEST_ITEMS_COUNT 9 int i; for(i = 0; i < 4; i++) { rasqal_rowsource *rowsource; size_t count; /* for _from_file */ FILE *handle = NULL; /* for _from_string */ void *string; size_t string_len; switch(i) { case 0: #ifdef RASQAL_DEBUG fprintf(stderr, "%s: Creating rowsource from a filename '%s'\n", program, OUT_FILENAME); #endif rowsource = rasqal_new_rowsource_from_filename((const char*)IN_FILENAME); if(!rowsource) { fprintf(stderr, "%s: Failed to create rowsource to filename '%s'\n", program, OUT_FILENAME); exit(1); } break; case 1: #ifdef RASQAL_DEBUG fprintf(stderr, "%s: Creating rowsource from file handle\n", program); #endif handle = fopen((const char*)OUT_FILENAME, "wb"); rowsource = rasqal_new_rowsource_from_file_handle(handle); if(!rowsource) { fprintf(stderr, "%s: Failed to create rowsource from a file handle\n", program); exit(1); } break; case 2: #ifdef RASQAL_DEBUG fprintf(stderr, "%s: Creating rowsource from a string\n", program); #endif rowsource = rasqal_new_rowsource_from_string(&string, &string_len, NULL); if(!rowsource) { fprintf(stderr, "%s: Failed to create rowsource from a string\n", program); exit(1); } break; case 3: #ifdef RASQAL_DEBUG fprintf(stderr, "%s: Creating rowsource from a sink\n", program); #endif rowsource = rasqal_new_rowsource_from_sink(); if(!rowsource) { fprintf(stderr, "%s: Failed to create rowsource from a sink\n", program); exit(1); } break; default: fprintf(stderr, "%s: Unknown test case %d init\n", program, i); exit(1); } count = rasqal_rowsource_get_rows_count(rowsource); if(count != OUT_BYTES_COUNT) { fprintf(stderr, "%s: I/O stream wrote %d bytes, expected %d\n", program, (int)count, (int)OUT_BYTES_COUNT); return 1; } #ifdef RASQAL_DEBUG fprintf(stderr, "%s: Freeing rowsource\n", program); #endif rasqal_free_rowsource(rowsource); switch(i) { case 0: remove(OUT_FILENAME); break; case 1: fclose(handle); remove(OUT_FILENAME); break; case 2: if(!string) { fprintf(stderr, "%s: I/O stream failed to create a string\n", program); return 1; } if(string_len != count) { fprintf(stderr, "%s: I/O stream created a string length %d, expected %d\n", program, (int)string_len, (int)count); return 1; } rasqal_free_memory(string); break; case 3: break; default: fprintf(stderr, "%s: Unknown test case %d tidy\n", program, i); exit(1); } } /* keep gcc -Wall happy */ return(0); }
int main(int argc, char **argv) { const char *program=rasqal_basename(argv[0]); fprintf(stderr, "%s: SPARQL query language not available, skipping test\n", program); return(0); }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; raptor_sequence* row_seq = NULL; raptor_sequence* expr_seq = NULL; int failures = 0; rasqal_variables_table* vt; rasqal_rowsource *input_rs = NULL; int vars_count; raptor_sequence* vars_seq = NULL; int test_id; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } query = rasqal_new_query(world, "sparql", NULL); vt = query->vars_table; for(test_id = 0; test_id < GROUP_TESTS_COUNT; test_id++) { int expected_rows_count = test_data[test_id].rows; int expected_vars_count = test_data[test_id].vars; const int* expected_group_ids = test_data[test_id].group_ids; int expected_ngroups = test_data[test_id].ngroups; raptor_sequence* seq = NULL; int count; int size; int i; int groups_counted; int last_group_id; vars_count = expected_vars_count; row_seq = rasqal_new_row_sequence(world, vt, test_data[test_id].data, vars_count, &vars_seq); if(row_seq) { input_rs = rasqal_new_rowsequence_rowsource(world, query, vt, row_seq, vars_seq); /* vars_seq and row_seq are now owned by input_rs */ vars_seq = row_seq = NULL; } if(!input_rs) { fprintf(stderr, "%s: failed to create rowsequence rowsource\n", program); failures++; goto tidy; } #ifdef HAVE_RAPTOR2_API expr_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression, (raptor_data_print_handler)rasqal_expression_print); #else expr_seq = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_expression, (raptor_sequence_print_handler*)rasqal_expression_print); #endif if(test_data[test_id].expr_vars[0] != NULL) { int vindex; const unsigned char* var_name; for(vindex = 0; (var_name = (const unsigned char*)test_data[test_id].expr_vars[vindex] ); vindex++) { rasqal_variable* v; rasqal_literal *l = NULL; rasqal_expression* e = NULL; v = rasqal_variables_table_get_by_name(vt, var_name); if(v) l = rasqal_new_variable_literal(world, v); if(l) e = rasqal_new_literal_expression(world, l); if(e) raptor_sequence_push(expr_seq, e); else { fprintf(stderr, "%s: failed to create variable %s\n", program, (const char*)var_name); failures++; goto tidy; } } } rowsource = rasqal_new_groupby_rowsource(world, query, input_rs, expr_seq); /* input_rs is now owned by rowsource */ input_rs = NULL; if(!rowsource) { fprintf(stderr, "%s: failed to create groupby rowsource\n", program); failures++; goto tidy; } seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: test %d rasqal_rowsource_read_all_rows() returned a NULL seq for a groupby rowsource\n", program, test_id); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != expected_rows_count) { fprintf(stderr, "%s: test %d rasqal_rowsource_read_all_rows() returned %d rows for a groupby rowsource, expected %d\n", program, test_id, count, expected_rows_count); failures++; goto tidy; } size = rasqal_rowsource_get_size(rowsource); if(size != expected_vars_count) { fprintf(stderr, "%s: test %d rasqal_rowsource_get_size() returned %d columns (variables) for a groupby rowsource, expected %d\n", program, test_id, size, expected_vars_count); failures++; goto tidy; } groups_counted = 0; last_group_id = -1; for(i = 0; i < count; i++) { rasqal_row* row = raptor_sequence_get_at(seq, i); if(row->group_id != last_group_id) { groups_counted++; last_group_id = row->group_id; } if(row->group_id != expected_group_ids[i]) { fprintf(stderr, "%s: test %d row #%d has group_id %d, expected %d\n", program, test_id, i, row->group_id, expected_group_ids[i]); failures++; goto tidy; } } if(groups_counted != expected_ngroups) { fprintf(stderr, "%s: test %d returnd %d groups, expected %d\n", program, test_id, groups_counted, expected_ngroups); failures++; goto tidy; } #ifdef RASQAL_DEBUG rasqal_rowsource_print_row_sequence(rowsource, seq, stderr); #endif raptor_free_sequence(seq); seq = NULL; rasqal_free_rowsource(rowsource); rowsource = NULL; if(expr_seq) raptor_free_sequence(expr_seq); expr_seq = NULL; } tidy: if(expr_seq) raptor_free_sequence(expr_seq); if(rowsource) rasqal_free_rowsource(rowsource); if(input_rs) rasqal_free_rowsource(input_rs); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char **argv) { const char *program=rasqal_basename(argv[0]); const char *query_language_name=QUERY_LANGUAGE; raptor_uri *base_uri; unsigned char *uri_string; int test_i; limit_test* test; int tests_failed_count=0; int single_shot= -1; int query_i; rasqal_world *world; world=rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } if(argc < 2 || argc > 3) { fprintf(stderr, "USAGE: %s data-filename [test number]\n", program); return(1); } if(argv[2]) single_shot=atoi(argv[2]); uri_string=raptor_uri_filename_to_uri_string(""); base_uri = raptor_new_uri(world->raptor_world_ptr, uri_string); raptor_free_memory(uri_string); for(query_i=0; query_i < NQUERIES; query_i++) { const char *query_format = limit_queries[query_i]; int dynamic_limits = (strstr(query_format, "%s %s") != NULL); for(test_i=(single_shot >=0 ? single_shot : 0); (test=&limit_offset_tests[test_i]) && (test->expected_count >=0); test_i++) { int result_i; rasqal_query *query = NULL; rasqal_query_results *results = NULL; const char* expected_results; int test_ok=1; unsigned char *data_string; unsigned char *query_string; size_t qs_len; #define LIM_OFF_BUF_SIZE 20 data_string=raptor_uri_filename_to_uri_string(argv[1]); qs_len = strlen((const char*)data_string) + strlen(query_format) + (2 * LIM_OFF_BUF_SIZE); query_string = RASQAL_MALLOC(unsigned char*, qs_len + 1); if(dynamic_limits) { char lim[LIM_OFF_BUF_SIZE]; char off[LIM_OFF_BUF_SIZE]; if(test->limit >= 0) snprintf(lim, LIM_OFF_BUF_SIZE, "LIMIT %d", test->limit); else *lim = '\0'; if(test->offset >= 0) snprintf(off, LIM_OFF_BUF_SIZE, "OFFSET %d", test->offset); else *off = '\0'; IGNORE_FORMAT_NONLITERAL_START snprintf((char*)query_string, qs_len, query_format, data_string, lim, off); IGNORE_FORMAT_NONLITERAL_END } else { IGNORE_FORMAT_NONLITERAL_START snprintf((char*)query_string, qs_len, query_format, data_string); IGNORE_FORMAT_NONLITERAL_END } raptor_free_memory(data_string); query = rasqal_new_query(world, query_language_name, NULL); if(!query) { fprintf(stderr, "%s: creating query in language %s FAILED\n", program, query_language_name); return(1); } #if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1 fprintf(stderr, "%s: preparing query %d test %d - %s\n", program, query_i, test_i, query_string); #endif if(rasqal_query_prepare(query, query_string, base_uri)) { fprintf(stderr, "%s: query %d test %d prepare '%s' FAILED\n", program, query_i, test_i, query_string); return(1); } if(!dynamic_limits) { rasqal_query_set_limit(query, test->limit); rasqal_query_set_offset(query, test->offset); } #if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1 fprintf(stderr, "%s: executing query %d test %d\n", program, query_i, test_i); #endif results=rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query %d test %d FAILED\n", program, query_i, test_i); return(1); } /* check results */ expected_results=test->expected_results[query_i]; result_i=0; tests_failed_count=0; while(results && !rasqal_query_results_finished(results)) { rasqal_literal *value; const char* str; char expected_str[2]={0,0}; int failed=1; if(result_i < test->expected_count) expected_str[0]=expected_results[result_i]; value=rasqal_query_results_get_binding_value(results, 0); if(value) { int error=0; str=(const char*)rasqal_literal_as_string_flags(value, 0, &error); if(!error && str) { size_t len=strlen(str); if(len == 1 && str[0] == expected_str[0]) failed=0; } } if(failed) { fprintf(stderr, "%s: query %d test %d result %d FAILED returning value '%s' expected value '%s'\n", program, query_i, test_i, result_i, (str ? str: "NULL"), expected_str); test_ok=0; } rasqal_query_results_next(results); result_i++; } if(results) rasqal_free_query_results(results); if(!test_ok) { fprintf(stderr, "%s: query %d test %d limit %d offset %d FAILED\n", program, query_i, test_i, test->limit, test->offset); } else { if(result_i != test->expected_count) { fprintf(stderr, "%s: query %d test %d limit %d offset %d FAILED returned %d results, expected %d\n", program, query_i, test_i, test->limit, test->offset, result_i, test->expected_count); test_ok=0; } } if(!test_ok) { tests_failed_count++; } else { #if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1 fprintf(stderr, "%s: query %d test %d OK\n", program, query_i, test_i); #endif } rasqal_free_query(query); RASQAL_FREE(char*, query_string); if(single_shot >=0) break; } /* end test loop */ } /* end query loop */
int main(int argc, char **argv) { const char *program=rasqal_basename(argv[0]); rasqal_query *query = NULL; rasqal_query_results *results = NULL; raptor_uri *base_uri; unsigned char *data_string; unsigned char *uri_string; const char *query_language_name=QUERY_LANGUAGE; const char *query_format=QUERY_FORMAT; unsigned char *query_string; int count; rasqal_world *world; const char *data_file; world=rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } if((data_file = getenv("RDF_DATA_FILE"))) { /* got data from environment */ } else { if(argc != 2) { fprintf(stderr, "USAGE: %s data-filename\n", program); return(1); } data_file = argv[1]; } data_string = raptor_uri_filename_to_uri_string(data_file); query_string=(unsigned char*)RASQAL_MALLOC(cstring, strlen((const char*)data_string)+strlen(query_format)+1); sprintf((char*)query_string, query_format, data_string); raptor_free_memory(data_string); uri_string=raptor_uri_filename_to_uri_string(""); base_uri = raptor_new_uri(world->raptor_world_ptr, uri_string); raptor_free_memory(uri_string); query=rasqal_new_query(world, query_language_name, NULL); if(!query) { fprintf(stderr, "%s: creating query in language %s FAILED\n", program, query_language_name); return(1); } printf("%s: preparing %s query\n", program, query_language_name); if(rasqal_query_prepare(query, query_string, base_uri)) { fprintf(stderr, "%s: %s query prepare FAILED\n", program, query_language_name); return(1); } RASQAL_FREE(cstring, query_string); printf("%s: executing query #1\n", program); results=rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 1 FAILED\n", program); return(1); } count=0; while(results && !rasqal_query_results_finished(results)) { int i; for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name=rasqal_query_results_get_binding_name(results, i); rasqal_literal *value=rasqal_query_results_get_binding_value(results, i); printf("result %d: variable %s=", count+1, (char*)name); rasqal_literal_print(value, stdout); putchar('\n'); } rasqal_query_results_next(results); count++; } if(results) rasqal_free_query_results(results); if(count != EXPECTED_RESULTS_COUNT) { fprintf(stderr, "%s: query execution 1 returned %d results, expected %d\n", program, count, EXPECTED_RESULTS_COUNT); return(1); } printf("%s: executing query #2\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 2 FAILED\n", program); return(1); } count=0; while(results && !rasqal_query_results_finished(results)) { int i; for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name=rasqal_query_results_get_binding_name(results, i); rasqal_literal *value=rasqal_query_results_get_binding_value(results, i); printf("result %d: variable %s=", count+1, (char*)name); rasqal_literal_print(value, stdout); putchar('\n'); } rasqal_query_results_next(results); count++; } if(results) rasqal_free_query_results(results); if(count != EXPECTED_RESULTS_COUNT) { fprintf(stderr, "%s: query execution 2 returned %d results, expected %d\n", program, count, EXPECTED_RESULTS_COUNT); return(1); } printf("%s: executing query #3\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 3 FAILED\n", program); return(1); } rasqal_free_query_results(results); printf("%s: executing query #4\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 4 FAILED\n", program); return(1); } rasqal_free_query_results(results); rasqal_free_query(query); raptor_free_uri(base_uri); rasqal_free_world(world); return 0; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; raptor_sequence *seq = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; rasqal_row* row = NULL; int count; int failures = 0; rasqal_variables_table* vt; int rows_count; int i; raptor_sequence* vars_seq = NULL; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } query = rasqal_new_query(world, "sparql", NULL); /* test 1-row rowsource (2 variables) */ rows_count = 1; #ifdef RASQAL_DEBUG RASQAL_DEBUG2("Testing %d-row rowsource\n", rows_count); #endif vt = rasqal_new_variables_table(world); /* add 2 variables to table and 1 row sequence */ seq = rasqal_new_row_sequence(world, vt, test_1_rows, 2, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create sequence of %d rows\n", program, rows_count); failures++; goto tidy; } rowsource = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!rowsource) { fprintf(stderr, "%s: failed to create %d-row sequence rowsource\n", program, rows_count); failures++; goto tidy; } /* vars_seq and seq are now owned by rowsource */ vars_seq = seq = NULL; row = rasqal_rowsource_read_row(rowsource); if(!row) { fprintf(stderr, "%s: read_row returned no row for a %d-row sequence rowsource\n", program, rows_count); failures++; goto tidy; } #ifdef RASQAL_DEBUG RASQAL_DEBUG1("Result Row:\n "); rasqal_row_print(row, stderr); fputc('\n', stderr); #endif rasqal_free_row(row); row = NULL; count = rasqal_rowsource_get_rows_count(rowsource); if(count != rows_count) { fprintf(stderr, "%s: read_rows returned count %d instead of %d for a %d-row sequence rowsource\n", program, count, rows_count, rows_count); failures++; goto tidy; } row = rasqal_rowsource_read_row(rowsource); if(row) { fprintf(stderr, "%s: read_row returned > %d rows for a %d-row sequence rowsource\n", program, rows_count, rows_count); failures++; goto tidy; } rasqal_free_rowsource(rowsource); rowsource = NULL; rasqal_free_variables_table(vt); vt = NULL; /* test 3-row rowsource */ rows_count = 3; #ifdef RASQAL_DEBUG RASQAL_DEBUG2("Testing %d-row rowsource\n", rows_count); #endif vt = rasqal_new_variables_table(world); /* add 4 variables to table and 3 row sequence */ seq = rasqal_new_row_sequence(world, vt, test_3_rows, 4, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create sequence of %d rows\n", program, rows_count); failures++; goto tidy; } rowsource = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!rowsource) { fprintf(stderr, "%s: failed to create %d-row sequence rowsource\n", program, rows_count); failures++; goto tidy; } /* vars_seq and seq are now owned by rowsource */ vars_seq = seq = NULL; for(i = 0; i < rows_count; i++) { row = rasqal_rowsource_read_row(rowsource); if(!row) { fprintf(stderr, "%s: read_row returned no row for row %d in a %d-row sequence rowsource\n", program, i, rows_count); failures++; goto tidy; } #ifdef RASQAL_DEBUG RASQAL_DEBUG1("Result Row:\n "); rasqal_row_print(row, stderr); fputc('\n', stderr); #endif rasqal_free_row(row); row = NULL; } count = rasqal_rowsource_get_rows_count(rowsource); if(count != rows_count) { fprintf(stderr, "%s: read_rows returned count %d instead of %d for a %d-row sequence rowsource\n", program, count, rows_count, rows_count); failures++; goto tidy; } row = rasqal_rowsource_read_row(rowsource); if(row) { fprintf(stderr, "%s: read_row returned >%d rows for a %d-row sequence rowsource\n", program, rows_count, rows_count); failures++; goto tidy; } rasqal_free_rowsource(rowsource); rowsource = NULL; rasqal_free_variables_table(vt); vt = NULL; tidy: if(row) rasqal_free_row(row); if(seq) raptor_free_sequence(seq); if(rowsource) rasqal_free_rowsource(rowsource); if(vt) rasqal_free_variables_table(vt); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }
int main(int argc, char *argv[]) { char const *program=rasqal_basename(*argv); int failures=0; rasqal_xsd_decimal a; rasqal_xsd_decimal b; rasqal_xsd_decimal *result; rasqal_xsd_decimal *result2; double result_d; char *result_s; int result_i; const long a_long = 1234567890L; const double a_double = 1234567890e0; const char* b_string = "123456789012345678"; const char* expected_a_plus_b = "123456790246913568"; const char* expected_a_plus_b_minus_b = "1234567890"; const char* expected_a_plus_b_minus_b_minus_a = "0"; const char* expected_negative_b = "-123456789012345678"; int expected_a_compare_b= -1; int expected_a_equals_b= 0; rasqal_world *world; world = rasqal_new_world(); #ifdef RASQAL_DECIMAL_MPFR fprintf(stderr, "%s: Using MPFR %s\n", program, mpfr_get_version()); #endif #ifdef RASQAL_DECIMAL_GMP #ifdef HAVE_GMP_VERSION fprintf(stderr, "%s: Using GMP %s\n", program, gmp_version); #else fprintf(stderr, "%s: Using GMP version unknown\n", program); #endif #endif #ifdef RASQAL_DECIMAL_NONE fprintf(stderr, "%s: Using double\n", program); #endif #ifdef RASQAL_DECIMAL_NONE #define FAIL_LABEL #define FAIL failures++ #else #define FAIL_LABEL tidy: #define FAIL failures++; goto tidy #endif rasqal_xsd_decimal_init(&a); rasqal_xsd_decimal_init(&b); result = rasqal_new_xsd_decimal(world); result2 = rasqal_new_xsd_decimal(world); if(!result || !result2) { fprintf(stderr, "%s: rasqal_new_xsd_decimal() failed\n", program); FAIL; } rasqal_xsd_decimal_set_long(&a, a_long); rasqal_xsd_decimal_set_string(&b, b_string); result_d=rasqal_xsd_decimal_get_double(&a); if(result_d != a_double) { fprintf(stderr, "FAILED: a=%f expected %f\n", result_d, a_double); FAIL; } result_s=rasqal_xsd_decimal_as_string(&b); if(strcmp(result_s, b_string)) { fprintf(stderr, "FAILED: b=%s expected %s\n", result_s, b_string); FAIL; } /* result = a+b */ rasqal_xsd_decimal_add(result, &a, &b); result_s=rasqal_xsd_decimal_as_string(result); if(strcmp(result_s, expected_a_plus_b)) { fprintf(stderr, "FAILED: a+b=%s expected %s\n", result_s, expected_a_plus_b); FAIL; } /* result2 = result-b */ rasqal_xsd_decimal_subtract(result2, result, &b); result_s=rasqal_xsd_decimal_as_string(result2); if(strcmp(result_s, expected_a_plus_b_minus_b)) { fprintf(stderr, "FAILED: (a+b)-b=%s expected %s\n", result_s, expected_a_plus_b_minus_b); FAIL; } /* result = result2-a */ rasqal_xsd_decimal_subtract(result, result2, &a); result_s=rasqal_xsd_decimal_as_string(result); if(strcmp(result_s, expected_a_plus_b_minus_b_minus_a)) { fprintf(stderr, "FAILED: (a+b)-b-a=%s expected %s\n", result_s, expected_a_plus_b_minus_b_minus_a); FAIL; } result_i=rasqal_xsd_decimal_compare(&a, &b); if((expected_a_compare_b < 0 && result_i >= 0) || (expected_a_compare_b > 0 && result_i <= 0) || (expected_a_compare_b == 0 && result_i != 0)) { fprintf(stderr, "FAILED: a compare b = %d expected %d\n", result_i, expected_a_compare_b); FAIL; } result_i=rasqal_xsd_decimal_equals(&a, &b); if(result_i != expected_a_equals_b) { fprintf(stderr, "FAILED: a equals b = %d expected %d\n", result_i, expected_a_equals_b); FAIL; } /* result2 = -b */ rasqal_xsd_decimal_negate(result, &b); result_s=rasqal_xsd_decimal_as_string(result); if(strcmp(result_s, expected_negative_b)) { fprintf(stderr, "FAILED: -b=%s expected %s\n", result_s, expected_negative_b); FAIL; } FAIL_LABEL rasqal_xsd_decimal_clear(&a); rasqal_xsd_decimal_clear(&b); if(result) rasqal_free_xsd_decimal(result); if(result2) rasqal_free_xsd_decimal(result2); rasqal_free_world(world); #ifdef RASQAL_DECIMAL_NONE if(failures) fprintf(stderr, "%s: ignoring %d failures as RASQAL_DECIMAL_NONE specified\n", program, failures); return 0; #else return failures; #endif }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; rasqal_row* row = NULL; int count; raptor_sequence* seq = NULL; int failures = 0; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } query = rasqal_new_query(world, "sparql", NULL); rowsource = rasqal_new_empty_rowsource(world, query); if(!rowsource) { fprintf(stderr, "%s: failed to create empty rowsource\n", program); failures++; goto tidy; } row = rasqal_rowsource_read_row(rowsource); if(!row) { fprintf(stderr, "%s: read_row failed to return a row for an empty rowsource\n", program); failures++; goto tidy; } if(row->size) { fprintf(stderr, "%s: read_row returned an non-empty row size %d for a empty stream\n", program, row->size); failures++; goto tidy; } count = rasqal_rowsource_get_rows_count(rowsource); if(count != 1) { fprintf(stderr, "%s: read_rows returned count %d for a empty stream\n", program, count); failures++; goto tidy; } rasqal_free_row(row); row = NULL; rasqal_free_rowsource(rowsource); /* re-init rowsource */ rowsource = rasqal_new_empty_rowsource(world, query); seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: read_rows returned a NULL seq for a empty stream\n", program); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != 1) { fprintf(stderr, "%s: read_rows returned size %d seq for a empty stream\n", program, count); failures++; goto tidy; } tidy: if(row) rasqal_free_row(row); if(seq) raptor_free_sequence(seq); if(rowsource) rasqal_free_rowsource(rowsource); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }