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

Reprise des tests unitaires
continuous-integration/drone/push Build is failing Details

Browse Source
master
Pauline PRADY 11 months ago
parent f7f4e0c3cb
commit 28fca8d70b
19 changed files with 204 additions and 633 deletions
Show Stats Download Patch File Download Diff File

20
Sources/UnitTesting/AjouterCodeEventArgsUT.cs
Unescape View File

@ -1,20 +0,0 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class AjouterCodeEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
Code monCode = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.BLEU)]);
AjouterCodeEventArgs evenement = new AjouterCodeEventArgs(monCode);
Assert.Equal(monCode, evenement.Code);
}
}
}

21
Sources/UnitTesting/AjouterJoueurEventArgs.cs
Unescape View File

@ -1,21 +0,0 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using CoreLibrary.Joueurs;
using Xunit;
namespace UnitTesting
{
public class AjouterJoueurEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
Joueur monJoueur = new Joueur("Céleste");
AjouterJoueurEventArgs evenement = new AjouterJoueurEventArgs(monJoueur);
Assert.Equal(monJoueur, evenement.Joueur);
}
}
}

172
Sources/UnitTesting/CodeUT.cs
Unescape View File

@ -1,5 +1,6 @@
using CoreLibrary.Core;
using CoreLibrary.Exceptions;
using System.Collections.ObjectModel;
using Xunit;
namespace UnitTesting
@ -12,7 +13,9 @@ namespace UnitTesting
Code code = new Code(4);
Assert.NotNull(code);
Assert.Empty(code.Jetons);
Assert.Equal(0, code.NbJetons);
Assert.Equal(0, code.Taille);
Assert.False(code.Complet);
Assert.True(code.Vide);
}
[Fact]
@ -22,46 +25,35 @@ namespace UnitTesting
Assert.Throws<TailleCodeException>(() => new Code(-1));
}
[Fact]
public void TestDeuxiemeConstructeurValide()
{
Jeton[] jetons = [new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLEU)];
Code code = new Code(jetons);
Assert.NotNull(code);
Assert.Equal(3, code.Jetons.Count());
Assert.Equal(3, code.NbJetons);
}
[Fact]
public void TestDeuxiemeConstructeurInvalide()
{
Assert.Throws<TailleCodeException>(() => new Code([]));
}
[Fact]
public void TestAjouterJetonValide()
{
Jeton jeton = new Jeton(Couleur.JAUNE);
Jeton jeton = new Jeton(Couleur.Jaune);
Code code = new Code(3);
code.AjouterJeton(jeton);
Assert.Equal(1, code.NbJetons);
Assert.Equal(1, code.Taille);
Assert.Equal(jeton, code.Jetons.ElementAt(0));
}
[Fact]
public void TestAjouterJetonInvalide()
{
Code code = new Code([new Jeton(Couleur.NOIR)]);
Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.ROUGE)));
{
Jeton jeton = new Jeton(Couleur.Jaune);
Code code = new Code(3);
code.AjouterJeton(jeton);
Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge)));
}
[Fact]
public void TestSupprimerDernierJetonValide()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Jeton jeton = new Jeton(Couleur.Rouge);
Code code = new Code(3);
code.AjouterJeton(jeton);
code.AjouterJeton(jeton);
code.AjouterJeton(jeton);
code.SupprimerDernierJeton();
Assert.Equal(2, code.NbJetons);
Assert.Equal(2, code.Taille);
}
[Fact]
@ -74,8 +66,12 @@ namespace UnitTesting
[Fact]
public void TestRecupererJetonValide()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Jeton jetonAttendu = new Jeton(Couleur.BLEU);
Jeton jeton1 = new Jeton(Couleur.Rouge);
Jeton jeton2 = new Jeton(Couleur.Bleu);
Code code = new Code(3);
code.AjouterJeton(jeton1);
code.AjouterJeton(jeton2);
Jeton jetonAttendu = new Jeton(Couleur.Bleu);
Jeton jeton = code.RecupererJeton(1);
Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
}
@ -98,16 +94,19 @@ namespace UnitTesting
[Fact]
public void TestJetonsValide()
{
Jeton[] jetonsAttendus = [new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLEU)];
Code code = new Code(jetonsAttendus);
IEnumerable<Jeton?> lesJetons = code.Jetons;
Jeton[] jetonsAttendus = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
Code code = new Code(3);
code.AjouterJeton(jetonsAttendus[0]);
code.AjouterJeton(jetonsAttendus[1]);
code.AjouterJeton(jetonsAttendus[2]);
ObservableCollection<Jeton> lesJetons = code.Jetons;
Assert.Equal(jetonsAttendus.Length, lesJetons.Count());
int index = 0;
foreach (Jeton jetonAttendu in jetonsAttendus)
{
Assert.Equal(jetonAttendu.Couleur, lesJetons.ElementAt(index)?.Couleur);
Assert.Equal(jetonAttendu.Couleur, lesJetons.ElementAt(index).Couleur);
index++;
}
}
@ -115,8 +114,12 @@ namespace UnitTesting
[Fact]
public void TestEstCompletValide()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
bool estComplet = code.EstComplet();
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code = new Code(3);
code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]);
bool estComplet = code.Complet;
Assert.True(estComplet);
}
@ -124,16 +127,19 @@ namespace UnitTesting
public void TestEstCompletInvalide()
{
Code code = new Code(3);
bool estComplet = code.EstComplet();
bool estComplet = code.Complet;
Assert.False(estComplet);
}
[Fact]
public void TestTailleMaximaleValide()
{
Jeton[] jetons = [new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLEU)];
Code code = new Code(jetons);
int tailleMaximale = code.NbJetonsMax;
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
Code code = new Code(3);
code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]);
int tailleMaximale = code.TailleMax;
Assert.Equal(jetons.Length, tailleMaximale);
}
@ -141,81 +147,71 @@ namespace UnitTesting
[Fact]
public void TestComparerValide()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code([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);
code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]);
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Equal(3, indicateurs.Count());
Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
Assert.DoesNotContain(Indicateur.BONNECOULEUR, indicateurs);
}
[Fact]
public void TestComparerBonnePlace()
public void TestComparerDifferent()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.NOIR)]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
Assert.Equal(2, indicateurs.Count());
Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
Assert.DoesNotContain(Indicateur.BONNECOULEUR, indicateurs);
}
Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
Code code1 = new Code(3);
code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]);
[Fact]
public void TestComparerBonneCouleur()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Equal(2, indicateurs.Count());
Assert.Contains(Indicateur.BONNECOULEUR, indicateurs);
Assert.DoesNotContain(Indicateur.BONNEPLACE, indicateurs);
Assert.Empty(indicateurs);
}
[Fact]
public void TestComparerBonnePlaceEtCouleur()
public void TestComparerMonCodeIncomplet()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLANC), new Jeton(Couleur.BLEU)]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
Code code1 = new Code(3);
Assert.Equal(3, indicateurs.Count());
Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
Assert.Contains(Indicateur.BONNECOULEUR, indicateurs);
}
Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
Code code2 = new Code(3);
code2.AjouterJeton(jetons2[0]);
code2.AjouterJeton(jetons2[1]);
code2.AjouterJeton(jetons2[2]);
[Fact]
public void TestComparerDifferent()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.NOIR)]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
IEnumerable<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Empty(indicateurs);
}
[Fact]
public void TestComparerMonCodeIncomplet()
public void TestComparerSonCodeIncomplet()
{
Code code = new Code(3);
Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
Code code1 = new Code(3);
code1.AjouterJeton(jetons1[0]);
code1.AjouterJeton(jetons1[1]);
code1.AjouterJeton(jetons1[2]);
Assert.Empty(indicateurs);
}
Code code2 = new Code(3);
[Fact]
public void TestComparerSonCodeIncomplet()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
Code autreCode = new Code(3);
IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
Assert.Empty(indicateurs);
}

