public void ShouldAddMappingSetForGivenType()
 {
     var filler = new Filler();
     filler.Configure<Foo>();
     Assert.That(filler.MappingSets.Count(), Is.EqualTo(1));
     Assert.That(filler.MappingSets.First().Type, Is.EqualTo(typeof(Foo)));
 }

		public void Must_support_enums_out_of_the_box()
		{
			var filler = new Filler<MyClass>();
			filler.Setup()
				.OnProperty(x => x.Manual).Use(() => ManualSetupEnum.B)
				.OnProperty(x => x.Ignored).IgnoreIt();

			for (int n = 0; n < 1000; n++)
			{
				var c = filler.Create();

				Assert.IsTrue(
					c.Standard == StandardEnum.A || 
					c.Standard == StandardEnum.B || 
					c.Standard == StandardEnum.C);

				Assert.IsTrue(
					c.Numbered == NumberedEnum.A ||
					c.Numbered == NumberedEnum.B ||
					c.Numbered == NumberedEnum.C);

				Assert.IsTrue(
					c.Flags == FlagsEnum.A ||
					c.Flags == FlagsEnum.B ||
					c.Flags == FlagsEnum.C);

				Assert.IsTrue((int)c.Nasty == 0);

				Assert.IsTrue(c.Manual == ManualSetupEnum.B);

				Assert.IsTrue((int)c.Ignored == 0);
			}
		}

	public static void Main ()
	{
		var r = new Random ();
		var objs = new object [9];
		var which = 0;
		var last = new Filler [Bitmaps.NumWhich];
		for (var i = 0; i < 1000000000; ++i)
		{
			var o = Bitmaps.MakeAndFill (which, objs, r.Next (2) == 0);
			objs [r.Next (objs.Length)] = o;
			last [which] = o;

			if (i % 761 == 0)
			{
				var l = last [r.Next (Bitmaps.NumWhich)];
				if (l != null)
					l.Fill (objs);
			}

			/*
			  if (i % 10007 == 0)
			  Console.WriteLine (o.GetType ().Name + " " + which);
			*/

			if (i % 5 == 0)
				objs [r.Next (objs.Length)] = null;

			if (++which >= Bitmaps.NumWhich)
				which = 0;
		}
	}

        public void WhenClassWithCopyConstructorIsCreatedNoExceptionShallBeThrown()
        {
            var f = new Filler<ClassWithCopyConstructorAndNormalConstructor>();
            var cc = f.Create();

            Assert.NotNull(cc);
        }

        public void DependencyOrderingWorksWithSubclassesAsWellAsPrimitives()
        {
            var rootObject = new Foo();
            var filler = new Filler();

            var generator = MockRepository.GenerateStub<IGenerateDummyData>();
            generator.Stub(g => g.Generate(Arg<GenerationContext>.Is.Anything)).Return("Chris");

            var dependentGenerator = MockRepository.GenerateStub<IGenerateDummyData>();
            dependentGenerator.Stub(g => g.Generate(Arg<GenerationContext>.Is.Anything))
                .Do(new GeneratorDelegate(context => string.Format("Hello {0}", context.RootAs<Foo>().Bar.Name)));

            filler.Configure<Goo>(config => config.For(goo => goo.Name).Use(dependentGenerator));
            filler.Configure<Bar>(config => config.For(goo => goo.Name).Use(generator));

            filler.Configure<Foo>(config =>
            {
                config.For(f => f.Goo).Order(2);
                config.For(f => f.Bar).Order(1);
            });

            filler.Fill(rootObject);

            Assert.That(rootObject.Goo.Name, Is.EqualTo("Hello Chris"));
        }

        public void CreateMultipleInstances()
        {
            Filler<LibraryFillingTest.Person> filler = new Filler<LibraryFillingTest.Person>();
            IEnumerable<LibraryFillingTest.Person> pList = filler.Create(10);

            Assert.NotNull(pList);
            Assert.Equal(10, pList.Count());
        }

        public void Ensure_that_double_does_not_return_infinity()
        {
            var filler = new Filler<MyClass>();
            var myClass = filler.Create();
            Assert.False(double.IsInfinity(myClass._double));

            Assert.False(float.IsInfinity(myClass._float));
        }

        public void RecursiveFill_WithIgnoredProperties_Succeeds()
        {
            var filler = new Filler<TestParent>();
            filler.Setup().OnProperty(p => p.Child).IgnoreIt();
            var result = filler.Create();

            Assert.NotNull(result);
        }

        public void RecursiveFill_WithFunc_Succeeds()
        {
            var filler = new Filler<TestParent>();
            filler.Setup().OnProperty(p => p.Child).Use(() => new TestChild());
            var result = filler.Create();

            Assert.NotNull(result.Child);
        }

        public void ParentShallGetFilledWithourError()
        {
            Filler<Parent> filler = new Filler<Parent>();

            var filledObject = filler.Create();
            Assert.NotNull(filledObject);
            Assert.NotNull(filledObject.MakeTheError);
            Assert.False(string.IsNullOrWhiteSpace(filledObject.Child.MakeTheError));
        }

 public void Clone()
 {
     var pFiller = new Filler<Identity>();
     var test = pFiller.Create();
     var clone = test.Clone();
     var compareLogic = new CompareLogic();
     var result = compareLogic.Compare(test, clone);
     Assert.True(result.AreEqual, result.DifferencesString);
 }

        public void IfIgnoreInheritanceIsSetToTrueTheNameOfTheStudentShouldBeNull()
        {
            Filler<Student> filler = new Filler<Student>();
            filler.Setup().IgnoreInheritance();
            var student = filler.Create();

            Assert.Null(student.FirstName);
            Assert.NotNull(student.Class);
        }

        public void Must_be_able_to_handle_inheritance_and_sealed()
        {
            var filler = new Filler<InheritedClass>();
            var obj = filler.Create();

            Assert.NotEqual(0, obj.NormalNumber);
            Assert.NotEqual(0, obj.OverrideNormalNumber);
            Assert.NotEqual(0, obj.SealedOverrideNormalNumber);
        }

        public void AHashsetShouldBeGenerated()
        {
            Filler<HashSet<string>> filler = new Filler<HashSet<string>>();

            var hashset = filler.Create();

            Assert.NotNull(hashset);
            Assert.True(hashset.Any());
        }

        public void TestFillLibraryWithPocoOfABook()
        {
            Filler<LibraryConstructorPoco> lib = new Filler<LibraryConstructorPoco>();
            lib.Setup()
                .OnProperty(x => x.Books).IgnoreIt();

            LibraryConstructorPoco filledLib = lib.Create();
            Assert.IsNotNull(filledLib.Books);
            Assert.AreEqual(1, filledLib.Books.Count);
        }

        public void FillNullableEnum()
        {
            var filler = new Filler<ClassWithNullableEnum>();

            var c = filler.Create();
            Assert.IsTrue(
                c.NullableEnum == StandardEnum.A ||
                c.NullableEnum == StandardEnum.B ||
                c.NullableEnum == StandardEnum.C);
        }

        public void Test_With_Many_MinWords_And_Many_MinSentences()
        {
            Filler<Book> book = new Filler<Book>();
            book.Setup()
                .OnProperty(x => x.ISBN).Use(new Lipsum(LipsumFlavor.InDerFremde, 3, 9, minWords: 51));

            var b = book.Create();

            Assert.IsNotNull(b);
        }

        public void Test_With_German_Default_Settings()
        {
            Filler<Book> book = new Filler<Book>();
            book.Setup()
                .OnProperty(x => x.ISBN).Use(new Lipsum(LipsumFlavor.InDerFremde));

            var b = book.Create();

            Assert.IsNotNull(b);
        }

 public void Ensure_that_each_primitive_datatype_is_mapped_by_default()
 {
     var filler = new Filler<MyClass>();
     var myClasses = filler.Create(100).ToArray();
     foreach (var myClass in myClasses)
     {
         Assert.NotEqual(default(Guid), myClass._Guid);
         Assert.NotEqual(default(decimal), myClass._Decimal);
     }
 }

        public void TestFillLibraryWithDictionary()
        {
            Filler<LibraryConstructorDictionary> lib = new Filler<LibraryConstructorDictionary>();
            lib.Setup()
                .OnType<IBook>().CreateInstanceOf<Book>()
                .OnProperty(x => x.Books).IgnoreIt();

            LibraryConstructorDictionary filledLib = lib.Create();
            Assert.IsNotNull(filledLib.Books);
        }