public void DoesNotIgnoreHiddenViews()
{
var view = LayoutTestHelpers.CreateTestView(new Size(100, 100));
var hiddenView = LayoutTestHelpers.CreateTestView(new Size(100, 100));
hiddenView.Visibility.Returns(Visibility.Hidden);
var stack = CreateTestLayout(new List <IView>()
{
view, hiddenView
});
var manager = new HorizontalStackLayoutManager(stack);
var measure = manager.Measure(double.PositiveInfinity, 100);
manager.ArrangeChildren(new Rect(Point.Zero, measure));
// View is visible, so we expect it to be measured and arranged
view.Received().Measure(Arg.Any <double>(), Arg.Any <double>());
view.Received().Arrange(Arg.Any <Rect>());
// View is hidden, so we expect it to be measured and arranged (since it'll need to take up space)
hiddenView.Received().Measure(Arg.Any <double>(), Arg.Any <double>());
hiddenView.Received().Arrange(Arg.Any <Rect>());
}
public void IgnoresCollapsedViews()
{
var view = LayoutTestHelpers.CreateTestView(new Size(100, 100));
var collapsedView = LayoutTestHelpers.CreateTestView(new Size(100, 100));
collapsedView.Visibility.Returns(Visibility.Collapsed);
var stack = CreateTestLayout(new List <IView>()
{
view, collapsedView
});
var manager = new HorizontalStackLayoutManager(stack);
var measure = manager.Measure(double.PositiveInfinity, 100);
manager.ArrangeChildren(new Rect(Point.Zero, measure));
// View is visible, so we expect it to be measured and arranged
view.Received().Measure(Arg.Any <double>(), Arg.Any <double>());
view.Received().Arrange(Arg.Any <Rect>());
// View is collapsed, so we expect it not to be measured or arranged
collapsedView.DidNotReceive().Measure(Arg.Any <double>(), Arg.Any <double>());
collapsedView.DidNotReceive().Arrange(Arg.Any <Rect>());
}
public void ViewsArrangedWithDesiredHeights()
{
var stack = CreateTestLayout();
var manager = new HorizontalStackLayoutManager(stack);
var view1 = CreateTestView(new Size(100, 200));
var view2 = CreateTestView(new Size(100, 150));
var children = new List <IView>()
{
view1, view2
}.AsReadOnly();
stack.Children.Returns(children);
var measurement = manager.Measure(double.PositiveInfinity, double.PositiveInfinity);
manager.Arrange(new Rectangle(Point.Zero, measurement));
// The tallest IView is 200, so the stack should be that tall
Assert.Equal(200, measurement.Height);
// We expect the first IView to be at 0,0 with a width of 100 and a height of 200
var expectedRectangle1 = new Rectangle(0, 0, 100, 200);
view1.Received().Arrange(Arg.Is(expectedRectangle1));
// We expect the second IView to be at 100, 0 with a width of 100 and a height of 150
var expectedRectangle2 = new Rectangle(100, 0, 100, 150);
view2.Received().Arrange(Arg.Is(expectedRectangle2));
}
public void MeasureRespectsMinWidth(double minWidth, double viewWidth, double expectedWidth)
{
var stack = BuildStack(viewCount: 1, viewWidth: viewWidth, viewHeight: 100);
stack.MinimumWidth.Returns(minWidth);
var gridLayoutManager = new HorizontalStackLayoutManager(stack);
var measure = gridLayoutManager.Measure(double.PositiveInfinity, double.PositiveInfinity);
Assert.Equal(expectedWidth, measure.Width);
}
public void SpacingMeasurement(int viewCount, double viewWidth, int spacing, double expectedWidth)
{
var stack = BuildStack(viewCount, viewWidth, 100);
stack.Spacing.Returns(spacing);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
Assert.Equal(expectedWidth, measuredSize.Width);
}
public void MeasureRespectsMaxHeight(double maxHeight, double viewHeight, double expectedHeight)
{
var stack = BuildStack(viewCount: 1, viewWidth: 100, viewHeight: viewHeight);
stack.MaximumHeight.Returns(maxHeight);
var layoutManager = new HorizontalStackLayoutManager(stack);
var measure = layoutManager.Measure(double.PositiveInfinity, double.PositiveInfinity);
Assert.Equal(expectedHeight, measure.Height);
}
public void MinHeightDominatesMaxHeight()
{
var stack = BuildStack(viewCount: 1, viewWidth: 100, viewHeight: 100);
stack.MinimumHeight.Returns(75);
stack.MaximumHeight.Returns(50);
var layoutManager = new HorizontalStackLayoutManager(stack);
var measure = layoutManager.Measure(double.PositiveInfinity, double.PositiveInfinity);
// The minimum value should beat out the maximum value
Assert.Equal(75, measure.Height);
}
public void MaxHeightDominatesHeight()
{
var stack = BuildStack(viewCount: 1, viewWidth: 100, viewHeight: 100);
stack.Height.Returns(75);
stack.MaximumHeight.Returns(50);
var gridLayoutManager = new HorizontalStackLayoutManager(stack);
var measure = gridLayoutManager.Measure(double.PositiveInfinity, double.PositiveInfinity);
// The maximum value beats out the explicit value
Assert.Equal(50, measure.Height);
}
public void ArrangeRespectsBounds()
{
var stack = BuildStack(viewCount: 1, viewWidth: 100, viewHeight: 100);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
manager.ArrangeChildren(new Rect(new Point(10, 15), measuredSize));
var expectedRectangle0 = new Rect(10, 15, 100, 100);
stack[0].Received().Arrange(Arg.Is(expectedRectangle0));
}
public void ArrangeAccountsForPadding(double left, double top, double right, double bottom)
{
var viewWidth = 100d;
var viewHeight = 100d;
var padding = new Thickness(left, top, right, bottom);
var stack = BuildPaddedStack(padding, viewWidth, viewHeight);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, double.PositiveInfinity);
manager.ArrangeChildren(new Rect(Point.Zero, measuredSize));
AssertArranged(stack[0], padding.Left, padding.Top, viewWidth, viewHeight);
}
public void ChildMeasureAccountsForPadding(Size viewSize, Thickness padding, Size measureConstraints, Size expectedMeasureConstraint)
{
var view = LayoutTestHelpers.CreateTestView(new Size(viewSize.Width, viewSize.Height));
var stack = CreateTestLayout(new List <IView>()
{
view
});
stack.Padding.Returns(padding);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(measureConstraints.Width, measureConstraints.Height);
view.Received().Measure(Arg.Is(expectedMeasureConstraint.Width), Arg.Is(expectedMeasureConstraint.Height));
}
public void SpacingArrangementOneItem(int spacing)
{
var stack = BuildStack(1, 100, 100);
stack.Spacing.Returns(spacing);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
manager.ArrangeChildren(new Rect(Point.Zero, measuredSize));
var expectedRectangle = new Rect(0, 0, 100, 100);
stack[0].Received().Arrange(Arg.Is(expectedRectangle));
}
public void StackAppliesWidth(double viewWidth, double stackWidth, double expectedWidth)
{
var view = LayoutTestHelpers.CreateTestView(new Size(viewWidth, 100));
var stack = CreateTestLayout(new List <IView>()
{
view
});
stack.Width.Returns(stackWidth);
var manager = new HorizontalStackLayoutManager(stack);
var measurement = manager.Measure(double.PositiveInfinity, 100);
Assert.Equal(expectedWidth, measurement.Width);
}
public void MeasureAccountsForPadding(double left, double top, double right, double bottom)
{
var viewWidth = 100d;
var viewHeight = 100d;
var padding = new Thickness(left, top, right, bottom);
var expectedHeight = padding.VerticalThickness + viewHeight;
var expectedWidth = padding.HorizontalThickness + viewWidth;
var stack = BuildPaddedStack(padding, viewWidth, viewHeight);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, double.PositiveInfinity);
Assert.Equal(expectedHeight, measuredSize.Height);
Assert.Equal(expectedWidth, measuredSize.Width);
}
public void LtrShouldHaveFirstItemOnTheLeft()
{
var stack = BuildStack(viewCount: 2, viewWidth: 100, viewHeight: 100);
stack.FlowDirection.Returns(FlowDirection.LeftToRight);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
manager.ArrangeChildren(new Rect(Point.Zero, measuredSize));
// We expect that the starting view (0) should be arranged on the left,
// and the next rectangle (1) should be on the right
var expectedRectangle0 = new Rect(0, 0, 100, 100);
var expectedRectangle1 = new Rect(100, 0, 100, 100);
stack[0].Received().Arrange(Arg.Is(expectedRectangle0));
stack[1].Received().Arrange(Arg.Is(expectedRectangle1));
}
public void StackAppliesWidth(double viewWidth, double stackWidth, double expectedWidth)
{
var stack = CreateTestLayout();
var view = CreateTestView(new Size(viewWidth, 100));
var children = new List <IView>()
{
view
}.AsReadOnly();
stack.Children.Returns(children);
stack.Width.Returns(stackWidth);
var manager = new HorizontalStackLayoutManager(stack);
var measurement = manager.Measure(double.PositiveInfinity, 100);
Assert.That(measurement.Width, Is.EqualTo(expectedWidth));
}
public void SpacingArrangementTwoItems(int spacing)
{
var stack = BuildStack(2, 100, 100);
stack.Spacing.Returns(spacing);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
manager.Arrange(new Rectangle(Point.Zero, measuredSize));
var expectedRectangle0 = new Rectangle(0, 0, 100, 100);
stack.Children[0].Received().Arrange(Arg.Is(expectedRectangle0));
var expectedRectangle1 = new Rectangle(100 + spacing, 0, 100, 100);
stack.Children[1].Received().Arrange(Arg.Is(expectedRectangle1));
}
public void ArrangeAccountsForFill()
{
var stack = BuildStack(viewCount: 1, viewWidth: 100, viewHeight: 100);
stack.HorizontalLayoutAlignment.Returns(LayoutAlignment.Fill);
stack.VerticalLayoutAlignment.Returns(LayoutAlignment.Fill);
var layoutManager = new HorizontalStackLayoutManager(stack);
_ = layoutManager.Measure(double.PositiveInfinity, double.PositiveInfinity);
var arrangedWidth = 1000;
var arrangedHeight = 1000;
var target = new Rect(Point.Zero, new Size(arrangedWidth, arrangedHeight));
var actual = layoutManager.ArrangeChildren(target);
// Since we're arranging in a space larger than needed and the layout is set to Fill in both directions,
// we expect the returned actual arrangement size to be as large as the target space
Assert.Equal(arrangedWidth, actual.Width);
Assert.Equal(arrangedHeight, actual.Height);
}
public void RtlShouldStartAtRightEdge()
{
var stack = BuildStack(viewCount: 2, viewWidth: 100, viewHeight: 100);
stack.FlowDirection.Returns(FlowDirection.RightToLeft);
stack.HorizontalLayoutAlignment.Returns(LayoutAlignment.Fill);
stack.Spacing.Returns(0);
var manager = new HorizontalStackLayoutManager(stack);
var measuredSize = manager.Measure(double.PositiveInfinity, 100);
// Arranging in a larger space than measured to simulate a Fill situation
var rightEdge = measuredSize.Width * 2;
manager.ArrangeChildren(new Rect(0, 0, rightEdge, measuredSize.Height));
// We expect that the starting view (0) should be arranged on the right,
// and the next rectangle (1) should be on the left
var expectedRectangle0 = new Rect(rightEdge - 100, 0, 100, 100);
var expectedRectangle1 = new Rect(rightEdge - 200, 0, 100, 100);
stack[0].Received().Arrange(Arg.Is(expectedRectangle0));
stack[1].Received().Arrange(Arg.Is(expectedRectangle1));
}