20
Sources/UnitTesting/ConstruireJoueurEventArgsUT.cs
Unescape View File

@ -1,20 +0,0 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class ConstruireJoueurEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
ConstruireJoueurEventArgs evenement = new ConstruireJoueurEventArgs("Bonjour");
ConstruireJoueurEventArgs evenement2 = new ConstruireJoueurEventArgs(null);
Assert.Equal("Bonjour", evenement.Nom);
Assert.Null(evenement2.Nom);
}
}
}

6
Sources/UnitTesting/DemanderNomEventArgsUT.cs
Unescape View File

@ -9,12 +9,12 @@ namespace UnitTesting
[Fact]
public void TestConstructeurValide()
{
JoueurBuilder joueurBuilder = new JoueurBuilder();
Joueur joueur = new Joueur();
int indice = 15;
DemanderJoueurEventArgs evenement = new DemanderJoueurEventArgs(indice, joueurBuilder);
PartieDemanderJoueurEventArgs evenement = new PartieDemanderJoueurEventArgs(indice, joueur);
Assert.Equal(joueurBuilder, evenement.JoueurBuilder);
Assert.Equal(joueur, evenement.JoueurDemande);
Assert.Equal(indice, evenement.Indice);
}

19
Sources/UnitTesting/JouerCodeEventArgsUT.cs
Unescape View File

