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

Jump to bottom

Action message select overloaded function #314 #739

Open
wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Action message select overloaded function #314 #739

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
1deb551
First implementation can select different overloads
KasperSK Sep 25, 2020
47dd9a8
Enable action message to pick method based on parameters and their type
KasperSK Jan 28, 2021
ba1cfa5
Added parameter check to when resolving guard methods
KasperSK Jan 29, 2021
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
381 changes: 381 additions & 0 deletions src/Caliburn.Micro.Platform.Tests/ActionMessageTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,381 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Xunit;

namespace Caliburn.Micro.Platform.Tests
{
public class ActionMessageTests
{
[Fact]
public void GetMethodPicksOverLoadStructParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = 1 });
am.Parameters.Add(new Parameter() { Value = 1 });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(1, 1));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadStructStringParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = 1 });
am.Parameters.Add(new Parameter() { Value = 1 });
am.Parameters.Add(new Parameter() { Value = "" });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(1, 1, ""));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadStringParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = "" });
am.Parameters.Add(new Parameter() { Value = "" });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded("", ""));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadStringStructParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = "" });
am.Parameters.Add(new Parameter() { Value = "" });
am.Parameters.Add(new Parameter() { Value = 1 });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded("", "", 1));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadTwoDifferntParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Foo() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(new Foo(), new Bar()));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadTwoBaseParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Foo() });
am.Parameters.Add(new Parameter() { Value = new Foo() });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(new Foo(), new Foo()));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadTwoDerivedParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Bar() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(new Bar(), new Bar()));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadEnumParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = OverloadEnum.One });
var obj = new Overloads();

var expected = MethodInfoHelper.GetMethodInfo<Overloads>(o => o.Overloaded(OverloadEnum.One));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadDerivedOnlyParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Bar() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new OverloadsDerivedOnly();

var expected = MethodInfoHelper.GetMethodInfo<OverloadsDerivedOnly>(o => o.Overloaded(new Bar(), new Bar()));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadDerivedOnlyBaseParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Foo() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new OverloadsDerivedOnly();

MethodInfo expected = null;

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}


[Fact]
public void GetMethodPicksOverLoadBaseOnlyParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Bar() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new OverloadsBaseOnly();

var expected = MethodInfoHelper.GetMethodInfo<OverloadsBaseOnly>(o => o.Overloaded(new Foo(), new Foo()));

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

[Fact]
public void GetMethodPicksOverLoadBaseOnlyBaseParameter()
{
//Arrange
var am = new ActionMessage();
am.MethodName = "Overloaded";

am.Parameters.Add(new Parameter() { Value = new Foo() });
am.Parameters.Add(new Parameter() { Value = new Bar() });
var obj = new OverloadsBaseOnly();

MethodInfo expected = MethodInfoHelper.GetMethodInfo<OverloadsBaseOnly>(o => o.Overloaded(new Foo(), new Foo()));
;

//Act
var result = ActionMessage.GetTargetMethod(am, obj);

//Assert
Assert.Equal(result, expected);
}

enum OverloadEnum
{
One,Two,Three
}

class OverloadsBaseOnly
{
public void Overloaded(Foo f)
{

}

public void Overloaded(Foo f, Foo f2)
{

}
}

class OverloadsDerivedOnly
{
public void Overloaded(Bar b)
{

}

public void Overloaded(Bar b, Bar b2)
{

}
}

class Overloads
{
public void Overloaded(int i)
{

}

public void Overloaded(int i, int i2)
{

}

public void Overloaded(int i, int i2, string s)
{

}

public void Overloaded(string s)
{

}

public void Overloaded(string s, string s2)
{

}

public void Overloaded(string s, string s2, int i)
{

}

public void Overloaded(Foo F)
{

}

public void Overloaded(Bar B)
{

}

public void Overloaded(OverloadEnum E)
{

}

public void Overloaded(Foo s, Foo f)
{

}

public void Overloaded(Foo s, Bar b)
{

}

public void Overloaded(Bar s, Bar b)
{

}

public void Overloaded(Bar s, Foo f)
{

}
}

class Foo
{

}

class Bar : Foo
{

}
}

public static class MethodInfoHelper
{
public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
{
var member = expression.Body as MethodCallExpression;

if (member != null)
return member.Method;

throw new ArgumentException("Expression is not a method", "expression");
}

}
}
Loading