WPF

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;


public class MyCanvas : Canvas
{
    public static DependencyProperty ItemsSourceProperty =
        DependencyProperty.Register("ItemsSource",
        typeof(IEnumerable), typeof(MyCanvas),

        new FrameworkPropertyMetadata((IEnumerable)null,
            new PropertyChangedCallback(OnItemsSourcePropertyChanged)));

    private static Dictionary<INotifyCollectionChanged, MyCanvas> references = new Dictionary<INotifyCollectionChanged, MyCanvas>();

    public IEnumerable ItemsSource
    {
        get
        {
            return (IEnumerable)this.GetValue(ItemsSourceProperty);
        }
        set
        {
            this.SetValue(ItemsSourceProperty, value);
        }
    }

    private static void OnItemsSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var canvas = d as MyCanvas;
        repopulateChildren(canvas);


        if (canvas.ItemsSource is CompositeCollection)
        {
            CompositeCollection CollectionHolder = ((CompositeCollection)canvas.ItemsSource);

                foreach (CollectionContainer item in CollectionHolder)
            {

                ObservableCollection<UIElement> elements = (ObservableCollection<UIElement>)item.Collection;
                references.Add((elements as INotifyCollectionChanged), canvas);
                elements.CollectionChanged -= collectionChangedHandler;
                elements.CollectionChanged += collectionChangedHandler;
            }

        }
        else if (canvas.ItemsSource is IEnumerable<UIElement>)
        {
            var be = BindingOperations.GetBindingExpression(canvas, MyCanvas.ItemsSourceProperty);

            if (be != null)
            {
                var elements = (be.ResolvedSourcePropertyName == null ? be.ResolvedSource :
                    be.ResolvedSource.GetType().GetProperty(be.ResolvedSourcePropertyName).GetValue(be.ResolvedSource)) as INotifyCollectionChanged;

                if (elements != null)
                {
                    var cv = references.FirstOrDefault(i => i.Value == canvas);
                    if (!cv.Equals(default(KeyValuePair<INotifyCollectionChanged, MyCanvas>)))
                        references.Remove(cv.Key);


                    references[elements] = canvas;
                    elements.CollectionChanged -= collectionChangedHandler;
                    elements.CollectionChanged += collectionChangedHandler;
                }
            }
            else references.Clear();

        }

    }

    private static void collectionChangedHandler(object sender, NotifyCollectionChangedEventArgs e)
    {
        
        MyCanvas cv;

        if (references.TryGetValue(sender as INotifyCollectionChanged, out cv))
        {

            switch (e.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (var item in e.NewItems) cv.Children.Add(item as UIElement);
                break;
            case NotifyCollectionChangedAction.Remove:
                {
                    foreach (var item in e.OldItems)
                    {
                        cv.Children.Remove(item as UIElement);
                    }

                    break;
                }

            case NotifyCollectionChangedAction.Reset:
                repopulateChildren(cv);
                break;
        }
        }
    }


    public static DependencyProperty PerservedChildrenProperty = DependencyProperty.Register("PerservedChildren", typeof(int), typeof(MyCanvas), new PropertyMetadata(0));

    public int PerservedChildren
    {
        get
        {
            return (int)this.GetValue(PerservedChildrenProperty);
        }
        set
        {
            this.SetValue(PerservedChildrenProperty, value);
        }
    }

    private static void repopulateChildren(MyCanvas cv)
    {


        for (int i = cv.Children.Count - 1; i >= cv.PerservedChildren; i--)
        {
            cv.Children.RemoveAt(i);
        }

        var elements = (IEnumerable)cv.GetValue(ItemsSourceProperty );

        if (elements is CompositeCollection)
        {
            CompositeCollection CollectionHost = ((CompositeCollection)elements);
            foreach (CollectionContainer item in CollectionHost)
            {

                foreach (UIElement pp in item.Collection)
                {
                    if (!(cv.Children.Contains(pp)))
                        cv.Children.Add(pp);
                }
            }
        }
        else if (elements is IEnumerable<UIElement>)
        {
            foreach (UIElement elem in elements)
            {
                cv.Children.Add(elem);
            }
        }

    }

}

//Part 1 -- its not Getting updated 
           Status.Background = new SolidColorBrush(Colors.Orange);
            Status.Content = "Exporting, please wait...";

       //Part 2 is working
           Logger.ExportLogToExcel(); 

      //Part 3 is Working 

            Status.Background = new SolidColorBrush(Colors.Yellow);
            Status.Content = "Exported to Excel Successfully";

1. How do you unit test a piece of UI becoming visible/invisible? The bound bool may be correct, but the converter could fail.
2. How do you unit test data validations?

<Window.Resources>
        <sys:String x:Key="icon1">icon1.png</sys:String>
        <sys:String x:Key="icon2">icon2.png</sys:String>
        <sys:String x:Key="icon3">icon3.png</sys:String>
</Window.Resources>
...
<ListView x:Name="listView1" >
            <ListView.ItemTemplate>
                <DataTemplate>
                    <Image Source="{Binding}" Stretch="None" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>