@ -1,19 +0,0 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class JouerCodeEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
Code monCode = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.BLEU)]);
JouerCodeEventArgs evenement = new JouerCodeEventArgs(monCode);
Assert.Equal(monCode, evenement.Code);
}
}
}

50
Sources/UnitTesting/JoueurBuilderUT.cs
Unescape View File

@ -1,50 +0,0 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using CoreLibrary.Joueurs;
using System.Reflection;
using Xunit;
namespace UnitTesting
{
public class JoueurBuilderUT
{
[Fact]
public void JoueurBuilderTest()
{
string nom = "Céleste";
string? nomEvenement = "";
JoueurBuilder builder = new JoueurBuilder();
builder.ConstruireJoueur += (Object? sender, ConstruireJoueurEventArgs e) => nomEvenement = e.Nom;
builder.Nom(nom);
Assert.Equal(nom, nomEvenement);
}
[Fact]
public void JoueurBuilderQuandConstruireJoueur()
{
string nom = "Céleste";
string? nomEvenement = "";
JoueurBuilder builder = new JoueurBuilder();
builder.ConstruireJoueur += (Object? sender, ConstruireJoueurEventArgs e) => nomEvenement = e.Nom;
Type type = typeof(JoueurBuilder);
MethodInfo? methodInfo = type.GetMethod("QuandConstruireJoueur", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(methodInfo);
methodInfo.Invoke(builder, [nom]);
Assert.Equal(nom, nomEvenement);
}
[Fact]
public void JoueurBuilderQuandConstruireJoueurSansBranchement()
{
JoueurBuilder builder = new JoueurBuilder();
Assert.Null(Record.Exception(() => builder.Nom("Pauline")));
}
}
}

73
Sources/UnitTesting/JoueurUT.cs
Unescape View File

@ -11,86 +11,27 @@ namespace UnitTesting
[Fact]
public void TestConstructeur1Valide()
{
string nom = "toto";
string nom = "";
Joueur joueur = new Joueur(nom);
Joueur joueur = new Joueur();
Assert.Equal(nom, joueur.Nom);
Assert.Equal(0, joueur.NbCoutTotal);
Assert.Equal(0, joueur.NbPartieGagnee);
Assert.Equal(0, joueur.NbPartieEgalite);
Assert.Equal(0, joueur.NbPartiePerdue);
Assert.False(joueur.EstConnecte);
}
[Fact]
public void TestConstructeur2Valide()
{
string nom = "Bob";
int nbCoutTotal = 10;
int nbPartieGagnee = 5;
int nbPartieEgalite = 2;
int nbPartiePerdue = 3;
Joueur joueur = new Joueur(nom, nbCoutTotal, nbPartieGagnee, nbPartieEgalite, nbPartiePerdue);
Assert.Equal(nom, joueur.Nom);
Assert.Equal(nbCoutTotal, joueur.NbCoutTotal);
Assert.Equal(nbPartieGagnee, joueur.NbPartieGagnee);
Assert.Equal(nbPartieEgalite, joueur.NbPartieEgalite);
Assert.Equal(nbPartiePerdue, joueur.NbPartiePerdue);
}
[Fact]
public void TestEvenement()
{
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.JAUNE), new Jeton(Couleur.VERT)]);
Code? codeEvenement = null;
Joueur j = new Joueur("Céleste");
j.JouerCode += (Object? sender, JouerCodeEventArgs e) => codeEvenement = e.Code;
j.Code(code);
Assert.NotNull(codeEvenement);
Assert.Equal(code, codeEvenement);
}
[Fact]
public void JoueurQuandJouerCode()
{
Code code = new Code(4);
code.AjouterJeton(new Jeton(Couleur.Rouge));
code.AjouterJeton(new Jeton(Couleur.Blanc));
code.AjouterJeton(new Jeton(Couleur.Blanc));
code.AjouterJeton(new Jeton(Couleur.Noir));
Code? codeEvenement = null;
string nom = "toto";
Joueur joueur = new Joueur("Céleste");
joueur.JouerCode += (Object? sender, JouerCodeEventArgs e) => codeEvenement = e.Code;
Joueur joueur = new Joueur(nom);
Type type = typeof(Joueur);
MethodInfo? methodInfo = type.GetMethod("QuandJouerCode", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(methodInfo);
methodInfo.Invoke(joueur, [code]);
Assert.NotNull(codeEvenement);
Assert.Equal(code, codeEvenement);
Assert.Equal(nom, joueur.Nom);
Assert.False(joueur.EstConnecte);
}
[Fact]
public void JoueurQuandJouerCodeSansBranchement()
{
Joueur joueur = new Joueur("Pauline");
Code code = new Code(4);
code.AjouterJeton(new Jeton(Couleur.ROUGE));
code.AjouterJeton(new Jeton(Couleur.BLANC));
code.AjouterJeton(new Jeton(Couleur.BLEU));
code.AjouterJeton(new Jeton(Couleur.NOIR));
Assert.Null(Record.Exception(() => joueur.Code(code)));
}
}
}

