Ajout de dequeue et bollarray avec leurs tests
This commit is contained in:
376
Anna et Ethan/shell_test.c
Normal file
376
Anna et Ethan/shell_test.c
Normal file
@@ -0,0 +1,376 @@
|
||||
#include "shell_test.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "files.h"
|
||||
#include "graphs.h"
|
||||
#include "nfa.h"
|
||||
#include "nfa_determi.h"
|
||||
#include "nfa_tocode.h"
|
||||
#include "parse_regexp.h"
|
||||
#include "parser.h"
|
||||
#include "shell_languages.h"
|
||||
#include "shell_tools.h"
|
||||
#include "type_boolarray.h"
|
||||
#include "type_dequeue.h"
|
||||
|
||||
// Cette fonction est appelée par le shell sur la commande "test".
|
||||
// Vous pouvez y mettre le code que vous voulez tester.
|
||||
|
||||
#define TEST_DEQUEUE true
|
||||
#define TEST_BOOLARRAY false
|
||||
#define NB_TESTS_OCCUR 1000
|
||||
|
||||
static void printf_dequeue(dequeue *dq, char *function, char *var,
|
||||
int i_function, int i_result) {
|
||||
if (function != NULL)
|
||||
printf("%s(", function);
|
||||
else
|
||||
printf("%s\n", var);
|
||||
if (function != NULL && i_function >= 0) printf("%d, ", i_function);
|
||||
if (function != NULL) printf("%s)", var);
|
||||
if (function != NULL && i_result >= 0)
|
||||
printf(" = %d\n", i_result);
|
||||
else if (function != NULL)
|
||||
printf("\n");
|
||||
print_dequeue(dq);
|
||||
printf("isempty_dequeue(%s) = %d\n", var, isempty_dequeue(dq));
|
||||
printf("size_dequeue(%s) = %d\n", var, size_dequeue(dq));
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void printf_boolarray(barray *ba, char *function, char *var,
|
||||
int i_function, int i_result) {
|
||||
if (function != NULL)
|
||||
printf("%s(", function);
|
||||
else
|
||||
printf("%s\n", var);
|
||||
if (function != NULL && i_function >= 0) printf("%d, ", i_function);
|
||||
if (function != NULL) printf("%s)", var);
|
||||
if (function != NULL && i_result >= 0)
|
||||
printf(" = %d\n", i_result);
|
||||
else if (function != NULL)
|
||||
printf("\n");
|
||||
printf("Boolarray : ");
|
||||
for (uint i = 0; i < getsize_barray(ba); i++) {
|
||||
printf("%d ", getval_barray(ba, i));
|
||||
}
|
||||
printf("\n");
|
||||
printf("getsize_barray(%s) = %d\n", var, getsize_barray(ba));
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void test(void) {
|
||||
// regexp *myexp;
|
||||
|
||||
// Cette première affectation ne fonctionnera que si vous avez implémenté
|
||||
// les fonctions du module regexp.h.
|
||||
// myexp = parse_string_regexp("(a+bb)*");
|
||||
|
||||
// L'affichage de l'expression régulière est fait par la fonction reg_print,
|
||||
// définie dans printing.c et déjà fournie. Vous pouvez la décommenter pour
|
||||
// afficher l'expression régulière, après avoir implémenté les fonctions
|
||||
// nécessaires dans regexp.c.
|
||||
// reg_print(myexp);
|
||||
|
||||
// Autre exemple, avec une construction directe de NFA.
|
||||
// nfa* A = create_sing_epsilon();
|
||||
// nfa_view(A);
|
||||
|
||||
// Tests de dequeue
|
||||
if (TEST_DEQUEUE) {
|
||||
dequeue *dq = create_dequeue();
|
||||
printf_dequeue(dq, NULL, "dq", 0, -1);
|
||||
for (uint i = 11; i <= 20; i++) {
|
||||
rigins_dequeue(i, dq);
|
||||
// printf_dequeue(dq, "rigins_dequeue", "dq", i, -1);
|
||||
}
|
||||
for (uint i = 10; i > 0; i--) {
|
||||
lefins_dequeue(i, dq);
|
||||
// printf_dequeue(dq, "leftins_dequeue", "dq", i, -1);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test rigins_dequeue et leftins_dequeue\n"); // Test rigins_dequeue
|
||||
// et leftins_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(lefread_dequeue(dq, i) == i + 1);
|
||||
printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
|
||||
}
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
if (i % 2 == 0) {
|
||||
uint tmp[i / 2];
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
// printf_dequeue(dq, "lefread_dequeue", "dq", -1,
|
||||
// lefread_dequeue(dq, 0));
|
||||
tmp[j] = lefpull_dequeue(dq);
|
||||
// printf_dequeue(dq, "lefpull_dequeue",
|
||||
// "dq", -1, -1);
|
||||
}
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
lefins_dequeue(tmp[i / 2 - j - 1], dq);
|
||||
// printf_dequeue(dq, "lefins_dequeue", "dq", tmp[j], -1);
|
||||
}
|
||||
} else {
|
||||
uint tmp[i / 2];
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
// printf_dequeue(dq, "rigread_dequeue", "dq", -1,
|
||||
// rigread_dequeue(dq, 0));
|
||||
tmp[j] = rigpull_dequeue(dq);
|
||||
// printf_dequeue(dq, "rigpull_dequeue", "dq", -1, -1);
|
||||
}
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
rigins_dequeue(tmp[i / 2 - j - 1], dq);
|
||||
// printf_dequeue(dq, "rigins_dequeue", "dq", tmp[j], -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test lefpull_dequeue et rigpull_dequeue\n"); // Test
|
||||
// lefpull_dequeue et
|
||||
// rigpull_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(lefread_dequeue(dq, i) == i + 1);
|
||||
printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test makeempty_dequeue et copy_dequeue_right in array [1, 20]\n"); // Test makeempty_dequeue et copy_dequeue_right
|
||||
printf("--------------------\n");
|
||||
dequeue *dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
makeempty_dequeue(dq2);
|
||||
// printf_dequeue(dq2, "makeempty_dequeue", "dq2", -1, -1);
|
||||
copy_dequeue_right(dq2, dq, i);
|
||||
// printf_dequeue(dq2, "copy_dequeue_right", "dq2", i, -1);
|
||||
printf("----------");
|
||||
printf(" Test +%d ", i);
|
||||
printf("----------\n");
|
||||
for (uint j = 0; j < size_dequeue(dq2); j++) {
|
||||
assert(lefread_dequeue(dq2, j) == lefread_dequeue(dq, j) + i);
|
||||
printf("assert(lefread_dequeue(dq2, %d) == %d) check\n", j,
|
||||
lefread_dequeue(dq, j) + i);
|
||||
}
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test mem_dequeue in array [1, 20]\n"); // Test mem_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
uint value = rand() % 100;
|
||||
// printf_dequeue(dq, "mem_dequeue", "dq2", value,
|
||||
// mem_dequeue(value, dq));
|
||||
assert(mem_dequeue(value, dq) == (value > 0 && value <= 20));
|
||||
printf("assert(mem_dequeue(%d, dq) == %d) check\n", value,
|
||||
(value > 0 && value <= 20));
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq2);
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
// printf_dequeue(dq2, "random", "dq2", -1, -1);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
// printf_dequeue(dq2, "sort_dequeue_norepeat", "dq2", -1, -1);
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test sort_dequeue_norepeat\n"); // Test sort_dequeue_norepeat
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq2) - 1; i++) {
|
||||
assert(lefread_dequeue(dq2, i) < lefread_dequeue(dq2, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
// for (uint i = 0; i < 20; i++) {
|
||||
// printf_dequeue(dq2, "mem_dequeue_sorted", "dq2", i,
|
||||
// mem_dequeue_sorted(i, dq2));
|
||||
// }
|
||||
printf("--------------------\n");
|
||||
printf("Test mem_dequeue_sorted\n"); // Test mem_dequeue_sorted
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
assert(mem_dequeue_sorted(i, dq2) == mem_dequeue(i, dq2));
|
||||
printf("assert(mem_dequeue_sorted(%d, dq2) == %d) check\n", i,
|
||||
mem_dequeue(i, dq2));
|
||||
}
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test merge_sorted_dequeue\n"); // Test merge_sorted_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
dequeue *dq3 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
copy_dequeue_right(dq3, dq, 0);
|
||||
merge_sorted_dequeue(dq3, dq2);
|
||||
for (uint i = 0; i < size_dequeue(dq3) - 1; i++) {
|
||||
assert(lefread_dequeue(dq3, i) < lefread_dequeue(dq3, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq3); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) ||
|
||||
mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(%d, dq) || "
|
||||
"mem_dequeue_sorted(%d, dq2)) check\n",
|
||||
k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq, i), dq3));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(leftread_dequeue(dq, %d), "
|
||||
"dq3)) check\n",
|
||||
k, i);
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq2); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq2, i), dq3));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(leftread_dequeue(dq2, %d), "
|
||||
"dq3)) check\n",
|
||||
k, i);
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
if (dq3 == NULL) delete_dequeue(dq3);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test make_inter_sorted_dequeue\n"); // Test
|
||||
// make_inter_sorted_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
|
||||
for (uint i = 0; i < size_dequeue(dq3); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) &&
|
||||
mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(%d, dq) && "
|
||||
"mem_dequeue_sorted(%d, dq2)) check\n",
|
||||
k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
if (dq3 == NULL) delete_dequeue(dq3);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test intersec_dequeue\n"); // Test
|
||||
// intersec_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
bool result = intersec_dequeue(dq, dq2);
|
||||
dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
|
||||
assert(result == (size_dequeue(dq3) > 0));
|
||||
printf(
|
||||
"%u - size_dequeue(make_inter_sorted_dequeue(dq, dq2)) check\n",
|
||||
k);
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
}
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
uint val = rand() % 100;
|
||||
insert_dequeue(dq, val);
|
||||
for (uint i = 0; i < size_dequeue(dq) - 1; i++) {
|
||||
assert(lefread_dequeue(dq, i) < lefread_dequeue(dq, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
assert(mem_dequeue_sorted(val, dq));
|
||||
printf("%u - assert(mem_dequeue_sorted(%d, dq)) check\n", k, val);
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Plus de %d tests effectués avec succès\n", NB_TESTS_OCCUR * 5);
|
||||
}
|
||||
// Tests de boolarray
|
||||
if (TEST_BOOLARRAY) {
|
||||
barray *ba = create_barray(10);
|
||||
printf_boolarray(ba, NULL, "ba", 0, -1);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
if (i % 2 == 0) {
|
||||
settrue_barray(ba, i);
|
||||
printf_boolarray(ba, "settrue_barray", "ba", i, -1);
|
||||
} else {
|
||||
setfalse_barray(ba, i);
|
||||
printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
|
||||
}
|
||||
}
|
||||
delete_barray(ba);
|
||||
ba = create_barray(10);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
bool x = rand() % 2;
|
||||
if (x) {
|
||||
settrue_barray(ba, i);
|
||||
printf_boolarray(ba, "settrue_barray", "ba", i, -1);
|
||||
} else {
|
||||
setfalse_barray(ba, i);
|
||||
printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
|
||||
}
|
||||
}
|
||||
barray *ba2 = create_barray(10);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
bool x = rand() % 2;
|
||||
if (x) {
|
||||
settrue_barray(ba2, i);
|
||||
} else {
|
||||
setfalse_barray(ba2, i);
|
||||
}
|
||||
}
|
||||
printf_boolarray(ba2, NULL, "ba2", -1, -1);
|
||||
barray *ba3 = or_barray(ba, ba2);
|
||||
printf_boolarray(ba3, "or_barray", "ba3", -1, -1);
|
||||
delete_barray(ba3);
|
||||
ba3 = and_barray(ba, ba2);
|
||||
printf_boolarray(ba3, "and_barray", "ba3", -1, -1);
|
||||
delete_barray(ba3);
|
||||
delete_barray(ba2);
|
||||
printf_boolarray(ba, NULL, "ba", -1, -1);
|
||||
ba2 = copy_barray(ba);
|
||||
printf_boolarray(ba2, "copy_barray", "ba", -1, -1);
|
||||
delete_barray(ba);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user