C# Verify.IsTrue方法代码示例

        public void ChildPropertyChangesWithCommit()
        {
            using (var verify = new Verify())
            {
                var customer = CreateCustomer(verify);

                //more setup
                customer.FirstName = "Tom";
                customer.LastName = "Doe";
                customer.AcceptChanges();
                if (customer.IsChanged)
                    verify.Inconclusive("setup failed");

                var eventAssertCustomer = new PropertyChangedEventTest(verify, customer);

                customer.PropertyChanged += (s, e) => Debug.WriteLine(e.PropertyName);

                //local changes
                customer.FirstName = "Bob";
                eventAssertCustomer.ExpectEvent("FirstName");
                eventAssertCustomer.ExpectEvent("FullName");
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.IsTrue(customer.IsChanged, "");
                verify.IsTrue(customer.IsChangedLocal, "");
                verify.AreEqual(1, customer.ChangedProperties().Count, "There should be one changed property");
                verify.AreEqual("FirstName", customer.ChangedProperties()[0], "The property should be FirstName");

                //this time IsChanged shouldn't be raised again
                customer.LastName = "Jones";
                eventAssertCustomer.ExpectEvent("LastName");
                eventAssertCustomer.ExpectEvent("FullName");
                eventAssertCustomer.ExpectNothing();
                verify.IsTrue(customer.IsChanged, "");
                verify.IsTrue(customer.IsChangedLocal, "");

                //accept changes
                customer.AcceptChanges();
                verify.IsFalse(customer.IsChanged, "");
                verify.IsFalse(customer.IsChangedLocal, "");
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.AreEqual("Bob", customer.FirstName, "");
                verify.AreEqual("Jones", customer.LastName, "");
                verify.AreEqual(0, customer.ChangedProperties().Count, "There shouldn't be any changed properties");
            }
        }

        public void MetadataCache_Test4()
        {
            using (var verify = new Verify())
            {
                var result = MetadataCache.GetMetadata(typeof(Mock));

                var source1 = result.Properties["CalculatedSource1"];
                var target = result.Properties["CalculatedTarget"];

                verify.IsTrue(source1.AffectsCalculatedFields, "AffectsCalculatedFields");
                CollectionAssert.Contains(source1.CalculatedFields, target);
            }
        }

 public void MetadataCache_Test26()
 {
     using (var verify = new Verify())
     {
         var result = MetadataCache.GetMetadata(typeof(Mock));
         PropertyMetadata p;
         verify.IsTrue(result.Properties.TryGetValue("PublicProperty", out p), "TryGet should have succeeded");
         verify.IsNotNull(p, "TryGet should have succeeded");
     }
 }

 public void MetadataCache_Test23()
 {
     using (var verify = new Verify())
     {
         var result = (ICollection<PropertyMetadata>)MetadataCache.GetMetadata(typeof(Mock)).Properties;
         verify.IsTrue(result.IsReadOnly, "Collection should be read only");
     }
 }

        public void MetadataCache_SetOnlyProperty_Test()
        {
            using (var verify = new Verify())
            {
                var result = MetadataCache.GetMetadata(typeof(Mock));
                verify.IsNotNull(result, "GetMetadata returned a null");

                var setOnlyProperty = result.Properties["SetOnlyProperty"];
                verify.IsNotNull(setOnlyProperty, "property wasn't found");
                verify.IsFalse(setOnlyProperty.AffectsCalculatedFields, "not used in calculated fields");
                verify.AreEqual(0, setOnlyProperty.CalculatedFields.Length, "not used in calculated fields");
                verify.IsFalse(setOnlyProperty.CanRead, "CanRead");
                verify.IsTrue(setOnlyProperty.CanWrite, "CanWrite");
                verify.AreEqual("SetOnlyProperty", setOnlyProperty.Name, "Name");
                verify.AreEqual("SetOnlyProperty", setOnlyProperty.PropertyChangedEventArgs.PropertyName, "PropertyName");
                verify.AreEqual(typeof(int), setOnlyProperty.PropertyType, "PropertyType");

                verify.AreEqual(0, setOnlyProperty.Validators.Length, "not used in validation");
            }
        }

        public void MetadataCache_PublicProperty_Test()
        {
            using (var verify = new Verify())
            {
                var result = MetadataCache.GetMetadata(typeof(Mock));
                verify.IsNotNull(result, "GetMetadata returned a null");

                var publicProperty = result.Properties["PublicProperty"];
                verify.IsNotNull(publicProperty, "property wasn't found");
                verify.IsFalse(publicProperty.AffectsCalculatedFields, "not used in calculated fields");
                verify.AreEqual(0, publicProperty.CalculatedFields.Length, "not used in calculated fields");
                verify.IsTrue(publicProperty.CanRead, "CanRead");
                verify.IsTrue(publicProperty.CanWrite, "CanWrite");
                verify.AreEqual("PublicProperty", publicProperty.Name, "Name");
                verify.AreEqual("PublicProperty", publicProperty.PropertyChangedEventArgs.PropertyName, "PropertyName");
                verify.AreEqual(typeof(int), publicProperty.PropertyType, "PropertyType");

                verify.AreEqual(0, publicProperty.Validators.Length, "not used in validation");

                verify.IsTrue(result.Constructors.HasDefaultConstructor, "this should have a automatically implemented default constructor");
            }
        }

        public void MetadataCache_DefaultConstructor_Test()
        {
            using (var verify = new Verify())
            {
                var a = MetadataCache.GetMetadata(typeof(AutoConstructor));
                verify.IsTrue(a.Constructors.HasDefaultConstructor, "AutoConstructor should have a automatically implemented default constructor");

                var b = MetadataCache.GetMetadata(typeof(DefaultConstructor));
                verify.IsTrue(b.Constructors.HasDefaultConstructor, "DefaultConstructor should have a automatically implemented default constructor");

                var c = MetadataCache.GetMetadata(typeof(DefaultConstructorPrivateClass));
                verify.IsTrue(c.Constructors.HasDefaultConstructor, "DefaultConstructorPrivateClass should have a automatically implemented default constructor");

                var d = MetadataCache.GetMetadata(typeof(PrivateDefaultConstructor));
                verify.IsFalse(d.Constructors.HasDefaultConstructor, "PrivateDefaultConstructor does not have a visible default constructor");

                var e = MetadataCache.GetMetadata(typeof(NonDefaultConstructor));
                verify.IsFalse(e.Constructors.HasDefaultConstructor, "NonDefaultConstructor does not have a default constructor");

                var f = MetadataCache.GetMetadata(typeof(StaticConstructor));
                verify.IsTrue(f.Constructors.HasDefaultConstructor, "NonDefaultConstructor does not have a default constructor");

            }
        }

        public void WeakReferenceCollection_Remove_Test1()
        {
            using (var verify = new Verify())
            {
                string item1 = "AAA";
                string item2 = "BBB";

                var list = new List<string>();
                list.Add(item1);
                list.Add(item2);

                var result = new WeakReferenceCollection<string>();
                result.AddRange(list);
                verify.ItemsAreEqual(new[] { "AAA", "BBB" }, result, "Two items should have been in the collection.");

                verify.IsTrue(result.Remove(item2), "item 1 should have been removable");

                verify.ItemsAreEqual(new[] { "AAA" }, result, "One item should have been left in the collection.");

                verify.IsTrue(result.Remove(item1), "item 2 should have been removable");

                verify.IsEmpty(result, "Removal failed");

                verify.IsFalse(result.Remove(item1), "item was already removed");

                verify.ArgumentNullException("item", () => result.Remove(null));

            }
        }

        public void LocalChangesWithCommit()
        {
            using (var verify = new Verify())
            {
                var customer = CreateCustomer(verify);
                var eventAssertCustomer = new PropertyChangedEventTest(verify, customer);

                //local changes
                customer.FirstName = "Tom";
                eventAssertCustomer.ExpectEvent("FirstName");
                eventAssertCustomer.ExpectEvent("FullName");
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.IsTrue(customer.IsChanged, "");
                verify.IsTrue(customer.IsChangedLocal, "");

                //accept changes
                customer.AcceptChanges();
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.IsFalse(customer.IsChanged, "");
                verify.IsFalse(customer.IsChangedLocal, "");

                //more local changes
                customer.FirstName = "Bob";
                eventAssertCustomer.ExpectEvent("FirstName");
                eventAssertCustomer.ExpectEvent("FullName");
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.IsTrue(customer.IsChanged, "");
                verify.IsTrue(customer.IsChangedLocal, "");

                //this time IsChanged shouldn't be raised again
                customer.LastName = "Jones";
                eventAssertCustomer.ExpectEvent("LastName");
                eventAssertCustomer.ExpectEvent("FullName");
                eventAssertCustomer.ExpectNothing();
                verify.IsTrue(customer.IsChanged, "");
                verify.IsTrue(customer.IsChangedLocal, "");

                //accept changes
                customer.AcceptChanges();
                verify.IsFalse(customer.IsChanged, "");
                verify.IsFalse(customer.IsChangedLocal, "");
                eventAssertCustomer.ExpectEvent("IsChangedLocal");
                eventAssertCustomer.ExpectEvent("IsChanged");
                eventAssertCustomer.ExpectNothing();
                verify.AreEqual("Bob", customer.FirstName, "");
                verify.AreEqual("Jones", customer.LastName, "");
            }
        }