From 5e3f604308e514e3392160e307602288d9f1e53a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 14 Jun 2017 01:51:11 +0200
Subject: [PATCH] Removed unnecessary service locator code.

`ILayoutManager` is not longer retrieved from `AvaloniaLocator` so can remove this stuff.
---
 .../LayoutManagerTests.cs                     | 314 ++++++++----------
 .../LayoutableTests.cs                        |  87 +++--
 2 files changed, 174 insertions(+), 227 deletions(-)

diff --git a/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs b/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
index 5f43a8d00e..3526b29cb5 100644
--- a/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
+++ b/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
@@ -15,285 +15,239 @@ namespace Avalonia.Layout.UnitTests
         public void Measures_And_Arranges_InvalidateMeasured_Control()
         {
             var target = new LayoutManager();
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot { Child = control };
 
-            using (Start(target))
-            {
-                var control = new LayoutTestControl();
-                var root = new LayoutTestRoot { Child = control };
-
-                target.ExecuteInitialLayoutPass(root);
-                control.Measured = control.Arranged = false;
+            target.ExecuteInitialLayoutPass(root);
+            control.Measured = control.Arranged = false;
 
-                control.InvalidateMeasure();
-                target.ExecuteLayoutPass();
+            control.InvalidateMeasure();
+            target.ExecuteLayoutPass();
 
-                Assert.True(control.Measured);
-                Assert.True(control.Arranged);
-            }
+            Assert.True(control.Measured);
+            Assert.True(control.Arranged);
         }
 
         [Fact]
         public void Arranges_InvalidateArranged_Control()
         {
             var target = new LayoutManager();
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot { Child = control };
 
-            using (Start(target))
-            {
-                var control = new LayoutTestControl();
-                var root = new LayoutTestRoot { Child = control };
-
-                target.ExecuteInitialLayoutPass(root);
-                control.Measured = control.Arranged = false;
+            target.ExecuteInitialLayoutPass(root);
+            control.Measured = control.Arranged = false;
 
-                control.InvalidateArrange();
-                target.ExecuteLayoutPass();
+            control.InvalidateArrange();
+            target.ExecuteLayoutPass();
 
-                Assert.False(control.Measured);
-                Assert.True(control.Arranged);
-            }
+            Assert.False(control.Measured);
+            Assert.True(control.Arranged);
         }
 
         [Fact]
         public void Measures_Parent_Of_Newly_Added_Control()
         {
             var target = new LayoutManager();
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot();
 
-            using (Start(target))
-            {
-                var control = new LayoutTestControl();
-                var root = new LayoutTestRoot();
-
-                target.ExecuteInitialLayoutPass(root);
-                root.Child = control;
-                root.Measured = root.Arranged = false;
+            target.ExecuteInitialLayoutPass(root);
+            root.Child = control;
+            root.Measured = root.Arranged = false;
 
-                target.ExecuteLayoutPass();
+            target.ExecuteLayoutPass();
 
-                Assert.True(root.Measured);
-                Assert.True(root.Arranged);
-                Assert.True(control.Measured);
-                Assert.True(control.Arranged);
-            }
+            Assert.True(root.Measured);
+            Assert.True(root.Arranged);
+            Assert.True(control.Measured);
+            Assert.True(control.Arranged);
         }
 
         [Fact]
         public void Measures_In_Correct_Order()
         {
             var target = new LayoutManager();
-
-            using (Start(target))
+            LayoutTestControl control1;
+            LayoutTestControl control2;
+            var root = new LayoutTestRoot
             {
-                LayoutTestControl control1;
-                LayoutTestControl control2;
-                var root = new LayoutTestRoot
+                Child = control1 = new LayoutTestControl
                 {
-                    Child = control1 = new LayoutTestControl
-                    {
-                        Child = control2 = new LayoutTestControl(),
-                    }
-                };
+                    Child = control2 = new LayoutTestControl(),
+                }
+            };
 
 
-                var order = new List<ILayoutable>();
-                Size MeasureOverride(ILayoutable control, Size size)
-                {
-                    order.Add(control);
-                    return new Size(10, 10);
-                }
+            var order = new List<ILayoutable>();
+            Size MeasureOverride(ILayoutable control, Size size)
+            {
+                order.Add(control);
+                return new Size(10, 10);
+            }
 
