tsai
/
Avalonia
mirror of https://github.com/AvaloniaUI/Avalonia.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Removed unnecessary service locator code. 

`ILayoutManager` is not longer retrieved from `AvaloniaLocator` so can remove this stuff.
pull/1014/head
Steven Kirk 9 years ago
parent
188a0ce442
commit
5e3f604308
2 changed files with 174 additions and 227 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 314
      tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
  2. 87
      tests/Avalonia.Layout.UnitTests/LayoutableTests.cs

314
tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
View File

@ -15,285 +15,239 @@ namespace Avalonia.Layout.UnitTests
public void Measures_And_Arranges_InvalidateMeasured_Control() public void Measures_And_Arranges_InvalidateMeasured_Control()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
using (Start(target)) target.ExecuteInitialLayoutPass(root);
{ control.Measured = control.Arranged = false;
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root);
control.Measured = control.Arranged = false;
control.InvalidateMeasure(); control.InvalidateMeasure();
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.True(control.Measured); Assert.True(control.Measured);
Assert.True(control.Arranged); Assert.True(control.Arranged);
}
} }
[Fact] [Fact]
public void Arranges_InvalidateArranged_Control() public void Arranges_InvalidateArranged_Control()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
using (Start(target)) target.ExecuteInitialLayoutPass(root);
{ control.Measured = control.Arranged = false;
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root);
control.Measured = control.Arranged = false;
control.InvalidateArrange(); control.InvalidateArrange();
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.False(control.Measured); Assert.False(control.Measured);
Assert.True(control.Arranged); Assert.True(control.Arranged);
}
} }
[Fact] [Fact]
public void Measures_Parent_Of_Newly_Added_Control() public void Measures_Parent_Of_Newly_Added_Control()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var control = new LayoutTestControl();
var root = new LayoutTestRoot();
using (Start(target)) target.ExecuteInitialLayoutPass(root);
{ root.Child = control;
var control = new LayoutTestControl(); root.Measured = root.Arranged = false;
var root = new LayoutTestRoot();
target.ExecuteInitialLayoutPass(root);
root.Child = control;
root.Measured = root.Arranged = false;
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.True(root.Measured); Assert.True(root.Measured);
Assert.True(root.Arranged); Assert.True(root.Arranged);
Assert.True(control.Measured); Assert.True(control.Measured);
Assert.True(control.Arranged); Assert.True(control.Arranged);
}
} }
[Fact] [Fact]
public void Measures_In_Correct_Order() public void Measures_In_Correct_Order()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
LayoutTestControl control1;
using (Start(target)) LayoutTestControl control2;
var root = new LayoutTestRoot
{ {
LayoutTestControl control1; Child = control1 = new LayoutTestControl
LayoutTestControl control2;
var root = new LayoutTestRoot
{ {
Child = control1 = new LayoutTestControl Child = control2 = new LayoutTestControl(),
{ }
Child = control2 = new LayoutTestControl(), };
}
};
var order = new List<ILayoutable>(); var order = new List<ILayoutable>();
Size MeasureOverride(ILayoutable control, Size size) Size MeasureOverride(ILayoutable control, Size size)
{ {
order.Add(control); order.Add(control);
return new Size(10, 10); return new Size(10, 10);
} }
root.DoMeasureOverride = MeasureOverride; root.DoMeasureOverride = MeasureOverride;
control1.DoMeasureOverride = MeasureOverride; control1.DoMeasureOverride = MeasureOverride;
control2.DoMeasureOverride = MeasureOverride; control2.DoMeasureOverride = MeasureOverride;
target.ExecuteInitialLayoutPass(root); target.ExecuteInitialLayoutPass(root);
control2.InvalidateMeasure(); control2.InvalidateMeasure();
control1.InvalidateMeasure(); control1.InvalidateMeasure();
root.InvalidateMeasure(); root.InvalidateMeasure();
order.Clear(); order.Clear();
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.Equal(new ILayoutable[] { root, control1, control2 }, order); Assert.Equal(new ILayoutable[] { root, control1, control2 }, order);
}
} }
[Fact] [Fact]
public void Measures_Root_And_Grandparent_In_Correct_Order() public void Measures_Root_And_Grandparent_In_Correct_Order()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
LayoutTestControl control1;
using (Start(target)) LayoutTestControl control2;
var root = new LayoutTestRoot
{ {
LayoutTestControl control1; Child = control1 = new LayoutTestControl
LayoutTestControl control2;
var root = new LayoutTestRoot
{ {
Child = control1 = new LayoutTestControl Child = control2 = new LayoutTestControl(),
{ }
Child = control2 = new LayoutTestControl(), };
}
};
var order = new List<ILayoutable>(); var order = new List<ILayoutable>();
Size MeasureOverride(ILayoutable control, Size size) Size MeasureOverride(ILayoutable control, Size size)
{ {
order.Add(control); order.Add(control);
return new Size(10, 10); return new Size(10, 10);
} }
root.DoMeasureOverride = MeasureOverride; root.DoMeasureOverride = MeasureOverride;
control1.DoMeasureOverride = MeasureOverride; control1.DoMeasureOverride = MeasureOverride;
control2.DoMeasureOverride = MeasureOverride; control2.DoMeasureOverride = MeasureOverride;
target.ExecuteInitialLayoutPass(root); target.ExecuteInitialLayoutPass(root);
control2.InvalidateMeasure(); control2.InvalidateMeasure();
root.InvalidateMeasure(); root.InvalidateMeasure();
order.Clear(); order.Clear();
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.Equal(new ILayoutable[] { root, control2 }, order); Assert.Equal(new ILayoutable[] { root, control2 }, order);
}
} }
[Fact] [Fact]
public void Doesnt_Measure_Non_Invalidated_Root() public void Doesnt_Measure_Non_Invalidated_Root()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
using (Start(target)) target.ExecuteInitialLayoutPass(root);
{ root.Measured = root.Arranged = false;
var control = new LayoutTestControl(); control.Measured = control.Arranged = false;
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root); control.InvalidateMeasure();
root.Measured = root.Arranged = false; target.ExecuteLayoutPass();
control.Measured = control.Arranged = false;
control.InvalidateMeasure(); Assert.False(root.Measured);
target.ExecuteLayoutPass(); Assert.False(root.Arranged);
Assert.True(control.Measured);
Assert.False(root.Measured); Assert.True(control.Arranged);
Assert.False(root.Arranged);
Assert.True(control.Measured);
Assert.True(control.Arranged);
}
} }
[Fact] [Fact]
public void Doesnt_Measure_Removed_Control() public void Doesnt_Measure_Removed_Control()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
using (Start(target)) target.ExecuteInitialLayoutPass(root);
{ control.Measured = control.Arranged = false;
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root);
control.Measured = control.Arranged = false;
control.InvalidateMeasure(); control.InvalidateMeasure();
root.Child = null; root.Child = null;
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.False(control.Measured); Assert.False(control.Measured);
Assert.False(control.Arranged); Assert.False(control.Arranged);
}
} }
[Fact] [Fact]
public void Measures_Root_With_Infinity() public void Measures_Root_With_Infinity()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var root = new LayoutTestRoot();
var availableSize = default(Size);
using (Start(target)) // Should not measure with this size.
{ root.MaxClientSize = new Size(123, 456);
var root = new LayoutTestRoot();
var availableSize = default(Size);
// Should not measure with this size.
root.MaxClientSize = new Size(123, 456);
root.DoMeasureOverride = (_, s) => root.DoMeasureOverride = (_, s) =>
{ {
availableSize = s; availableSize = s;
return new Size(100, 100); return new Size(100, 100);
}; };
target.ExecuteInitialLayoutPass(root); target.ExecuteInitialLayoutPass(root);
Assert.Equal(Size.Infinity, availableSize); Assert.Equal(Size.Infinity, availableSize);
}
} }
[Fact] [Fact]
public void Arranges_Root_With_DesiredSize() public void Arranges_Root_With_DesiredSize()
{ {
var target = new LayoutManager(); var target = new LayoutManager();
var root = new LayoutTestRoot
using (Start(target))
{ {
var root = new LayoutTestRoot Width = 100,
{ Height = 100,
Width = 100, };
Height = 100,
};
var arrangeSize = default(Size); var arrangeSize = default(Size);
root.DoArrangeOverride = (_, s) => root.DoArrangeOverride = (_, s) =>
{ {
arrangeSize = s; arrangeSize = s;
return s; return s;
}; };
target.ExecuteInitialLayoutPass(root); target.ExecuteInitialLayoutPass(root);
Assert.Equal(new Size(100, 100), arrangeSize); Assert.Equal(new Size(100, 100), arrangeSize);
root.Width = 120; root.Width = 120;
target.ExecuteLayoutPass(); target.ExecuteLayoutPass();
Assert.Equal(new Size(120, 100), arrangeSize); Assert.Equal(new Size(120, 100), arrangeSize);
}
} }
[Fact] [Fact]
public void Invalidating_Child_Remeasures_Parent() 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 (border = new Border())
{ }
Children = new Controls.Controls }
{ };
(border = new Border())
}
}
};
root.LayoutManager.ExecuteInitialLayoutPass(root); root.LayoutManager.ExecuteInitialLayoutPass(root);
Assert.Equal(new Size(0, 0), root.DesiredSize); Assert.Equal(new Size(0, 0), root.DesiredSize);
border.Width = 100; border.Width = 100;
border.Height = 100; border.Height = 100;
root.LayoutManager.ExecuteLayoutPass(); root.LayoutManager.ExecuteLayoutPass();
Assert.Equal(new Size(100, 100), panel.DesiredSize); 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;
} }
} }
} }

