private async Task <Tuple <IArbreConstruction, IFabriqueArbreDepuisJson> > ChargerFichierEtConstruire()
{
if (null != arbreDepuisFichierJson)
{
return(arbreDepuisFichierJson);
}
IArbreConstruction arbre = new ArbreConstruction();
IFabriqueArbreDepuisJson fabrique = new FabriqueArbreDepuisJson(
arbre,
@"Services\Arbre\Construction\Donnees\Json\ConstructionArbre.json");
await fabrique
.ChargerFichierAsync();
// Action à vérifier
await fabrique
.ConstruireAsync();
arbreDepuisFichierJson = new Tuple <IArbreConstruction, IFabriqueArbreDepuisJson>(
arbre,
fabrique);
return(arbreDepuisFichierJson);
}
public void AjouterMemeTransitionAvecSymbole()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
var etatSource = arbre.AjouterEtat();
var etatCible = arbre.AjouterEtat();
const char symbole = 'a';
var transition1 = arbre.AjouterTransition(
etatSource,
etatCible,
symbole);
// Action à vérifier
var transition2 = arbre.AjouterTransition(
etatSource,
etatCible,
symbole);
// Tests
Assert
.AreEqual(
transition1,
transition2);
}
public async Task ConstruireRepetitionMin2Max3Echec()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
const string chemin = "123456";
var elementRacine = new ElementRepetitionConstructionDto(
new ElementCheminConstructionDto(chemin),
2,
3);
IFabriqueArbre fabrique = new FabriqueArbre(
arbre,
elementRacine);
// Action à vérifier
await fabrique
.ConstruireAsync();
// Tests
Assert
.IsNotNull(
(fabrique as FabriqueArbre).ElementsConstruction);
var navigateur = (arbre as ArbreConstruction)
.RecupererNavigateurMultiSymbolesSur(
arbre.EtatEntree);
// 0 fois => pas suffisant
navigateur
.TransitionsSansSymbole();
Assert
.IsFalse(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
// 1 fois => pas suffisant
navigateur
.TransitionPar(
chemin);
Assert
.IsFalse(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
// 2 fois => ok
navigateur
.TransitionPar(
chemin);
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
// 3 fois => ok
navigateur
.TransitionPar(
chemin);
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
// 4 fois => non
navigateur
.TransitionPar(
chemin);
Assert
.IsFalse(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
}
public async Task ConstruireReferenceDoubleNiveau()
{
// Préparations
// Construction de 2 étiquette, l'une appelant l'autre
IArbreConstruction arbre = new ArbreConstruction();
const string chemin = "123456";
var typeBlock = EnumTypeBlock.Reference;
const string idEtiquetteEnfant = "EtiqEnfant";
var elementEtiquetteEnfant = new ElementEtiquetteConstructionDto(
typeBlock,
idEtiquetteEnfant,
new ElementCheminConstructionDto(chemin));
const string idEtiquetteParent = "EtiqParent";
var elementEtiquetteParent = new ElementEtiquetteConstructionDto(
typeBlock,
idEtiquetteParent,
new ElementReferenceConstructionDto(idEtiquetteEnfant));
var elementReference = new ElementReferenceConstructionDto(
idEtiquetteParent);
var elementSequence = new SequenceElementsConstructionDto(
new[]
{
elementReference,
elementReference
});
var elementRacine = new ChoixElementsConstructionDto(
new ElementConstructionDto[] {
elementEtiquetteEnfant,
elementEtiquetteParent,
elementSequence // = séquence contenant 2 références à l'étiquette de plus haut niveau
});
IFabriqueArbre fabrique = new FabriqueArbre(
arbre,
elementRacine);
// Action à vérifier
await fabrique
.ConstruireAsync();
// Tests
Assert
.IsNotNull(
(fabrique as FabriqueArbre).ElementsConstruction);
var navigateur = (arbre as ArbreConstruction)
.RecupererNavigateurMultiSymbolesSur(
arbre.EtatEntree);
// 1 fois => pas suffisant
navigateur
.TransitionPar(
chemin);
Assert
.IsFalse(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
// 2 fois => ok
navigateur
.TransitionPar(
chemin);
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(arbre.EtatSortie));
}
public void TransitionsAvecSymboleX2()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
const char symbole1 = 'a';
const char symbole2 = 'b';
var etat1 = arbre.AjouterEtat();
var etat2 = arbre.AjouterEtat();
var etat3 = arbre.AjouterEtat();
var etat4 = arbre.AjouterEtat();
var etat5 = arbre.AjouterEtat();
var etat6 = arbre.AjouterEtat();
var etat7 = arbre.AjouterEtat();
arbre.AjouterTransition(
etat1,
etat2);
arbre.AjouterTransition(
etat1,
etat4,
symbole1);
arbre.AjouterTransition(
etat2,
etat3);
arbre.AjouterTransition(
etat4,
etat5);
arbre.AjouterTransition(
etat5,
etat6,
symbole2);
arbre.AjouterTransition(
etat6,
etat7);
var navigateur = (arbre as ArbreConstruction)
.RecupererNavigateurMultiSymbolesSur(
etat1);
// Action à vérifier
navigateur
.TransitionPar(symbole1);
navigateur
.TransitionPar(symbole2);
// Tests
// Tests sur l'origine
Assert
.AreEqual(
1,
navigateur.EtatsOrigine.Count());
Assert
.IsTrue(
navigateur.EtatsOrigine.Contains(etat1));
// Tests sur les états courants
Assert
.AreEqual(
2,
navigateur.EtatsCourants.Count());
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat6));
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat7));
// Tests sur les transitions
Assert
.AreEqual(
4,
navigateur.Transitions.Count());
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat1 && t.EtatCible == etat4));
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat4 && t.EtatCible == etat5));
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat5 && t.EtatCible == etat6));
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat6 && t.EtatCible == etat7));
}
public void Ajouter2TransitionsAvecMemeSymbole()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
var etatSource = arbre.AjouterEtat();
var etatCible1 = arbre.AjouterEtat();
var etatCible2 = arbre.AjouterEtat();
const char symbole = 'a';
var transition1 = arbre.AjouterTransition(
etatSource,
etatCible1,
symbole);
// Action à vérifier
var transition2 = arbre.AjouterTransition(
etatSource,
etatCible2,
symbole);
// Tests
var etatSourceInfos = (arbre as ArbreConstruction)
.RecupererInfos(etatSource);
var etatSourceTransitionsSortantes = etatSourceInfos
.TransitionsSortantes;
var transitionIntermediaire = etatSourceTransitionsSortantes
.RecupererTransitionAvecSymbole(symbole);
var etatIntermediaire = transitionIntermediaire
.EtatCible;
var etatIntermediaireInfos = (arbre as ArbreConstruction)
.RecupererInfos(etatIntermediaire);
var etatIntermediaireTransitionsSortantes = etatIntermediaireInfos
.TransitionsSortantes
.Transitions;
Assert
.IsFalse(
new[] { etatSource, etatCible1, etatCible2 }.Contains(etatIntermediaire));
Assert
.IsTrue(
etatSourceTransitionsSortantes.Transitions.All(t => t != transition1));
Assert
.AreEqual(
symbole,
transitionIntermediaire.Symbole);
Assert
.AreEqual(
etatSource,
transitionIntermediaire.EtatSource);
Assert
.AreEqual(
2,
etatIntermediaireTransitionsSortantes.Count());
Assert
.IsTrue(
etatIntermediaireTransitionsSortantes.All(t => !t.Symbole.HasValue));
Assert
.IsNull(
transition2.Symbole);
Assert
.IsTrue(
etatIntermediaireTransitionsSortantes.Any(t => t.EtatCible == etatCible1));
Assert
.IsTrue(
etatIntermediaireTransitionsSortantes.Any(t => t.EtatCible == etatCible2));
}
public void TransitionsSansSymbole()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
var etat1 = arbre.AjouterEtat();
var etat2 = arbre.AjouterEtat();
var etat3 = arbre.AjouterEtat();
var etat4 = arbre.AjouterEtat();
arbre.AjouterTransition(
etat1,
etat2);
arbre.AjouterTransition(
etat1,
etat4,
'a');
arbre.AjouterTransition(
etat2,
etat3);
var navigateur = (arbre as ArbreConstruction)
.RecupererNavigateurSur(
etat1);
// Action à vérifier
navigateur
.TransitionsSansSymbole();
// Tests
// Tests sur l'origine
Assert
.AreEqual(
1,
navigateur.EtatsOrigine.Count());
Assert
.IsTrue(
navigateur.EtatsOrigine.Contains(etat1));
// Tests sur les états courants
Assert
.AreEqual(
3,
navigateur.EtatsCourants.Count());
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat1));
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat2));
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat3));
// Tests sur les transitions
Assert
.AreEqual(
2,
navigateur.Transitions.Count());
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat1 && t.EtatCible == etat2));
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat2 && t.EtatCible == etat3));
}
public void TransitionsAvecSymbole()
{
// Préparations
IArbreConstruction arbre = new ArbreConstruction();
const char symbole = 'a';
var etat1 = arbre.AjouterEtat();
var etat2 = arbre.AjouterEtat();
var etat3 = arbre.AjouterEtat();
var etat4 = arbre.AjouterEtat();
var etat5 = arbre.AjouterEtat();
arbre.AjouterTransition(
etat1,
etat2);
arbre.AjouterTransition(
etat1,
etat4,
symbole);
arbre.AjouterTransition(
etat2,
etat3);
arbre.AjouterTransition(
etat4,
etat5);
var navigateur = (arbre as ArbreConstruction)
.RecupererNavigateurSur(
etat1);
navigateur
.ForcerTransitionsSansSymboleEnSortie = false;
// Action à vérifier
navigateur
.TransitionPar(symbole);
// Tests
// Tests sur l'origine
Assert
.AreEqual(
1,
navigateur.EtatsOrigine.Count());
Assert
.IsTrue(
navigateur.EtatsOrigine.Contains(etat1));
// Tests sur les états courants
Assert
.AreEqual(
1,
navigateur.EtatsCourants.Count());
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat4));
// Tests sur les transitions
Assert
.AreEqual(
1,
navigateur.Transitions.Count());
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat1 && t.EtatCible == etat4));
// + Transitions sans symbole
navigateur
.TransitionsSansSymbole();
// Tests sur les états courants
Assert
.AreEqual(
2,
navigateur.EtatsCourants.Count());
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat4));
Assert
.IsTrue(
navigateur.EtatsCourants.Contains(etat5));
// Tests sur les transitions
Assert
.AreEqual(
2,
navigateur.Transitions.Count());
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat1 && t.EtatCible == etat4));
Assert
.IsTrue(
navigateur.Transitions.Any(t => t.EtatSource == etat4 && t.EtatCible == etat5));
}