19
Sources/UnitTesting/ManagerUT.cs
Unescape View File

@ -1,4 +1,5 @@
using CoreLibrary.Manager;
using CoreLibrary.Manageurs;
using CoreLibrary.Persistance;
using Xunit;
namespace UnitTesting
@ -8,18 +9,10 @@ namespace UnitTesting
[Fact]
public void TestConstruteur()
{
Manager manager = new Manager(new Stub());
Assert.NotNull(manager.Joueurs);
Assert.NotEmpty(manager.Joueurs);
}
[Fact]
public void TestDispose()
{
Stub stub = new Stub();
Manager manager = new Manager(stub);
manager.Dispose();
Assert.True(stub.EstEnregistre);
IPersistance persistance = new PersistanceJSON();
Manageur manageur = new Manageur(persistance);
Assert.NotNull(manageur.Joueurs);
Assert.NotEmpty(manageur.Joueurs);
}
}
}

16
Sources/UnitTesting/NouveauJoueurEventArgsUT.cs
Unescape View File

@ -1,16 +0,0 @@
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class NouveauJoueurEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
NouveauJoueurEventArgs evenement = new NouveauJoueurEventArgs("Céleste");
Assert.Equal("Céleste", evenement.Nom);
}
}
}

2
Sources/UnitTesting/NouveauTourEventArgsUT.cs
Unescape View File

@ -1,5 +1,5 @@
using CoreLibrary.Core;
using CoreLibrary.Events;
using CoreLibrary.Evenements;
using CoreLibrary.Joueurs;
using Xunit;

26
Sources/UnitTesting/PartieDemanderJoueurJouerEventArgsUT.cs
Unescape View File

