C# 单元测试获胜'；t运行：进程因StackOverflowException而终止

我正在进行单元测试，以测试我编写的算法，不幸的是，由于以下错误，这些测试甚至无法运行：

[10-6-2018 00:12:00信息]==========运行测试完成：0运行（0:00:065685302）========== [10-6-2018 00:12:04信息]----运行测试已开始------ [10-6-2018 00:12:09错误]活动测试运行已中止。原因：进程因StackOverflowException而终止

这些都是我的单元测试：

namespace AlgoritmeTest
{
    [TestClass]
    public class AlgoritmeTests
    {
        [TestMethod]
        public void TestAddingWagonToTrain()
        {
            Train train = new Train();
            Wagon wagon = new Wagon(10);

            List<Wagon> expected = new List<Wagon>();
            expected.Add(wagon);

            train.AddWagon(wagon);
            List<Wagon> actual = train.GetWagons();
            Assert.AreEqual(expected, actual, "Failed to add wagon to train");

        }

        [TestMethod]
        public void TestAddingAnimalToWagon()
        {
            Train train = new Train();
            Wagon wagon = new Wagon(10);
            Animal animal = new Animal("Goudvis", AnimalFood.Meat, AnimalSize.Big);


            List<Animal> expected = new List<Animal>();
            expected.Add(animal);

            wagon.AddAnimal(animal);
            List<Animal> actual = wagon.GetAnimals();

            Assert.AreEqual(expected, actual, "Failed to add animal to wagon");
        }
        [TestMethod]
        public void TestIfAnimalsAreReturned()
        {
            Animal animal = new Animal();

            Animal goudvis = new Animal("Goudvis", AnimalFood.Meat, AnimalSize.Big);
            Animal visstick = new Animal("Visstick", AnimalFood.Meat, AnimalSize.Big);
            animal.animalsFromTheCircus.Add(goudvis);
            animal.animalsFromTheCircus.Add(new Animal("Potvis", AnimalFood.Plants, AnimalSize.Medium));
            animal.animalsFromTheCircus.Add(new Animal("Zalm", AnimalFood.Meat, AnimalSize.Small));
            animal.animalsFromTheCircus.Add(visstick);
            animal.animalsFromTheCircus.Add(new Animal("Varkenshaasje", AnimalFood.Plants, AnimalSize.Big));

            List<Animal> expected = new List<Animal>();
            expected.Add(goudvis);
            expected.Add(visstick);

            List<Animal> actual = animal.GetAllBigMeatEaters();

            Assert.AreEqual(expected, actual, "Failed to get all animals which meet criteria");
        }
        [TestMethod]
        public void TestIfAlgorithmStepWorks()
        {
            Program program = new Program();
            Animal animal = new Animal();

            Wagon wagon = new Wagon(10);
            Wagon wagon2 = new Wagon(10);

            Animal goudvis = new Animal("Goudvis", AnimalFood.Meat, AnimalSize.Big);
            Animal visstick = new Animal("Visstick", AnimalFood.Meat, AnimalSize.Big);

            animal.animalsFromTheCircus.Add(goudvis);
            animal.animalsFromTheCircus.Add(visstick);
            animal.animalsFromTheCircus.Add(new Animal("Potvis", AnimalFood.Plants, AnimalSize.Medium));
            animal.animalsFromTheCircus.Add(new Animal("Zalm", AnimalFood.Meat, AnimalSize.Small));
            animal.animalsFromTheCircus.Add(new Animal("Varkenshaasje", AnimalFood.Plants, AnimalSize.Big));

            wagon.AddAnimal(goudvis);
            wagon2.AddAnimal(visstick);

            Train expected = new Train();

            expected.AddWagon(wagon);
            expected.AddWagon(wagon2);



            program.SetUpProgram(animal.animalsFromTheCircus);
            Train actual = program.AddAllMeatEaters();

            Assert.AreEqual(expected, actual, "Failed to get all animals which meet criteria and place them in train according to alogrithm");
        }
    }
}

名称空间算法测试
{
[测试类]
公共类算法学家
{
[测试方法]
公共无效测试
{
列车=新列车（）；
货车=新货车（10）；
预期列表=新列表（）；
预期。添加（货车）；
火车；货车；
列表实际值=train.GetWagons（）；
Assert.AreEqual（预期、实际，“未能将货车添加到列车”）；
}
[测试方法]
公共无效测试添加Nimaltowagon（）
{
列车=新列车（）；
货车=新货车（10）；
动物=新动物（“Goudvis”，动物食品。肉类，动物化。大）；
预期列表=新列表（）；
预期。添加（动物）；
四轮马车。动物（动物）；
列表实际值=旅行车。GetAnimals（）；
Assert.AreEqual（预期、实际，“未能将动物添加到货车”）；
}
[测试方法]
public void testifanimalsareturned（）
{
动物=新动物（）；
动物goudvis=新动物（“goudvis”，动物食品。肉，动物大小。大）；
动物内脏棒=新动物（“内脏棒”，动物食品。肉类，动物大小。大）；
动物。来自圈闭的动物。添加（goudvis）；
添加（新动物（“Potvis”，动物食品。植物，动物化。培养基））；
动物。来自Circus的动物。添加（新动物（“Zalm”，动物食品。肉，动物化。小））；
动物。来自圆环体的动物。添加（visstick）；
添加（新动物（“Varkenshaasje”，AnimalFood.Plants，AnimalSize.Big））；
预期列表=新列表（）；
预期。添加（goudvis）；
预期。添加（visstick）；
List actual=animal.GetAllBigMeatEaters（）；
Assert.AreEqual（预期、实际，“未能获得所有符合标准的动物”）；
}
[测试方法]
公共空间测试FalgorithMstepWorks（）
{
程序=新程序（）；
动物=新动物（）；
货车=新货车（10）；
货车2=新货车（10）；
动物goudvis=新动物（“goudvis”，动物食品。肉，动物大小。大）；
动物内脏棒=新动物（“内脏棒”，动物食品。肉类，动物大小。大）；
动物。来自圈闭的动物。添加（goudvis）；
动物。来自圆环体的动物。添加（visstick）；
添加（新动物（“Potvis”，动物食品。植物，动物化。培养基））；
动物。来自Circus的动物。添加（新动物（“Zalm”，动物食品。肉，动物化。小））；
添加（新动物（“Varkenshaasje”，AnimalFood.Plants，AnimalSize.Big））；
四轮马车。AddAnimal（goudvis）；
货车2.AddAnimal（visstick）；
预期列车=新列车（）；
预期的。附加货车（货车）；
预期的。货车（货车2）；
程序。设置程序（来自圆环体的动物）；
Train actual=program.addallmeaters（）；
断言.AreEqual（预期，实际，“未能获得所有符合标准的动物，并根据alogrithm将它们放入训练中”）；
}
}
}

