Exemple #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++;
        }
Exemple #2
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");
            }
        }