public void EmptyGlobalClassIsCorrectlyReturned()
{
Compile(@"class TestClass { }");
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].Name.Should().Be("TestClass");
CompiledTypes[0].Should().BeAssignableTo <JsClass>();
}
public void EnumsWork()
{
Compile(@"enum Test1 {}");
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].Should().BeAssignableTo <JsEnum>();
CompiledTypes[0].CSharpTypeDefinition.Name.Should().Be("Test1");
}
public void PartialClassesAreOnlyReturnedOnce()
{
Compile(@"partial class TestClass { }", @"partial class TestClass { }");
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].CSharpTypeDefinition.Name.Should().Be("TestClass");
CompiledTypes.Should().ContainItemsAssignableTo <JsClass>();
}
public void ClassTypeIsSetCorrectly()
{
Compile(new[] { "class Test1{} struct Test2{} interface Test3{}" }, allowUserDefinedStructs: true);
CompiledTypes.Should().HaveCount(3);
Assert.That(((JsClass)CompiledTypes.Single(tp => tp.Name == "Test1")).ClassType, Is.EqualTo(JsClass.ClassTypeEnum.Class));
Assert.That(((JsClass)CompiledTypes.Single(tp => tp.Name == "Test2")).ClassType, Is.EqualTo(JsClass.ClassTypeEnum.Struct));
Assert.That(((JsClass)CompiledTypes.Single(tp => tp.Name == "Test3")).ClassType, Is.EqualTo(JsClass.ClassTypeEnum.Interface));
}
public void InheritingNothingOrObjectShouldGiveObjectAsBaseType()
{
Compile(@"class Test1 : object {}
class Test2 {}");
CompiledTypes.Should().HaveCount(2);
Stringify(FindClass("Test1").BaseClass).Should().Be("{inh_Object}");
Stringify(FindClass("Test2").BaseClass).Should().Be("{inh_Object}");
}
public void NestedClassesWork()
{
Compile(@"class TestClass1 { class TestClass2 { class TestClass3 { } } class TestClass4 {} }");
CompiledTypes.Select(t => t.CSharpTypeDefinition.FullName).Should().BeEquivalentTo(new[] { "TestClass1",
"TestClass1.TestClass2",
"TestClass1.TestClass2.TestClass3",
"TestClass1.TestClass4", });
CompiledTypes.Should().ContainItemsAssignableTo <JsClass>();
}
public void TakenIfWorks() {
Compile(new[] {
@"
class A {}
#if true
class B {}
#endif
" });
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] { "A", "B" });
}
public void UndefWorks() {
Compile(new[] {
@"
#undef MY_SYMBOL
class A {}
#if MY_SYMBOL
class B {}
#endif
" }, defineConstants: new[] { "MY_SYMBOL" });
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] { "A" });
}
public void DefineWorks() {
Compile(new[] {
@"
#define MY_SYMBOL
class A {}
#if MY_SYMBOL
class B {}
#endif
" });
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] { "A", "B" });
}
public void TakenElseWorks() {
Compile(new[] {
@"
class A {}
#if false
class B {}
#else
class C {}
#endif
" });
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] { "A", "C" });
}
public void NotTakenIfWorks()
{
Compile(new[] {
@"
class A {}
#if false
class B {}
#endif
"
});
CompiledTypes.Select(t => t.CSharpTypeDefinition.Name).Should().BeEquivalentTo(new[] { "A" });
}
public void PassingDefineConstantsWorks() {
Compile(new[] {
@"
class A {}
#if MY_SYMBOL1
class B {}
#endif
#if MY_SYMBOL2
class B {}
#endif
" }, defineConstants: new[] { "MY_SYMBOL1" });
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] { "A", "B" });
}
public void ClassesWithGenerateCodeSetToFalseAndTheirNestedClassesAreNotInTheOutput()
{
var metadataImporter = new MockMetadataImporter {
GetTypeSemantics = type => TypeScriptSemantics.NormalType(type.Name, generateCode: type.Name != "C2")
};
Compile(new[] { "class C1 {} class C2 { class C3 {} }" }, metadataImporter: metadataImporter);
CompiledTypes.Select(t => t.CSharpTypeDefinition.Name).Should().BeEquivalentTo(new[] { "C1", "C3" });
metadataImporter = new MockMetadataImporter {
GetTypeSemantics = type => type.Name != "C2" ? TypeScriptSemantics.NormalType(type.Name) : TypeScriptSemantics.NotUsableFromScript()
};
Compile(new[] { "class C1 {} class C2 { class C3 {} }" }, metadataImporter: metadataImporter);
CompiledTypes.Select(t => t.CSharpTypeDefinition.Name).Should().BeEquivalentTo(new[] { "C1", "C3" });
}
public void TakenElseWorksWithElif()
{
Compile(new[] {
@"
class A {}
#if false
class B {}
#elif false
class C {}
#else
class D {}
#endif
"
});
CompiledTypes.Select(t => t.CSharpTypeDefinition.Name).Should().BeEquivalentTo(new[] { "A", "D" });
}
public void EnumsWithGenerateCodeSetToFalseAreNotInTheOutput()
{
var metadataImporter = new MockMetadataImporter {
GetTypeSemantics = type => TypeScriptSemantics.NormalType(type.Name, generateCode: type.Name != "C2")
};
Compile(new[] { "enum C1 {} enum C2 {}" }, metadataImporter);
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].CSharpTypeDefinition.Name.Should().Be("C1");
metadataImporter = new MockMetadataImporter {
GetTypeSemantics = type => type.Name != "C2" ? TypeScriptSemantics.NormalType(type.Name) : TypeScriptSemantics.NotUsableFromScript()
};
Compile(new[] { "enum C1 {} enum C2 {}" }, metadataImporter);
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].CSharpTypeDefinition.Name.Should().Be("C1");
}
private IEnumerable <IDirectiveMiddleware> ExtractMiddlewares(
IDirectiveMiddlewareDescriptor[] middlewareDescriptors,
CompiledTypes compiledTypes)
{
for (var i = 0; i < middlewareDescriptors.Length; i++)
{
string delegateName =
ClassSourceCodeGenerator.GetDelegateName(i);
FieldInfo field = compiledTypes.MiddlewareType.GetField(
delegateName,
BindingFlags.Static | BindingFlags.Public);
yield return(new DirectiveDelegateMiddleware(
middlewareDescriptors[i].DirectiveName,
(DirectiveMiddleware)field.GetValue(field)));
}
}
private IEnumerable <FieldResolver> ExtractResolvers(
IFieldResolverDescriptor[] resolverDescriptors,
CompiledTypes compiledTypes)
{
for (var i = 0; i < resolverDescriptors.Length; i++)
{
string delegateName =
ClassSourceCodeGenerator.GetDelegateName(i);
FieldInfo field = compiledTypes.ResolverType.GetField(
delegateName,
BindingFlags.Static | BindingFlags.Public);
yield return(new FieldResolver(
resolverDescriptors[i].Field.TypeName,
resolverDescriptors[i].Field.FieldName,
(FieldResolverDelegate)field.GetValue(field)));
}
}
public void NamespacingWorks()
{
Compile(@"class Test1 {
}
namespace Nmspace1.Nmspace2 {
namespace Nmspace3 {
class Test2 {}
}
class Test3 {}
}
namespace Nmspace4 {
class Test4 {}
namespace Nmspace5 {
class Test5 {}
}
namespace Nmspace5 {
class Test6 {}
}
class Test7 {}
}
class Test8 {}
namespace Nmspace1 {
namespace Nmspace2 {
class Test9 {}
}
}
class Test10 {}
");
CompiledTypes.Select(t => t.Name).Should().BeEquivalentTo(new[] {
"Test1",
"Nmspace1.Nmspace2.Nmspace3.Test2",
"Nmspace1.Nmspace2.Test3",
"Nmspace4.Test4",
"Nmspace4.Nmspace5.Test5",
"Nmspace4.Nmspace5.Test6",
"Nmspace4.Test7",
"Test8",
"Nmspace1.Nmspace2.Test9",
"Test10",
});
CompiledTypes.Should().ContainItemsAssignableTo <JsClass>();
}
public ResolverBuilderResult Build()
{
if (_descriptors.Count == 0)
{
return(ResolverBuilderResult.Empty);
}
IFieldResolverDescriptor[] resolverDescriptors =
_descriptors.OfType <IFieldResolverDescriptor>().ToArray();
IDirectiveMiddlewareDescriptor[] middlewareDescriptors =
_descriptors.OfType <IDirectiveMiddlewareDescriptor>().ToArray();
CompiledTypes compiledTypes =
Compile(resolverDescriptors, middlewareDescriptors);
return(new ResolverBuilderResult(
ExtractResolvers(resolverDescriptors, compiledTypes).ToArray(),
ExtractMiddlewares(middlewareDescriptors, compiledTypes)
.ToArray()));
}
public void StructsShouldInheritValueType()
{
Compile(new[] { @"struct Test {}" }, allowUserDefinedStructs: true);
CompiledTypes.Should().HaveCount(1);
Stringify(FindClass("Test").BaseClass).Should().Be("{inh_ValueType}");
}
public void DelegatesAreNotImported()
{
Compile(new[] { "delegate void D(int i);" });
CompiledTypes.Should().BeEmpty();
}
