API tools faq
paste
Advertisement
Guest User

pruebas_abb

a guest
Jun 24th, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.61 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * prueba_hash.c
  3.  * Pruebas para el tipo de dato abstracto Tabla de Hash
  4.  * Copyright: (2011) Margarita Manterola, Maximiliano Curia
  5.  * Licencia: CC-BY-SA 2.5 (ar) ó CC-BY-SA 3.0
  6.  */
  7.  
  8. #include "abb.h"
  9. #include "testing.h"
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <unistd.h>  // For ssize_t in Linux.
  15.  
  16.  
  17. /* ******************************************************************
  18.  *                        PRUEBAS UNITARIAS
  19.  * *****************************************************************/
  20.  
  21. int comparar(char* clave1, char* clave2){
  22.  
  23.     int resultado = strcmp(clave2,clave1);
  24.  
  25.     return resultado;
  26.  
  27. }
  28.  
  29. static void prueba_crear_abb_vacio()
  30. {
  31.     abb_t* abb = abb_crear(comparar, NULL);
  32.  
  33.     print_test("Prueba abb crear abb vacio", abb);
  34.     print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  35.     print_test("Prueba abb obtener clave A, es NULL, no existe", !abb_obtener(abb, "A"));
  36.     print_test("Prueba abb pertenece clave A, es false, no existe", !abb_pertenece(abb, "A"));
  37.     print_test("Prueba abb borrar clave A, es NULL, no existe", !abb_borrar(hash, "A"));
  38.  
  39.     abb_destruir(abb);
  40. }
  41.  
  42. static void prueba_iterar_abb_vacio()
  43. {
  44.     abb_t* abb = abb_crear(comparar, NULL);
  45.     abb_iter_t* iter = abb_iter_in_crear(abb);
  46.     print_test("Prueba abb iter crear iterador abb vacio", iter);
  47.     print_test("Prueba abb iter esta al final", abb_iter_in_al_final(iter));
  48.     print_test("Prueba abb iter avanzar es false", !abb_iter_in_avanzar(iter));
  49.     print_test("Prueba abb iter ver actual es NULL", !abb_iter_in_ver_actual(iter));
  50.  
  51.     abb_iter_in_destruir(iter);
  52.     abb_destruir(abb);
  53. }
  54.  
  55. static void prueba_hash_insertar()
  56. {
  57.     printf("\n");
  58.     abb_t* abb = abb_crear(comparar,NULL);
  59.  
  60.     char *clave1 = "perro", *valor1 = "guau";
  61.     char *clave2 = "gato", *valor2 = "miau";
  62.     char *clave3 = "vaca", *valor3 = "mu";
  63.  
  64.     /* Inserta 1 valor y luego lo borra */
  65.     print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1));
  66.     print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  67.     print_test("Prueba abb obtener clave1 es valor1", abb_obtener(abb, clave1) == valor1);
  68.     print_test("Prueba abb obtener clave1 es valor1", abb_obtener(abb, clave1) == valor1);
  69.     print_test("Prueba abb pertenece clave1, es true", abb_pertenece(abb, clave1));
  70.     print_test("Prueba abb borrar clave1, es valor1", abb_borrar(abb, clave1) == valor1);
  71.     print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  72.  
  73.     /* Inserta otros 2 valores y no los borra (se destruyen con el hash) */
  74.     print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2));
  75.     print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  76.     print_test("Prueba abb obtener clave2 es valor2", abb_obtener(abb, clave2) == valor2);
  77.     print_test("Prueba abb obtener clave2 es valor2", abb_obtener(abb, clave2) == valor2);
  78.     print_test("Prueba abb pertenece clave2, es true", abb_pertenece(abb, clave2));
  79.  
  80.     print_test("Prueba abb insertar clave3", abb_guardar(abb, clave3, valor3));
  81.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  82.     print_test("Prueba abb obtener clave3 es valor3", abb_obtener(abb, clave3) == valor3);
  83.     print_test("Prueba abb obtener clave3 es valor3", abb_obtener(abb, clave3) == valor3);
  84.     print_test("Prueba abb pertenece clave3, es true", abb_pertenece(abb, clave3));
  85.  
  86.     abb_destruir(abb);
  87. }
  88.  
  89. static void prueba_abb_reemplazar()
  90. {
  91.     abb_t* abb = abb_crear(comparar, NULL);
  92.  
  93.     char *clave1 = "perro", *valor1a = "guau", *valor1b = "warf";
  94.     char *clave2 = "gato", *valor2a = "miau", *valor2b = "meaow";
  95.  
  96.     /* Inserta 2 valores y luego los reemplaza */
  97.     print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1a));
  98.     print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  99.     print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  100.     print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2a));
  101.     print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  102.     print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  103.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  104.  
  105.     print_test("Prueba abb insertar clave1 con otro valor", abb_guardar(abb, clave1, valor1b));
  106.     print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  107.     print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  108.     print_test("Prueba abb insertar clave2 con otro valor", abb_guardar(abb, clave2, valor2b));
  109.     print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  110.     print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  111.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  112.  
  113.     abb_destruir(abb);
  114. }
  115.  
  116. static void prueba_abb_reemplazar_con_destruir()
  117. {
  118.     abb_t* abb = abb_crear(comparar, free);
  119.  
  120.     char *clave1 = "perro", *valor1a, *valor1b;
  121.     char *clave2 = "gato", *valor2a, *valor2b;
  122.  
  123.     /* Pide memoria para 4 valores */
  124.     valor1a = malloc(10 * sizeof(char));
  125.     valor1b = malloc(10 * sizeof(char));
  126.     valor2a = malloc(10 * sizeof(char));
  127.     valor2b = malloc(10 * sizeof(char));
  128.  
  129.     /* Inserta 2 valores y luego los reemplaza (debe liberar lo que reemplaza) */
  130.     print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1a));
  131.     print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  132.     print_test("Prueba abb obtener clave1 es valor1a", abb_obtener(abb, clave1) == valor1a);
  133.     print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2a));
  134.     print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  135.     print_test("Prueba abb obtener clave2 es valor2a", abb_obtener(abb, clave2) == valor2a);
  136.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  137.  
  138.     print_test("Prueba abb insertar clave1 con otro valor", abb_guardar(abb, clave1, valor1b));
  139.     print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  140.     print_test("Prueba abb obtener clave1 es valor1b", abb_obtener(abb, clave1) == valor1b);
  141.     print_test("Prueba abb insertar clave2 con otro valor", abb_guardar(abb, clave2, valor2b));
  142.     print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  143.     print_test("Prueba abb obtener clave2 es valor2b", abb_obtener(abb, clave2) == valor2b);
  144.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  145.  
  146.     /* Se destruye el hash (se debe liberar lo que quedó dentro) */
  147.     abb_destruir(abb);
  148. }
  149.  
  150. static void prueba_abb_borrar()
  151. {
  152.     abb_t* abb = abb_crear(comparar, NULL);
  153.  
  154.     char *clave1 = "perro", *valor1 = "guau";
  155.     char *clave2 = "gato", *valor2 = "miau";
  156.     char *clave3 = "vaca", *valor3 = "mu";
  157.     printf("\n");
  158.  
  159.     /* Inserta 3 valores y luego los borra */
  160.     print_test("Prueba abb insertar clave1", abb_guardar(abb, clave1, valor1));
  161.     print_test("Prueba abb insertar clave2", abb_guardar(abb, clave2, valor2));
  162.     print_test("Prueba abb insertar clave3", abb_guardar(abb, clave3, valor3));
  163.  
  164.     /* Al borrar cada elemento comprueba que ya no está pero los otros sí. */
  165.     print_test("Prueba abb pertenece clave3, es verdadero", abb_pertenece(abb, clave3));
  166.     print_test("Prueba abb borrar clave3, es valor3", abb_borrar(abb, clave3) == valor3);
  167.     print_test("Prueba abb borrar clave3, es NULL", !abb_borrar(abb, clave3));
  168.     print_test("Prueba abb pertenece clave3, es falso", !abb_pertenece(abb, clave3));
  169.     print_test("Prueba abb obtener clave3, es NULL", !abb_obtener(abb, clave3));
  170.     print_test("Prueba abb la cantidad de elementos es 2", abb_cantidad(abb) == 2);
  171.  
  172.     print_test("Prueba abb pertenece clave1, es verdadero", abb_pertenece(abb, clave1));
  173.     print_test("Prueba abb borrar clave1, es valor1", abb_borrar(abb, clave1) == valor1);
  174.     print_test("Prueba abb borrar clave1, es NULL", !abb_borrar(abb, clave3));
  175.     print_test("Prueba abb pertenece clave1, es falso", !abb_pertenece(abb, clave1));
  176.     print_test("Prueba abb obtener clave1, es NULL", !abb_obtener(abb, clave1));
  177.     print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  178.  
  179.     print_test("Prueba abb pertenece clave2, es verdadero", abb_pertenece(abb, clave2));
  180.     print_test("Prueba abb borrar clave2, es valor2", abb_borrar(abb, clave2) == valor2);
  181.     print_test("Prueba abb borrar clave2, es NULL", !abb_borrar(abb, clave3));
  182.     print_test("Prueba abb pertenece clave2, es falso", !abb_pertenece(abb, clave2));
  183.     print_test("Prueba abb obtener clave2, es NULL", !abb_obtener(abb, clave2));
  184.     print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  185.  
  186.     abb_destruir(abb);
  187. }
  188.  
  189. static void prueba_abb_clave_vacia()
  190. {
  191.     abb_t* abb = abb_crear(comparar,NULL);
  192.  
  193.     char *clave = "", *valor = "";
  194.  
  195.     print_test("Prueba abb insertar clave vacia", abb_guardar(abb, clave, valor));
  196.     print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  197.     print_test("Prueba abb obtener clave vacia es valor", abb_obtener(abb, clave) == valor);
  198.     print_test("Prueba abb pertenece clave vacia, es true", abb_pertenece(abb, clave));
  199.     print_test("Prueba abb borrar clave vacia, es valor", abb_borrar(abb, clave) == valor);
  200.     print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  201.  
  202.     abb_destruir(abb);
  203. }
  204.  
  205. static void prueba_abb_valor_null()
  206. {
  207.     abb_t* abb = abb_crear(comparar,NULL);
  208.  
  209.     char *clave = "", *valor = NULL;
  210.  
  211.     /* Inserta 1 valor y luego lo borra */
  212.     print_test("Prueba abb insertar clave vacia valor NULL", abb_guardar(abb, clave, valor));
  213.     print_test("Prueba abb la cantidad de elementos es 1", abb_cantidad(abb) == 1);
  214.     print_test("Prueba abb obtener clave vacia es valor NULL", abb_obtener(abb, clave) == valor);
  215.     print_test("Prueba abb pertenece clave vacia, es true", abb_pertenece(abb, clave));
  216.     print_test("Prueba abb borrar clave vacia, es valor NULL", abb_borrar(abb, clave) == valor);
  217.     print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  218.  
  219.     abb_destruir(abb);
  220. }
  221.  
  222. static void prueba_abb_volumen(size_t largo, bool debug)
  223. {
  224.     abb_t* abb = abb_crear(comparar,NULL);
  225.  
  226.     const size_t largo_clave = 10;
  227.     char (*claves)[largo_clave] = malloc(largo * largo_clave);
  228.  
  229.     unsigned* valores[largo];
  230.  
  231.     /* Inserta 'largo' parejas en el hash */
  232.     bool ok = true;
  233.     for (unsigned i = 0; i < largo; i++) {
  234.         valores[i] = malloc(sizeof(int));
  235.         sprintf(claves[i], "%08d", i);
  236.         *valores[i] = i;
  237.         ok = abb_guardar(abb, claves[i], valores[i]);
  238.         if (!ok) break;
  239.     }
  240.  
  241.     if (debug) print_test("Prueba abb almacenar muchos elementos", ok);
  242.     if (debug) print_test("Prueba abb la cantidad de elementos es correcta", abb_cantidad(abb) == largo);
  243.  
  244.     /* Verifica que devuelva los valores correctos */
  245.     for (size_t i = 0; i < largo; i++) {
  246.         ok = abb_pertenece(abb, claves[i]);
  247.         if (!ok) break;
  248.         ok = abb_obtener(abb, claves[i]) == valores[i];
  249.         if (!ok) break;
  250.     }
  251.  
  252.     if (debug) print_test("Prueba abb pertenece y obtener muchos elementos", ok);
  253.     if (debug) print_test("Prueba abb la cantidad de elementos es correcta", abb_cantidad(abb) == largo);
  254.  
  255.     /* Verifica que borre y devuelva los valores correctos */
  256.     for (size_t i = 0; i < largo; i++) {
  257.         ok = abb_borrar(abb, claves[i]) == valores[i];
  258.         if (!ok) break;
  259.     }
  260.  
  261.     if (debug) print_test("Prueba abb borrar muchos elementos", ok);
  262.     if (debug) print_test("Prueba abb la cantidad de elementos es 0", abb_cantidad(abb) == 0);
  263.  
  264.     /* Destruye el hash y crea uno nuevo que sí libera */
  265.     abb_destruir(abb);
  266.     abb = abb_crear(comparar, free);
  267.  
  268.     /* Inserta 'largo' parejas en el hash */
  269.     ok = true;
  270.     for (size_t i = 0; i < largo; i++) {
  271.         ok = abb_guardar(abb, claves[i], valores[i]);
  272.         if (!ok) break;
  273.     }
  274.  
  275.     free(claves);
  276.  
  277.     /* Destruye el hash - debería liberar los enteros */
  278.     abb_destruir(abb);
  279.  
  280. }
  281.  
  282. static ssize_t buscar(const char* clave, char* claves[], size_t largo)
  283. {
  284.     for (size_t i = 0; i < largo; i++) {
  285.         if (strcmp(clave, claves[i]) == 0) return (ssize_t) i;
  286.     }
  287.     return -1;
  288. }
  289.  
  290. static void prueba_abb_iterar()
  291. {
  292.     abb_t* abb = abb_crear(comparar,NULL);
  293.  
  294.     char *claves[] = {"perro", "gato", "vaca"};
  295.     char *valores[] = {"guau", "miau", "mu"};
  296.  
  297.     /* Inserta 3 valores */
  298.     print_test("Prueba abb insertar clave1", abb_guardar(abb, claves[0], valores[0]));
  299.     print_test("Prueba abb insertar clave2", abb_guardar(abb, claves[1], valores[1]));
  300.     print_test("Prueba abb insertar clave3", abb_guardar(abb, claves[2], valores[2]));
  301.  
  302.     // Prueba de iteración sobre las claves almacenadas.
  303.     abb_iter_t* iter = abb_iter_in_crear(abb);
  304.     const char *clave;
  305.     ssize_t indice;
  306.  
  307.     print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  308.  
  309.     /* Primer valor */
  310.     clave = abb_iter_in_ver_actual(iter);
  311.     indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  312.     print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  313.     print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  314.     print_test("Prueba abb iterador avanzar es true", abb_iter_in_avanzar(iter));
  315.     print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  316.  
  317.     /* Segundo valor */
  318.     clave = abb_iter_in_ver_actual(iter);
  319.     indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  320.     print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  321.     print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  322.     print_test("Prueba abb iterador avanzar es true", abb_iter_in_avanzar(iter));
  323.     print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  324.  
  325.     /* Tercer valor */
  326.     clave = abb_iter_in_ver_actual(iter);
  327.     indice = buscar(clave, claves, sizeof(claves) / sizeof(char *));
  328.     print_test("Prueba abb iterador ver actual, es una clave valida", indice != -1);
  329.     print_test("Prueba abb iterador ver actual, no es el mismo puntero", clave != claves[indice]);
  330.     /* Se anula esta prueba por diferencias de criterios */
  331.     abb_iter_in_avanzar(iter);
  332.     print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  333.  
  334.     /* Vuelve a tratar de avanzar, por las dudas */
  335.     print_test("Prueba abb iterador ver actual, es NULL", !abb_iter_in_ver_actual(iter));
  336.     print_test("Prueba abb iterador avanzar es false", !abb_iter_in_avanzar(iter));
  337.     print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  338.  
  339.     abb_iter_destruir(iter);
  340.     abb_destruir(abb);
  341. }
  342.  
  343. static void prueba_abb_iterar_volumen(size_t largo)
  344. {
  345.     abb_t* abb = abb_crear(comparar, NULL);
  346.  
  347.     const size_t largo_clave = 10;
  348.     char (*claves)[largo_clave] = malloc(largo * largo_clave);
  349.  
  350.     size_t valores[largo];
  351.  
  352.     /* Inserta 'largo' parejas en el hash */
  353.     bool ok = true;
  354.     for (unsigned i = 0; i < largo; i++) {
  355.         sprintf(claves[i], "%08d", i);
  356.         valores[i] = i;
  357.         ok = abb_guardar(abb, claves[i], &valores[i]);
  358.         if (!ok) break;
  359.     }
  360.  
  361.     // Prueba de iteración sobre las claves almacenadas.
  362.     abb_iter_t* iter = abb_iter_in_crear(abb);
  363.     print_test("Prueba abb iterador esta al final, es false", !abb_iter_in_al_final(iter));
  364.  
  365.     ok = true;
  366.     unsigned i;
  367.     const char *clave;
  368.     size_t *valor;
  369.  
  370.     for (i = 0; i < largo; i++) {
  371.         if ( abb_iter_in_al_final(iter) ) {
  372.             ok = false;
  373.             break;
  374.         }
  375.         clave = abb_iter_in_ver_actual(iter);
  376.         if ( clave == NULL ) {
  377.             ok = false;
  378.             break;
  379.         }
  380.         valor = abb_obtener(abb, clave);
  381.         if ( valor == NULL ) {
  382.             ok = false;
  383.             break;
  384.         }
  385.         *valor = largo;
  386.         abb_iter_in_avanzar(iter);
  387.     }
  388.     print_test("Prueba abb iteración en volumen", ok);
  389.     print_test("Prueba abb iteración en volumen, recorrio todo el largo", i == largo);
  390.     print_test("Prueba abb iterador esta al final, es true", abb_iter_in_al_final(iter));
  391.  
  392.     ok = true;
  393.     for (i = 0; i < largo; i++) {
  394.         if ( valores[i] != largo ) {
  395.             ok = false;
  396.             break;
  397.         }
  398.     }
  399.     print_test("Prueba abb iteración en volumen, se cambiaron todo los elementos", ok);
  400.  
  401.     free(claves);
  402.     abb_iter_destruir(iter);
  403.     abb_destruir(abb);
  404. }
  405.  
  406. /* ******************************************************************
  407.  *                        FUNCIÓN PRINCIPAL
  408.  * *****************************************************************/
  409.  
  410.  
  411. void pruebas_abb_catedra()
  412. {
  413.     /* Ejecuta todas las pruebas unitarias. */
  414.     prueba_crear_abb_vacio();
  415.     prueba_iterar_abb_vacio();
  416.     prueba_abb_insertar();
  417.     prueba_abb_reemplazar();
  418.     prueba_abb_reemplazar_con_destruir();
  419.     prueba_abb_borrar();
  420.     prueba_abb_clave_vacia();
  421.     prueba_abb_valor_null();
  422.     prueba_abb_volumen(5000, true);
  423.     prueba_abb_iterar();
  424.     prueba_abb_iterar_volumen(5000);
  425. }
  426.  
  427. void pruebas_volumen_catedra(size_t largo)
  428. {
  429.     prueba_abb_volumen(largo, false);
  430. }
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!