405 lines
17 KiB
C
405 lines
17 KiB
C
#include "shell_test.h"
|
|
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
|
|
#include "error.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 100000
|
|
#define NB_MAX_SIZE_DEQUEUE 100
|
|
|
|
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);
|
|
|
|
if (NB_MAX_SIZE_DEQUEUE == 0) {
|
|
ERROR("NB_MAX_SIZE_DEQUEUE doit être supérieur à 0");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// 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 < (uint)rand() % 100; 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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; 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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; 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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE + 1; 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; size_dequeue(dq2) > 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 / (NB_TESTS_OCCUR / 100), 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; size_dequeue(dq2) > 0 && i < size_dequeue(dq2);
|
|
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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
lefins_dequeue(rand() % 100, dq);
|
|
}
|
|
for (uint i = 0; i < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
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; size_dequeue(dq3) > 0 && i < size_dequeue(dq3) - 1;
|
|
i++) {
|
|
printf("size = %d\n", size_dequeue(dq3));
|
|
assert(lefread_dequeue(dq3, i) < lefread_dequeue(dq3, i + 1));
|
|
printf(
|
|
"%u%% - assert(lefread_dequeue(dq2, %d) < "
|
|
"lefread_dequeue(dq2, "
|
|
"%d)) "
|
|
"check\n",
|
|
k / (NB_TESTS_OCCUR / 100), i, i + 1);
|
|
}
|
|
for (uint i = 0; size_dequeue(dq3) > 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 / (NB_TESTS_OCCUR / 100), lefread_dequeue(dq3, i),
|
|
lefread_dequeue(dq3, i));
|
|
}
|
|
for (uint i = 0; size_dequeue(dq) > 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 / (NB_TESTS_OCCUR / 100), i);
|
|
}
|
|
for (uint i = 0; size_dequeue(dq2) > 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 / (NB_TESTS_OCCUR / 100), 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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
lefins_dequeue(rand() % 100, dq);
|
|
}
|
|
for (uint i = 0; i < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
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; size_dequeue(dq3) > 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 / (NB_TESTS_OCCUR / 100), 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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
lefins_dequeue(rand() % 100, dq);
|
|
}
|
|
for (uint i = 0; i < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
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 / (NB_TESTS_OCCUR / 100));
|
|
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 < (uint)rand() % NB_MAX_SIZE_DEQUEUE; i++) {
|
|
lefins_dequeue(rand() % 100, dq);
|
|
}
|
|
sort_dequeue_norepeat(dq);
|
|
uint val = rand() % 100;
|
|
insert_dequeue(dq, val);
|
|
for (uint i = 0; size_dequeue(dq) > 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 / (NB_TESTS_OCCUR / 100), i, i + 1);
|
|
}
|
|
assert(mem_dequeue_sorted(val, dq));
|
|
printf("%u%% - assert(mem_dequeue_sorted(%d, dq)) check\n",
|
|
k / (NB_TESTS_OCCUR / 100), 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);
|
|
}
|
|
}
|