Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove LINQ and reflection from EasingTypeConverter #19260

Merged
merged 6 commits into from
Jun 7, 2024
Merged

Remove LINQ and reflection from EasingTypeConverter #19260

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
d6e5449
Clean up / Linq removal
imememani Dec 6, 2023
14d0e19
Removed ToLowerInvariant
imememani Dec 6, 2023
eb17a46
Fix return value / further improvements
imememani Dec 10, 2023
8143733
Merge branch 'main' into pr/19260
mattleibow Jun 6, 2024
c903863
Tests
mattleibow Jun 6, 2024
fe76275
Update EasingTypeConverter.cs
mattleibow Jun 6, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
105 changes: 40 additions & 65 deletions src/Core/src/Converters/EasingTypeConverter.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,6 @@
using System;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Reflection;
using static Microsoft.Maui.Easing;

#nullable disable
Expand All @@ -20,81 +18,58 @@ public override bool CanConvertTo(ITypeDescriptorContext context, Type destinati

public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var strValue = value?.ToString();
if (value is null)
return null;

var strValue = value as string ?? value.ToString();

if (string.IsNullOrWhiteSpace(strValue))
return null;

strValue = strValue?.Trim() ?? "";
var parts = strValue.Split('.');

if (parts.Length == 2 && parts[0] == nameof(Easing))
strValue = parts[parts.Length - 1];

if (strValue.Equals(nameof(Linear), StringComparison.OrdinalIgnoreCase))
return Linear;
if (strValue.Equals(nameof(SinIn), StringComparison.OrdinalIgnoreCase))
return SinIn;
if (strValue.Equals(nameof(SinOut), StringComparison.OrdinalIgnoreCase))
return SinOut;
if (strValue.Equals(nameof(SinInOut), StringComparison.OrdinalIgnoreCase))
return SinInOut;
if (strValue.Equals(nameof(CubicIn), StringComparison.OrdinalIgnoreCase))
return CubicIn;
if (strValue.Equals(nameof(CubicOut), StringComparison.OrdinalIgnoreCase))
return CubicOut;
if (strValue.Equals(nameof(CubicInOut), StringComparison.OrdinalIgnoreCase))
return CubicInOut;
if (strValue.Equals(nameof(BounceIn), StringComparison.OrdinalIgnoreCase))
return BounceIn;
if (strValue.Equals(nameof(BounceOut), StringComparison.OrdinalIgnoreCase))
return BounceOut;
if (strValue.Equals(nameof(SpringIn), StringComparison.OrdinalIgnoreCase))
return SpringIn;
if (strValue.Equals(nameof(SpringOut), StringComparison.OrdinalIgnoreCase))
return SpringOut;

var fallbackValue = typeof(Easing)
.GetTypeInfo()
.DeclaredFields
.FirstOrDefault(f => f.Name.Equals(strValue, StringComparison.OrdinalIgnoreCase))
?.GetValue(null);

if (fallbackValue is Easing fallbackEasing)
return fallbackEasing;

throw new InvalidOperationException($"Cannot convert \"{strValue}\" into {typeof(Easing)}");
if (parts.Length == 2 && Compare(parts[0], nameof(Easing)))
strValue = parts[1];

return strValue switch
{
_ when Compare(strValue, nameof(Linear)) => Linear,
_ when Compare(strValue, nameof(SinIn)) => SinIn,
_ when Compare(strValue, nameof(SinOut)) => SinOut,
_ when Compare(strValue, nameof(SinInOut)) => SinInOut,
_ when Compare(strValue, nameof(CubicIn)) => CubicIn,
_ when Compare(strValue, nameof(CubicOut)) => CubicOut,
_ when Compare(strValue, nameof(CubicInOut)) => CubicInOut,
_ when Compare(strValue, nameof(BounceIn)) => BounceIn,
_ when Compare(strValue, nameof(BounceOut)) => BounceOut,
_ when Compare(strValue, nameof(SpringIn)) => SpringIn,
_ when Compare(strValue, nameof(SpringOut)) => SpringOut,
_ => throw new InvalidOperationException($"Cannot convert \"{strValue}\" into {typeof(Easing)}")
};

static bool Compare(string left, string right) =>
left.Equals(right, StringComparison.OrdinalIgnoreCase);
}

public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (value is not Easing easing)
throw new NotSupportedException();

if (easing == Linear)
return nameof(Linear);
if (easing == SinIn)
return nameof(SinIn);
if (easing == SinOut)
return nameof(SinOut);
if (easing == SinInOut)
return nameof(SinInOut);
if (easing == CubicIn)
return nameof(CubicIn);
if (easing == CubicOut)
return nameof(CubicOut);
if (easing == CubicInOut)
return nameof(CubicInOut);
if (easing == BounceIn)
return nameof(BounceIn);
if (easing == BounceOut)
return nameof(BounceOut);
if (easing == SpringIn)
return nameof(SpringIn);
if (easing == SpringOut)
return nameof(SpringOut);

