celeste.barbosa
/
mastermind
2
3
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

coverage de code
continuous-integration/drone/push Build is passing Details

Browse Source
master
Céleste BARBOSA 11 months ago
parent ff89de9bb5
commit 06905bc6ee
1 changed files with 250 additions and 218 deletions
Show Stats Download Patch File Download Diff File

468
Sources/UnitTesting/CodeUT.cs
Unescape View File

@ -1,220 +1,252 @@
using CoreLibrary.Core; using CoreLibrary.Core;
using CoreLibrary.Exceptions; using CoreLibrary.Exceptions;
using System.Collections.ObjectModel; using System.Collections.ObjectModel;
using Xunit; using Xunit;
namespace UnitTesting namespace UnitTesting
{ {
public class CodeUT public class CodeUT
{ {
[Fact] [Fact]
public void TestPremierConstructeurValide() public void TestPremierConstructeurValide()
{ {
Code code = new Code(4); Code code = new Code(4);
Assert.NotNull(code); Assert.NotNull(code);
Assert.Empty(code.Jetons); Assert.Empty(code.Jetons);
Assert.Equal(0, code.Taille); Assert.Equal(0, code.Taille);
Assert.False(code.Complet); Assert.False(code.Complet);
Assert.True(code.Vide); Assert.True(code.Vide);
} }
[Fact] [Fact]
public void TestPremierConstructeurInvalide() public void TestPremierConstructeurInvalide()
{ {
Assert.Throws<TailleCodeException>(() => new Code(-1)); Assert.Throws<TailleCodeException>(() => new Code(-1));
} }
[Fact] [Fact]
public void TestAjouterJetonValide() public void TestAjouterJetonValide()
{ {
Jeton jeton = new Jeton(Couleur.Jaune); Jeton jeton = new Jeton(Couleur.Jaune);
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
Assert.Equal(1, code.Taille); Assert.Equal(1, code.Taille);
Assert.Equal(jeton, code.Jetons.ElementAt(0)); Assert.Equal(jeton, code.Jetons.ElementAt(0));
} }
[Fact] [Fact]
public void TestAjouterJetonInvalide() public void TestAjouterJetonInvalide()
{ {
Jeton jeton = new Jeton(Couleur.Jaune); Jeton jeton = new Jeton(Couleur.Jaune);
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge))); Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge)));
} }
[Fact] [Fact]
public void TestSupprimerDernierJetonValide() public void TestSupprimerDernierJetonValide()
{ {
Jeton jeton = new Jeton(Couleur.Rouge); Jeton jeton = new Jeton(Couleur.Rouge);
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
code.AjouterJeton(jeton); code.AjouterJeton(jeton);
code.SupprimerDernierJeton(); code.SupprimerDernierJeton();
Assert.Equal(2, code.Taille); Assert.Equal(2, code.Taille);
} }
[Fact] [Fact]
public void TestSupprimerDernierJetonInvalide() public void TestSupprimerDernierJetonInvalide()
{ {
Code code = new Code(4); Code code = new Code(4);
Assert.Throws<CodeVideException>(() => code.SupprimerDernierJeton()); Assert.Throws<CodeVideException>(() => code.SupprimerDernierJeton());
} }
[Fact] [Fact]
public void TestRecupererJetonValide() public void TestRecupererJetonValide()
{ {
Jeton jeton1 = new Jeton(Couleur.Rouge); Jeton jeton1 = new Jeton(Couleur.Rouge);
Jeton jeton2 = new Jeton(Couleur.Bleu); Jeton jeton2 = new Jeton(Couleur.Bleu);
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jeton1); code.AjouterJeton(jeton1);
code.AjouterJeton(jeton2); code.AjouterJeton(jeton2);
Jeton jetonAttendu = new Jeton(Couleur.Bleu); Jeton jetonAttendu = new Jeton(Couleur.Bleu);
Jeton jeton = code.RecupererJeton(1); Jeton jeton = code.RecupererJeton(1);
Assert.Equal(jetonAttendu.Couleur, jeton.Couleur); Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
} }
[Fact] [Fact]
public void TestRecupererJetonInvalide() public void TestRecupererJetonInvalide()
{ {
Code code = new Code(4); Code code = new Code(4);
Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(-1)); Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(-1));
Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(4)); Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(4));
} }
[Fact] [Fact]
public void TestRecupererJetonNull() public void TestRecupererJetonNull()
{ {
Code code = new Code(4); Code code = new Code(4);
Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(1)); Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(1));
} }
[Fact] [Fact]
public void TestJetonsValide() public void TestJetonsValide()
{ {
Jeton[] jetonsAttendus = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)]; Jeton[] jetonsAttendus = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jetonsAttendus[0]); code.AjouterJeton(jetonsAttendus[0]);
code.AjouterJeton(jetonsAttendus[1]); code.AjouterJeton(jetonsAttendus[1]);
code.AjouterJeton(jetonsAttendus[2]); code.AjouterJeton(jetonsAttendus[2]);
ObservableCollection<Jeton> lesJetons = code.Jetons; ObservableCollection<Jeton> lesJetons = code.Jetons;
Assert.Equal(jetonsAttendus.Length, lesJetons.Count()); Assert.Equal(jetonsAttendus.Length, lesJetons.Count());
int index = 0; int index = 0;
foreach (Jeton jetonAttendu in jetonsAttendus) foreach (Jeton jetonAttendu in jetonsAttendus)
{ {
Assert.Equal(jetonAttendu.Couleur, lesJetons.ElementAt(index).Couleur); Assert.Equal(jetonAttendu.Couleur, lesJetons.ElementAt(index).Couleur);
index++; index++;
} }
} }
[Fact] [Fact]
public void TestEstCompletValide() public void TestEstCompletValide()
{ {
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)]; Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jetons[0]); code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]); code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]); code.AjouterJeton(jetons[2]);
bool estComplet = code.Complet; bool estComplet = code.Complet;
Assert.True(estComplet); Assert.True(estComplet);
} }
[Fact] [Fact]
public void TestEstCompletInvalide() public void TestEstCompletInvalide()
{ {
Code code = new Code(3); Code code = new Code(3);
bool estComplet = code.Complet; bool estComplet = code.Complet;
Assert.False(estComplet); Assert.False(estComplet);
} }
[Fact] [Fact]
public void TestTailleMaximaleValide() public void TestTailleMaximaleValide()
{ {
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)]; Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
Code code = new Code(3); Code code = new Code(3);
code.AjouterJeton(jetons[0]); code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]); code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]); code.AjouterJeton(jetons[2]);
int tailleMaximale = code.TailleMax; int tailleMaximale = code.TailleMax;
Assert.Equal(jetons.Length, tailleMaximale); Assert.Equal(jetons.Length, tailleMaximale);
} }
[Fact] [Fact]
public void TestComparerValide() public void TestComparerValide()
{ {
Jeton[] jetons1 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)]; Jeton[] jetons1 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code1 = new Code(3); Code code1 = new Code(3);
code1.AjouterJeton(jetons1[0]); code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]); code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]); code1.AjouterJeton(jetons1[2]);
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)]; Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3); Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]); code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]); code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]); code2.AjouterJeton(jetons2[2]);
IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2); IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Equal(3, indicateurs.Count()); Assert.Equal(3, indicateurs.Count());
} }
[Fact] [Fact]
public void TestComparerDifferent() public void TestComparerDifferent()
{ {
Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)]; Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
Code code1 = new Code(3); Code code1 = new Code(3);
code1.AjouterJeton(jetons1[0]); code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]); code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]); code1.AjouterJeton(jetons1[2]);
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)]; Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3); Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]); code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]); code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]); code2.AjouterJeton(jetons2[2]);
IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2); IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Empty(indicateurs); Assert.Empty(indicateurs);
} }
[Fact] [Fact]
public void TestComparerMonCodeIncomplet() public void TestComparerMonCodeIncomplet()
{ {
Code code1 = new Code(3); Code code1 = new Code(3);
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)]; Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3); Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]); code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]); code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]); code2.AjouterJeton(jetons2[2]);
IEnumerable<Indicateur> indicateurs = code1.Comparer(code2); IEnumerable<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Empty(indicateurs); Assert.Empty(indicateurs);
} }
[Fact] [Fact]
public void TestComparerSonCodeIncomplet() public void TestComparerSonCodeIncomplet()
{ {
Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)]; Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
Code code1 = new Code(3); Code code1 = new Code(3);
code1.AjouterJeton(jetons1[0]); code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]); code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]); code1.AjouterJeton(jetons1[2]);
Code code2 = new Code(3); Code code2 = new Code(3);
Assert.Throws<CodeIncompletException>(() => code1.Comparer(code2)); Assert.Throws<CodeIncompletException>(() => code1.Comparer(code2));
} }
} [Fact]
public void TestToString()
} {
Code code = new Code(4);
Assert.Equal("Code(0)", code.ToString());
code.AjouterJeton(new Jeton());
Assert.Equal("Code(1)", code.ToString());
}
[Fact]
public void TestComparerCodeInvalide()
{
Code code = new Code(1);
code.AjouterJeton(new Jeton());
Code code1 = new Code(2);
code1.AjouterJeton(new Jeton());
code1.AjouterJeton(new Jeton());
Assert.Throws<CodeInvalideException>(() => code.Comparer(code1));
}
[Fact]
public void TestComparerCodeCorrect()
{
Code code = new Code(1);
code.AjouterJeton(new Jeton());
code.Comparer(code);
}
}
}

Write Preview
Loading…
Cancel
Save