-                root.DoMeasureOverride = MeasureOverride;
-                control1.DoMeasureOverride = MeasureOverride;
-                control2.DoMeasureOverride = MeasureOverride;
-                target.ExecuteInitialLayoutPass(root);
+            root.DoMeasureOverride = MeasureOverride;
+            control1.DoMeasureOverride = MeasureOverride;
+            control2.DoMeasureOverride = MeasureOverride;
+            target.ExecuteInitialLayoutPass(root);
 
-                control2.InvalidateMeasure();
-                control1.InvalidateMeasure();
-                root.InvalidateMeasure();
+            control2.InvalidateMeasure();
+            control1.InvalidateMeasure();
+            root.InvalidateMeasure();
 
-                order.Clear();
-                target.ExecuteLayoutPass();
+            order.Clear();
+            target.ExecuteLayoutPass();
 
-                Assert.Equal(new ILayoutable[] { root, control1, control2 }, order);
-            }
+            Assert.Equal(new ILayoutable[] { root, control1, control2 }, order);
         }
 
         [Fact]
         public void Measures_Root_And_Grandparent_In_Correct_Order()
         {
             var target = new LayoutManager();
-
-            using (Start(target))
+            LayoutTestControl control1;
+            LayoutTestControl control2;
+            var root = new LayoutTestRoot
             {
-                LayoutTestControl control1;
-                LayoutTestControl control2;
-                var root = new LayoutTestRoot
+                Child = control1 = new LayoutTestControl
                 {
-                    Child = control1 = new LayoutTestControl
-                    {
-                        Child = control2 = new LayoutTestControl(),
-                    }
-                };
+                    Child = control2 = new LayoutTestControl(),
+                }
+            };
 
 
-                var order = new List<ILayoutable>();
-                Size MeasureOverride(ILayoutable control, Size size)
-                {
-                    order.Add(control);
-                    return new Size(10, 10);
-                }
+            var order = new List<ILayoutable>();
+            Size MeasureOverride(ILayoutable control, Size size)
+            {
+                order.Add(control);
+                return new Size(10, 10);
+            }
 
-                root.DoMeasureOverride = MeasureOverride;
-                control1.DoMeasureOverride = MeasureOverride;
-                control2.DoMeasureOverride = MeasureOverride;
-                target.ExecuteInitialLayoutPass(root);
+            root.DoMeasureOverride = MeasureOverride;
+            control1.DoMeasureOverride = MeasureOverride;
+            control2.DoMeasureOverride = MeasureOverride;
+            target.ExecuteInitialLayoutPass(root);
 
-                control2.InvalidateMeasure();
-                root.InvalidateMeasure();
+            control2.InvalidateMeasure();
+            root.InvalidateMeasure();
 
-                order.Clear();
-                target.ExecuteLayoutPass();
+            order.Clear();
+            target.ExecuteLayoutPass();
 
