Improve unit test code coverage further

Stylet/LabelledValue.cs

@@ -32,6 +32,10 @@ namespace Stylet
             set { SetAndNotify(ref this._value, value); }
         }
 
+        public LabelledValue()
+        {
+        }
+
         public LabelledValue(string label, T value)
         {
             this._label = label;

Stylet/LambdaComparer.cs

@@ -20,6 +20,8 @@ namespace Stylet
         /// <param name="comparer">Comparer, which takes two {T} instances and returns true if they are equal</param>
         public LambdaComparer(Func<T, T, bool> comparer)
         {
+            if (comparer == null)
+                throw new ArgumentNullException("comparer");
             this.comparer = comparer;
         }
 

Stylet/Screen.cs

@@ -25,7 +25,7 @@ namespace Stylet
         /// <summary>
         /// WeakEventManager owned by this screen (lazy)
         /// </summary>
-        protected IWeakEventManager weakEventManager
+        protected virtual IWeakEventManager weakEventManager
         {
             get
             {
@@ -43,7 +43,7 @@ namespace Stylet
         /// <param name="selector">Expression for selecting the property to observe, e.g. x => x.PropertyName</param>
         /// <param name="handler">Handler to be called when that property changes</param>
         /// <returns>A resource which can be used to undo the binding</returns>
-        protected IEventBinding BindWeak<TSource, TProperty>(TSource source, Expression<Func<TSource, TProperty>> selector, Action<TProperty> handler)
+        protected virtual IEventBinding BindWeak<TSource, TProperty>(TSource source, Expression<Func<TSource, TProperty>> selector, Action<TProperty> handler)
             where TSource : class, INotifyPropertyChanged
         {
             return this.weakEventManager.BindWeak(source, selector, handler);

Stylet/ValidatingModelBase.cs

@@ -28,7 +28,7 @@ namespace Stylet
         /// <summary>
         /// IValidationAdapter to use to validate properties. You're expected to write your own, using your favourite validation library
         /// </summary>
-        protected IValidatorAdapter validator
+        protected virtual IValidatorAdapter validator
         {
             get { return this._validator; }
             set

StyletUnitTests/LabelledValueTests.cs

@@ -0,0 +1,103 @@
+using NUnit.Framework;
+using Stylet;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StyletUnitTests
+{
+    [TestFixture]
+    public class LabelledValueTests
+    {
+        [Test]
+        public void StoresLabelAndValue()
+        {
+            var lbv = new LabelledValue<int>("an int", 5);
+            Assert.AreEqual("an int", lbv.Label);
+            Assert.AreEqual(5, lbv.Value);
+        }
+
+        [Test]
+        public void SettingLabelAndValueRaisePropertyChangedNotifications()
+        {
+            var lbv = new LabelledValue<float>();
+
+            lbv.PropertyChangedDispatcher = a => a();
+            var changedProperties = new List<string>();
+            lbv.PropertyChanged += (o, e) => changedProperties.Add(e.PropertyName);
+
+            lbv.Label = "hello";
+            lbv.Value = 2.2f;
+
+            Assert.That(changedProperties, Is.EquivalentTo(new[] { "Label", "Value" }));
+        }
+
+        [Test]
+        public void EqualsIdenticalLabelledValues()
+        {
+            var lbv1 = new LabelledValue<int>("int", 5);
+            var lbv2 = new LabelledValue<int>("int", 5);
+
+            // Test both variants
+            Assert.That(lbv1.Equals(lbv2));
+            Assert.That(lbv1.Equals((object)lbv2));
+        }
+
+        [Test]
+        public void NotEqualLabeledValuesOfDifferentTypes()
+        {
+            var lbv1 = new LabelledValue<int>("test", 5);
+            var lbv2 = new LabelledValue<double>("test", 5.0);
+
+            Assert.False(lbv1.Equals(lbv2));
+        }
+
+        [Test]
+        public void NotEqualNull()
+        {
+            var lbv = new LabelledValue<int>("test", 5);
+            Assert.False(lbv.Equals(null));
+        }
+
+        [Test]
+        public void NotEqualDifferentLabel()
+        {
+            var lbv1 = new LabelledValue<int>("test", 5);
+            var lbv2 = new LabelledValue<int>("testy", 5);
+            Assert.IsFalse(lbv1.Equals(lbv2));
+        }
+
+        [Test]
+        public void NotEqualDifferentValues()
+        {
+            var lbv1 = new LabelledValue<int>("test", 5);
+            var lbv2 = new LabelledValue<int>("test", 6);
+            Assert.IsFalse(lbv1.Equals(lbv2));
+        }
+
+        [Test]
+        public void GetHashCodeSameForIdenticalLabelledValues()
+        {
+            var lbv1 = new LabelledValue<int>("int", 5);
+            var lbv2 = new LabelledValue<int>("int", 5);
+
+            Assert.AreEqual(lbv1.GetHashCode(), lbv2.GetHashCode());
+        }
+
+        [Test]
+        public void ToStringReturnsLabel()
+        {
+            var lbv = new LabelledValue<int>("label", 3);
+            Assert.AreEqual("label", lbv.ToString());
+        }
+
+        [Test]
+        public void CreateCreatesLabelledValue()
+        {
+            var lbv = LabelledValue.Create("test", 2.2f);
+            Assert.AreEqual(new LabelledValue<float>("test", 2.2f), lbv);
+        }
+    }
+}

StyletUnitTests/LambdaComparerTests.cs

@@ -0,0 +1,46 @@
+using NUnit.Framework;
+using Stylet;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StyletUnitTests
+{
+    [TestFixture]
+    public class LambdaComparerTests
+    {
+        [Test]
+        public void CallsLambdaToCompareObjects()
+        {
+            int a = 0;
+            int b = 0;
+            var c = new LambdaComparer<int>((x, y) =>
+            {
+                a = x;
+                b = y;
+                return false;
+            });
+
+            var result = c.Equals(3, 4);
+
+            Assert.AreEqual(3, a);
+            Assert.AreEqual(4, b);
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void ThrowsIfNullLambdaPassed()
+        {
+            Assert.Throws<ArgumentNullException>(() => new LambdaComparer<int>(null));
+        }
+
+        [Test]
+        public void ReturnsHashCodeOfPassedObject()
+        {
+            var c = new LambdaComparer<int>((a, b) => false);
+            Assert.AreEqual(5.GetHashCode(), c.GetHashCode(5));
+        }
+    }
+}

StyletUnitTests/ScreenTests.cs

@@ -3,7 +3,9 @@ using NUnit.Framework;
 using Stylet;
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows;
@@ -15,6 +17,20 @@ namespace StyletUnitTests
     {
         private class MyScreen : Screen
         {
+            public IValidatorAdapter Validator
+            {
+                get { return base.validator; }
+                set { base.validator = value; }
+            }
+
+            public IWeakEventManager WeakEventManager
+            {
+                get { return base.weakEventManager; }
+            }
+
+            public MyScreen() { }
+            public MyScreen(IValidatorAdapter validator) : base(validator) { }
+
             public bool OnActivateCalled;
             protected override void OnActivate()
             {
@@ -46,6 +62,21 @@ namespace StyletUnitTests
             }
         }
 
+        private class WeakEventScreen : Screen
+        {
+            public IWeakEventManager WeakEventManager;
+            protected override IWeakEventManager weakEventManager
+            {
+                get { return this.WeakEventManager; }
+            }
+
+            public new IEventBinding BindWeak<TSource, TProperty>(TSource source, Expression<Func<TSource, TProperty>> selector, Action<TProperty> handler)
+                where TSource : class, INotifyPropertyChanged
+            {
+                return base.BindWeak(source, selector, handler);
+            }
+        }
+
         private MyScreen screen;
 
         [TestFixtureSetUp]
@@ -240,5 +271,36 @@ namespace StyletUnitTests
             this.screen.TryClose(true);
             parent.Verify(x => x.CloseItem(this.screen, true));
         }
+
+        [Test]
+        public void PassesValidatorAdapter()
+        {
+            var adapter = new Mock<IValidatorAdapter>();
+            var screen = new MyScreen(adapter.Object);
+            Assert.AreEqual(adapter.Object, screen.Validator);
+        }
+
+        [Test]
+        public void WeakEventManagerReturnsConsistentObject()
+        {
+            var w1 = screen.WeakEventManager;
+            var w2 = screen.WeakEventManager;
+            Assert.AreEqual(w1, w2);
+        }
+
+        [Test]
+        public void BindWeakProxies()
+        {
+            var s = new WeakEventScreen();
+            var m = new Mock<IWeakEventManager>();
+            s.WeakEventManager = m.Object;
+
+            var source = new LabelledValue<int>("test", 5);
+            Expression<Func<LabelledValue<int>, int>> selector = x => x.Value;
+            Action<int> handler = x => { };
+            s.BindWeak(source, selector, handler);
+
+            m.Verify(x => x.BindWeak(source, selector, handler));
+        }
     }
 }

StyletUnitTests/StyletUnitTests.csproj

@@ -62,6 +62,8 @@
     <Compile Include="ExecuteTests.cs" />
     <Compile Include="ExpressionExtensionsTests.cs" />
     <Compile Include="IoCTests.cs" />
+    <Compile Include="LabelledValueTests.cs" />
+    <Compile Include="LambdaComparerTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PropertyChangedBaseTests.cs" />
     <Compile Include="PropertyChangedExtensionsTests.cs" />