public void ShouldTranslateASealedParameterlessCtorInfo()
{
var ctor = typeof(SealedInternalHelper)
.GetNonPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(ctor);
translated.ShouldBe("internal WhenTranslatingConstructorInfos.SealedInternalHelper()");
}
public void ShouldTranslateAParameterlessCtorInfo()
{
var ctor = typeof(Helper)
.GetPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(ctor);
translated.ShouldBe("public WhenTranslatingConstructorInfos.Helper()");
}
public void ShouldTranslateAnAbstractParameterlessCtorInfo()
{
var ctor = typeof(AbstractHelper)
.GetNonPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(ctor);
translated.ShouldBe("protected WhenTranslatingConstructorInfos.AbstractHelper()");
}
public void ShouldTranslateAParameterlessTwoOpenGenericsCtorInfo()
{
var method = typeof(Helper <,>)
.GetPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(method);
translated.ShouldBe("public WhenTranslatingConstructorInfos.Helper<T1, T2>()");
}
public void ShouldTranslateAnOpenGenericCtorInfo()
{
var ctor = typeof(Helper <>)
.GetPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(ctor);
translated.ShouldBe("public WhenTranslatingConstructorInfos.Helper<T>()");
}
public void ShouldTranslateAClosedGenericCtorInfo()
{
var ctor = typeof(Helper <Dictionary <int, string> >)
.GetPublicInstanceConstructor();
var translated = DefinitionsTranslator.Translate(ctor);
translated.ShouldBe("public WhenTranslatingConstructorInfos.Helper<Dictionary<int, string>>()");
}
public void ShouldTranslateAnAbstractClassParameterlessMethodInfo()
{
var method = typeof(AbstractHelper)
.GetPublicInstanceMethod(nameof(AbstractHelper.InstanceParameterless));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
"public string WhenTranslatingMethodInfos.AbstractHelper.InstanceParameterless()";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAnOpenGenericMethodInfo()
{
var method = typeof(Helper)
.GetPublicInstanceMethod(nameof(Helper.InstanceParameterlessSingleGeneric));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
"public Type WhenTranslatingMethodInfos.Helper.InstanceParameterlessSingleGeneric<T>()";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAnAbstractInstancePropertyGetter()
{
var getter = typeof(AbstractHelper)
.GetPublicInstanceProperty(nameof(AbstractHelper.PublicInstanceProperty))
.GetGetter();
var translated = DefinitionsTranslator.Translate(getter);
const string EXPECTED =
"public abstract int WhenTranslatingMethodInfos.AbstractHelper.PublicInstanceProperty { get; }";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAClosedGenericMethodInfo()
{
var method = typeof(Helper)
.GetPublicInstanceMethod(nameof(Helper.InstanceParameterlessSingleGeneric))
.MakeGenericMethod(typeof(Dictionary <,>));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
"public Type WhenTranslatingMethodInfos.Helper.InstanceParameterlessSingleGeneric<Dictionary<TKey, TValue>>()";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAPublicInstancePropertySetter()
{
var setter = typeof(Helper)
.GetPublicInstanceProperty(nameof(Helper.PublicInstanceProperty))
.GetSetter();
var translated = DefinitionsTranslator.Translate(setter);
const string EXPECTED =
"public int WhenTranslatingMethodInfos.Helper.PublicInstanceProperty { set; }";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAProtectedInternalInstancePropertyGetter()
{
var getter = typeof(Helper)
.GetNonPublicInstanceProperty(nameof(Helper.ProtectedInternalInstanceProperty))
.GetGetter(nonPublic: true);
var translated = DefinitionsTranslator.Translate(getter);
const string EXPECTED =
"protected internal string WhenTranslatingMethodInfos.Helper.ProtectedInternalInstanceProperty { get; }";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateASingleParameterCtorInfo()
{
var ctor = typeof(Helper)
.GetPublicInstanceConstructor(typeof(int));
var translated = DefinitionsTranslator.Translate(ctor);
const string EXPECTED =
@"public WhenTranslatingConstructorInfos.Helper
(
int value
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateARefParameter()
{
var ctor = typeof(Helper)
.GetPublicInstanceConstructor(typeof(object).MakeByRefType());
var translated = DefinitionsTranslator.Translate(ctor);
const string EXPECTED =
@"public WhenTranslatingConstructorInfos.Helper
(
ref object value
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateASingleParameterMethodInfo()
{
var method = typeof(Helper)
.GetPublicInstanceMethod(nameof(Helper.InstanceOneParameter));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public int WhenTranslatingMethodInfos.Helper.InstanceOneParameter
(
int value
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAnOutParameter()
{
var method = typeof(Helper)
.GetPublicStaticMethod(nameof(Helper.StaticOutParameter));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public static string WhenTranslatingMethodInfos.Helper.StaticOutParameter
(
out int value
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateATwoParameterCtorInfo()
{
var ctor = typeof(Helper)
.GetPublicInstanceConstructor(typeof(DateTime), typeof(int));
var translated = DefinitionsTranslator.Translate(ctor);
const string EXPECTED =
@"public WhenTranslatingConstructorInfos.Helper
(
DateTime date,
int days
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateATwoParameterMethodInfo()
{
var method = typeof(Helper)
.GetPublicInstanceMethod(nameof(Helper.InstanceTwoParameters));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public DateTime WhenTranslatingMethodInfos.Helper.InstanceTwoParameters
(
DateTime date,
int days
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateARefParameter()
{
var method = typeof(Helper)
.GetPublicStaticMethod(nameof(Helper.StaticRefParameter))
.MakeGenericMethod(typeof(List <List <int> >));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public static void WhenTranslatingMethodInfos.Helper.StaticRefParameter<List<List<int>>>
(
ref List<List<int>> value
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAThreeParametersTwoOpenGenericsMethodInfo()
{
var method = typeof(Helper)
.GetPublicInstanceMethod(nameof(Helper.InstanceThreeParametersTwoGenerics));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public void WhenTranslatingMethodInfos.Helper.InstanceThreeParametersTwoGenerics<T1, T2>
(
int value,
Func<int, T1> func,
T2 value2
)";
translated.ShouldBe(EXPECTED);
}
public void ShouldTranslateAThreeParametersTwoGenericsCtorInfo()
{
var method = typeof(Helper <DateTime, TimeSpan>)
.GetPublicInstanceConstructor(typeof(int), typeof(Func <int, DateTime>), typeof(TimeSpan));
var translated = DefinitionsTranslator.Translate(method);
const string EXPECTED =
@"public WhenTranslatingConstructorInfos.Helper<DateTime, TimeSpan>
(
int value,
Func<int, DateTime> func,
TimeSpan value2
)";
translated.ShouldBe(EXPECTED);
}
public static void GetData(
object target,
Stream outgoingData,
Action <Stream, string> serializer)
{
string value;
switch (target)
{
case Expression expression:
value = expression.ToReadableString() ?? "default(void)";
break;
case Type type:
value = type.GetFriendlyName();
break;
case MethodInfo method:
value = DefinitionsTranslator.Translate(method);
break;
case ConstructorInfo ctor:
value = DefinitionsTranslator.Translate(ctor);
break;
default:
if (target == null)
{
return;
}
value = target.GetType().GetFriendlyName();
break;
}
serializer.Invoke(outgoingData, value);
}
public void ShouldTranslateAPublicStruct()
{
var translated = DefinitionsTranslator.Translate(typeof(PublicStructHelper));
translated.ShouldBe("public struct PublicStructHelper");
}
public void ShouldTranslateASealedNestedInternalType()
{
var translated = DefinitionsTranslator.Translate(typeof(NestedSealedInternalHelper));
translated.ShouldBe("internal sealed class WhenTranslatingTypes.NestedSealedInternalHelper");
}
public void ShouldTranslateAnOpenGenericType()
{
var translated = DefinitionsTranslator.Translate(typeof(NestedPublicHelper <>));
translated.ShouldBe("public class WhenTranslatingTypes.NestedPublicHelper<T>");
}
public void ShouldTranslateAClosedGenericType()
{
var translated = DefinitionsTranslator.Translate(typeof(NestedPublicHelper <Dictionary <string, string> >));
translated.ShouldBe("public class WhenTranslatingTypes.NestedPublicHelper<Dictionary<string, string>>");
}
public void ShouldTranslateATwoOpenGenericsType()
{
var translated = DefinitionsTranslator.Translate(typeof(NestedProtectedHelper <,>));
translated.ShouldBe("protected class WhenTranslatingTypes.NestedProtectedHelper<T1, T2>");
}
public void ShouldTranslateANullCtorInfo()
{
var translated = DefinitionsTranslator.Translate(default(ConstructorInfo));
translated.ShouldBe("[Constructor not found]");
}
public void ShouldTranslateANullMethodInfo()
{
var translated = DefinitionsTranslator.Translate(default(MethodInfo));
translated.ShouldBe("[Method not found]");
}
public void ShouldTranslateAnAbstractNestedPrivateType()
{
var translated = DefinitionsTranslator.Translate(typeof(NestedPrivateAbstractHelper));
translated.ShouldBe("private abstract class WhenTranslatingTypes.NestedPrivateAbstractHelper");
}