@ -0,0 +1,26 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class PartieDemanderJoueurJouerEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
int tour = 2;
string nom = "MonJoueur";
Plateau plateau = new Plateau(3, 4);
Code code = new Code(4);
bool estJoueur = true;
PartieDemanderJoueurJouerEventArgs evenement = new PartieDemanderJoueurJouerEventArgs(tour, nom, plateau, code, estJoueur);
Assert.Equal(tour, evenement.Tour);
Assert.Equal(nom, evenement.Nom);
Assert.Equal(plateau, evenement.Plateau);
Assert.Equal(code, evenement.Code);
Assert.Equal(estJoueur, evenement.EstJoueur);
}
}
}

83
Sources/UnitTesting/PartieNonCommenceeExceptionUT.cs
Unescape View File

@ -1,83 +0,0 @@
using CoreLibrary.Exceptions;
using System.Reflection;
using System.Runtime.Serialization;
using Xunit;
namespace UnitTesting
{
public class PartieNonCommenceeExceptionUT
{
[Fact]
public void ExceptionDefaut()
{
Assert.ThrowsAsync<PartieNonCommenceeException>(() => throw new PartieNonCommenceeException());
}
[Fact]
public void ExceptionMessage()
{
string message = "Mon super gros problème.";
Assert.ThrowsAsync<PartieNonCommenceeException>(() => throw new PartieNonCommenceeException(message));
try
{
throw new PartieNonCommenceeException(message);
}
catch(PartieNonCommenceeException e)
{
Assert.Equal(message, e.Message);
}
}
[Fact]
public void ExceptionMessageEtException()
{
string message = "Mon super gros problème.";
string message2 = "Pas de chance...";
InvalidOperationException parent = new InvalidOperationException(message2);
Assert.ThrowsAsync<PartieNonCommenceeException>(() => throw new PartieNonCommenceeException(message, parent));
try
{
throw new PartieNonCommenceeException(message, parent);
}
catch (PartieNonCommenceeException e)
{
Assert.Equal(message, e.Message);
Assert.NotNull(e.InnerException);
Assert.IsType<InvalidOperationException>(e.InnerException);
Assert.Equal(message2, e.InnerException.Message);
}
}
[Fact]
public void ExceptionSerialisation()
{
PartieNonCommenceeException exception = new PartieNonCommenceeException();
#pragma warning disable SYSLIB0050
SerializationInfo info = new SerializationInfo(typeof(PartieNonCommenceeException), new FormatterConverter());
StreamingContext contexte = new StreamingContext(StreamingContextStates.All);
#pragma warning restore SYSLIB0050
#pragma warning disable SYSLIB0051
exception.GetObjectData(info, contexte);
#pragma warning restore SYSLIB0051
Assert.Equal(exception.Message, info.GetString("Message"));
#pragma warning disable SYSLIB0050
PartieNonCommenceeException exceptionSerialisee =
(PartieNonCommenceeException)FormatterServices.GetUninitializedObject(typeof(PartieNonCommenceeException));
#pragma warning restore SYSLIB0050
ConstructorInfo? constructeur = typeof(PartieNonCommenceeException).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, [typeof(SerializationInfo), typeof(StreamingContext)], null);
Assert.NotNull(constructeur);
constructeur.Invoke(exceptionSerialisee, [info, contexte]);
Assert.Equal(exception.Message, exceptionSerialisee.Message);
}
}
}

20
Sources/UnitTesting/PartiePartieTermineeEventArgsUT.cs
Unescape View File

@ -0,0 +1,20 @@

using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class PartiePartieTermineeEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
IReadOnlyList<string> gagnants = new List<string>(["joueur1", "joueur2"]);
IReadOnlyList<string> perdants = new List<string>(["joueur3"]);
PartiePartieTermineeEventArgs evenement = new PartiePartieTermineeEventArgs(gagnants, perdants);
Assert.Equal(gagnants, evenement.Gagnants);
Assert.Equal(perdants, evenement.Perdants);
}
}
}

19
Sources/UnitTesting/PartiePasserLaMainEventArgsUT.cs
Unescape View File

@ -0,0 +1,19 @@

