public void ChangeTrackingModelBase_BasicFunctionalityTest()
        {
            using (var verify = new Verify())
            {
                var person = new ChangeTrackingPerson();
                var eventAssert = new PropertyChangedEventTest(verify, person);

                Assert.IsNull(person.FirstName);
                Assert.AreEqual("", person.LastName);

                eventAssert.ExpectNothing();

                person.FirstName = "John";

                eventAssert.ExpectEvent("FirstName");
                eventAssert.ExpectEvent("FullName");
                eventAssert.ExpectEvent("IsChangedLocal");
                eventAssert.ExpectEvent("IsChanged");

                person.LastName = "Doe";

                eventAssert.ExpectEvent("LastName");
                eventAssert.ExpectEvent("FullName");

                person.InvokeGoodPropertyMessage();
                eventAssert.ExpectEvent("FullName");

                person.InvokeAllPropertyMessage();
                eventAssert.ExpectEvent("");

            }
        }

 public void CalculatedFieldAttribute_Test3()
 {
     using (var verify = new Verify())
     {
         verify.ArgumentException("sources", () => new CalculatedFieldAttribute(null), "empty lists are not allowed");
     }
 }

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

                //changes to a child in a collection
                var eventAssertOrder0 = new PropertyChangedEventTest(verify, customer.Orders[0]);
                var newOrderDate = new DateTime(2010, 5, 5);
                customer.Orders[0].OrderDate = newOrderDate;

                eventAssertOrder0.ExpectEvent("OrderDate");
                eventAssertOrder0.ExpectEvent("IsChangedLocal");
                eventAssertOrder0.ExpectEvent("IsChanged");
                eventAssertOrder0.ExpectNothing();

                //eventAssertCustomer.ExpectEvent("IsChanged");
                //eventAssertCustomer.ExpectNothing();

                //rollback
                customer.RejectChanges();
                verify.AreEqual(OrderDate1, customer.Orders[0].OrderDate, "Order date didn't roll back");

                verify.IsFalse(customer.IsChanged, "");
                eventAssertCustomer.ExpectEvent("IsChanged");

            }
        }

 public void ExtendedObservableCollection_AddRemoveOverrideTest()
 {
     using (var verify = new Verify())
     {
         var result = new FooCollection(new[] { new Foo(), new Foo(), new Foo() });
         verify.AreEqual(3, result.AddCount, "count was incorrect");
     }
 }

        public void CalculatedFieldAttribute_Test2()
        {
            using (var verify = new Verify())
            {
                verify.ArgumentException("sources", () => new CalculatedFieldAttribute(null));

            }
        }

 public void WeakReferenceCollection_Add()
 {
     using (var verify = new Verify())
     {
         var result = new WeakReferenceCollection<string>();
         verify.ArgumentNullException("item", () => result.Add(null));
     }
 }

 public void ItemEventArgs_ItemTest()
 {
     using (var verify = new Verify())
     {
         var x = new ItemEventArgs<string>("xxx");
         verify.AreEqual("xxx", x.Item, "Item property was not set correctly");
     }
 }

 public void WeakReferenceCollection_AddRange_Test1()
 {
     using (var verify = new Verify())
     {
         IList<string> list = null;
         var result = new WeakReferenceCollection<string>();
         verify.ArgumentNullException("list", () => result.AddRange(list));
     }
 }

 public void CollectionUtilities_AddRange_Test2()
 {
     using (var verify = new Verify())
     {
         List<string> target = null;
         List<string> list = null;
         verify.ArgumentNullException("target", () => CollectionUtilities.AddRange(target, list));
     }
 }

 public void CollectionUtilities_AddRange_Test10()
 {
     using (var verify = new Verify())
     {
         IEnumerable<int> list = new List<int> { 1, 2, 3 };
         ICollection<int> target = new ReadOnlyCollection<int>(new List<int>());
         verify.ArgumentException("target", () => CollectionUtilities.AddRange(target, list), "read-only list");
         verify.ArgumentException("target", () => CollectionUtilities.AddRange(target, 1, 2, 3), "read-only list");
     }
 }

 public void CollectionUtilities_AddRange_Test11()
 {
     using (var verify = new Verify())
     {
         var list = (new List<int> { 1, 2, 3 }).Where(x => true);
         ICollection<int> target = new ReadOnlyCollection<int>(new List<int>());
         verify.ArgumentException("target", () => CollectionUtilities.AddRange(target, list), "read-only list");
         verify.ArgumentException("target", () => CollectionUtilities.AddRange(target, 1, 2, 3), "read-only list");
     }
 }

 public void ExtendedObservableCollection_RemoveNullHandlerTest()
 {
     using (var verify = new Verify())
     {
         var list = new ObservableCollectionExtended<int>();
         var result = new ReadOnlyObservableCollectionExtended<int>(list);
         verify.ArgumentNullException("eventHandler", () => result.RemoveHandler((IListener<NotifyCollectionChangedEventArgs>)null));
         verify.ArgumentNullException("eventHandler", () => result.RemoveHandler((IListener<PropertyChangedEventArgs>)null));
     }
 }

 public void PropertyMetadataCollection_CopyTo_Test3()
 {
     using (var verify = new Verify())
     {
         var result = MetadataCache.GetMetadata(typeof(Tests.Metadata.Mock)).Properties;
         var array = new PropertyMetadata[result.Count];
         result.CopyTo(array, 0);
         foreach (var p in result)
             CollectionAssert.Contains(array, p);
     }
 }

        public void ExtendedObservableCollection_AddNullHandlerTest()
        {
            using (var verify = new Verify())
            {
                var result = new FooCollection();

                verify.ArgumentNullException("eventHandler", () => result.AddHandler((IListener<NotifyCollectionChangedEventArgs>)null));
                verify.ArgumentNullException("eventHandler", () => result.AddHandler((IListener<PropertyChangedEventArgs>)null));
                verify.ArgumentNullException("eventHandler", () => result.AddHandler((IListener<RelayedEventArgs<PropertyChangedEventArgs>>)null));
            }
        }

 public void ValidationResultCollection_Test1()
 {
     using (var verify = new Verify())
     {
         var collection = new ValidationResultCollection();
         var result = collection.Add("Test", "FirstName", "LastName");
         verify.AreEqual("Test", result.ErrorMessage, "Error message");
         verify.AreEqual("FirstName", result.MemberNames.ToList()[0], "member 0");
         verify.AreEqual("LastName", result.MemberNames.ToList()[1], "member 1");
     }
 }

        public void CalculatedFieldAttribute_Test1()
        {
            using (var verify = new Verify())
            {
                string fields = "AAA, BBB,CCC";
                var result = new CalculatedFieldAttribute(fields);
                verify.AreEqual(fields, result.Sources, "the field list shouldn't be altered in any way");
                verify.ItemsAreEqual(new[] { "AAA", "BBB", "CCC" }, result.SourceProperties, "");

            }
        }

        public static Page Fetch(Service service)
        {
            if (!Platform.HasInternetConnection())
            {
                return new ContentPage
                {
                    Content = new Label
                        {
                            Text = Localize.GetString("TelegramPleaseConnectToInternet"),
                            VerticalOptions = LayoutOptions.CenterAndExpand,
                            HorizontalOptions = LayoutOptions.CenterAndExpand,
                            XAlign = TextAlignment.Center,
                            Font = Font.SystemFontOfSize(18),
                        },
                    Title = Localize.GetString("TelegramSetupWizardTitle"),
                    Padding = 30,
                };
            }

            LoadSettingsIfNeeded();

            if (_cachedPage != null)
            {
                return _cachedPage;
            }

            var tabs = new TabbedPage();

            var code = new Code(service, tabs);
            var verify = new Verify(service, tabs, code);
            var info = new Info(service, tabs, verify);

            tabs.Children.Add(info);
            tabs.PropertyChanged += (sender, e) =>
                {
                    if (e.PropertyName == "CurrentPage")
                    {
                        var selected = tabs.CurrentPage;
                        if (selected is Info)
                        {
                            tabs.Children.Remove(verify);
                            tabs.Children.Remove(code);
                        }
                        if (selected is Verify)
                        {
                            tabs.Children.Remove(code);
                        }
                    }
                };

            tabs.Title = Localize.GetString("TelegramSetupWizardTitle");
            _cachedPage = tabs;
            return tabs;
        }

        public void ExtendedObservableCollection_AddRange_Test1()
        {
            using (var verify = new Verify())
            {
                var weakNotifier = new WeakNotifier();
                var notifier = new Notifier();
                var temp = new[] { notifier, weakNotifier };

                var result = new ObservableCollectionExtended<object>();
                result.AddRange(temp);
                ConstructorAssertions(verify, result, weakNotifier, notifier);
            }
        }

        public void CollectionUtilities_AddRange_Test3()
        {
            using (var verify = new Verify())
            {
                List<string> target = new List<string>();
                List<string> list = new List<string>();
                target.Add("AAA");
                list.Add("BBB");
                list.Add("CCC");

                CollectionUtilities.AddRange(target, list);
                verify.ItemsAreEqual(new[] { "AAA", "BBB", "CCC" }, target, "AddRange should have added 3 items");
            }
        }

        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");
            }
        }