Animal.cs

public class Animal
{
    private string animalName;
    private AnimalFood animalFood;
    private AnimalSize animalSize;

    public Animal(string animalName, AnimalFood animalFood, AnimalSize animalSize)
    {
        this.animalName = animalName;
        this.animalFood = animalFood;
        this.animalSize = animalSize;
    }
    public Animal()
    {

    }

    public List<Animal> animalsFromTheCircus = new DataGenerator().GenerateAnimals(100);

    public List<Animal> GetallAnimals()
    {
        return animalsFromTheCircus;
    }

    public List<Animal> GetAllBigMeatEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Big && animal.getAnimalFood() == AnimalFood.Meat).ToList();
    }
    public List<Animal> GetAllBigMeatEaters(List<Animal> animalsFromTheCircus)
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Big && animal.getAnimalFood() == AnimalFood.Meat).ToList();
    }
    public List<Animal> GetAllSmallMeatEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Small && animal.getAnimalFood() == AnimalFood.Meat).ToList();
    }
    public List<Animal> GetAllBigPlantEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Big && animal.getAnimalFood() == AnimalFood.Plants).ToList();
    }

    public List<Animal> GetAllMediumMeatEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Medium && animal.getAnimalFood() == AnimalFood.Meat).ToList();
    }
    public List<Animal> GetAllMediumPlantEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Medium && animal.getAnimalFood() == AnimalFood.Plants).ToList();
    }

    public List<Animal> GetAllSmallPlantEaters()
    {
        return animalsFromTheCircus.Where(animal => animal.getAnimalSize() == AnimalSize.Small && animal.getAnimalFood() == AnimalFood.Plants).ToList();
    }

    public string getAnimalName()
    {
        return this.animalName;
    }

    public AnimalFood getAnimalFood()
    {
        return this.animalFood;
    }

    public AnimalSize getAnimalSize()
    {
        return this.animalSize;
    }
}

   public class Wagon
{
    private List<Animal> animals;
    private int maxSize;

    public Wagon(int maxSize)
    {
        this.animals = new List<Animal>();
        this.maxSize = maxSize;
    }

    public void AddAnimal(Animal animal)
    {
        this.animals.Add(animal);
    }

    public List<Animal> GetAnimals()
    {
        return this.animals;
    }
}

    public class Train
{
    private List<Wagon> wagons;

    public Train()
    {
        this.wagons = new List<Wagon>();
    }

    public void AddWagon(Wagon wagon)
    {
        this.wagons.Add(wagon);
    }

    public List<Wagon> GetWagons()
    {
        return this.wagons;
    }
}

公共类动物
{
私有字符串animalName；
私人动物食品；
私人动物化动物化；
公共动物（字符串animalName、AnimalFood AnimalFood、AnimalSize AnimalSize）
{
this.animalName=animalName；
this.animalFood=动物食品；
this.animalSize=animalSize；
}
公共动物（）
{
}
public List animals fromcus=new DataGenerator（）。GenerateAnimals（100）；
公共列表GetallAnimals（）
{
将动物从圈中返回；
}
公共列表GetAllBigMeatEaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Big&&animal.getAnimalFood（）==AnimalFood.Meat.ToList（）返回动物；
}
公共列表获取所有大型肉食者（列出来自Circus的动物）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Big&&animal.getAnimalFood（）==AnimalFood.Meat.ToList（）返回动物；
}
公共列表GetAllSmallMeatEaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Small&&animal.getAnimalFood（）==AnimalFood.Meat.ToList（）返回动物；
}
公共列表GetAllBigPlantEaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Big&&animal.getAnimalFood（）==AnimalFood.Plants.ToList（）返回动物；
}
公共列表getAllMediumMetaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Medium&&animal.getAnimalFood（）==AnimalFood.Meat.ToList（）返回动物；
}
公共列表GetAllMediumpanaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Medium&&animal.getAnimalFood（）==AnimalFood.Plants.ToList（）返回动物；
}
公共列表GetAllSmallPlantEaters（）
{
从circus.Where（animal=>animal.getAnimalSize（）==AnimalSize.Small&&animal.getAnimalFood（）==AnimalFood.Plants.ToList（）返回动物；
}
公共字符串getAnimalName（）
{
返回this.animalName；
}
公共动物食品
{
把这个还给我。动物食品
public List<Animal> animalsFromTheCircus = new DataGenerator().GenerateAnimals(100);