87
tests/Avalonia.Layout.UnitTests/LayoutableTests.cs
View File

@ -11,80 +11,73 @@ namespace Avalonia.Layout.UnitTests
public void Only_Calls_LayoutManager_InvalidateMeasure_Once() public void Only_Calls_LayoutManager_InvalidateMeasure_Once()
{ {
var target = new Mock<ILayoutManager>(); var target = new Mock<ILayoutManager>();
var control = new Decorator();
using (Start(target.Object)) var root = new LayoutTestRoot
{ {
var control = new Decorator(); Child = control,
var root = new LayoutTestRoot { Child = control }; LayoutManager = target.Object,
};
root.Measure(Size.Infinity); root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize)); root.Arrange(new Rect(root.DesiredSize));
target.ResetCalls(); 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] [Fact]
public void Only_Calls_LayoutManager_InvalidateArrange_Once() public void Only_Calls_LayoutManager_InvalidateArrange_Once()
{ {
var target = new Mock<ILayoutManager>(); var target = new Mock<ILayoutManager>();
var control = new Decorator();
using (Start(target.Object)) var root = new LayoutTestRoot
{ {
var control = new Decorator(); Child = control,
var root = new LayoutTestRoot { Child = control }; LayoutManager = target.Object,
};
root.Measure(Size.Infinity); root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize)); root.Arrange(new Rect(root.DesiredSize));
target.ResetCalls(); 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] [Fact]
public void Attaching_Control_To_Tree_Invalidates_Parent_Measure() public void Attaching_Control_To_Tree_Invalidates_Parent_Measure()
{ {
var target = new Mock<ILayoutManager>(); var target = new Mock<ILayoutManager>();
var control = new Decorator();
using (Start(target.Object)) var root = new LayoutTestRoot
{ {
var control = new Decorator(); Child = control,
var root = new LayoutTestRoot { Child = control }; LayoutManager = target.Object,
};
root.Measure(Size.Infinity); root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize)); root.Arrange(new Rect(root.DesiredSize));
Assert.True(control.IsMeasureValid); Assert.True(control.IsMeasureValid);
root.Child = null; root.Child = null;
root.Measure(Size.Infinity); root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize)); root.Arrange(new Rect(root.DesiredSize));
Assert.False(control.IsMeasureValid); Assert.False(control.IsMeasureValid);
Assert.True(root.IsMeasureValid); Assert.True(root.IsMeasureValid);
target.ResetCalls(); target.ResetCalls();
root.Child = control; root.Child = control;
Assert.False(root.IsMeasureValid); Assert.False(root.IsMeasureValid);
Assert.False(control.IsMeasureValid); Assert.False(control.IsMeasureValid);
target.Verify(x => x.InvalidateMeasure(root), Times.Once()); 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;
} }
} }
} }

Write Preview
Loading…
Cancel
Save