result_t* test_arbreSupprimer() {
result_t* r = creerResultat();
//Cas général
{
arbre_t * a = NULL;
assert_t* assert;
donnee_t* s;
int res=VRAI;
a = initArbre("a*(b*(c+d)+e)+f");
arbreSupprimer(&(a->lv));
creerTamponDonnee(s, TYPE_RETOUR, arbreToString(a));
if (a->lv == NULL) {
res = FAUX;
}
else if (a->lv->valeur != 'e') {
res = FAUX;
}
assert = assertion(r, res, "Cas général (suppresion de b)");
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "a*(b*(c+d)+e)+f"));
ajouterDonnee(assert, s);
libererArbre(a);
}
return r;
}
result_t* test_arbreRecherche() {
result_t* r = creerResultat();
//Cas général
{
arbre_t * a = NULL;
arbre_t ** prec;
assert_t* assert;
donnee_t* s;
a = initArbre("a*(b*(c+d)+e)+f");
prec = arbreRecherche('e', &a);
assert = assertion(r, (*prec)->valeur == 'e',
"Cas général (recherche de e)");
creerTamponDonnee(s,TYPE_RETOUR, arbreToString(*prec));
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "a*(b*(c+d)+e)+f"));
ajouterDonnee(assert, s);
libererArbre(a);
}
//Cas introuvable
{
arbre_t * a = NULL;
arbre_t ** prec;
assert_t* assert;
donnee_t* s;
a = initArbre("a*(b*(c+d)+e)+f");
prec = arbreRecherche('g', &a);
assert = assertion(r, *prec == NULL, "Cas non trouvé (recherche de g)");
creerTamponDonnee(s,TYPE_RETOUR, arbreToString(*prec));
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "a*(b*(c+d)+e)+f"));
ajouterDonnee(assert, s);
libererArbre(a);
}
return r;
}
void ajouterDeupuisTab(Donnees * const d, const int * const tab, const int taille)
{
int count = 0;
while(count < taille)
{
ajouterDonnee(d, tab[count], tab[count+1], tab[count+2]);
count+=3;
}
}
result_t* test_compterNoeuds() {
result_t* r = creerResultat();
{
arbre_t* arbre;
donnee_t* e;
DEBUG_creerArbreDroit_static(arbre);
int size;
e = creerDonnee(TYPE_ENTREE, "a*(b+c*d)");
size = compterNoeuds(arbre);
assert_t* a = assertion(r, size == 4, "Cas général (droit)");
ajouterDonnee(a, e);
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de noeuds", size));
}
{
arbre_t* gauche;
DEBUG_creerArbreGauche_static(gauche);
int size;
size = compterNoeuds(gauche);
assert_t* a = assertion(r, size == 4, "Cas général (gauche)");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "a*(b*d+c)"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de noeuds", size));
}
{
arbre_t* arbre;
int size;
DEBUG_creerArbreComplexe_static(arbre);
size = compterNoeuds(arbre);
assert_t* a = assertion(r, size == 13, "Cas complexe");
ajouterDonnee(a,
creerDonnee(TYPE_ENTREE, "a*(b*(e*(h+i+j)+f)+c+d*g*(k*m+l))"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de noeuds", size));
}
{
int size = compterNoeuds(NULL);
assert_t* a = assertion(r, size == 0, "Cas arbre vide");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "null"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de noeuds", size));
}
return r;
}
result_t* test_initArbre() {
result_t* r = creerResultat();
//Cas général
{
donnee_t* s;
arbre_t * a = NULL;
int res;
a = initArbre("a*(b*(c+d)+e)+f");
res = (a->valeur == 'a') && (a->lv->valeur == 'b')
&& (a->lv->lv->valeur == 'c') && (a->lv->lv->lh->valeur == 'd')
&& (a->lv->lh->valeur == 'e') && (a->lh->valeur == 'f');
assert_t* assert = assertion(r, res, "Cas général");
creerTamponDonnee(s, TYPE_SORTIE, arbreToString(a));
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "a*(b*(c+d)+e)+f"));
ajouterDonnee(assert, s);
libererArbre(a);
}
//Cas complexe
{
donnee_t* s;
arbre_t * a = NULL;
int res;
char * buf;
a = initArbre("a*(b+c*(d+e+f+g))+x*d*e+g*(h+i)");
buf = arbreToString(a);
res = !strcmp(buf,"[ a b c d e f g x d e g h i ]");
free(buf);
assert_t* assert = assertion(r, res, "Cas d'un arbre complexe");
creerTamponDonnee(s, TYPE_SORTIE, arbreToString(a));
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "a*(b+c*(d+e+f+g))+x*d*e+g*(h+i)"));
ajouterDonnee(assert, s);
libererArbre(a);
}
//Cas arbre à un élément
{
donnee_t* s;
arbre_t * a = NULL;
int res;
a = initArbre("A");
res = (a->valeur == 'A' && a->lv == NULL && a->lh == NULL);
assert_t* assert = assertion(r, res, "Cas à un seul noeud");
creerTamponDonnee(s, TYPE_SORTIE, arbreToString(a));
ajouterDonnee(assert, creerDonnee(TYPE_ENTREE, "A"));
ajouterDonnee(assert, s);
libererArbre(a);
}
return r;
}
result_t* test_compterFeuilles() {
result_t* r = creerResultat();
{
arbre_t* head;
DEBUG_creerArbreDroit_static(head);
int nb = compterFeuilles(head);
assert_t* a = assertion(r, nb == 2, "Cas général à droite");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "a*(b+c*d)"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de feuille", nb));
}
{
arbre_t* head;
DEBUG_creerArbreGauche_static(head);
int nb = compterFeuilles(head);
assert_t* a = assertion(r, nb == 2, "Cas général à gauche");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "a*(b*d+c)"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de feuilles", nb));
}
{
arbre_t* head;
DEBUG_creerArbreComplexe_static(head);
int nb = compterFeuilles(head);
assert_t* a = assertion(r, nb == 7, "Cas complexe");
ajouterDonnee(a,
creerDonnee(TYPE_ENTREE, "a*(b*(e*(h+i+j)+f)+c+d*g*(k*m+l))"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de feuilles", nb));
}
{
int nb = compterFeuilles(NULL);
assert_t* a = assertion(r, nb == 0, "Cas arbre vide");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "null"));
ajouterDonnee(a,
creerDonneeWithInt(TYPE_RETOUR, "Nombre de feuilles", nb));
}
return r;
}
result_t* test_mesurerHauteur() {
result_t* r = creerResultat();
{
arbre_t* head;
DEBUG_creerArbreDroit_static(head);
int deep = mesurerHauteur(head);
assert_t* a = assertion(r, deep == 2, "Cas général à droite");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "a*(b+c*d)"));
ajouterDonnee(a, creerDonneeWithInt(TYPE_RETOUR, "Hauteur", deep));
}
{
arbre_t* head;
DEBUG_creerArbreGauche_static(head);
int deep = mesurerHauteur(head);
assert_t* a = assertion(r, deep == 2, "Cas général à gauche");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "a*(b*d+c)"));
ajouterDonnee(a, creerDonneeWithInt(TYPE_RETOUR, "Hauteur", deep));
}
{
arbre_t* head;
DEBUG_creerArbreComplexe_static(head);
int nb = mesurerHauteur(head);
assert_t* a = assertion(r, nb == 4, "Cas complexe");
ajouterDonnee(a,
creerDonnee(TYPE_ENTREE, "a*(b*(e*(h+i+j)+f)+c+d*g*(k*m+l))"));
ajouterDonnee(a, creerDonneeWithInt(TYPE_RETOUR, "Hauteur", nb));
}
{
int deep = mesurerHauteur(NULL);
assert_t* a = assertion(r, deep == 0, "Cas arbre vide");
ajouterDonnee(a, creerDonnee(TYPE_ENTREE, "null"));
ajouterDonnee(a, creerDonneeWithInt(TYPE_RETOUR, "Hauteur", deep));
}
return r;
}