-                Assert.Equal(new ILayoutable[] { root, control2 }, order);
-            }
+            Assert.Equal(new ILayoutable[] { root, control2 }, order);
         }
 
         [Fact]
         public void Doesnt_Measure_Non_Invalidated_Root()
         {
             var target = new LayoutManager();
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot { Child = control };
 
-            using (Start(target))
-            {
-                var control = new LayoutTestControl();
-                var root = new LayoutTestRoot { Child = control };
+            target.ExecuteInitialLayoutPass(root);
+            root.Measured = root.Arranged = false;
+            control.Measured = control.Arranged = false;
 
-                target.ExecuteInitialLayoutPass(root);
-                root.Measured = root.Arranged = false;
-                control.Measured = control.Arranged = false;
+            control.InvalidateMeasure();
+            target.ExecuteLayoutPass();
 
-                control.InvalidateMeasure();
-                target.ExecuteLayoutPass();
-
-                Assert.False(root.Measured);
-                Assert.False(root.Arranged);
-                Assert.True(control.Measured);
-                Assert.True(control.Arranged);
-            }
+            Assert.False(root.Measured);
+            Assert.False(root.Arranged);
+            Assert.True(control.Measured);
+            Assert.True(control.Arranged);
         }
 
         [Fact]
         public void Doesnt_Measure_Removed_Control()
         {
             var target = new LayoutManager();
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot { Child = control };
 
-            using (Start(target))
-            {
-                var control = new LayoutTestControl();
-                var root = new LayoutTestRoot { Child = control };
-
-                target.ExecuteInitialLayoutPass(root);
-                control.Measured = control.Arranged = false;
+            target.ExecuteInitialLayoutPass(root);
+            control.Measured = control.Arranged = false;
 
-                control.InvalidateMeasure();
-                root.Child = null;
-                target.ExecuteLayoutPass();
+            control.InvalidateMeasure();
+            root.Child = null;
+            target.ExecuteLayoutPass();
 
-                Assert.False(control.Measured);
-                Assert.False(control.Arranged);
-            }
+            Assert.False(control.Measured);
+            Assert.False(control.Arranged);
         }
 
         [Fact]
         public void Measures_Root_With_Infinity()
         {
             var target = new LayoutManager();
+            var root = new LayoutTestRoot();
+            var availableSize = default(Size);
 
-            using (Start(target))
-            {
-                var root = new LayoutTestRoot();
-                var availableSize = default(Size);
-
-                // Should not measure with this size.
-                root.MaxClientSize = new Size(123, 456);
+            // Should not measure with this size.
+            root.MaxClientSize = new Size(123, 456);
 
-                root.DoMeasureOverride = (_, s) =>
-                {
-                    availableSize = s;
-                    return new Size(100, 100);
-                };
+            root.DoMeasureOverride = (_, s) =>
+            {
+                availableSize = s;
+                return new Size(100, 100);
+            };
 
-                target.ExecuteInitialLayoutPass(root);
+            target.ExecuteInitialLayoutPass(root);
 
-                Assert.Equal(Size.Infinity, availableSize);
-            }
+            Assert.Equal(Size.Infinity, availableSize);
         }
 
         [Fact]
         public void Arranges_Root_With_DesiredSize()
         {
             var target = new LayoutManager();
- 
-            using (Start(target))
+            var root = new LayoutTestRoot
             {
-                var root = new LayoutTestRoot
-                {
-                    Width = 100,
-                    Height = 100,
-                };
+                Width = 100,
+                Height = 100,
+            };
  
-                var arrangeSize = default(Size);
+            var arrangeSize = default(Size);
  
-                root.DoArrangeOverride = (_, s) =>
-                {
-                    arrangeSize = s;
-                    return s;
-                };
+            root.DoArrangeOverride = (_, s) =>
+            {
+                arrangeSize = s;
+                return s;
+            };
  
-                target.ExecuteInitialLayoutPass(root);
-                Assert.Equal(new Size(100, 100), arrangeSize);
+            target.ExecuteInitialLayoutPass(root);
+            Assert.Equal(new Size(100, 100), arrangeSize);
  
-                root.Width = 120;
+            root.Width = 120;
  
-                target.ExecuteLayoutPass();
-                Assert.Equal(new Size(120, 100), arrangeSize);
-            }
+            target.ExecuteLayoutPass();
+            Assert.Equal(new Size(120, 100), arrangeSize);
         }
 
         [Fact]
         public void Invalidating_Child_Remeasures_Parent()
         {
-            using (AvaloniaLocator.EnterScope())
-            {
-                Border border;
-                StackPanel panel;
+            Border border;
+            StackPanel panel;
 
-                var root = new LayoutTestRoot
+            var root = new LayoutTestRoot
+            {
+                Child = panel = new StackPanel
+                {
+                    Children = new Controls.Controls
                 {
-                    Child = panel = new StackPanel
-                    {
-                        Children = new Controls.Controls
-                    {
-                        (border = new Border())
-                    }
-                    }
-                };
+                    (border = new Border())
+                }
+                }
+            };
                 
-                root.LayoutManager.ExecuteInitialLayoutPass(root);
-                Assert.Equal(new Size(0, 0), root.DesiredSize);
+            root.LayoutManager.ExecuteInitialLayoutPass(root);
+            Assert.Equal(new Size(0, 0), root.DesiredSize);
 
-                border.Width = 100;
-                border.Height = 100;
+            border.Width = 100;
+            border.Height = 100;
 
-                root.LayoutManager.ExecuteLayoutPass();
-                Assert.Equal(new Size(100, 100), panel.DesiredSize);
-            }                
-        }
-
-        private IDisposable Start(LayoutManager layoutManager)
-        {
-            var result = AvaloniaLocator.EnterScope();
-            AvaloniaLocator.CurrentMutable.Bind<ILayoutManager>().ToConstant(layoutManager);
-            return result;
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(new Size(100, 100), panel.DesiredSize);
         }
     }
 }
