int test_accessible(){
int result = 1;
Automate* aut1 = mot_to_automate("abcde");
ajouter_transition( aut1, 3, 'a', 3);
ajouter_transition( aut1, 3, 'b', 2);
ajouter_transition( aut1, 3, 'c', 1);
ajouter_transition( aut1, 1, 'e', 3);
ajouter_etat( aut1, 6);
ajouter_etat( aut1, 7);
ajouter_transition( aut1, 6, 'a', 7);
ajouter_transition( aut1, 7, 'e', 6);
printf("Automate 1: \n");
print_automate(aut1);
printf("\n");
Automate* aut2 = automate_accessible(aut1);
printf("Resultat: \n");
print_automate(aut2);
printf("\n");
liberer_automate(aut1);
return result;
}
int test_automate_vide(){
BEGIN_TEST;
int result = 1;
Automate * automate = creer_automate();
TEST(
1
&& ! est_un_etat_de_l_automate( automate, 0)
&& ! est_un_etat_final_de_l_automate( automate, 0)
&& ! est_un_etat_initial_de_l_automate( automate, 0)
&& ! est_une_lettre_de_l_automate( automate, 'a')
&& ! est_une_transition_de_l_automate( automate, 0, 'a', 0 )
, result
);
liberer_automate( automate );
return result;
}
Matrice creer_matrice_transistions(Automate* a, char c){
Automate * abis = creer_automate_etats_0_n(a);
int n = taille_ensemble(get_etats(abis));
Matrice m = creer_matrice(n);
tree t=tree_creat();
tree_set(t, c);
m->mot = t;
int i, j;
for(i = 0; i < m->taille; i++){
for(j = 0; j< m->taille; j++){
m->tab[i][j] = INFINI;
}
}
Table_iterateur it1;
Ensemble_iterateur it2;
for ( it1 = premier_iterateur_table(get_transitions(abis));
! iterateur_ensemble_est_vide(it1);
it1 = iterateur_suivant_ensemble(it1)
){
Cle * cle = (Cle*) get_cle(it1);
Ensemble * fins = (Ensemble*) get_valeur(it1);
int tmp = get_lettre_cle(cle);
if(tmp == (int)c){
for( it2 = premier_iterateur_ensemble(fins);
! iterateur_ensemble_est_vide(it2);
it2 = iterateur_suivant_ensemble(it2)
){
int f = get_element(it2);
int cout = get_cout_cle(cle)==0 ? 0: 1;
m->tab[get_origine_cle(cle)][f] = cout;
}
}
}
liberer_automate(abis);
return m;
}
int test_mot_accepte(){
BEGIN_TEST;
int result = 1;
Automate * automate = creer_automate();
ajouter_transition( automate, 1, 'a', 1 );
ajouter_transition( automate, 1, 'b', 2 );
ajouter_etat_final( automate, 2 );
ajouter_etat_initial( automate, 1 );
TEST( le_mot_est_reconnu( automate, "b" ), result );
TEST( le_mot_est_reconnu( automate, "ab" ), result );
TEST( le_mot_est_reconnu( automate, "aab" ), result );
TEST( ! le_mot_est_reconnu( automate, "aba" ), result );
liberer_automate( automate );
return result;
}
void wrap_liberer_automate( Automate * aut ){
if( aut ){
liberer_automate(aut);
}
}
int test_execute_fonctions(){
BEGIN_TEST
int res = 1;
Automate * automate2;
Automate * automate;
Automate * result = NULL;
Ensemble * ens = NULL;
Ensemble * ens1 = NULL;
automate = creer_automate();
result = NULL;
ajouter_lettre( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_final( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_initial( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
get_initiaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_finaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_alphabet( automate );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_initial_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_final_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_une_lettre_de_l_automate( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens1 = creer_ensemble( NULL, NULL, NULL );
ens = delta_star( automate, ens1, "aba" );
if( ens ) liberer_ensemble( ens );
liberer_ensemble( ens1 );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
le_mot_est_reconnu( automate, "abaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = mot_to_automate( "abbaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens = etats_accessibles( automate, 0 );
if( ens ) liberer_ensemble( ens );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_accessible( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = miroir( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_co_accessible(automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_prefixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_suffixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_facteurs( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ens = creer_ensemble( NULL, NULL, NULL );
result = creer_automate_des_sur_mot(
automate, ens
);
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_ensemble( ens );
automate = creer_automate();
automate2 = creer_automate();
result = NULL;
result = creer_automate_de_concatenation( automate, automate2 );
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_automate( automate2 );
automate = creer_automate();
result = NULL;
result = creer_automate_des_sous_mots( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
return res;
}
int test_delta_delta_star(){
BEGIN_TEST;
int result = 1;
Automate* automate = creer_automate();
ajouter_etat( automate, 3 );
ajouter_etat( automate, 5 );
ajouter_transition( automate, 3, 'a', 5 );
ajouter_transition( automate, 5, 'b', 3 );
ajouter_transition( automate, 5, 'a', 5 );
ajouter_transition( automate, 5, 'c', 6 );
ajouter_etat_initial( automate, 3 );
ajouter_etat_final( automate, 6 );
TEST(
1
&& est_un_etat_de_l_automate( automate, 3 )
&& est_un_etat_de_l_automate( automate, 5 )
&& est_un_etat_de_l_automate( automate, 6 )
&& est_un_etat_initial_de_l_automate( automate, 3 )
&& ! est_un_etat_initial_de_l_automate( automate, 5 )
&& ! est_un_etat_initial_de_l_automate( automate, 6 )
&& ! est_un_etat_final_de_l_automate( automate, 3 )
&& ! est_un_etat_final_de_l_automate( automate, 5 )
&& est_un_etat_final_de_l_automate( automate, 6 )
&& est_une_lettre_de_l_automate( automate, 'a' )
&& est_une_lettre_de_l_automate( automate, 'b' )
&& est_une_lettre_de_l_automate( automate, 'c' )
&& ! est_une_lettre_de_l_automate( automate, 'd' )
&& est_une_transition_de_l_automate( automate, 3, 'a', 5 )
&& est_une_transition_de_l_automate( automate, 5, 'b', 3 )
&& est_une_transition_de_l_automate( automate, 5, 'a', 5 )
&& est_une_transition_de_l_automate( automate, 5, 'c', 6 )
&& ! est_une_transition_de_l_automate( automate, 3, 'b', 5 )
&& ! est_une_transition_de_l_automate( automate, 1, 'b', 5 )
&& ! est_une_transition_de_l_automate( automate, 3, 'a', 1 )
, result
);
Ensemble * etat_courant = creer_ensemble( NULL, NULL, NULL );
ajouter_element( etat_courant, 3 );
deplacer_ensemble( etat_courant, delta( automate, etat_courant, 'a' ) );
TEST(
1
&& est_dans_l_ensemble( etat_courant, 5 )
&& taille_ensemble( etat_courant ) ==1
, result
);
deplacer_ensemble(
etat_courant, delta_star( automate, etat_courant, "ab" )
);
TEST(
1
&& est_dans_l_ensemble( etat_courant, 3 )
&& taille_ensemble( etat_courant ) ==1
, result
);
deplacer_ensemble(
etat_courant, delta_star( automate, etat_courant, "ac" )
);
TEST(
1
&& est_dans_l_ensemble( etat_courant, 6 )
&& taille_ensemble( etat_courant ) ==1
, result
);
deplacer_ensemble(
etat_courant, delta_star( automate, etat_courant, "" )
);
TEST(
1
&& est_dans_l_ensemble( etat_courant, 6 )
&& taille_ensemble( etat_courant ) ==1
, result
);
deplacer_ensemble(
etat_courant, delta_star( automate, etat_courant, "c" )
);
TEST(
1
&& taille_ensemble( etat_courant ) == 0
, result
);
liberer_ensemble( etat_courant );
liberer_automate( automate );
return result;
}
int test_creer_automate(){
BEGIN_TEST;
int result = 1;
Automate * automate = creer_automate();
ajouter_lettre( automate, 'a' );
ajouter_lettre( automate, 'd' );
ajouter_etat( automate, 3 );
ajouter_etat_final( automate, 6 );
ajouter_transition( automate, 3, 'a', 5 );
ajouter_transition( automate, 3, 'b', 3 );
ajouter_etat_final( automate, 5 );
ajouter_etat_initial( automate, 3 );
TEST(
1
&& est_un_etat_de_l_automate( automate, 3)
&& est_un_etat_de_l_automate( automate, 5)
&& est_un_etat_de_l_automate( automate, 6)
, result
);
TEST(
1
&& ! est_un_etat_final_de_l_automate( automate, 3)
&& est_un_etat_final_de_l_automate( automate, 5)
&& est_un_etat_final_de_l_automate( automate, 6)
, result
);
TEST(
1
&& est_un_etat_initial_de_l_automate( automate, 3)
&& ! est_un_etat_initial_de_l_automate( automate, 5)
, result
);
TEST(
1
&& est_une_lettre_de_l_automate( automate, 'a')
&& est_une_lettre_de_l_automate( automate, 'b')
&& est_une_lettre_de_l_automate( automate, 'd')
&& ! est_une_lettre_de_l_automate( automate, 'c')
, result
);
TEST(
1
&& est_une_transition_de_l_automate( automate, 3, 'a', 5 )
&& est_une_transition_de_l_automate( automate, 3, 'b', 3 )
&& ! est_une_transition_de_l_automate( automate, 3, 'b', 5 )
&& ! est_une_transition_de_l_automate( automate, 3, 'a', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'a', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'b', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'a', 5 )
&& ! est_une_transition_de_l_automate( automate, 5, 'b', 5 )
, result
);
const Ensemble* ens = get_initiaux( automate );
TEST(
1
&& ens
&& est_dans_l_ensemble( ens, 3 )
&& ! est_dans_l_ensemble( ens, 5 )
&& ! est_dans_l_ensemble( ens, 6 )
, result
);
ens = get_finaux( automate );
TEST(
1
&& ens
&& ! est_dans_l_ensemble( ens, 3 )
&& est_dans_l_ensemble( ens, 5 )
&& est_dans_l_ensemble( ens, 6 )
, result
);
ens = get_alphabet( automate );
TEST(
1
&& ens
&& est_dans_l_ensemble( ens, 'a')
&& est_dans_l_ensemble( ens, 'b')
&& ! est_dans_l_ensemble( ens, 'c')
&& est_dans_l_ensemble( ens, 'd')
, result
);
liberer_automate( automate );
return result;
}
int main(){
Automate * a = creer_automate();
/* Automate * a2 = creer_automate(); */
/* printf("\n==========automate(a)==============\n"); */
/* ajouter_transition(a, 1, 'a', 1, 1); */
/* ajouter_transition(a, 2, 'a', 1, 1); */
/* ajouter_transition(a, 1, 'a', 1, 2); */
/* ajouter_transition(a, 2, 'a', 0, 2); */
/* ajouter_transition(a, 3, 'a', 3, 3); */
/* ajouter_transition(a, 1, 'b', 1, 1); */
/* ajouter_transition(a, 1, 'b', 1, 3); */
/* ajouter_transition(a, 3, 'b', 1, 1); */
/* ajouter_transition(a, 3, 'b', 0, 3); */
/* ajouter_etat_initial(a, 1); */
/* ajouter_etat_final(a, 1); */
printf("\n==========automate(a)==============\n");
ajouter_transition(a, 0, 'a', 0, 0);
ajouter_transition(a, 0, 'b', 0, 0);
ajouter_transition(a, 0, 'b', 0, 1);
ajouter_transition(a, 1, 'a', 1, 1);
ajouter_transition(a, 1, 'b', 0, 2);
ajouter_transition(a, 2, 'a', 0, 2);
ajouter_transition(a, 2, 'b', 0, 2);
ajouter_transition(a, 3, 'a', 0, 3);
ajouter_transition(a, 3, 'b', 1, 3);
ajouter_etat_initial(a, 0);
ajouter_etat_initial(a, 1);
ajouter_etat_initial(a, 3);
ajouter_etat_final(a, 1);
ajouter_etat_final(a, 2);
ajouter_etat_final(a, 3);
print_automate(a);
printf("Voulez vous voir le graphe de cet automate? (y/n) *Graphviz nécessaire*\n");
char entree;
scanf("%c", &entree);
if(entree == 'y'){
creergraphe(a);
system("dot -Tpng auto.gv -o auto.png");
system("xdg-open auto.png &"); //open avec le logiciel par default
/* system("firefox auto.png >/dev/null 2>&1 &"); */ //open avec firefox
}
printf("\n");
printf("\n==========L'automate a est-il limité ?==============\n");
printf("Calcul de l'automate des matrices...\n");
clock_t time = clock();
Mautomate * maut = creer_mautomate(a);
time= clock();
printf("Temps de calcul : %.3f seconde\n", (double)time/CLOCKS_PER_SEC);
printf("Calcul des limites...\n");
Matrice res = (Matrice)est_limite(a, maut);
if(res==NULL)
printf("L'automate est limité.\n");
else{
printf("L'automate n'est pas limité, voici la premiere matrice qui cause le cout infini :\n");
print_matrice_in_R(res);
}
print_mautomate(maut);
liberer_mautomate(maut);
liberer_automate(a);//c'est bon
return 0;
}