using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class PartiePasserLaMainEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
string joueur = "MonJoueur";
PartiePasserLaMainEventArgs evenement = new PartiePasserLaMainEventArgs(joueur);
Assert.Equal(joueur, evenement.Joueur);
}
}
}

24
Sources/UnitTesting/PartieTermineeEventArgsUT.cs
Unescape View File

@ -1,24 +0,0 @@
using CoreLibrary.Joueurs;
using CoreLibrary.Core;
using CoreLibrary.Events;
using Xunit;
namespace UnitTesting
{
public class PartieTermineeEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
Plateau plateau = new Plateau(4, 12);
Joueur[] gagnants = [new Joueur("Pauline"), new Joueur("Camille")];
Joueur[] perdants = [new Joueur("Céleste")];
PartieTermineeEventArgs evenement = new PartieTermineeEventArgs(gagnants, perdants);
Assert.Equal(gagnants, evenement.Gagnants);
Assert.Equal(perdants, evenement.Perdants);
}
}
}

19
Sources/UnitTesting/PlateauAjouterCodeEventArgsUT.cs
Unescape View File

@ -0,0 +1,19 @@
using CoreLibrary.Core;
using CoreLibrary.Evenements;
using Xunit;
namespace UnitTesting
{
public class PlateauAjouterCodeEventArgsUT
{
[Fact]
public void TestConstructeurValide()
{
Plateau plateau = new Plateau(4,3);
PlateauAjouterCodeEventArgs evenement = new PlateauAjouterCodeEventArgs(plateau);
Assert.Equal(plateau, evenement.Plateau);
}
}
}

207
Sources/UnitTesting/PlateauUT.cs
Unescape View File

