public async Task PercentValueInitializesCorrectly(double min, double max, double value)
{
var expectedValue = Math.Clamp(value, min, max);
var expectedPercent = (expectedValue - min) / (max - min);
var slider = new SliderStub()
{
Maximum = max,
Minimum = min,
Value = value
};
Assert.Equal(min, slider.Minimum);
Assert.Equal(max, slider.Maximum);
Assert.Equal(expectedValue, slider.Value);
var native = await GetValueAsync(slider, (handler) =>
{
return(new
{
Min = GetNativeMinimum(handler),
Max = GetNativeMaximum(handler),
Val = GetNativeProgress(handler),
});
});
var nativePercent = (native.Val - native.Min) / (native.Max - native.Min);
Assert.Equal(expectedPercent, nativePercent, 5);
}
public async Task InsertAddsChildToNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
var button = new ButtonStub();
layout.Add(slider);
var handler = await CreateHandlerAsync(layout);
var children = await InvokeOnMainThreadAsync(() =>
{
return(GetNativeChildren(handler));
});
Assert.Equal(1, children.Count);
Assert.Same(slider.Handler.NativeView, children[0]);
children = await InvokeOnMainThreadAsync(() =>
{
handler.Insert(0, button);
return(GetNativeChildren(handler));
});
Assert.Equal(2, children.Count);
Assert.Same(button.Handler.NativeView, children[0]);
Assert.Same(slider.Handler.NativeView, children[1]);
}
public async Task HandlerRemovesChildFromNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
layout.Add(slider);
var handler = await CreateHandlerAsync(layout);
var children = await InvokeOnMainThreadAsync(() =>
{
return(GetNativeChildren(handler));
});
Assert.Equal(1, children.Count);
Assert.Same(slider.Handler.NativeView, children[0]);
var count = await InvokeOnMainThreadAsync(() =>
{
handler.Remove(slider);
return(GetNativeChildCount(handler));
});
Assert.Equal(0, count);
}
public async Task ClearRemovesChildrenFromNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
var button = new ButtonStub();
layout.Add(slider);
layout.Add(button);
var handler = await CreateHandlerAsync(layout);
var children = await InvokeOnMainThreadAsync(() =>
{
return(GetNativeChildren(handler));
});
Assert.Equal(2, children.Count);
Assert.Same(slider.Handler.PlatformView, children[0]);
Assert.Same(button.Handler.PlatformView, children[1]);
var count = await InvokeOnMainThreadAsync(() =>
{
handler.Clear();
return(GetNativeChildCount(handler));
});
Assert.Equal(0, count);
}
public async Task UpdateNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
var button = new ButtonStub();
layout.Add(slider);
var handler = await CreateHandlerAsync(layout);
var children = await InvokeOnMainThreadAsync(() =>
{
return(GetNativeChildren(handler));
});
Assert.Equal(1, children.Count);
Assert.Same(slider.Handler.PlatformView, children[0]);
children = await InvokeOnMainThreadAsync(() =>
{
layout[0] = button;
handler.Update(0, button);
return(GetNativeChildren(handler));
});
Assert.Equal(1, children.Count);
Assert.Same(button.Handler.PlatformView, children[0]);
}
public async Task ThumbColorInitializesCorrectly()
{
var slider = new SliderStub()
{
ThumbColor = Color.Purple
};
await ValidateNativeThumbColor(slider, Color.Purple);
}
public async Task MaximumInitializesCorrectly()
{
var slider = new SliderStub()
{
Maximum = 1
};
await ValidatePropertyInitValue(slider, () => slider.Maximum, GetNativeMaximum, 1);
}
public async Task NativeMeasurementFiniteGivenInfiniteConstraints()
{
var slider = new SliderStub();
var size = await GetValueAsync(slider, (h) => h.GetDesiredSize(double.PositiveInfinity, double.PositiveInfinity));
Assert.False(double.IsInfinity(size.Width));
Assert.False(double.IsInfinity(size.Height));
}
public async Task ValueInitializesCorrectly()
{
var slider = new SliderStub()
{
Maximum = 1,
Minimum = 0,
Value = 0.5
};
await ValidatePropertyInitValue(slider, () => slider.Value, GetNativeProgress, slider.Value);
}
public async Task ContentInitializes()
{
var slider = new SliderStub();
var page = new PageStub
{
Content = slider
};
await CreateHandlerAsync(page);
Assert.Equal(slider.Handler.NativeView, GetNativePageContent(page));
}
public async Task HandlerRemovesChildFromNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
layout.Add(slider);
var handler = await CreateHandlerAsync(layout);
handler.Remove(slider);
Assert.Equal(0, GetNativeChildCount(handler));
}
public async Task ContentUpdates()
{
var slider = new SliderStub();
var page = new PageStub
{
Content = new SliderStub()
};
await CreateHandlerAsync(page);
await InvokeOnMainThreadAsync(() => page.Content = slider);
Assert.Equal(slider.Handler.NativeView, GetNativePageContent(page));
}
public async Task ThumbImageSourceInitializesCorrectly()
{
var slider = new SliderStub()
{
ThumbImageSource = new FileImageSourceStub("red.png")
};
await InvokeOnMainThreadAsync(async() =>
{
var handler = CreateHandler <SliderHandler>(slider);
await Task.Delay(1000);
await handler.NativeView.AssertContainsColor(Colors.Red);
});
}
public async Task DisconnectHandlerRemovesChildFromNativeLayout()
{
var layout = new LayoutStub();
var slider = new SliderStub();
layout.Add(slider);
var handler = await CreateHandlerAsync(layout);
var count = await InvokeOnMainThreadAsync(() =>
{
layout.Handler.DisconnectHandler();
return(GetNativeChildCount(handler));
});
Assert.Equal(0, count);
}
public async Task ContentInitializes()
{
var slider = new SliderStub();
var page = new PageStub
{
Content = slider
};
await InvokeOnMainThreadAsync(() =>
{
var handler = CreateHandler(page);
var nativeView = GetNativePageContent(handler);
Assert.Equal(slider.Handler.NativeView, nativeView);
});
}
public async Task ContentUpdates()
{
var slider = new SliderStub();
var page = new PageStub
{
Content = new ButtonStub()
};
await InvokeOnMainThreadAsync(() =>
{
var handler = CreateHandler(page);
page.Content = slider;
var platformView = GetNativePageContent(handler);
Assert.Equal(slider.Handler.PlatformView, platformView);
});
}
public async Task MeasureMatchesExplicitValues()
{
var layout = new LayoutStub();
var content = new SliderStub
{
DesiredSize = new Size(50, 50)
};
layout.Add(content);
layout.Width = 100;
layout.Height = 150;
var contentViewHandler = await CreateHandlerAsync(layout);
var measure = await InvokeOnMainThreadAsync(() => layout.Measure(double.PositiveInfinity, double.PositiveInfinity));
Assert.Equal(layout.Width, measure.Width, 0);
Assert.Equal(layout.Height, measure.Height, 0);
}
public async Task RespectsMinimumValues()
{
var cv = new ContentViewStub();
var content = new SliderStub
{
DesiredSize = new Size(50, 50)
};
cv.Content = content;
cv.MinimumWidth = 100;
cv.MinimumHeight = 150;
var contentViewHandler = await CreateHandlerAsync(cv);
var measure = await InvokeOnMainThreadAsync(() => cv.Measure(double.PositiveInfinity, double.PositiveInfinity));
Assert.Equal(cv.MinimumWidth, measure.Width, 0);
Assert.Equal(cv.MinimumHeight, measure.Height, 0);
}
public async Task MaximumInitializesCorrectly()
{
var xplatMaximum = 1;
var slider = new SliderStub()
{
Maximum = xplatMaximum
};
double expectedValue = SliderExtensions.NativeMaxValue;
var values = await GetValueAsync(slider, (handler) =>
{
return(new
{
ViewValue = slider.Maximum,
NativeViewValue = GetNativeMaximum(handler)
});
});
Assert.Equal(xplatMaximum, values.ViewValue);
Assert.Equal(expectedValue, values.NativeViewValue);
}
public async Task ValueInitializesCorrectly()
{
var xplatValue = 0.5;
var slider = new SliderStub()
{
Maximum = 1,
Minimum = 0,
Value = xplatValue
};
int expectedValue = (int)(SliderExtensions.NativeMaxValue / 2);
var values = await GetValueAsync(slider, (handler) =>
{
return(new
{
ViewValue = slider.Value,
NativeViewValue = GetNativeProgress(handler)
});
});
Assert.Equal(xplatValue, values.ViewValue);
Assert.Equal(expectedValue, values.NativeViewValue);
}
