Skip to content

Add tests for #96 #208

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

Open
wants to merge 13 commits into
base: main
Choose a base branch
from
Open

Add tests for #96 #208

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
13 commits
Select commit Hold shift + click to select a range
d80289e
Add tests for #96
hazzik Mar 13, 2017
b6ee4a4
Merge branch 'develop' into gh-96
hazzik Feb 5, 2021
7aa2eda
Merge branch 'develop' into gh-96
hazzik Feb 6, 2021
3aa4d7b
Add more tests
hazzik Feb 6, 2021
4874e2b
Merge branch 'main' into gh-96
hazzik Oct 17, 2022
91831a4
Merge branch 'main' into gh-96
hazzik May 2, 2024
af5120e
Merge branch 'main' into gh-96
hazzik Oct 2, 2025
64de79c
Merge branch 'main' into gh-96
hazzik Oct 2, 2025
ab68c08
Merge branch 'main' into gh-96
hazzik Nov 1, 2025
149e369
Fix arguments order
hazzik Nov 1, 2025
6b5194e
Add Unit32 enum test
hazzik Nov 1, 2025
46fd818
Fix tests
hazzik Nov 1, 2025
a929424
Merge branch 'main' into gh-96
hazzik Nov 20, 2025
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
354 changes: 354 additions & 0 deletions src/DelegateDecompiler.Tests/ByteEnumTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,354 @@
using System;
using System.Linq;
using System.Linq.Expressions;
using NUnit.Framework;

