public void TestShelterCounter()
{
AnimalShelter shelter = new AnimalShelter();
shelter.Enqueue(new Animal("Dog"));
shelter.Enqueue(new Animal("Cat"));
Assert.Equal(2, shelter.Total);
}
public void EnqueueCat()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Cat("Billy"));
Assert.True(myShelter.Cats.Front.Value is Cat);
}
public void EnqueueDog()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Dog("Bo"));
Assert.True(myShelter.Dogs.Front.Value is Dog);
}
private static void DequeueAndValidateDogs(AnimalShelter shelter, params int[] ids)
{
foreach (var id in ids)
{
Assert.AreEqual(id, shelter.DequeueDog().Id);
}
}
public void EnqueueAnimal()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Animal());
Assert.True(myShelter.OtherAnimals.Front.Value is Animal);
}
public void CheckTempGetReset()
{
Animal dogOne = new Animal("dog");
dogOne.Name = "ron";
Animal dogTwo = new Animal("dog");
dogTwo.Name = "demi";
Animal dogThree = new Animal("dog");
dogThree.Name = "sparky";
Animal catOne = new Animal("cat");
catOne.Name = "fluffy";
Animal catTwo = new Animal("cat");
catTwo.Name = "mike";
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(dogOne);
myShelter.Enqueue(dogTwo);
myShelter.Enqueue(catOne);
myShelter.Enqueue(catTwo);
myShelter.Enqueue(dogThree);
myShelter.Dequeue("cat");
Assert.Equal(2, myShelter.TempHoldStack.Count); //make sure the two first items(dogs) are added to temp stack
Assert.Equal("ron", myShelter.Dequeue("dog").Name); //make sure the first dog ron is returned
Assert.Empty(myShelter.TempHoldStack); //make sure temp stack is empty becuase it empties into outbound stack when dequeue is called.
}
public void CanDequeueProperly()
{
Cat testCat1 = new Cat("Cat 1");
Cat testCat2 = new Cat("Cat 2");
Cat testCat3 = new Cat("Cat 3");
Cat testCat4 = new Cat("Cat 4");
Dog testDog1 = new Dog("Dog 1");
Dog testDog2 = new Dog("Dog 2");
Dog testDog3 = new Dog("Dog 3");
AnimalShelter testShelter = new AnimalShelter(testCat1);
testShelter.Enqueue(testCat2);
testShelter.Enqueue(testCat3);
testShelter.Enqueue(testDog1);
testShelter.Enqueue(testCat4);
testShelter.Enqueue(testDog2);
Assert.Equal(testShelter.Front.GetType().Name.ToLower(), testShelter.Dequeue("unicorn").GetType().Name.ToLower());
Assert.Equal("dog", testShelter.Dequeue("DOG").GetType().Name.ToLower());
Assert.Equal("cat", testShelter.Dequeue("cAt").GetType().Name.ToLower());
Assert.Equal("dog", testShelter.Dequeue("DoG").GetType().Name.ToLower());
Assert.Equal("cat", testShelter.Dequeue("cAT").GetType().Name.ToLower());
Assert.Equal("cat", testShelter.Dequeue("cAt").GetType().Name.ToLower());
}
public void CanTakeInADog()
{
Dog jeff = new Dog("Jeff");
AnimalShelter animalShelter = new AnimalShelter(jeff);
Assert.Equal("Jeff", animalShelter.FrontAnimal.Name);
}
public void CanTakeInACat()
{
Cat jiffy = new Cat("Jiffy");
AnimalShelter animalShelter = new AnimalShelter(jiffy);
Assert.Equal("Jiffy", animalShelter.FrontAnimal.Name);
}
public void CanDequeueAnItemFromTheShelter()
{
// Arrange
AnimalShelter shelter = new AnimalShelter();
Dog[] dogs = new Dog[4];
//Dog testDog = new Dog();
int counter = 1;
foreach (Dog item in dogs)
{
shelter.Enqueue(new Dog()
{
Name = $"{counter++}"
});
}
// Act
Animal testNode = shelter.Dequeue("dog");
string returnFromMethod = testNode.Name;
string expected = "1";
// Assert
Assert.Equal(expected, returnFromMethod);
}
public IActionResult GetByUser(int id)
{
User _user = _userRepository.GetSingle(u => u.Id == id, u => u.FavoriteAnimals);
if (_user != null)
{
IEnumerable <Animal> _animals = _animalRepository
.AllIncluding(a => a.AnimalsToAnimalShelter)
.OrderBy(a => a.Id)
.ToList();
IList <AnimalDetailsViewModel> _animalViewModel = new List <AnimalDetailsViewModel>();
foreach (var animal in _animals)
{
AnimalShelter _animalShelterDb = _animalShelterRepository.GetSingle(s => s.Id == animal.AnimalsToAnimalShelter.AnimalShelterId);
AnimalDetailsViewModel _animalDetailsViewModel = Mapper.Map <Animal, AnimalDetailsViewModel>(animal);
if (_user.FavoriteAnimals.Select(x => x.AnimalId).ToList().Contains(animal.Id))
{
_animalDetailsViewModel.IsFavorite = true;
}
_animalDetailsViewModel.AnimalShelter = Mapper.Map <AnimalShelter, AnimalShelterViewModel>(_animalShelterDb);
_animalViewModel.Add(_animalDetailsViewModel);
}
return(new OkObjectResult(_animalViewModel));
}
return(NotFound());
}
public void CanDequeueTheSpecifiedTypeFromTheShelter()
{
// Arrange
AnimalShelter shelter = new AnimalShelter();
for (int i = 0; i < 8; i++)
{
if (i % 2 == 0)
{
shelter.Enqueue(new Cat());
}
else
{
shelter.Enqueue(new Dog());
}
}
// Act
Animal testNode = shelter.Dequeue("dog");
var expected = new Dog();
// Assert
Assert.Equal(expected.GetType(), testNode.GetType());
}
public void TestDequeueMatch()
{
AnimalShelter shelter = new AnimalShelter();
shelter.Enqueue(new Animal("Dog"));
shelter.Enqueue(new Animal("Cat"));
Assert.Equal("CAT", shelter.Dequeue("cat").Value);
}
public void TestDequeueInvalidAnimal()
{
AnimalShelter shelter = new AnimalShelter();
shelter.Enqueue(new Animal("Dog"));
shelter.Enqueue(new Animal("Cat"));
Assert.Null(shelter.Dequeue("ferret").Value);
}
public void Queue_stays_in_order_after_dequeue_in_middle()
{
// Arrange
AnimalShelter <Animal> testQueue = new AnimalShelter <Animal>();
Dog newDog = new Dog();
Cat newCat = new Cat();
testQueue.ArriveAtShelter(newDog);
testQueue.ArriveAtShelter(newCat);
testQueue.ArriveAtShelter(newDog);
testQueue.ArriveAtShelter(newCat);
// Removing from center to prove the order stays the same
testQueue.TakeHome <Cat>();
// Act
Dog firstDog = testQueue.TakeHome <Dog>();
Dog secondDog = testQueue.TakeHome <Dog>();
Cat secondCat = testQueue.TakeHome <Cat>();
//Assert
Assert.Equal("dog", firstDog.Type);
Assert.Equal("dog", secondDog.Type);
Assert.Equal("cat", secondCat.Type);
}
public void DequeueAnimal()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Animal());
Assert.True(myShelter.Dequeue("other") is Animal);
}
public void TestMultiEnqueue()
{
AnimalShelter shelter = new AnimalShelter();
shelter.Enqueue(new Animal("Dog"));
shelter.Enqueue(new Animal("Cat"));
Assert.Equal("CAT", shelter.Rear.Value);
}
public void DeoptDog()
{
AnimalShelter shelter = new AnimalShelter();
Dog spot = new Dog();
shelter.Enqueue(spot);
Assert.IsType <Dog>(shelter.dogs.head.data);
}
public void CanEnqueue(string value, string expected)
{
AnimalShelter myShelter = new AnimalShelter(new Animal("cat"));
myShelter.Enqueue(new Animal(value));
Assert.Equal(expected, myShelter.Rear.Value);
}
public void DeoptCat()
{
AnimalShelter shelter = new AnimalShelter();
Cat wiskers = new Cat();
shelter.Enqueue(wiskers);
Assert.IsType <Cat>(shelter.cats.head.data);
}
public void CannotDequeueNonExistentAnimal()
{
Cat cat1 = new Cat("Fluffy");
AnimalShelter animalShelter = new AnimalShelter(cat1);
Animal someAnimal = animalShelter.DequeueWithType(typeof(Snake));
Assert.Null(someAnimal);
}
public void Enqueue_AddsToEmptyShelterQueue()
{
AnimalShelter shelter = new AnimalShelter();
Dog dog = new Dog("Puppers");
shelter.Enqueue(dog);
Assert.Equal("Puppers", shelter.QOne.Front.Name);
}
public void CanEnqueueAnAnimalThatIsNotCatOrDog()
{
Animal cat1 = new Cat("cat1");
Animal fish = new Fish("fish");
AnimalShelter shelter = new AnimalShelter(cat1);
Assert.Equal("You added a \"something\" to the shelter.", shelter.Enqueue(fish));
}
public void CanCreateShelter()
{
Cat cat1 = new Cat("Fluffy");
AnimalShelter animalShelter = new AnimalShelter(cat1);
Assert.IsType <AnimalShelter>(animalShelter);
Assert.Equal(1, animalShelter.Size);
}
public void DequeueDog()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Dog("Rex"));
myShelter.Enqueue(new Dog("Rufus"));
Assert.Equal("Rex", myShelter.Dequeue("dog").Name);
}
public void CanEnqueueAnAnimal()
{
Animal cat1 = new Cat("cat1");
Animal cat2 = new Cat("cat2");
AnimalShelter shelter = new AnimalShelter(cat1);
Assert.Equal("Added a cat to the shelter!", shelter.Enqueue(cat2));
}
public void DequeueCat()
{
AnimalShelter myShelter = new AnimalShelter();
myShelter.Enqueue(new Cat("Fluffy"));
myShelter.Enqueue(new Cat("Felix"));
Assert.Equal("Fluffy", myShelter.Dequeue("cat").Name);
}
public void CanCreateAnEmptyAnimalShelter()
{
//Arrange
AnimalShelter testShelter = new AnimalShelter();
//Assert
Assert.Null(testShelter.Dequeue("cat"));
}
public void SuccessfulEnqueue()
{
AnimalShelter shelter = new AnimalShelter();
shelter.Enqueue(new Dog());
Assert.NotNull(shelter.First);
}
public void CanEnqueueADog()
{
Animal a1 = new Animal("dog1");
AnimalShelter WeHope = new AnimalShelter(a1);
WeHope.Enqueue("dog2");
Assert.Equal("dog2", WeHope.Rear.type);
}
public static void Main()
{
AnimalShelter snake = new AnimalShelter("snake",3,false);
AnimalShelter doggie = new AnimalShelter("dog",2,false);
AnimalShelter cat = new AnimalShelter("cat",4,false);
AnimalShelter fatcat = new AnimalShelter("cat",5,false);
List<AnimalShelter> Animals = new List<AnimalShelter>() { snake, doggie, cat, fatcat };
foreach(AnimalShelter animal in Animals)
{
Console.WriteLine(animal.Species+ " is Adopted? " +animal.IsAdopted);
}
Console.WriteLine("Enter maximum Age for pet: ");
string stringMaxAge = Console.ReadLine();
int maxAge = int.Parse(stringMaxAge);
List<AnimalShelter> AnimalSheltersMatchingSearch = new List<AnimalShelter>();
foreach (AnimalShelter animal in Animals)
{
if (animal.Age <= maxAge)
{
AnimalSheltersMatchingSearch.Add(animal);
}
}
foreach(AnimalShelter animal in AnimalSheltersMatchingSearch)
{
Console.WriteLine("Adopt "+animal.Species+"(yes/no)?");
string adopt = Console.ReadLine();
if(adopt=="yes"){
animal.ChangeAdopted();
}
}
foreach(AnimalShelter animal in Animals)
{
Console.WriteLine(animal.Species+ " is Adopted? " +animal.IsAdopted);
}
}
