/* Prueba que la funcion comparar se ejecute correctamente. */ void prueba_comparar() { /* Declaro los vectores a utilizar. */ int vacio[] = {}; int unico[] = { 5 }; int vec1[] = { 1, 2, 3, 4, 5 }; int vec2[] = { 1, 2, 5 }; int vec3[] = { 5, 8, 9 }; /* Declaro los largos de los vectores */ int nvacio = 0; int nunico = 1; int nvec1 = 5; int nvec2 = 3; int nvec3 = 3; print_test("Prueba comparar vacio, unico", comparar(vacio, nvacio, unico, nunico) == -1); print_test("Prueba comparar unico, vec3", comparar(unico, nunico, vec3, nvec3) == -1); print_test("Prueba comparar vec1, vec1", comparar(vec1, nvec1, vec1, nvec1) == 0); print_test("Prueba comparar vec2, vec1", comparar(vec2, nvec2, vec1, nvec1) == 1); print_test("Prueba comparar vec3, vec2", comparar(vec3, nvec3, vec2, nvec2) == 1); }
int main (void) { TestStruct* data; /* save */ printf("Saving...\n"); data = (TestStruct*)malloc(sizeof(TestStruct)); if (data == NULL) { fprintf(stderr, "malloc(): %s\n", strerror(errno)); return 1; } data->id = 500; data->name = "Elanthis"; data->hp = 70; data->hp_max = 75; print_test(data); save_test(data); free(data); /* load */ printf("Loading...\n"); data = load_test(); if (data == NULL) { fprintf(stderr, "load_data(): %s\n", strerror(errno)); return 1; } print_test(data); free(data); return 0; }
void pruebas_heap_vacio(void){ heap_t* heap=heap_crear(int_cmp); print_test("Heap vacío...",heap_cantidad(heap)==0); print_test("Ver max es NULL...",heap_ver_max(heap)==NULL); print_test("Desencolar es NULL...",heap_desencolar(heap)==NULL); heap_destruir(heap,NULL); }
void pruebas_cola_de_pilas() { printf("\nINICIO DE PRUEBAS CON COLA DE PILAS\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); pila_t* pila = pila_crear(); pila_t* pila2 = pila_crear(); int a = 1, b = 2, c = 3, d = 4, e = 5; int* p_a = &a; int* p_b = &b; int* p_c = &c; int* p_d = &d; int* p_e = &e; /* Inicio de pruebas */ // Apilo todos los elementos pila_apilar(pila, p_a); pila_apilar(pila, p_b); pila_apilar(pila, p_c); pila_apilar(pila2, p_d); pila_apilar(pila2, p_e); // Encolo las pilas print_test("Prueba encolar pila 1", cola_encolar(cola, pila)); print_test("Prueba encolar pila 2", cola_encolar(cola, pila2)); /* Destruyo la cola */ cola_destruir(cola, pila_destruir_wrapper); print_test("La cola fue destruida", true); }
void pruebas_cola_destruir(){ //19 punto* p = malloc(sizeof(punto)); p->x = 1; p->y = 2; cola_t *cola =cola_crear(); cola_encolar(cola, p); print_test("Ver primero igual a struct punto", cola_ver_primero(cola) == p); cola_desencolar(cola); //20 print_test("Desencolar struct punto, cola vacia", cola_esta_vacia(cola)); //21 cola_encolar(cola, p); cola_destruir(cola, destruir_punto); print_test("Destruir cola con struct punto encolado", true); //22 cola_t* cola_1 = cola_crear(); for(int i = 0; i<500; i++){ if (i%2==0) cola_encolar(cola_1, p); else cola_desencolar(cola_1); } print_test("Intercalar encolar y desencolar", cola_esta_vacia(cola_1)); cola_destruir(cola_1, destruir_punto); destruir_punto(p); }
void pruebas_volumen(){ printf("***** Inicio de pruebas de volumen *****\n"); bool ok = true; cola_t* cola = cola_crear(); print_test("cola esta vacia", cola_esta_vacia(cola)); int vec[TAM_PRUEBAS]; for(int a =0; a < TAM_PRUEBAS; a++){ vec[a] = a; ok = cola_encolar(cola, &vec[a]); if (!ok) break; } print_test("Todos los elementos fueron encolados con exito", ok); for(int b = 0; b < TAM_PRUEBAS ; b++){ ok = *(int*)cola_desencolar(cola) == vec[b] ? true : false ; if (!ok) break; } print_test("Todos los elementos fueron desencolados en orden", ok); cola_destruir(cola, NULL); }
/* Prueba que la funcion swap se ejecute correctamente. */ void prueba_swap() { int a = 5, b = 6; swap(&a,&b); print_test("Prueba swap 1", (a==6 && b==5)); a = 10, b = -10; swap(&a,&b); print_test("Prueba swap 2", (a==-10 && b==10)); }
void pruebas_cola_vacia(){ printf("***** Inicio de pruebas cola vacia *****\n"); cola_t* cola = cola_crear(); print_test("cola creada con exito ",cola!=NULL); print_test("cola esta vacia ",cola_esta_vacia(cola)); print_test("cola ver primero devuelve NULL", !cola_ver_primero(cola)); print_test("cola desencolar devuelve NULL", !cola_desencolar(cola)); cola_destruir(cola,NULL); }
int test_list(void) { int ret = 0; allocator_t *allocator; iterator_t it,next; container_t *ct; /* *allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC); */ allocator = allocator_creator(ALLOCATOR_TYPE_CDS_MALLOC); allocator_cds_init(allocator, 0, 0, 1024); dbg_str(DBG_CONTAINER_DETAIL,"list allocator addr:%p",allocator); ct = container_creator(CONTAINER_TYPE_LIST,allocator); container_list_init(ct,sizeof(struct test)); /* *container_push_front(ct,&test); *container_push_front(ct,&test2); *container_push_front(ct,&test3); */ dbg_str(DBG_CONTAINER_DETAIL,"run at here"); container_push_back(ct,&test); container_push_back(ct,&test2); container_push_back(ct,&test3); dbg_str(DBG_CONTAINER_DETAIL,"iter ordinal"); for( it = container_begin(ct); !iterator_equal(it,container_end(ct)); it = iterator_next(it)) { print_test((struct test *)iterator_get_pointer(it)); } dbg_str(DBG_CONTAINER_DETAIL,"iter insert test"); int i = 0; for( it = container_begin(ct); !iterator_equal(it,container_end(ct)); it = iterator_next(it),i++) { if(i == 1){ break; } } dbg_str(DBG_CONTAINER_DETAIL,"it list_head:%p",it.pos.list_head_p); container_insert(ct,it,&test4); dbg_str(DBG_CONTAINER_DETAIL,"iter delte test"); container_for_each_safe(it,next,ct){ //container_delete(ct,it); print_test((struct test *)iterator_get_pointer(it)); }
int main(int argc, char *argv[]) { // FILE *foo; int i=0; int j=0; float total_time; float total_rate; struct command_def bmcommand; struct result_def bmresult; #if 1 if(bmcommand_from_console(argc, argv, &bmcommand) == BMTRUE) { print_test(bmcommand); bmresult = benchmark(bmcommand); print_result(bmcommand, bmresult); } // printf("m: %d, p: %d, ip: %s, ds: %d, bs: %d\n", // bmcommand.mode,bmcommand.port_number,bmcommand.ip_address,bmcommand.total_data_size,bmcommand.buffer_size); #else for(i=256; i< 1459;i+=1202) { for(j=0;j<6;j++) { // fudging it for now... bmcommand.buffer_size = 2000; bmcommand.mode = RECEIVER; if(j>=3) { bmcommand.mode = SENDER; bmcommand.buffer_size = i; } bmcommand.port_number = 50; bmcommand.protocol = TCP; // command.ip_address not needed for receiver strcpy(bmcommand.ip_address,"192.168.0.50"); // command.total_data_size not needed for receiver bmcommand.total_data_size = 100000000; print_test(bmcommand); bmresult = benchmark(bmcommand); /// total_time = get_total_time(bmresult.start_time, bmresults.stop_time); print_result(bmcommand, bmresult); if(j<=3) sleep(1); else sleep(4); } } #endif return 0; }
/* Pruebas para un vector de tamanio 0*/ void pruebas_vector_nulo() { printf("INICIO DE PRUEBAS CON VECTOR DE TAMANIO 0\n"); /* Declaro las variables a utilizar*/ vector_t* vec = vector_crear(0); /* Inicio de pruebas */ print_test("crear vector con tamanio 0", vec != NULL); print_test("obtener tamanio vector es 0", vector_obtener_tamanio(vec) == 0); /* Pruebo que guardar en un vector de tamanio 0 devuelve false siempre (no se puede guardar) */ print_test("guardar en vec[0] es false", !vector_guardar(vec, 0, 5)); print_test("guardar en vec[1] es false", !vector_guardar(vec, 1, 10)); print_test("guardar en vec[15] es false", !vector_guardar(vec, 15, 0)); /* Pruebo que obtener valores de un vector de tamaño 0 devuelve false */ int valor; print_test("obtener vec[0] es false", !vector_obtener(vec, 0, &valor)); print_test("obtener vec[1] es false", !vector_obtener(vec, 1, &valor)); /* Destruyo el vector*/ vector_destruir(vec); print_test("el vector fue destruido", true); }
void BinaryTreeTest::test_tree_height() { test_header( "tree height" ); Tree<int> tree; print_test( tree.height() == 0 ); tree.insert( 10 ); print_test( tree.height() == 1 ); tree.insert( 15 ); print_test( tree.height() == 2 ); tree.insert( 5 ); print_test( tree.height() == 2 ); }
void json_report(FILE *f, struct criterion_global_stats *stats) { fprintf(f, JSON_BASE_TEMPLATE_BEGIN, stats->tests_passed, stats->tests_failed, stats->tests_crashed, stats->tests_skipped ); fprintf(f, JSON_TESTSUITE_LIST_TEMPLATE_BEGIN); for (struct criterion_suite_stats *ss = stats->suites; ss; ss = ss->next) { fprintf(f, JSON_TESTSUITE_TEMPLATE_BEGIN, ss->suite->name, ss->tests_passed, ss->tests_failed, ss->tests_crashed, ss->tests_skipped ); fprintf(f, JSON_TEST_LIST_TEMPLATE_BEGIN); for (struct criterion_test_stats *ts = ss->tests; ts; ts = ts->next) { print_test(f, ts, ss); fprintf(f, ts->next ? ",\n" : "\n"); } fprintf(f, JSON_TEST_LIST_TEMPLATE_END); fprintf(f, JSON_TESTSUITE_TEMPLATE_END); fprintf(f, ss->next ? ",\n" : "\n"); } fprintf(f, JSON_TESTSUITE_LIST_TEMPLATE_END); fprintf(f, JSON_BASE_TEMPLATE_END); }
uint8_t do_prompt() { print(PSTR(">")); char group[10]; // scanf("%4s",group); scan_key(group,10); if (strcmp(group,"rf")==0) { return rf_do_prompt(); } else if (strcmp(group,"io")==0) { return io_do_prompt(); } else if (strcmp(group,"test")==0) { print_test(); scan_test(); } else if (strcmp(group,"timer")==0) { return timer_do_prompt(); } else if (strcmp(group,"server")==0) { return server_do_prompt(); } else if (strcmp(group,"client")==0) { return client_do_prompt(); } else if (strcmp(group,"set")==0) { return set_do_prompt(); } else if (strcmp(group,"pad")==0) { return pad_do_prompt(); } else if (strcmp(group,".")==0) { return 0; } return 1; }
void pruebas_cola_vacia() { printf("\nINICIO DE PRUEBAS CON COLA VACIA\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); /* Inicio de pruebas */ print_test("Prueba crear cola", cola != NULL); print_test("Prueba cola esta vacia despues de crearla", cola_esta_vacia(cola)); print_test("Prueba ver primero cola vacia", !cola_ver_primero(cola)); print_test("Prueba desencolar cola vacia", !cola_desencolar(cola)); /* Destruyo la cola */ cola_destruir(cola, NULL); print_test("La cola fue destruida", true); }
static int dump2_test(bytecode_input_t *d, int i, int version) { test_t test; int len; /* there is no short circuiting involved here */ i = bc_test_parse(d, i, version, &test); switch (test.type) { case BC_NOT: printf("NOT "); i = dump2_test(d, i, version); break; case BC_ANYOF: case BC_ALLOF: len = test.u.aa.ntests; printf("%s({%d}\n\t", (test.type == BC_ANYOF) ? "ANYOF" : "ALLOF", len); while (len--) { i = dump2_test(d, i, version); printf("\t"); } printf(")\n"); break; default: print_test(&test); break; } return i; }
int main() { int *x, y; // I fully realize how silly it is to make x into a pointer. /* Sets x */ for( *x = 0; *x < 10; ++( *x ) ); /* Sets y */ while( y != 90 ) { if( y < 80 ) { y = y + 10; } else if( y >= 80 ) { ++y; } } /* Prints x + y */ print_test( *x, y ); return 0; }
/* compress/decompress a file */ static void handle_file(char *file, struct stat *sbp) { off_t usize, gsize; char outfile[PATH_MAX]; infile = file; if (dflag) { usize = file_uncompress(file, outfile, sizeof(outfile)); #ifndef SMALL if (vflag && tflag) print_test(file, usize != -1); #endif if (usize == -1) return; gsize = sbp->st_size; } else { gsize = file_compress(file, outfile, sizeof(outfile)); if (gsize == -1) return; usize = sbp->st_size; } #ifndef SMALL if (vflag && !tflag) print_verbage(file, (cflag) ? NULL : outfile, usize, gsize); #endif }
void xml_report(FILE *f, struct criterion_global_stats *stats) { fprintf(f, XML_BASE_TEMPLATE_BEGIN, stats->nb_tests, stats->tests_failed, stats->tests_crashed, stats->tests_skipped ); for (struct criterion_suite_stats *ss = stats->suites; ss; ss = ss->next) { fprintf(f, XML_TESTSUITE_TEMPLATE_BEGIN, ss->suite->name, ss->nb_tests, ss->tests_failed, ss->tests_crashed, ss->tests_skipped, ss->tests_skipped ); for (struct criterion_test_stats *ts = ss->tests; ts; ts = ts->next) { print_test(f, ts, ss); } fprintf(f, XML_TESTSUITE_TEMPLATE_END); } fprintf(f, XML_BASE_TEMPLATE_END); }
void BinaryTreeTest::test_node_children_are_null_by_default() { test_header( "node children are null by default" ); Node<int> node; print_test( node.left == NULL && node.right == NULL ); }
int main(int argc, const char *argv[]) { V_NODE *head = NULL; int flag = 0; print_test(); head = load_link(); while(!flag) { print_list(); switch(get_choice()) { case 1: head = add_link(head); break; case 2: head = delete_link(head); break; case 3: print_link(head); break; case 4: flag = 1 ; save_link(head); break; default : break; } } return 0; }
void OperatorOverloadingTest::check_map_item_set_type() { print_header( "map_item gets type correctly" ); MapItem item( 'Z' ); print_test( item.getType() == 'Z' ); }
void OperatorOverloadingTest::check_map_item_constructor() { print_header( "map_item constructor accepts char" ); MapItem item( 'O' ); print_test( item.getType() == 'O' ); }
void OperatorOverloadingTest::check_map_item_default_constructor() { print_header( "map_item default constructor initializes to E" ); MapItem item; print_test( item.getType() == 'E' ); }
void BinaryTreeTest::test_node_creation_with_value() { test_header( "node creation with value" ); int test_value = 42; Node<int> node( test_value ); print_test( node.data == test_value ); }
void OperatorOverloadingTest::check_map_build() { print_header( "map builds correctly" ); map->build( 0, 1, 'O' ); codes[ 1 ] = 'O'; print_test( map->getMapItem( 0, 1 ).getType() == 'O' ); }
void BinaryTreeTest::test_tree_is_full() { test_header( "tree is full" ); Tree<int> tree; tree.insert( 50 ); tree.insert( 100 ); tree.insert( 25 ); tree.insert( 12 ); tree.insert( 35 ); tree.insert( 30 ); tree.insert( 40 ); print_test( tree.isFull() ); tree.insert( 5 ); print_test( ! tree.isFull() ); }
AdaptiveSizePolicyOutput(AdaptiveSizePolicy* size_policy, uint count) : _size_policy(size_policy) { if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) { _do_print = print_test(count); } else { _do_print = false; } }
void BinaryTreeTest::test_tree_contains() { test_header( "tree insert and contains" ); int something = 42; Tree<int> tree; tree.insert( something ); print_test( tree.contains( something ) == true ); }
void QueueTest::clear_queue() { test_header( "clearing the queue (isEmpty and dequeue)" ); while( ! queue->isEmpty() ) { queue->dequeue(); } // Makes the assumption that program would fail if loop fails print_test( true ); }