public void B6_CarteMemPeutAjouter()
{
m_maxScore += 4;
int tailleEnMo = CarteMemoire.TAILLE_MIN;
long tailleEnOctets = tailleEnMo * 1024L * 1024;
ICarteMemoire target = new CarteMemoire("test", tailleEnMo);
IPhoto objPhotoTest = new Photo(new Size(1000, 1000), 1, 0, 0);
int taillePhoto = objPhotoTest.TailleEnOctets;
Assert.IsTrue(target.PeutAjouter(objPhotoTest));
target.Ajouter(objPhotoTest);
m_totalScore++;
Assert.IsTrue(target.PeutAjouter(objPhotoTest));
target.Ajouter(objPhotoTest);
m_totalScore++;
Assert.IsFalse(target.PeutAjouter(objPhotoTest));
m_totalScore++;
Assert.IsFalse(target.PeutAjouter(null));
m_totalScore++;
}
public void B1_CarteMemConstructeur()
{
m_maxScore += 5;
string nom = "";
int longueurChaine = m_objRandom.Next(25);
for (int index = 0; index < longueurChaine; index++)
{
nom += ((char)(m_objRandom.Next(0, 26) + 'A')).ToString();
}
int tailleEnMo = m_objRandom.Next(CarteMemoire.TAILLE_MAX / 2, CarteMemoire.TAILLE_MAX);
long tailleEnOctets = tailleEnMo * 1024L * 1024;
ICarteMemoire target = new CarteMemoire(nom, tailleEnMo);
//Test les 5 propriétés en lecture
Assert.AreEqual(nom, target.Nom);
Assert.AreEqual(tailleEnOctets, target.TailleEnOctets);
Assert.AreEqual(0, target.EspaceUtilise);
Assert.AreEqual(0, target.NbPhotos);
Assert.AreEqual(tailleEnOctets, target.EspaceDisponible);
m_totalScore += 3;
// tests des valeurs limites de la taille
Assert.IsTrue(InstancierUneCarteMemoireAvecArgumentOutOfRange(int.MinValue), "CarteMemoireAvecArgumentOutOfRange");
Assert.IsTrue(InstancierUneCarteMemoireAvecArgumentOutOfRange(CarteMemoire.TAILLE_MIN - 1), "CarteMemoireAvecArgumentOutOfRange");
Assert.IsFalse(InstancierUneCarteMemoireAvecArgumentOutOfRange(CarteMemoire.TAILLE_MIN), "limite inférieure");
Assert.IsFalse(InstancierUneCarteMemoireAvecArgumentOutOfRange(CarteMemoire.TAILLE_MAX), "limite suppérieure");
Assert.IsTrue(InstancierUneCarteMemoireAvecArgumentOutOfRange(CarteMemoire.TAILLE_MAX + 1), "CarteMemoireAvecArgumentOutOfRange");
Assert.IsTrue(InstancierUneCarteMemoireAvecArgumentOutOfRange(int.MaxValue), "CarteMemoireAvecArgumentOutOfRange");
m_totalScore += 2;
}
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++;
}
private bool InstancierUneCarteMemoireAvecArgumentOutOfRange(int pTailleEnMegaOctets)
{
try
{
CarteMemoire objCarte = new CarteMemoire("ABC", pTailleEnMegaOctets);
return(false);
}
catch (ArgumentOutOfRangeException)
{
return(true);
}
catch (Exception)
{
return(false);
}
}
public void B7_CarteMemChargerPhotos()
{
m_maxScore += 5;
const string NOM_FICHIER_TEST = "CarteTest";
Directory.SetCurrentDirectory("../../../AppCamera/bin/Debug");
StreamWriter objSW = new StreamWriter(NOM_FICHIER_TEST + ".txt");
int nbPhotos = m_objRandom.Next(10, 15);
int espaceUtilisé = 0;
for (int index = 0; index < nbPhotos; index++)
{
IPhoto objPhoto = CréerUnePhotoTest();
objSW.WriteLine(objPhoto);
espaceUtilisé += objPhoto.TailleEnOctets;
}
objSW.Close();
int tailleEnMo = CarteMemoire.TAILLE_MAX;
long tailleEnOctets = tailleEnMo * 1024L * 1024;
ICarteMemoire target = new CarteMemoire(NOM_FICHIER_TEST, tailleEnMo);
target.ChargerPhotos();
Assert.AreEqual(nbPhotos, target.NbPhotos);
// On va recharger les photos, cela devrait donner le même résultat
target.ChargerPhotos();
Assert.AreEqual(nbPhotos, target.NbPhotos);
m_totalScore += 3;
// on va vérifier l'espace utilisé et disponible sur la carte
Assert.AreEqual(espaceUtilisé, target.EspaceUtilise);
Assert.AreEqual(tailleEnOctets - espaceUtilisé, target.EspaceDisponible);
m_totalScore += 1;
// on va vérifier le fonctionnement avec un fichier vide
objSW = new StreamWriter(NOM_FICHIER_TEST + ".txt");
objSW.Close();
target.ChargerPhotos();
Assert.AreEqual(0, target.NbPhotos);
Assert.AreEqual(0, target.EspaceUtilise);
Assert.AreEqual(tailleEnOctets, target.EspaceDisponible);
m_totalScore += 1;
}
public void B8_CarteMemEnregistrerPhotos()
{
m_maxScore += 5;
const string NOM_FICHIER_TEST = "CarteTest";
Directory.SetCurrentDirectory("../../../AppCamera/bin/Debug");
int tailleEnMo = CarteMemoire.TAILLE_MAX;
long tailleEnOctets = tailleEnMo * 1024L * 1024;
ICarteMemoire target = new CarteMemoire(NOM_FICHIER_TEST, tailleEnMo);
ICarteMemoire backup = new CarteMemoire(NOM_FICHIER_TEST, tailleEnMo);
int nbPhotos = m_objRandom.Next(10, 15);
target.Vider();
for (int index = 0; index < nbPhotos; index++)
{
Photo photoTest = CréerUnePhotoTest();
target.Ajouter(photoTest);
backup.Ajouter(photoTest);
}
target.EnregistrerPhotos();
target.Vider();
target.ChargerPhotos();
Assert.AreEqual(nbPhotos, target.NbPhotos);
m_totalScore += 2;
// H15 Ici on va s'assurer que les photos chargées sont identiques à celles qui devaient être enregistrées
for (int index = 0; index < backup.NbPhotos; index++)
{
IPhoto photoChargée = target.PhotoAt(index);
IPhoto photoAEnregistrer = backup.PhotoAt(index);
Assert.AreEqual(photoChargée.TailleEnPixels, photoAEnregistrer.TailleEnPixels);
Assert.AreEqual(photoChargée.TailleEnOctets, photoAEnregistrer.TailleEnOctets);
Assert.AreEqual(photoChargée.FacteurCompression, photoAEnregistrer.FacteurCompression);
Assert.AreEqual(photoChargée.Sensibilite, photoAEnregistrer.Sensibilite);
Assert.AreEqual(photoChargée.Flash, photoAEnregistrer.Flash);
}
m_totalScore += 3;
}
public void B2_CarteMemAjouter()
{
m_maxScore += 5;
string nom = "";
for (int index = 0; index < m_objRandom.Next(25); index++)
{
nom += ((char)(m_objRandom.Next(0, 26) + 'A')).ToString();
}
int tailleEnMo = m_objRandom.Next(CarteMemoire.TAILLE_MAX / 2, CarteMemoire.TAILLE_MAX);
long tailleEnOctetsDeLaCarte = tailleEnMo * 1024L * 1024;
ICarteMemoire target = new CarteMemoire(nom, tailleEnMo);
IPhoto objPhotoTest = CréerUnePhotoTest();
// On va ajouter une photo sur la carte mémoire
target.Ajouter(objPhotoTest);
//ça ne change pas la taille de la carte mémoire
Assert.AreEqual(tailleEnOctetsDeLaCarte, target.TailleEnOctets);
m_totalScore++;
Assert.AreEqual(1, target.NbPhotos);
m_totalScore++;
Assert.AreEqual(objPhotoTest.TailleEnOctets, target.EspaceUtilise);
Assert.AreEqual(tailleEnOctetsDeLaCarte - objPhotoTest.TailleEnOctets, target.EspaceDisponible);
m_totalScore++;
// On va essayer d'ajouter une photo --> null
// à ce stade il n'y pas de carte dans la caméra
try
{
target.Ajouter(null);
Assert.Fail("ArgumentNullException attendue");
}
catch (ArgumentNullException)
{
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("ArgumentNullException attendue");
}
// On va essayer d'ajouter une photo sur une carte ne disposant pas suffisamment d'espace libre
target = new CarteMemoire(nom, CarteMemoire.TAILLE_MIN);
Size taille = new Size(Photo.LARGEUR_MAX, Photo.HAUTEUR_MAX);
IPhoto objPhoto = new Photo(taille, Photo.COMPRESSION_MIN, enuSensibilite.ISO_100, enuFlash.Activé);
try
{
target.Ajouter(objPhoto);
Assert.Fail("InvalidOperationException attendue");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(CarteMemoire.ERR_MSG_ESPACE_INSUFFISANT, e.Message);
m_totalScore++;
}
catch (Exception)
{
Assert.Fail("InvalidOperationException 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");
}
}
