public void TestAnimalQDeQ1()
        {
            Animal      dog1  = new Animal(AnimalOption.Dog);
            AnimalQueue dog1Q = new AnimalQueue();

            dog1Q.Enqueue(dog1);
            AnimalNode   dog1Node = dog1Q.Dequeue();
            AnimalOption type2    = dog1Node.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Dog, type2);
        }
        public void TestAnimalQEnQ1()
        {
            Animal      dogGeorge = new Animal(AnimalOption.Dog);
            AnimalQueue georgeQ   = new AnimalQueue();

            georgeQ.Enqueue(dogGeorge);
            AnimalNode   georgeNode = georgeQ.Dequeue();
            AnimalOption type1      = georgeNode.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Dog, type1);
        }
        public void TestAnimalQPeek1()
        {
            Animal      dogPeek1  = new Animal(AnimalOption.Dog);
            AnimalQueue dogPeek1Q = new AnimalQueue();

            dogPeek1Q.Enqueue(dogPeek1);
            AnimalNode   dog1Node = dogPeek1Q.Peek();
            AnimalOption type4    = dog1Node.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Dog, type4);
        }
        public void TestShelterEnQ1()
        {
            Animal        animal1  = new Animal(AnimalOption.Dog);
            Animal        animal1A = new Animal(AnimalOption.Dog);
            AnimalShelter shelter1 = new AnimalShelter(animal1);

            shelter1.ShelterEnqueue(animal1A);
            AnimalNode   shelterAnimalNode1 = shelter1.AnimalQueue1.Rear;
            AnimalOption type6 = shelterAnimalNode1.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Dog, type6);
        }
        public void TestShelterEnQ2()
        {
            Animal        animal2  = new Animal(AnimalOption.Dog);
            Animal        animal3  = new Animal(AnimalOption.Cat);
            Animal        animal4  = new Animal(AnimalOption.Cat);
            AnimalShelter shelter2 = new AnimalShelter(animal2);

            shelter2.ShelterEnqueue(animal3);
            shelter2.ShelterEnqueue(animal4);
            AnimalNode   shelterAnimalNode2 = shelter2.AnimalQueue1.Rear;
            AnimalOption type7 = shelterAnimalNode2.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Cat, type7);
        }
        public void TestAnimalQDeQ3()
        {
            Animal      dog3      = new Animal(AnimalOption.Dog);
            Animal      cat1      = new Animal(AnimalOption.Cat);
            Animal      cat2      = new Animal(AnimalOption.Cat);
            AnimalNode  puppyNode = new AnimalNode(dog3);
            AnimalQueue animal1Q  = new AnimalQueue(puppyNode);

            animal1Q.Enqueue(cat1);
            animal1Q.Enqueue(cat2);
            AnimalNode   junk1Node = animal1Q.Dequeue();
            AnimalNode   checkNode = animal1Q.Dequeue();
            AnimalOption type3     = checkNode.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Cat, type3);
        }
        public void TestShelterEnQ3()
        {
            Animal        animal5  = new Animal(AnimalOption.Dog);
            Animal        animal6  = new Animal(AnimalOption.Cat);
            Animal        animal7  = new Animal(AnimalOption.Dog);
            Animal        animal8  = new Animal(AnimalOption.Dog);
            AnimalShelter shelter3 = new AnimalShelter(animal5);

            shelter3.ShelterEnqueue(animal6);
            shelter3.ShelterEnqueue(animal7);
            shelter3.ShelterEnqueue(animal8);
            AnimalNode   shelterAnimalNode3 = shelter3.AnimalQueue1.Rear;
            AnimalOption type8 = shelterAnimalNode3.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Dog, type8);
        }
        public void TestAnimalQPeek3()
        {
            Animal      dogPeek3     = new Animal(AnimalOption.Dog);
            Animal      catPeek1     = new Animal(AnimalOption.Cat);
            AnimalNode  puppyNode2   = new AnimalNode(dogPeek3);
            AnimalQueue animalPeek3Q = new AnimalQueue(puppyNode2);

            animalPeek3Q.Enqueue(dogPeek3);
            animalPeek3Q.Dequeue();
            animalPeek3Q.Dequeue();
            animalPeek3Q.Enqueue(catPeek1);
            AnimalNode   animal3Node = animalPeek3Q.Peek();
            AnimalOption type5       = animal3Node.AnimalValue.AnimalProp;

            Assert.Equal(AnimalOption.Cat, type5);
        }
Esempio n. 9
0
 //instantiate (with and without starter value)
 public Animal(AnimalOption animalParam)
 {
     AnimalProp = animalParam;
 }