throw new NotSupportedException();
return easing switch
{
_ when easing.Equals(Linear) => nameof(Linear),
_ when easing.Equals(SinIn) => nameof(SinIn),
_ when easing.Equals(SinOut) => nameof(SinOut),
_ when easing.Equals(SinInOut) => nameof(SinInOut),
_ when easing.Equals(CubicIn) => nameof(CubicIn),
_ when easing.Equals(CubicOut) => nameof(CubicOut),
_ when easing.Equals(CubicInOut) => nameof(CubicInOut),
_ when easing.Equals(BounceIn) => nameof(BounceIn),
_ when easing.Equals(BounceOut) => nameof(BounceOut),
_ when easing.Equals(SpringIn) => nameof(SpringIn),
_ when easing.Equals(SpringOut) => nameof(SpringOut),
_ => throw new NotSupportedException(),
};
}

public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
Expand Down
74 changes: 67 additions & 7 deletions ...trols/tests/Core.UnitTests/EasingTests.cs → ...tests/UnitTests/Animations/EasingTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,12 +2,19 @@
using Microsoft.Maui.Converters;
using Xunit;

namespace Microsoft.Maui.Controls.Core.UnitTests
namespace Microsoft.Maui.UnitTests
{

public class EasingTests : BaseTestFixture
[Category(TestCategory.Animations)]
public class EasingTests
{
[Theory, MemberData(nameof(TestDataHelpers.Range), 0, 10, 1, MemberType = typeof(TestDataHelpers))]
[Theory]
[InlineData(0.0)]
[InlineData(1.0)]
[InlineData(2.0)]
[InlineData(5.0)]
[InlineData(8.0)]
[InlineData(9.0)]
[InlineData(10.0)]
public void Linear(double input)
{
Assert.Equal(input, Easing.Linear.Ease(input));
Expand All @@ -19,6 +26,7 @@ public void Linear(double input)
public void AllRunFromZeroToOne(double val)
{
const double epsilon = 0.001;

Assert.True(Math.Abs(val - Easing.Linear.Ease(val)) < epsilon);
Assert.True(Math.Abs(val - Easing.BounceIn.Ease(val)) < epsilon);
Assert.True(Math.Abs(val - Easing.BounceOut.Ease(val)) < epsilon);
Expand All @@ -33,45 +41,97 @@ public void AllRunFromZeroToOne(double val)
}

[Fact]
public void TestEasingTypeConverter()
public void CanConvert()
{
var converter = new EasingTypeConverter();

Assert.True(converter.CanConvertFrom(typeof(string)));
Assert.Null(converter.ConvertFromInvariantString(null));
Assert.Null(converter.ConvertFromInvariantString(string.Empty));
}

[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData(" ")]
public void NonTextEasingsAreNull(string input)
{
var converter = new EasingTypeConverter();

Assert.Null(converter.ConvertFromInvariantString(input));
}

[Fact]
public void CanConvertFromEasingNameToEasing()
{
var converter = new EasingTypeConverter();

Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("Linear"));
Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("linear"));
Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("Easing.Linear"));

Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("SinOut"));
Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("sinout"));
Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("Easing.SinOut"));

Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("SinIn"));
Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("sinin"));
Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("Easing.SinIn"));

Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("SinInOut"));
Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("sininout"));
Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("Easing.SinInOut"));

Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("CubicOut"));
Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("cubicout"));
Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("Easing.CubicOut"));

Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("CubicIn"));
Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("cubicin"));
Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("Easing.CubicIn"));

Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("CubicInOut"));
Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("cubicinout"));
Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("Easing.CubicInOut"));

Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("BounceOut"));
Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("bounceout"));
Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("Easing.BounceOut"));

Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("BounceIn"));
Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("bouncein"));
Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("Easing.BounceIn"));

Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("SpringOut"));
Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("springout"));
Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("Easing.SpringOut"));

Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("SpringIn"));
Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("springin"));
Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("Easing.SpringIn"));
}

[Fact]
public void CanConvertFromEasingToEasingName()
{
var converter = new EasingTypeConverter();

Assert.Equal("Linear", converter.ConvertToInvariantString(Easing.Linear));
Assert.Equal("SinOut", converter.ConvertToInvariantString(Easing.SinOut));
Assert.Equal("SinIn", converter.ConvertToInvariantString(Easing.SinIn));
Assert.Equal("SinInOut", converter.ConvertToInvariantString(Easing.SinInOut));
Assert.Equal("CubicOut", converter.ConvertToInvariantString(Easing.CubicOut));
Assert.Equal("CubicIn", converter.ConvertToInvariantString(Easing.CubicIn));
Assert.Equal("CubicInOut", converter.ConvertToInvariantString(Easing.CubicInOut));
Assert.Equal("BounceOut", converter.ConvertToInvariantString(Easing.BounceOut));
Assert.Equal("BounceIn", converter.ConvertToInvariantString(Easing.BounceIn));
Assert.Equal("SpringOut", converter.ConvertToInvariantString(Easing.SpringOut));
Assert.Equal("SpringIn", converter.ConvertToInvariantString(Easing.SpringIn));
}

[Fact]
public void InvalidEasingNamesThrow()
{
var converter = new EasingTypeConverter();

Assert.Throws<InvalidOperationException>(() => converter.ConvertFromInvariantString("WrongEasingName"));
Assert.Throws<InvalidOperationException>(() => converter.ConvertFromInvariantString("Easing.Linear.SinInOut"));
}
Expand Down
1 change: 1 addition & 0 deletions src/Core/tests/UnitTests/TestCategory.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ namespace Microsoft.Maui.UnitTests
{
public static class TestCategory
{
public const string Animations = "Animations";
public const string Core = "Core";
public const string CommandMapping = "CommandMapping";
public const string Layout = "Layout";
Expand Down
Loading