API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 21st, 2019
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 30.00 KB | None | 0 0
raw download clone embed print report
  1. Corrector: Jasmina Sella Faena
  2. Grupo: G43
  3. Entrega: ABB
  4. Fecha: 22/11
  5.  
  6. //abb.c:
  7. #include <stdlib.h>
  8. #include "abb.h"
  9. #include <stddef.h>
  10. #include <string.h>
  11. #include "testing.h"
  12. #include <stdio.h>
  13. #include <stdbool.h>
  14. #include <string.h>
  15. #include "pila.h"
  16.  
  17. typedef struct n_abb{
  18. struct n_abb* izq;
  19. struct n_abb* der;
  20. void* dato;
  21. char* clave;
  22. }n_abb_t;
  23.  
  24. struct abb{
  25. n_abb_t* raiz;
  26. abb_comparar_clave_t funcion_comparacion;
  27. abb_destruir_dato_t funcion_destruccion;
  28. size_t cant;
  29. };
  30.  
  31. struct abb_iter{
  32. const abb_t* arbol;
  33. pila_t* pila_ejecucion;
  34. };
  35.  
  36. typedef struct padre_hijo_n_abb {
  37. n_abb_t* padre;
  38. n_abb_t* nodo;
  39. } padre_hijo_n_abb_t;
  40.  
  41.  
  42. n_abb_t* crear_nodo(void *dato, const char* clave);
  43. char* strdup(const char* clave);
  44. bool _abb_in_order(n_abb_t* nodo, bool visitar(const char *, void *, void *), void *extra);
  45. padre_hijo_n_abb_t* buscar_nodo(const abb_t* abb, const char* clave);
  46. padre_hijo_n_abb_t* _buscar_nodo(const abb_t* abb, n_abb_t* nodo_actual,n_abb_t* padre, const char* clave, padre_hijo_n_abb_t* padre_hijo);
  47.  
  48. abb_t* abb_crear(abb_comparar_clave_t cmp, abb_destruir_dato_t destruir_dato){
  49. abb_t* abb = malloc(sizeof(abb_t));
  50. if(!abb) return NULL;
  51. abb->raiz = NULL;
  52. abb->funcion_comparacion = cmp;
  53. abb->funcion_destruccion = destruir_dato;
  54. abb->cant = 0;
  55. return abb;
  56. }
  57. padre_hijo_n_abb_t* buscar_nodo(const abb_t* abb, const char* clave){
  58. padre_hijo_n_abb_t* padre_hijo = malloc(sizeof(padre_hijo_n_abb_t));
  59. if(!padre_hijo) return NULL;
  60. return _buscar_nodo(abb, abb->raiz, NULL, clave, padre_hijo);
  61. }
  62.  
  63. padre_hijo_n_abb_t* _buscar_nodo(const abb_t* abb, n_abb_t* nodo_actual, n_abb_t*padre, const char* clave, padre_hijo_n_abb_t* padre_hijo){
  64. if(!nodo_actual){
  65. padre_hijo->padre = padre;
  66. padre_hijo->nodo = NULL;
  67. return padre_hijo;
  68. }
  69. int comparacion = abb->funcion_comparacion(clave, nodo_actual->clave);
  70. if(comparacion > 0) return _buscar_nodo(abb, nodo_actual->der, nodo_actual, clave, padre_hijo);
  71. if(comparacion < 0) return _buscar_nodo(abb, nodo_actual->izq, nodo_actual, clave, padre_hijo);
  72. padre_hijo->padre = padre;
  73. padre_hijo->nodo = nodo_actual;
  74. return padre_hijo;
  75. }
  76.  
  77. bool abb_guardar(abb_t *arbol, const char *clave, void *dato){
  78. padre_hijo_n_abb_t* padre_hijo = buscar_nodo(arbol, clave);
  79. if(!padre_hijo) return false;
  80. n_abb_t* nodo_actual = padre_hijo->nodo;
  81. n_abb_t* padre = padre_hijo->padre;
  82. if(!nodo_actual){
  83. n_abb_t* nodo_nuevo = crear_nodo(dato, clave);
  84. if (!nodo_nuevo) return false;
  85. if(arbol->cant == 0) arbol->raiz = nodo_nuevo;
  86. else{
  87. int comparacion_padre = arbol->funcion_comparacion(clave, padre->clave);
  88. if(comparacion_padre > 0) padre->der = nodo_nuevo;
  89. else padre->izq = nodo_nuevo;
  90. }
  91. arbol->cant++;
  92. free(padre_hijo);
  93. return true;
  94. }
  95. if (arbol->funcion_destruccion) arbol->funcion_destruccion(nodo_actual->dato);
  96. nodo_actual->dato = dato;
  97. free(padre_hijo);
  98. return true;
  99. }
  100.  
  101.  
  102. n_abb_t* crear_nodo(void *dato, const char* clave){
  103. char* clave_copia = strdup(clave);
  104. if(!clave_copia) return NULL;
  105. n_abb_t* nodo = malloc(sizeof(n_abb_t));
  106. if (!nodo) return NULL;
  107. nodo->dato = dato;
  108. nodo->clave = clave_copia;
  109. nodo->izq = NULL;
  110. nodo->der = NULL;
  111. return nodo;
  112. }
  113.  
  114. void *abb_borrar(abb_t *arbol, const char *clave){
  115. padre_hijo_n_abb_t* padre_hijo = buscar_nodo(arbol, clave);
  116. if(!padre_hijo) return NULL;
  117. n_abb_t* nodo_actual = padre_hijo->nodo;
  118. n_abb_t* padre = padre_hijo->padre;
  119. if (!nodo_actual){
  120. free(padre_hijo);
  121. return NULL;
  122. }
  123. void* dato = nodo_actual->dato;
  124. char* clave_actual = nodo_actual->clave;
  125. bool tiene_dos_hijos = false;
  126. if(!nodo_actual->der && !nodo_actual->izq){
  127. if(padre){
  128. int comparacion_padre = arbol->funcion_comparacion(nodo_actual->clave, padre->clave);
  129. if(comparacion_padre > 0) padre->der = NULL;
  130. else padre->izq = NULL;
  131. }
  132. free(nodo_actual);
  133. }
  134. else if((nodo_actual->der && !nodo_actual->izq) || (!nodo_actual->der && nodo_actual->izq)){
  135. if(!padre){
  136. if(nodo_actual->der) arbol->raiz = nodo_actual->der;
  137. else arbol->raiz = nodo_actual->izq;
  138. }
  139. else{
  140. int comparacion_padre = arbol->funcion_comparacion(nodo_actual->clave, padre->clave);
  141. if (comparacion_padre > 0){
  142. if(nodo_actual->der) padre->der = nodo_actual->der;
  143. else padre->der = nodo_actual->izq;
  144. }
  145. else{
  146. if(nodo_actual->der) padre->izq = nodo_actual->der;
  147. else padre->izq = nodo_actual->izq;
  148. }
  149. }
  150. free(nodo_actual);
  151. }
  152. else if(nodo_actual->der && nodo_actual->izq){
  153. n_abb_t* reemplazante = nodo_actual->der;
  154. while(reemplazante->izq) reemplazante = reemplazante->izq;
  155. char* clave_reemplazo = strdup(reemplazante->clave);
  156. nodo_actual->dato = abb_borrar(arbol, reemplazante->clave);
  157. nodo_actual->clave = clave_reemplazo;
  158. tiene_dos_hijos = true;
  159. }
  160. if(!tiene_dos_hijos) arbol->cant--;
  161. if(arbol->cant == 0) arbol->raiz = NULL;
  162. free(clave_actual);
  163. free(padre_hijo);
  164. return dato;
  165. }
  166.  
  167. void *abb_obtener(const abb_t *arbol, const char *clave){
  168. padre_hijo_n_abb_t* padre_hijo = buscar_nodo(arbol, clave);
  169. if (!padre_hijo->nodo){
  170. free(padre_hijo);
  171. return NULL;
  172. }
  173. void* dato = padre_hijo->nodo->dato;
  174. free(padre_hijo);
  175. return dato;
  176. }
  177.  
  178. bool abb_pertenece(const abb_t *arbol, const char *clave){
  179. padre_hijo_n_abb_t* padre_hijo = buscar_nodo(arbol, clave);
  180. bool estado = (padre_hijo->nodo) != NULL;
  181. free(padre_hijo);
  182. return estado;
  183. }
  184.  
  185. size_t abb_cantidad(abb_t *arbol){
  186. return arbol->cant;
  187. }
  188.  
  189. void abb_destruir(abb_t* arbol){
  190. while(arbol->raiz){
  191. void* dato = abb_borrar(arbol, arbol->raiz->clave);
  192. if(arbol->funcion_destruccion) arbol->funcion_destruccion(dato);
  193. }
  194. free(arbol);
  195. }
  196.  
  197. //Primitivas del iterador.
  198.  
  199. //Iterador INTERNO
  200.  
  201. void abb_in_order(abb_t *arbol, bool visitar(const char *, void *, void *), void *extra){
  202. if(!arbol->raiz) return;
  203. _abb_in_order(arbol->raiz, visitar, extra);
  204. }
  205.  
  206. bool _abb_in_order(n_abb_t* nodo, bool visitar(const char *, void *, void *), void *extra){
  207.  
  208. if (nodo->izq){
  209. if(!_abb_in_order(nodo->izq, visitar, extra)) return false;
  210. }
  211. if(!visitar(nodo->clave, nodo->dato, extra)) return false;
  212. if (nodo->der){
  213. if(!_abb_in_order(nodo->der, visitar, extra)) return false;
  214. }
  215. return true;
  216.  
  217. }
  218.  
  219. //Iterador EXTERNO
  220.  
  221. abb_iter_t* abb_iter_in_crear(const abb_t* arbol){
  222. abb_iter_t* iter = malloc(sizeof(abb_iter_t));
  223. if(!iter) return NULL;
  224. pila_t* pila_ejecucion = pila_crear();
  225. if(!pila_ejecucion){
  226. free(iter);
  227. return NULL;
  228. }iter->pila_ejecucion = pila_ejecucion;
  229. iter->arbol = arbol;
  230. if(arbol->cant != 0){
  231. pila_apilar(iter->pila_ejecucion, arbol->raiz);
  232. n_abb_t* tope = arbol->raiz;
  233. while(tope->izq){
  234. pila_apilar(iter->pila_ejecucion, tope->izq);
  235. tope = tope->izq;
  236. }
  237. }
  238. return iter;
  239. }
  240.  
  241. bool abb_iter_in_avanzar(abb_iter_t* iter){
  242. if(pila_esta_vacia(iter->pila_ejecucion)) return false;
  243. n_abb_t* desapilado = pila_desapilar(iter->pila_ejecucion);
  244. if(desapilado->der){
  245. pila_apilar(iter->pila_ejecucion, desapilado->der);
  246. n_abb_t* tope = pila_ver_tope(iter->pila_ejecucion);
  247. while(tope->izq){
  248. pila_apilar(iter->pila_ejecucion, tope->izq);
  249. tope = tope->izq;
  250. }
  251. }
  252. return true;
  253. }
  254.  
  255. const char* abb_iter_in_ver_actual(const abb_iter_t* iter){
  256. if(pila_esta_vacia(iter->pila_ejecucion)) return NULL;
  257. return ((n_abb_t*)pila_ver_tope(iter->pila_ejecucion))->clave;
  258. }
  259.  
  260. bool abb_iter_in_al_final(const abb_iter_t* iter){
  261. return pila_esta_vacia(iter->pila_ejecucion);
  262. }
  263.  
  264. void abb_iter_in_destruir(abb_iter_t* iter){
  265. if(!pila_esta_vacia(iter->pila_ejecucion)) pila_desapilar(iter->pila_ejecucion);
  266. pila_destruir(iter->pila_ejecucion);
  267. free(iter);
  268. }
  269.  
  270. //Codigo pruebas:
  271.  
  272. #include "abb.h"
  273. #include "testing.h"
  274. #include <stddef.h>
  275. #include <stdio.h>
  276. #include <stdlib.h>
  277. #include <string.h>
  278. #include <unistd.h>
  279. #define VOLUMEN 100
  280. #define TAM_CADENAS 10
  281. #include "pila.h"
  282.  
  283. /* ******************************************************************
  284. * PRUEBAS UNITARIAS ALUMNO
  285. * *****************************************************************/
  286.  
  287. void pila_destruir_wrapper(void* pila){
  288. pila_destruir((pila_t*) pila);
  289. }
  290.  
  291. void prueba_creacion_abb() {
  292. printf("~~PRUEBA DE CREACIÓN Y DESTRUCCIÓN DEL ABB~~\n");
  293. abb_t* abb = abb_crear(NULL, NULL);
  294. print_test("Prueba abb crear vacío", abb != NULL);
  295. print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  296. print_test("Prueba abb obtener clave A es NULL", !abb_obtener(abb, "hola"));
  297. print_test("Prueba abb obtener clave A es NULL", !abb_borrar(abb, "hola"));
  298. abb_destruir(abb);
  299. print_test("abb destruido", true);
  300. printf("\n");
  301. }
  302.  
  303. void prueba_guardar_elementos() {
  304. printf("~~PRUEBA DE INSERTAR Y BORRAR ELEMENTOS EN MEMORIA ESTÁTICA~~\n");
  305. abb_t* abb = abb_crear(strcmp, NULL);
  306. int n = 5;
  307. print_test("Prueba abb guardar un elemento", abb_guardar(abb, "numero", &n));
  308. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  309. print_test("Prueba abb obtener clave A es el valor", abb_obtener(abb, "numero") == &n);
  310. print_test("Prueba abb pertenece clave A es verdadero", abb_pertenece(abb, "numero"));
  311. print_test("Prueba abb obtener clave B es NULL", !abb_obtener(abb, "numero2"));
  312. print_test("Prueba abb pertenece clave B es falso", !abb_pertenece(abb, "numero2"));
  313. abb_destruir(abb);
  314. printf("\n");
  315. }
  316.  
  317. void prueba_guardar_elementos_2() {
  318. printf("~~PRUEBA DE INSERTAR Y BORRAR ELEMENTOS EN MEMORIA ESTÁTICA 2~~\n");
  319. abb_t* abb = abb_crear(strcmp, NULL);
  320. int n = 5;
  321. int n2 = 3;
  322. int n3 = 4;
  323. print_test("Prueba abb guardar clave 1", abb_guardar(abb, "algoritmos", &n));
  324. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  325. print_test("Prueba abb obtener clave 1 es el valor 1", abb_obtener(abb, "algoritmos") == &n);
  326. print_test("Prueba abb pertenece clave 1 es verdadero", abb_pertenece(abb, "algoritmos"));
  327. print_test("Prueba abb borrar clave 1 es valor 1", abb_borrar(abb, "algoritmos") == &n);
  328. print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  329. print_test("Prueba abb guardar clave 2", abb_guardar(abb, "programacion", &n2));
  330. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  331. print_test("Prueba abb obtener clave 2 es el valor 2", abb_obtener(abb, "programacion") == &n2);
  332. print_test("Prueba abb pertenece clave 2 es verdadero", abb_pertenece(abb, "programacion"));
  333. print_test("Prueba abb guardar clave 3", abb_guardar(abb, "hola", &n3));
  334. print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  335. print_test("Prueba abb obtener clave 3 es el valor 3", abb_obtener(abb, "hola") == &n3);
  336. print_test("Prueba abb pertenece clave 3 es verdadero", abb_pertenece(abb, "hola"));
  337. abb_destruir(abb);
  338. printf("\n");
  339. }
  340.  
  341. void prueba_guardar_elementos_3() {
  342. printf("~~PRUEBA DE INSERTAR Y BORRAR ELEMENTOS EN MEMORIA ESTÁTICA 3~~\n");
  343. abb_t* abb = abb_crear(strcmp, NULL);
  344. int n = 5;
  345. int n2 = 3;
  346. int n3 = 4;
  347. int n4 = 2;
  348. int n5 = 21;
  349. print_test("Prueba abb guardar clave 1", abb_guardar(abb, "algoritmos", &n));
  350. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  351. print_test("Prueba abb obtener clave 1 es el valor 1", abb_obtener(abb, "algoritmos") == &n);
  352. print_test("Prueba abb pertenece clave 1 es verdadero", abb_pertenece(abb, "algoritmos"));
  353. print_test("Prueba abb reemplazar clave 1", abb_guardar(abb, "algoritmos", &n4));
  354. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  355. print_test("Prueba abb obtener clave 1 es el valor 1", abb_obtener(abb, "algoritmos") == &n4);
  356.  
  357. print_test("Prueba abb guardar clave 2", abb_guardar(abb, "programacion", &n2));
  358. print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  359. print_test("Prueba abb obtener clave 2 es el valor 2", abb_obtener(abb, "programacion") == &n2);
  360. print_test("Prueba abb pertenece clave 2 es verdadero", abb_pertenece(abb, "programacion"));
  361.  
  362. print_test("Prueba abb guardar clave 3", abb_guardar(abb, "hola", &n3));
  363. print_test("Prueba abb la cantidad de elementos es 3", abb_cantidad(abb) == 3);
  364. print_test("Prueba abb obtener clave 3 es el valor 3", abb_obtener(abb, "hola") == &n3);
  365. print_test("Prueba abb pertenece clave 3 es verdadero", abb_pertenece(abb, "hola"));
  366.  
  367. print_test("Prueba abb guardar clave 4", abb_guardar(abb, "paralelepipedo", &n5));
  368. print_test("Prueba abb la cantidad de elementos es 4", abb_cantidad(abb) == 4);
  369. print_test("Prueba abb pertenece clave 4 es verdadero", abb_pertenece(abb, "paralelepipedo"));
  370. print_test("Prueba abb obtener clave 4 es el valor 4", abb_obtener(abb, "paralelepipedo") == &n5);
  371.  
  372. print_test("Prueba abb obtener clave 1 es el valor 1", abb_obtener(abb, "algoritmos") == &n4);
  373. print_test("Prueba abb obtener clave 2 es el valor 2", abb_obtener(abb, "programacion") == &n2);
  374. print_test("Prueba abb obtener clave 3 es el valor 3", abb_obtener(abb, "hola") == &n3);
  375.  
  376. abb_destruir(abb);
  377. printf("\n");
  378. }
  379.  
  380. char* gen_random(){
  381. static const char alphanum[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  382. char* str = malloc((TAM_CADENAS + 1) * sizeof(char));
  383. for (int i = 0; i < TAM_CADENAS; i++) str[i] = alphanum[(size_t)rand() % (size_t)(sizeof(alphanum) - 1)];
  384. str[TAM_CADENAS] = '\0';
  385. return str;
  386. }
  387.  
  388. void prueba_volumen() {
  389. printf("~~PRUEBA DE VOLUMEN~~\n");
  390. abb_t* abb = abb_crear(strcmp, NULL);
  391.  
  392. char* arr_cadenas[VOLUMEN];
  393. bool ok = true;
  394.  
  395. for(int i = 0; i < VOLUMEN; i++){
  396. arr_cadenas[i] = gen_random();
  397. if (!abb_guardar(abb, arr_cadenas[i], arr_cadenas + i )) ok = false;
  398. if(!abb_pertenece(abb, arr_cadenas[i])) ok = false;
  399. if (abb_obtener(abb, arr_cadenas[i]) != arr_cadenas + i) ok = false;
  400. if (abb_cantidad(abb) != 1 + i) ok = false;
  401. }
  402.  
  403. print_test("Guardo varios elementos, comprobando si todo salio correctamente", ok);
  404. print_test("El abb no está vacío", abb_cantidad(abb) != 0);
  405. print_test("La cantidad del abb es el volumen", abb_cantidad(abb) == VOLUMEN);
  406.  
  407. for (int i = 0; i < VOLUMEN; i++){
  408. char** dato = abb_borrar(abb, arr_cadenas[i]);
  409. if (dato != arr_cadenas + i) ok = false;
  410. if (abb_cantidad(abb) != VOLUMEN - 1 - i) ok = false;
  411. if (abb_obtener(abb, arr_cadenas[i])) ok = false;
  412. if (abb_pertenece(abb, arr_cadenas[i])) ok = false;
  413. free(arr_cadenas[i]);
  414. }
  415.  
  416. print_test("Borro varios elementos, comprobando si todo salio correctamente", ok);
  417. print_test("El abb está vacío", abb_cantidad(abb) == 0);
  418. abb_destruir(abb);
  419. print_test("El abb fue destruído", true);
  420. printf("\n");
  421. }
  422.  
  423. void prueba_abb_clave_vacia(){
  424. printf("~~PRUEBA DE INSERTAR CLAVE VACÍA~~\n");
  425. abb_t* abb = abb_crear(strcmp, NULL);
  426.  
  427. char *clave = "", *valor = "";
  428.  
  429. print_test("Prueba abb guardar clave vacia", abb_guardar(abb, clave, valor));
  430. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  431. print_test("Prueba abb obtener clave vacia es valor", abb_obtener(abb, clave) == valor);
  432. print_test("Prueba abb pertenece clave vacia, es true", abb_pertenece(abb, clave));
  433. print_test("Prueba abb borrar clave vacia, es valor", abb_borrar(abb, clave) == valor);
  434. print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  435.  
  436. abb_destruir(abb);
  437. printf("\n");
  438. }
  439.  
  440. void prueba_abb_reemplazar_con_destruir(){
  441. printf("~~PRUEBA DE INSERTAR Y BORRAR ELEMENTOS EN MEMORIA DINÁMICA~~\n");
  442. abb_t* abb = abb_crear(strcmp, free);
  443.  
  444. char *clave1 = "perro", *valor1a, *valor1b;
  445. char *clave2 = "gato", *valor2a, *valor2b;
  446.  
  447. valor1a = malloc(10 * sizeof(char));
  448. valor1b = malloc(10 * sizeof(char));
  449. valor2a = malloc(10 * sizeof(char));
  450. valor2b = malloc(10 * sizeof(char));
  451.  
  452. print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1a));
  453. print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  454. print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  455. print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2a));
  456. print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  457. print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  458. print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  459.  
  460. print_test("Prueba abb insertar clave1 con otro valor", abb_guardar(abb, clave1, valor1b));
  461. print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  462. print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  463. print_test("Prueba abb insertar clave2 con otro valor", abb_guardar(abb, clave2, valor2b));
  464. print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  465. print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  466. print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  467. abb_destruir(abb);
  468. printf("\n");
  469. }
  470.  
  471. void prueba_abb_borrar(){
  472. printf("~~PRUEBA DE BORRAR ELEMENTOS~~\n");
  473. abb_t* abb = abb_crear(strcmp, NULL);
  474.  
  475. char *clave1 = "perro", *valor1 = "guau";
  476. char *clave2 = "gato", *valor2 = "miau";
  477. char *clave3 = "vaca", *valor3 = "mu";
  478.  
  479. print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1));
  480. print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2));
  481. print_test("Prueba abb insertar clave3", abb_guardar(abb, clave3, valor3));
  482.  
  483. print_test("Prueba abb pertenece clave3, es verdadero", abb_pertenece(abb, clave3));
  484. print_test("Prueba abb borrar clave3, es valor3", abb_borrar(abb, clave3) == valor3);
  485. print_test("Prueba abb borrar clave3, es NULL", !abb_borrar(abb, clave3));
  486. print_test("Prueba abb pertenece clave3, es falso", !abb_pertenece(abb, clave3));
  487. print_test("Prueba abb obtener clave3, es NULL", !abb_obtener(abb, clave3));
  488. print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  489.  
  490. print_test("Prueba abb pertenece clave1, es verdadero", abb_pertenece(abb, clave1));
  491. print_test("Prueba abb borrar clave1, es valor1", abb_borrar(abb, clave1) == valor1);
  492. print_test("Prueba abb borrar clave1, es NULL", !abb_borrar(abb, clave1));
  493. print_test("Prueba abb pertenece clave1, es falso", !abb_pertenece(abb, clave1));
  494. print_test("Prueba abb obtener clave1, es NULL", !abb_obtener(abb, clave1));
  495. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  496.  
  497. print_test("Prueba abb pertenece clave2, es verdadero", abb_pertenece(abb, clave2));
  498. print_test("Prueba abb borrar clave2, es valor2", abb_borrar(abb, clave2) == valor2);
  499. print_test("Prueba abb borrar clave2, es NULL", !abb_borrar(abb, clave2));
  500. print_test("Prueba abb pertenece clave2, es falso", !abb_pertenece(abb, clave2));
  501. print_test("Prueba abb obtener clave2, es NULL", !abb_obtener(abb, clave2));
  502. print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  503.  
  504. abb_destruir(abb);
  505. printf("\n");
  506. }
  507.  
  508.  
  509. void prueba_insertar_null() {
  510. printf("~~PRUEBA DE GUARDAR VALOR NULL~~\n");
  511. abb_t* abb = abb_crear(strcmp, NULL);
  512.  
  513. char *clave = "", *valor = NULL;
  514.  
  515. print_test("Prueba abb insertar clave vacia valor NULL", abb_guardar(abb, clave, valor));
  516. print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  517. print_test("Prueba abb obtener clave vacia es valor NULL", abb_obtener(abb, clave) == valor);
  518. print_test("Prueba abb pertenece clave vacia, es true", abb_pertenece(abb, clave));
  519. print_test("Prueba abb borrar clave vacia, es valor NULL", abb_borrar(abb, clave) == valor);
  520. print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  521.  
  522. abb_destruir(abb);
  523. printf("\n");
  524. }
  525.  
  526. static ssize_t buscar(const char* clave, char* claves[], size_t largo)
  527. {
  528. for (size_t i = 0; i < largo; i++) {
  529. if (strcmp(clave, claves[i]) == 0) return (ssize_t) i;
  530. }
  531. return -1;
  532. }
  533.  
  534. void prueba_iterador_abb_vacio() {
  535. printf("~~PRUEBA DE CREAR ITERADOR EN ABB VACÍO~~\n");
  536. abb_t* abb = abb_crear(strcmp, NULL);
  537. print_test("La cantidad de elementos es 0", abb_cantidad(abb) == 0);
  538. print_test("Obtener la clave A es NULL, no existe", !abb_obtener(abb, "A"));
  539. print_test("Pertenece clave A es NULL, no existe", !abb_pertenece(abb, "A"));
  540. print_test("Borrar clave A es NULL, no existe", !abb_borrar(abb, "A"));
  541. abb_iter_t* iter = abb_iter_in_crear(abb);
  542. print_test("El iterador está al final", abb_iter_in_al_final(iter));
  543. print_test("Avanzar devuelve false", !abb_iter_in_avanzar(iter));
  544. print_test("Ver actual devuelve NULL", !abb_iter_in_ver_actual(iter));
  545. char* clave1 = "marciano";
  546. char* clave2 = "androide";
  547. char* clave3 = "pentagono";
  548. int valor1 = 1;
  549. int valor2 = 3;
  550. int valor3 = 7;
  551. print_test("Guardo la clave1", abb_guardar(abb, clave1, &valor1));
  552. print_test("Guardo la clave2", abb_guardar(abb, clave2, &valor2));
  553. print_test("Guardo la clave3", abb_guardar(abb, clave3, &valor3));
  554. print_test("El iterador esta al final" , abb_iter_in_al_final(iter));
  555. abb_iter_in_destruir(iter);
  556. abb_destruir(abb);
  557. printf("\n");
  558. }
  559.  
  560. void prueba_recorrer(){
  561. printf("~~PRUEBA RECORRER~~\n");
  562. abb_t* abb = abb_crear(strcmp, NULL);
  563. char* clave1 = "programa";
  564. char* clave2 = "medio";
  565. char* clave3 = "yugoslavo";
  566. char* clave4 = "arte";
  567. char* clave5 = "oro";
  568. char* clave6 = "super";
  569. char* clave7 = "zorro";
  570. int valor1 = 3;
  571. int valor2 = 32;
  572. int valor3 = 322;
  573. int valor4 = 455;
  574. int valor5 = 544;
  575. int valor6 = 777;
  576. int valor7 = 999;
  577. print_test("Guardo la clave 1", abb_guardar(abb, clave1, &valor1));
  578. print_test("Guardo la clave 2", abb_guardar(abb, clave2, &valor2));
  579. print_test("Guardo la clave 3", abb_guardar(abb, clave3, &valor3));
  580. print_test("Guardo la clave 4", abb_guardar(abb, clave4, &valor4));
  581. print_test("Guardo la clave 5", abb_guardar(abb, clave5, &valor5));
  582. print_test("Guardo la clave 6", abb_guardar(abb, clave6, &valor6));
  583. print_test("Guardo la clave 7", abb_guardar(abb, clave7, &valor7));
  584. abb_iter_t* iter = abb_iter_in_crear(abb);
  585. print_test("El iterador no esta al final", !abb_iter_in_al_final(iter));
  586. print_test("Ver actual es clave4", strcmp(abb_iter_in_ver_actual(iter), clave4) == 0);
  587. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  588. print_test("Ver actual es clave2", strcmp(abb_iter_in_ver_actual(iter), clave2) == 0);
  589. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  590. print_test("Ver actual es clave3", strcmp(abb_iter_in_ver_actual(iter), clave5) == 0);
  591. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  592. print_test("Ver actual es clave3", strcmp(abb_iter_in_ver_actual(iter), clave1) == 0);
  593. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  594. print_test("Ver actual es clave3", strcmp(abb_iter_in_ver_actual(iter), clave6) == 0);
  595. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  596. print_test("Ver actual es clave3", strcmp(abb_iter_in_ver_actual(iter), clave3) == 0);
  597. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  598. print_test("Ver actual es clave3", strcmp(abb_iter_in_ver_actual(iter), clave7) == 0);
  599. print_test("Avanzar es true", abb_iter_in_avanzar(iter));
  600. print_test("El iterador esta al final", abb_iter_in_al_final(iter));
  601. print_test("Avanzar es false", !abb_iter_in_avanzar(iter));
  602. printf("\n");
  603. abb_iter_in_destruir(iter);
  604. abb_destruir(abb);
  605. }
  606.  
  607.  
  608. void prueba_abb_iterar(){
  609. printf("~~PRUEBA DE ITERADOR ABB~~\n");
  610. abb_t* abb = abb_crear(strcmp, NULL);
  611.  
  612. char *claves[] = {"perro", "gato", "vaca"};
  613. char *valores[] = {"guau", "miau", "mu"};
  614.  
  615. print_test("Prueba abb insertar clave1", abb_guardar(abb, claves[0], valores[0]));
  616. print_test("Prueba abb insertar clave2", abb_guardar(abb, claves[1], valores[1]));
  617. print_test("Prueba abb insertar clave3", abb_guardar(abb, claves[2], valores[2]));
  618.  
  619. abb_iter_t* iter = abb_iter_in_crear(abb);
  620. const char *clave;
  621. ssize_t indice;
  622.  
  623. print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  624.  
  625. clave = abb_iter_in_ver_actual(iter);
  626. indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  627. print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  628. print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  629. print_test("Prueba abb iterador avanzar es true", abb_iter_in_avanzar(iter));
  630. print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  631.  
  632. clave = abb_iter_in_ver_actual(iter);
  633. indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  634. print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  635. print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  636. print_test("Prueba abb iterador avanzar es true", abb_iter_in_avanzar(iter));
  637. print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  638.  
  639. clave = abb_iter_in_ver_actual(iter);
  640. indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  641. print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  642. print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  643. abb_iter_in_avanzar(iter);
  644. print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  645.  
  646. print_test("Prueba abb iterador ver actual, es NULL", !abb_iter_in_ver_actual(iter));
  647. print_test("Prueba abb iterador avanzar es false", !abb_iter_in_avanzar(iter));
  648. print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  649.  
  650. abb_iter_in_destruir(iter);
  651. abb_destruir(abb);
  652. printf("\n");
  653. }
  654.  
  655. void prueba_abb_iterar_volumen(){
  656. printf("~~PRUEBA DE VOLUMEN ITERADOR ABB~~\n");
  657. abb_t* abb = abb_crear(strcmp, NULL);
  658.  
  659. const size_t largo_clave = 10;
  660. char (*claves)[largo_clave] = malloc(VOLUMEN * largo_clave);
  661.  
  662. size_t valores[VOLUMEN];
  663.  
  664. bool ok = true;
  665. for (unsigned i = 0; i < VOLUMEN; i++) {
  666. sprintf(claves[i], "%08d", i);
  667. valores[i] = i;
  668. ok = abb_guardar(abb, claves[i], &valores[i]);
  669. if (!ok) break;
  670. }
  671.  
  672. abb_iter_t* iter = abb_iter_in_crear(abb);
  673. print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  674.  
  675. ok = true;
  676. unsigned i;
  677. const char *clave;
  678. size_t *valor;
  679.  
  680. for (i = 0; i < VOLUMEN; i++) {
  681. if ( abb_iter_in_al_final(iter) ) {
  682. ok = false;
  683. break;
  684. }
  685. clave = abb_iter_in_ver_actual(iter);
  686. if ( clave == NULL ) {
  687. ok = false;
  688. break;
  689. }
  690. valor = abb_obtener(abb, clave);
  691. if ( valor == NULL ) {
  692. ok = false;
  693. break;
  694. }
  695. *valor = VOLUMEN;
  696. abb_iter_in_avanzar(iter);
  697. }
  698. print_test("Prueba abb iteración en volumen", ok);
  699. print_test("Prueba abb iteración en volumen, recorrio todo el largo", i == VOLUMEN);
  700. print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  701.  
  702. ok = true;
  703. for (i = 0; i < VOLUMEN; i++) {
  704. if ( valores[i] != VOLUMEN ) {
  705. ok = false;
  706. break;
  707. }
  708. }
  709. print_test("Prueba abb iteración en volumen, se cambiaron todo los elementos", ok);
  710.  
  711. free(claves);
  712. abb_iter_in_destruir(iter);
  713. abb_destruir(abb);
  714. printf("\n");
  715. }
  716.  
  717. bool multiplicar_por_2(const char* clave, void* dato, void* extra){
  718. *(int*) dato = *(int*) dato * 2;
  719. return true;
  720. }
  721.  
  722. void prueba_iterador_interno(){
  723. printf("~~PRUEBA DE ITERADOR INTERNO SIN CORTE Y SIN EXTRA~~\n");
  724. abb_t* abb = abb_crear(strcmp, NULL);
  725.  
  726. int a = 1;
  727. int b = 2;
  728. int c = 3;
  729.  
  730. print_test("Guardo la clave A", abb_guardar(abb, "arbol", &a));
  731. print_test("Guardo la clave B", abb_guardar(abb, "anda", &b));
  732. print_test("Guardo la clave B", abb_guardar(abb, "bien", &c));
  733. abb_in_order(abb, multiplicar_por_2, NULL);
  734.  
  735. bool ok = true;
  736. if (a != 2 || b !=4 || c != 6) ok = false;
  737. print_test("Aplico mi función visitar, que multiplica por 2 todos los elementos del abb", ok);
  738. abb_destruir(abb);
  739. printf("\n");
  740. }
  741.  
  742. bool multiplicar_primeros(const char* clave, void* dato, void* extra){
  743. if (*(size_t*) extra >= 5){
  744. return false;
  745. }
  746. *(int*) dato = *(int*) dato * 2;
  747. *(size_t*) extra += 1;
  748. return true;
  749. }
  750.  
  751. void prueba_iterador_interno2(){
  752. printf("~~PRUEBA DE ITERADOR INTERNO CON CORTE Y EXTRA~~\n");
  753. abb_t* abb = abb_crear(strcmp, NULL);
  754.  
  755. int a = 21;
  756. int b = 6;
  757. int c = 12;
  758. int d = 8;
  759. int e = 5;
  760. int f = 22;
  761. int g = 97;
  762.  
  763. print_test("Guardo la clave A", abb_guardar(abb, "arbol", &a));
  764. print_test("Guardo la clave A", abb_guardar(abb, "anda", &b));
  765. print_test("Guardo la clave A", abb_guardar(abb, "bien", &c));
  766. print_test("Guardo la clave A", abb_guardar(abb, "sin", &d));
  767. print_test("Guardo la clave A", abb_guardar(abb, "errores", &e));
  768. print_test("Guardo la clave A", abb_guardar(abb, "ni", &f));
  769. print_test("Guardo la clave A", abb_guardar(abb, "problemas", &g));
  770.  
  771. size_t contador = 0;
  772. abb_in_order(abb, multiplicar_primeros, &contador);
  773.  
  774. bool ok = true;
  775. if (a != 42 || b != 12 || c != 24 || d != 8 || e != 10 || f != 44 || g != 97){
  776. ok = false;
  777. }
  778. print_test("Aplico mi función visitar, que multiplica por 2 los primeros 5 elementos del abb", ok);
  779. abb_destruir(abb);
  780. printf("\n");
  781. }
  782.  
  783. void pruebas_abb_alumno() {
  784. printf("\n");
  785. prueba_creacion_abb();
  786. prueba_guardar_elementos();
  787. prueba_guardar_elementos_2();
  788. prueba_guardar_elementos_3();
  789. prueba_volumen();
  790. prueba_abb_clave_vacia();
  791. prueba_abb_reemplazar_con_destruir();
  792. prueba_abb_borrar();
  793. prueba_insertar_null();
  794. prueba_iterador_abb_vacio();
  795. prueba_recorrer();
  796. prueba_abb_iterar();
  797. prueba_abb_iterar_volumen();
  798. prueba_iterador_interno();
  799. prueba_iterador_interno2();
  800. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!