@ -12,7 +12,6 @@ namespace UnitTesting
{
Plateau plateau = new Plateau(4,12);
Assert.NotNull(plateau);
Assert.Equal(1, plateau.Tour);
Assert.False(plateau.Victoire);
}
@ -27,12 +26,16 @@ namespace UnitTesting
public void TestEstCompletTrue()
{
Plateau plateau = new Plateau(4, 3);
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
Code code = new Code(4);
code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]);
plateau.AjouterCode(code);
plateau.AjouterCode(code);
plateau.AjouterCode(code);
bool estComplet = plateau.EstComplet();
bool estComplet = plateau.Complet;
Assert.True(estComplet);
}
@ -41,32 +44,30 @@ namespace UnitTesting
public void TestEstCompletFalse()
{
Plateau plateau = new Plateau(4, 3);
Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
Code code = new Code(4);
code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]);
plateau.AjouterCode(code);
plateau.AjouterCode(code);
bool estComplet = plateau.EstComplet();
bool estComplet = plateau.Complet;
Assert.False(estComplet);
}
[Fact]
public void TestAjouterCodeValide()
{
Plateau plateau = new Plateau(4, 10);
Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
plateau.AjouterCode(code);
Assert.Equal(2, plateau.Tour);
}
[Fact]
public void TestAjouterCodeTailleIncorrecte()
{
Plateau plateau = new Plateau(4, 10);
Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune), new Jeton(Couleur.Bleu)];
Code code = new Code(4);
code.AjouterJeton(jetons[0]);
code.AjouterJeton(jetons[1]);
code.AjouterJeton(jetons[2]);
code.AjouterJeton(jetons[3]);
code.AjouterJeton(jetons[4]);
Assert.Throws<CodeInvalideException>(() => plateau.AjouterCode(code));
}
@ -95,175 +96,5 @@ namespace UnitTesting
plateau.AjouterCode(codeSecret);
Assert.True(plateau.Victoire);
}
[Fact]
public void TestEstBonCodeTailleException()
{
Plateau plateau = new Plateau(3, 5);
Code code = new Code(4);
Assert.Throws<CodeInvalideException>(() => plateau.EstBonCode(code));
}
[Fact]
public void TestEstBonCodeIncomplet()
{
Plateau plateau = new Plateau(3, 5);
Code code = new Code(3);
Assert.Throws<CodeIncompletException>(() => plateau.EstBonCode(code));
}
[Fact]
public void TestEstBonCodeTrue()
{
Plateau plateau = new Plateau(4, 10);
Type type = typeof(Plateau);
FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(fieldInfo);
Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
Assert.NotNull(codeSecret);
Assert.True(plateau.EstBonCode(codeSecret));
}
[Fact]
public void TestEstBonCodeFalse()
{
Plateau plateau = new Plateau(2, 10);
Type type = typeof(Plateau);
FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(fieldInfo);
Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
Assert.NotNull(codeSecret);
Jeton[] jetons = codeSecret.Jetons.Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
int i = 0;
int j = 1;
while (jetons[i].Couleur == jetons[j].Couleur)
{
++i;
++j;
if (j == jetons.Length)
{
plateau = new Plateau(2, 10);
codeSecret = (Code?)fieldInfo.GetValue(plateau);
Assert.NotNull(codeSecret);
jetons = codeSecret.Jetons.Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
i = 0;
j = 1;
}
}
Jeton tmp = jetons[0];
jetons[0] = jetons[1];
jetons[1] = tmp;
Code code = new Code(jetons);
Assert.False(plateau.EstBonCode(code));
}
[Fact]
public void TestEstBonCodeAucunIndicateur()
{
List<Couleur> couleurs = new List<Couleur>((Couleur[])Enum.GetValues(typeof(Couleur)));
Plateau plateau = new Plateau(4, 10);
Type type = typeof(Plateau);
FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(fieldInfo);
Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
Assert.NotNull(codeSecret);
Jeton[] jetons = codeSecret.Jetons.Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
for (int i=0; i<jetons.Length; ++i)
{
Couleur couleurJeton = jetons[i].Couleur;
couleurs.Remove(couleurJeton);
}
Code code = new Code(
[
new Jeton(couleurs[0]),
new Jeton(couleurs[0]),
new Jeton(couleurs[0]),
new Jeton(couleurs[0])
]
);
Assert.False(plateau.EstBonCode(code));
}
[Fact]
public void TestGrilleValide()
{
Plateau plateau = new Plateau(4, 3);
Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
Code code2 = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
plateau.AjouterCode(code1);
plateau.AjouterCode(code2);
IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
Assert.Equal(4, grille.First().Count());
Assert.Empty(grille.Last());
Assert.Equal(code1.Jetons, grille.ElementAt(0));
Assert.Equal(code2.Jetons, grille.ElementAt(1));
}
[Fact]
public void TestGrilleVide()
{
Plateau plateau = new Plateau(4, 3);
IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
foreach (IEnumerable<Jeton?> tour in grille)
{
Assert.All(tour, jeton => Assert.Null(jeton));
}
}
[Fact]
public void TestIndicateursVide()
{
Plateau plateau = new Plateau(4, 5);
foreach(Indicateur[] indicateur in plateau.Indicateurs())
{
Assert.Null(indicateur);
}
}
[Fact]
public void TestIndicateursAjouterDeuxCodes()
{
Plateau plateau = new Plateau(4, 5);
Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
Code code2 = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
plateau.AjouterCode(code1);
plateau.AjouterCode(code2);
Assert.NotNull(plateau.Indicateurs().ElementAt(0));
Assert.NotNull(plateau.Indicateurs().ElementAt(1));
Assert.Null(plateau.Indicateurs().ElementAt(2));
Assert.Null(plateau.Indicateurs().ElementAt(3));
Assert.Null(plateau.Indicateurs().ElementAt(4));
}
}
}

21
Sources/UnitTesting/StubUT.cs
Unescape View File

@ -1,21 +0,0 @@
using CoreLibrary.Manager;
using Xunit;
namespace UnitTesting
{
public class StubUT
{
[Fact]
public void ChargerTest()
{
Assert.NotEmpty(new Stub().Charger());
}
[Fact]
public void EnregistrerTest()
{
Assert.Null(Record.Exception(() => new Stub().Enregistrer([])));
}
}
}
Write Preview
Loading…
Cancel
Save