Exemplo n.º 1
0
        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++;
        }
Exemplo n.º 2
0
        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++;
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        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");
            }
        }
Exemplo n.º 5
0
        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");
            }
        }
Exemplo n.º 6
0
        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");
            }
        }
Exemplo n.º 7
0
        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");
            }
        }