diff --git a/tests/Avalonia.Layout.UnitTests/LayoutableTests.cs b/tests/Avalonia.Layout.UnitTests/LayoutableTests.cs
index dcc65edc74..68cdaa1b12 100644
--- a/tests/Avalonia.Layout.UnitTests/LayoutableTests.cs
+++ b/tests/Avalonia.Layout.UnitTests/LayoutableTests.cs
@@ -11,80 +11,73 @@ namespace Avalonia.Layout.UnitTests
         public void Only_Calls_LayoutManager_InvalidateMeasure_Once()
         {
             var target = new Mock<ILayoutManager>();
-
-            using (Start(target.Object))
+            var control = new Decorator();
+            var root = new LayoutTestRoot
             {
-                var control = new Decorator();
-                var root = new LayoutTestRoot { Child = control };
+                Child = control,
+                LayoutManager = target.Object,
+            };
 
-                root.Measure(Size.Infinity);
-                root.Arrange(new Rect(root.DesiredSize));
-                target.ResetCalls();
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
+            target.ResetCalls();
 
-                control.InvalidateMeasure();
-                control.InvalidateMeasure();
+            control.InvalidateMeasure();
+            control.InvalidateMeasure();
 
-                target.Verify(x => x.InvalidateMeasure(control), Times.Once());
-            }
+            target.Verify(x => x.InvalidateMeasure(control), Times.Once());
         }
 
         [Fact]
         public void Only_Calls_LayoutManager_InvalidateArrange_Once()
         {
             var target = new Mock<ILayoutManager>();
-
-            using (Start(target.Object))
+            var control = new Decorator();
+            var root = new LayoutTestRoot
             {
-                var control = new Decorator();
-                var root = new LayoutTestRoot { Child = control };
+                Child = control,
+                LayoutManager = target.Object,
+            };
 
-                root.Measure(Size.Infinity);
-                root.Arrange(new Rect(root.DesiredSize));
-                target.ResetCalls();
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
+            target.ResetCalls();
 
-                control.InvalidateArrange();
-                control.InvalidateArrange();
+            control.InvalidateArrange();
+            control.InvalidateArrange();
 
-                target.Verify(x => x.InvalidateArrange(control), Times.Once());
-            }
+            target.Verify(x => x.InvalidateArrange(control), Times.Once());
         }
 
         [Fact]
         public void Attaching_Control_To_Tree_Invalidates_Parent_Measure()
         {
             var target = new Mock<ILayoutManager>();
-
-            using (Start(target.Object))
+            var control = new Decorator();
+            var root = new LayoutTestRoot
             {
-                var control = new Decorator();
-                var root = new LayoutTestRoot { Child = control };
+                Child = control,
+                LayoutManager = target.Object,
+            };
 
-                root.Measure(Size.Infinity);
-                root.Arrange(new Rect(root.DesiredSize));
-                Assert.True(control.IsMeasureValid);
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
+            Assert.True(control.IsMeasureValid);
 
-                root.Child = null;
-                root.Measure(Size.Infinity);
-                root.Arrange(new Rect(root.DesiredSize));
+            root.Child = null;
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
 
-                Assert.False(control.IsMeasureValid);
-                Assert.True(root.IsMeasureValid);
+            Assert.False(control.IsMeasureValid);
+            Assert.True(root.IsMeasureValid);
 
-                target.ResetCalls();
+            target.ResetCalls();
 
-                root.Child = control;
+            root.Child = control;
 
-                Assert.False(root.IsMeasureValid);
-                Assert.False(control.IsMeasureValid);
-                target.Verify(x => x.InvalidateMeasure(root), Times.Once());
-            }
-        }
-
-        private IDisposable Start(ILayoutManager layoutManager)
-        {
-            var result = AvaloniaLocator.EnterScope();
-            AvaloniaLocator.CurrentMutable.Bind<ILayoutManager>().ToConstant(layoutManager);
-            return result;
+            Assert.False(root.IsMeasureValid);
+            Assert.False(control.IsMeasureValid);
+            target.Verify(x => x.InvalidateMeasure(root), Times.Once());
         }
     }
 }