public void B3_CarteMemVider()
{
m_maxScore += 4;
ICarteMemoire target = CréerUneCarteMemoireTest();
IPhoto objPhotoTest = CréerUnePhotoTest();
// on va ajouter quelques photos
int nbPhotos = m_objRandom.Next(5, 10);
for (int index = 0; index < nbPhotos; index++)
{
target.Ajouter(CréerUnePhotoTest());
}
Assert.AreEqual(nbPhotos, target.NbPhotos);
m_totalScore++;
// On va tester la méthode permettant de vider la carte
target.Vider();
Assert.AreEqual(0, target.NbPhotos);
m_totalScore++;
Assert.AreEqual(0, target.EspaceUtilise);
m_totalScore++;
Assert.AreEqual(target.EspaceDisponible, target.TailleEnOctets);
m_totalScore++;
}
public void C7a_PeutPrendreUnePhoto()
{
m_maxScore += 2;
ICamera target = new Camera();
// on test si on peut prendre une photo sans carte mémoire dans la caméra
Assert.IsFalse(target.PeutPrendreUnePhoto(), "Pas de carte mémoire");
// on insere une carte mémoire dans la caméra
ICarteMemoire objCarteMemoire = CréerUneCarteMemoireTest();
target.InsererCarteMemoire(objCarteMemoire);
Assert.IsTrue(target.PeutPrendreUnePhoto(), "Il y a une carte mémoire et de l'espace suffisant");
m_totalScore++;
// on vérifier si on peut prendre une photo trop grande pour l'espace disponible sur la carte mémoire
objCarteMemoire = new CarteMemoire("test", CarteMemoire.TAILLE_MIN);
target.EjecterCarteMemoire();
target.InsererCarteMemoire(objCarteMemoire);
target.Qualite = enuQualite.Excellente;
target.Dimension = enuDimension.Maximale;
Assert.IsFalse(target.PeutPrendreUnePhoto(), "Il y a une carte mémoire mais pas assez d'espace");
m_totalScore++;
}
public void C5_CameraPhotoCourante()
{
m_maxScore += 7;
ICamera target = new Camera();
ICarteMemoire objCarteMem = CréerUneCarteMemoireTest();
Assert.IsNull(target.PhotoCourante); // H14 24-12
for (int index = 0; index < m_objRandom.Next(10, 20); index++)
{
objCarteMem.Ajouter(CréerUnePhotoTest());
}
target.InsererCarteMemoire(objCarteMem);
Assert.AreEqual(0, target.PosPhotoCourante);
Assert.AreEqual(objCarteMem.PhotoAt(0), target.PhotoCourante); // H19
m_totalScore++;
target.PhotoSuivante();
Assert.AreEqual(1, target.PosPhotoCourante);
Assert.AreEqual(objCarteMem.PhotoAt(1), target.PhotoCourante); // H14 24-12
target.PhotoPrecedente();
Assert.AreEqual(0, target.PosPhotoCourante);
Assert.AreEqual(objCarteMem.PhotoAt(0), target.PhotoCourante); // H14 24-12
target.PhotoPrecedente();
Assert.AreEqual(objCarteMem.NbPhotos - 1, target.PosPhotoCourante);
Assert.AreEqual(objCarteMem.PhotoAt(objCarteMem.NbPhotos - 1), target.PhotoCourante); // H14 24-12
target.PhotoSuivante();
Assert.AreEqual(0, target.PosPhotoCourante);
m_totalScore++;
// à ce stade la carte mémoire est vide
target.ViderLaCarte();
ExécuterPhotoSuivanteEtPrecedente(target, Camera.ERR_MSG_CARTE_VIDE);
//à ce stade il n'y pas de carte dans la caméra
target.EjecterCarteMemoire();
try
{
target.ViderLaCarte();
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_MANQUANTE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
ExécuterPhotoSuivanteEtPrecedente(target, Camera.ERR_MSG_CARTE_MANQUANTE);
}
public void B4_CarteMemPhotoAt()
{
m_maxScore += 3;
ICarteMemoire target = CréerUneCarteMemoireTest();
for (int index = 0; index < m_objRandom.Next(10, 20); index++)
{
Photo objPhoto = CréerUnePhotoTest();
target.Ajouter(objPhoto);
Assert.AreEqual(objPhoto, target.PhotoAt(index));
}
m_totalScore++;
try
{
target.PhotoAt(-1);
Assert.Fail("ArgumentOutOfRangeException attendue");
}
catch (ArgumentOutOfRangeException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentOutOfRangeException attendue");
}
try
{
target.PhotoAt(target.NbPhotos);
Assert.Fail("ArgumentOutOfRangeException attendue");
}
catch (ArgumentOutOfRangeException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentOutOfRangeException attendue");
}
}
public void C4_CameraCarteMemoire()
{
m_maxScore += 6;
ICamera target = new Camera();
Assert.IsNull(target.CarteMemoireCourante);
ICarteMemoire objCarteMem = CréerUneCarteMemoireTest();
target.InsererCarteMemoire(objCarteMem);
Assert.AreEqual(objCarteMem, target.CarteMemoireCourante);
m_totalScore++;
target.ViderLaCarte();
Assert.AreEqual(0, objCarteMem.NbPhotos);
target.EjecterCarteMemoire();
Assert.IsNull(target.CarteMemoireCourante);
Assert.AreEqual(-1, target.PosPhotoCourante);
m_totalScore++;
// à ce stade il n'y pas de carte mémoire dans la caméra
try
{
target.EjecterCarteMemoire();
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_MANQUANTE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
// à ce stade il n'y pas de carte dans la caméra
try
{
target.ViderLaCarte();
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_MANQUANTE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
target.InsererCarteMemoire(objCarteMem);
// on va essayer d'insérer une autre carte dans la caméra
try
{
target.InsererCarteMemoire(objCarteMem);
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_PRÉSENTE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
// on va essayer d'introduire une carte null
try
{
target.EjecterCarteMemoire();
target.InsererCarteMemoire(null);
Assert.Fail("ArgumentNullException attendue");
}
catch (ArgumentNullException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentNullException attendue");
}
}
public void B5_CarteMemSupprimer()
{
m_maxScore += 5;
ICarteMemoire target = CréerUneCarteMemoireTest();
IPhoto objPhotoTest1 = CréerUnePhotoTest();
IPhoto objPhotoTest2 = CréerUnePhotoTest();
// On va ajouter deux photos sur la carte mémoire avant d'essayer de supprimer
target.Ajouter(objPhotoTest1);
target.Ajouter(objPhotoTest2);
long espaceUtiliséAvantSupp = target.EspaceUtilise;
long espaceDispoAvantSupp = target.EspaceDisponible;
// On va supprimer la deuxième photo
target.SupprimerAt(1);
Assert.AreEqual(1, target.NbPhotos);
m_totalScore++;
Assert.AreEqual(espaceUtiliséAvantSupp - objPhotoTest2.TailleEnOctets, target.EspaceUtilise);
Assert.AreEqual(espaceDispoAvantSupp + objPhotoTest2.TailleEnOctets, target.EspaceDisponible);
m_totalScore++;
// On va ajouter quelques photos sur la carte et les supprimer
target.Vider();
int nbPhotos = m_objRandom.Next(5, 10);
for (int index = 0; index < m_objRandom.Next(5, 10); index++)
{
target.Ajouter(CréerUnePhotoTest());
}
for (int index = 0; index < target.NbPhotos; index++)
{
espaceUtiliséAvantSupp = target.EspaceUtilise;
espaceDispoAvantSupp = target.EspaceDisponible;
int randomIndex = m_objRandom.Next(0, target.NbPhotos);
IPhoto objPhotoASupprimer = target.PhotoAt(randomIndex);
target.SupprimerAt(randomIndex);
Assert.AreEqual(espaceUtiliséAvantSupp - objPhotoASupprimer.TailleEnOctets, target.EspaceUtilise);
Assert.AreEqual(espaceDispoAvantSupp + objPhotoASupprimer.TailleEnOctets, target.EspaceDisponible);
}
m_totalScore++;
// on va supprimer une photo avec des arguments non valides
try
{
target.SupprimerAt(-1);
Assert.Fail("ArgumentOutOfRangeException attendue");
}
catch (ArgumentOutOfRangeException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentOutOfRangeException attendue");
}
try
{
target.SupprimerAt(target.NbPhotos);
Assert.Fail("ArgumentOutOfRangeException attendue");
}
catch (ArgumentOutOfRangeException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentOutOfRangeException attendue");
}
}
public void C7b_CameraPrendrePhoto()
{
m_maxScore += 7;
ICamera target = new Camera();
// on va prendre une photo sans carte mémoire dans la caméra
try
{
target.PrendrePhoto();
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_MANQUANTE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
// on va prendre une photo avec une carte mémoire dans la caméra
ICarteMemoire objCarteMemoire = CréerUneCarteMemoireTest();
target.InsererCarteMemoire(objCarteMemoire);
DateTime dateCourante = DateTime.Now;
Assert.IsTrue(target.PeutPrendreUnePhoto());
target.PrendrePhoto();
// on va vérifier si la photo à été ajoutée sur la carte mémoire
Assert.AreEqual(1, objCarteMemoire.NbPhotos);
// on va vérifier la date de la nouvelle photo
IPhoto objNouvellePhoto = objCarteMemoire.PhotoAt(0);
TimeSpan delaiMax = new TimeSpan(0, 1, 0); // une minute
Assert.IsTrue(objNouvellePhoto.Date - dateCourante < delaiMax);
m_totalScore++;
// on va supprimer la photo courante
target.SupprimerPhotoCourante();
Assert.AreEqual(0, objCarteMemoire.NbPhotos);
Assert.AreEqual(-1, target.PosPhotoCourante);
m_totalScore++;
// on va supprimer la photo courante avec une carte vide
try
{
target.SupprimerPhotoCourante();
Assert.Fail();
}
catch (InvalidOperationException e)
{
Assert.AreEqual(Camera.ERR_MSG_CARTE_VIDE, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
// on va prendre quelques photos
for (int index = 0; index < m_objRandom.Next(5, 10); index++)
{
target.PrendrePhoto();
Assert.AreEqual(index, target.PosPhotoCourante);
dateCourante = DateTime.Now;
objNouvellePhoto = objCarteMemoire.PhotoAt(index);
Assert.IsTrue(objNouvellePhoto.Date - dateCourante < delaiMax);
}
Assert.AreEqual(objCarteMemoire.NbPhotos - 1, target.PosPhotoCourante); // H14 24-12
m_totalScore++;
// on va supprimer les photos en partant de la dernière
target.PhotoPrecedente();
while (objCarteMemoire.NbPhotos > 0)
{
target.SupprimerPhotoCourante();
Assert.AreEqual(objCarteMemoire.NbPhotos - 1, target.PosPhotoCourante);
}
m_totalScore++;
// on va prendre une photo trop grande pour l'espace disponible sur la carte mémoire
objCarteMemoire = new CarteMemoire("test", CarteMemoire.TAILLE_MIN);
target.EjecterCarteMemoire();
target.InsererCarteMemoire(objCarteMemoire);
target.Qualite = enuQualite.Excellente;
target.Dimension = enuDimension.Maximale;
Assert.IsFalse(target.PeutPrendreUnePhoto());//déja testé
try
{
target.PrendrePhoto();
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(CarteMemoire.ERR_MSG_ESPACE_INSUFFISANT, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException attendue");
}
}