public void LambdaConstructorBindingTest()
{
var expected = true;
var typeResolutionService = new KnownTypeResolver(typeof(TypeFilter));
var lambda = CSharpExpression.Parse <TypeFilter>("new TypeFilter((t, c) => t != null)", typeResolutionService).Compile().Invoke();
var actual = lambda.Invoke(typeof(bool), null);
Assert.Equal(expected, actual);
}
public void LambdaConstructorBindingTest()
{
var expected = true;
var typeResolutionService = new KnownTypeResolver(typeof(Predicate <int>));
var lambda = CSharpExpression.ParseFunc <Predicate <int> >("new Predicate<int>(x => x > 0)", typeResolutionService).Compile().Invoke();
var actual = lambda.Invoke(1);
Assert.Equal(expected, actual);
}
public void GenericInvocationTest(string expression, int expected)
{
var typeResolutionService = new KnownTypeResolver(typeof(ExecutorTests.TestGenericClass <>), typeof(ExecutorTests.TestGenericClass <> .TestSubClass <,>));
expression = CSharpExpression.ParseFunc <int>(expression, typeResolutionService).Body.Render();
this.output.WriteLine("Rendered: " + expression);
var actual = CSharpExpression.ParseFunc <int>(expression, typeResolutionService).CompileAot(forceAot: true).Invoke();
Assert.Equal(expected, actual);
}
public void LambdaConstructorTest()
{
var typeResolutionService = new KnownTypeResolver(typeof(Func <Type, object, bool>));
var expression = CSharpExpression.ParseFunc <Func <Type, object, bool> >("new Func<Type, object, bool>((t, c) => t != null)", typeResolutionService).Body.Render();
this.output.WriteLine("Rendered: " + expression);
var expected = true;
var lambda = CSharpExpression.ParseFunc <Func <Type, object, bool> >(expression, typeResolutionService).CompileAot(forceAot: true).Invoke();
var actual = lambda.Invoke(typeof(bool), null);
Assert.Equal(expected, actual);
}
public void NullResolveTest(string expression, object expected)
{
var knownTypeResolver = new KnownTypeResolver(typeof(MyClass), typeof(ExecutorTests.TestGenericClass <>));
var actual = CSharpExpression.Evaluate <object>(expression, knownTypeResolver);
if (expected == null)
{
Assert.Null(actual);
}
else
{
Assert.Equal(expected, actual);
}
}
/// <summary>
/// Resolves a type by name.
/// Gets called by the WCF framework when deserializing.
/// </summary>
/// <param name="typeName"></param>
/// <param name="typeNamespace"></param>
/// <param name="declaredType"></param>
/// <param name="knownTypeResolver"></param>
/// <returns></returns>
public override Type ResolveName(string typeName, string typeNamespace, Type declaredType,
System.Runtime.Serialization.DataContractResolver knownTypeResolver)
{
try
{
return(KnownTypeResolver.ResolveType(Encoder.SafeDecode(typeName)) ??
(KnownTypeResolver.IsKnownType(declaredType)
? declaredType
: knownTypeResolver.ResolveName(typeName, typeNamespace, declaredType,
DummyDataContractResolver)));
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public void SimpleTypeResolutionTest(Type expected)
{
var typeName = MakeTypeReference(expected, fullName: false);
var typeFullName = MakeTypeReference(expected, fullName: true);
output.WriteLine("Name: " + typeName);
output.WriteLine("Full Name: " + typeFullName);
var knownTypeResolver = new KnownTypeResolver(expected);
var actual = default(Type);
var nameFound = knownTypeResolver.TryGetType(typeName, out actual);
Assert.True(nameFound, "Name is not found");
Assert.Equal(expected, actual);
var fullNameFound = knownTypeResolver.TryGetType(typeFullName, out actual);
Assert.True(fullNameFound, "Full name is not found");
Assert.Equal(expected, actual);
}
/// <summary>
/// Checks if type is considered a known type.
/// Gets called by the WCF framework when serializing.
/// </summary>
/// <param name="type"></param>
/// <param name="declaredType"></param>
/// <param name="knownTypeResolver"></param>
/// <param name="typeName"></param>
/// <param name="typeNamespace"></param>
/// <returns></returns>
public override bool TryResolveType(Type type, Type declaredType,
System.Runtime.Serialization.DataContractResolver knownTypeResolver, out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
try
{
if (!KnownTypeResolver.IsKnownType(type))
{
return(knownTypeResolver.TryResolveType(type, declaredType, DummyDataContractResolver, out typeName,
out typeNamespace));
}
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(Encoder.SafeEncode(type.AssemblyQualifiedName()));
typeNamespace = dictionary.Add("http://p2p.com");
return(true);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public void KnownTypeResolverConstructorTest(Type expected)
{
var knownTypeResolver = new KnownTypeResolver(expected);
Assert.NotNull(knownTypeResolver);
}
