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(); }