namespace DelegateDecompiler.Tests
{
[TestFixture]
public class ByteEnumTests : DecompilerTestsBase
{
public enum TestEnum : byte
{
Foo,
Bar
}

[Flags]
public enum TestFlagEnum : byte
{
None = 0,
Foo = 1,
Bar = 2,
}

[Test]
public void TestEnumParameterEqualsEnumConstant()
{
Expression<Func<TestEnum, bool>> expected1 = x => x == TestEnum.Bar;
Expression<Func<TestEnum, bool>> expected2 = x => (int) x == (int) TestEnum.Bar;
Func<TestEnum, bool> compiled = x => x == TestEnum.Bar;
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumConstantEqualsEnumParameter()
{
Expression<Func<TestEnum, bool>> expected1 = x => TestEnum.Bar == x;
Expression<Func<TestEnum, bool>> expected2 = x => (int) TestEnum.Bar == (int) x;
Func<TestEnum, bool> compiled = x => TestEnum.Bar == x;
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumPropertyNotEqualsFooOrElseEnumPropertyEqualsBar()
{
Expression<Func<TestEnum, bool>> expected1 = x => (x != TestEnum.Bar) || (x == TestEnum.Foo);
Expression<Func<TestEnum, bool>> expected2 = x => ((int)x != (int)TestEnum.Bar) || ((int)x == (int)TestEnum.Foo);
Func<TestEnum, bool> compiled = x => (x != TestEnum.Bar) || (x == TestEnum.Foo);
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumPropertyEqualsFooOrElseEnumPropertyEqualsBar()
{
Expression<Func<TestEnum, bool>> expected1 = x => (x == TestEnum.Bar) || (x == TestEnum.Foo);
Expression<Func<TestEnum, bool>> expected2 = x => ((int)x == (int)TestEnum.Bar) || ((int)x == (int)TestEnum.Foo);
Func<TestEnum, bool> compiled = x => (x == TestEnum.Bar) || (x == TestEnum.Foo);
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumParametersEqual()
{
Expression<Func<TestEnum, TestEnum, bool>> expected = (x, y) => x == y;
Func<TestEnum, TestEnum, bool> compiled = (x, y) => x == y;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterNotEqualsEnumConstant()
{
Expression<Func<TestEnum, bool>> expected1 = x => x != TestEnum.Bar;
Expression<Func<TestEnum, bool>> expected2 = x => (int) x != (int) TestEnum.Bar;
Func<TestEnum, bool> compiled = x => x != TestEnum.Bar;
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumConstantNotEqualsEnumParameter()
{
Expression<Func<TestEnum, bool>> expected1 = x => TestEnum.Bar != x;
Expression<Func<TestEnum, bool>> expected2 = x => (int) TestEnum.Bar != (int) x;
Func<TestEnum, bool> compiled = x => TestEnum.Bar != x;
Test(compiled, expected1, expected2);
}

[Test]
public void TestEnumParametersNotEqual()
{
Expression<Func<TestEnum, TestEnum, bool>> expected = (x, y) => x != y;
Func<TestEnum, TestEnum, bool> compiled = (x, y) => x != y;
Test(compiled, expected);
}

[Test]
public void TestEnumConstantHasFlagEnumParameter()
{
Expression<Func<TestFlagEnum, bool>> expected = x => TestFlagEnum.Bar.HasFlag(x);
Func<TestFlagEnum, bool> compiled = x => TestFlagEnum.Bar.HasFlag(x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterHasFlagEnumConstant()
{
Expression<Func<TestFlagEnum, bool>> expected = x => x.HasFlag(TestFlagEnum.Bar);
Func<TestFlagEnum, bool> compiled = x => x.HasFlag(TestFlagEnum.Bar);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterHasFlagEnumParameter()
{
Expression<Func<TestFlagEnum, bool>> expected = x => x.HasFlag(x);
Func<TestFlagEnum, bool> compiled = x => x.HasFlag(x);
Test(compiled, expected);
}

[Test]
public void TestEnumConstantAndEnumParameter()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => TestFlagEnum.Bar & x;
Func<TestFlagEnum, TestFlagEnum> compiled = x => TestFlagEnum.Bar & x;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAndEnumConstant()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => x & TestFlagEnum.Bar ;
Func<TestFlagEnum, TestFlagEnum> compiled = x => x & TestFlagEnum.Bar ;
Test(compiled, expected);
}

[Test]
public void TestNotEnumParameter()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => ~ x;
Func<TestFlagEnum, TestFlagEnum> compiled = x => ~ x;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAndEnumParameter()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => x & x;
Func<TestFlagEnum, TestFlagEnum> compiled = x => x & x ;
Test(compiled, expected);
}

[Test]
public void TestEnumConstantOrEnumParameter()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => TestFlagEnum.Bar | x;
Func<TestFlagEnum, TestFlagEnum> compiled = x => TestFlagEnum.Bar | x;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterOrEnumConstant()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => x | TestFlagEnum.Bar ;
Func<TestFlagEnum, TestFlagEnum> compiled = x => x | TestFlagEnum.Bar ;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterOrEnumParameter()
{
Expression<Func<TestFlagEnum, TestFlagEnum>> expected = x => x | x;
Func<TestFlagEnum, TestFlagEnum> compiled = x => x | x ;
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodParameter()
{
Expression<Func<TestEnum, bool>> expected = x => TestEnumMethod(x);
Func<TestEnum, bool> compiled = x => TestEnumMethod(x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithEnumParameter()
{
Expression<Func<TestEnum, bool>> expected = x => EnumMethod(x);
Func<TestEnum, bool> compiled = x => EnumMethod(x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithObjectParameter()
{
Expression<Func<TestEnum, bool>> expected = x => ObjectMethod(x);
Func<TestEnum, bool> compiled = x => ObjectMethod(x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt8Parameter()
{
Expression<Func<TestEnum, bool>> expected = x => Int8Method((byte) x);
Func<TestEnum, bool> compiled = x => Int8Method((byte) x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt16Parameter()
{
Expression<Func<TestEnum, bool>> expected = x => Int16Method((short) x);
Func<TestEnum, bool> compiled = x => Int16Method((short) x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt32Parameter()
{
Expression<Func<TestEnum, bool>> expected = x => Int32Method((int) x);
Func<TestEnum, bool> compiled = x => Int32Method((int) x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt64Parameter()
{
Expression<Func<TestEnum, bool>> expected = x => Int64Method((long) x);
Func<TestEnum, bool> compiled = x => Int64Method((long) x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsGenericMethodParameter()
{
Expression<Func<TestEnum, bool>> expected = x => GenericMethod(x);
Func<TestEnum, bool> compiled = x => GenericMethod(x);
Test(compiled, expected);
}

// The following tests check for the insertion of Expression.Convert in the expression tree for compatible types

[Test]
public void TestEnumCastSubtraction()
{
Expression<Func<TestEnum, int>> expected = x => (int)x - 10;
Func<TestEnum, int> compiled = x => (int)x - 10;
Test(compiled, expected);
}

[Test]
public void TestEnumCastMod()
{
Expression<Func<TestEnum, int>> expected = x => (int)x % 10;
Func<TestEnum, int> compiled = x => (int)x % 10;
Test(compiled, expected);
}

[Test]
public void TestEnumCastEquals()
{
Expression<Func<TestEnum, bool>> expected = x => (int)x == 10;
Func<TestEnum, bool> compiled = x => (int)x == 10;
Test(compiled, expected);
}

[Test]
public void TestEnumCastGreaterThan()
{
Expression<Func<TestEnum, bool>> expected = x => (int)x > 10;
Func<TestEnum, bool> compiled = x => (int)x > 10;
Test(compiled, expected);
}

[Test]
public void Issue61()
{
Expression<Func<decimal, decimal>> expected = x => Decimal.Round(x, 3, MidpointRounding.AwayFromZero);
Func<decimal, decimal> compiled = x => Decimal.Round(x, 3, MidpointRounding.AwayFromZero);
Test(compiled, expected);
}

[Test]
public void Issue98A()
{
Expression<Func<TestEnum?, TestEnum, bool>> expected = (x, y) => x == y;
Func<TestEnum?, TestEnum, bool> compiled = (x, y) => x == y;
Test(compiled, expected);
}

[Test]
public void Issue98B()
{
Expression<Func<TestEnum?, bool>> expected = x => x == TestEnum.Foo;
Func<TestEnum?, bool> compiled = x => x == TestEnum.Foo;
Test(compiled, expected);
}

[Test]
public void Issue160()
{
Expression<Func<int?, bool>> expected1 = x => (TestEnum?) x == TestEnum.Bar;
Expression<Func<int?, bool>> expected2 = x => (x.HasValue ? (TestEnum?) (x ?? 0) : null) == TestEnum.Bar;
Func<int?, bool> compiled = x => (TestEnum?) x == TestEnum.Bar;
Test(compiled, expected1, expected2);
}

[Test]
public void Issue176Array()
{
Expression<Func<TestEnum, bool>> expected = x => new [] {TestEnum.Foo, TestEnum.Bar}.Contains(x);
Func<TestEnum, bool> compiled = x => new[] {TestEnum.Foo, TestEnum.Bar}.Contains(x);
Test(compiled, expected);
}

private static bool TestEnumMethod(TestEnum p0)
{
throw new NotImplementedException();
}

private static bool EnumMethod(Enum p0)
{
throw new NotImplementedException();
}

private static bool ObjectMethod(object p0)
{
throw new NotImplementedException();
}

private static bool Int8Method(byte p0)
{
throw new NotImplementedException();
}

private static bool Int16Method(short p0)
{
throw new NotImplementedException();
}

private static bool Int32Method(int p0)
{
throw new NotImplementedException();
}

private static bool Int64Method(long p0)
{
throw new NotImplementedException();
}

private static bool GenericMethod<T>(T x)
{
throw new NotImplementedException();
}
}
}
13 changes: 13 additions & 0 deletions src/DelegateDecompiler.Tests/EnumTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -221,6 +221,14 @@ public void TestEnumParameterAsMethodWithObjectParameter()
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt8Parameter()
{
Expression<Func<TestEnum, bool>> expected = x => Int8Method((byte) x);
Func<TestEnum, bool> compiled = x => Int8Method((byte) x);
Test(compiled, expected);
}

[Test]
public void TestEnumParameterAsMethodWithInt16Parameter()
{
Expand Down Expand Up @@ -343,6 +351,11 @@ private static bool ObjectMethod(object p0)
throw new NotImplementedException();
}

private static bool Int8Method(byte p0)
{
throw new NotImplementedException();
}

private static bool Int16Method(short p0)
{
throw new NotImplementedException();
Expand Down
Loading
Loading