public void EnumsWork()
{
Compile(@"enum Test1 {}");
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].Should().BeAssignableTo <JsEnum>();
CompiledTypes[0].CSharpTypeDefinition.Name.Should().Be("Test1");
}
public void EmptyGlobalClassIsCorrectlyReturned()
{
Compile(@"class TestClass { }");
CompiledTypes.Should().HaveCount(1);
CompiledTypes[0].Name.Should().Be("TestClass");
CompiledTypes[0].Should().BeAssignableTo <JsClass>();
}
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 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");
}
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 void DelegatesAreNotImported()
{
Compile(new[] { "delegate void D(int i);" });
CompiledTypes.Should().BeEmpty();
}
public void StructsShouldInheritValueType()
{
Compile(new[] { @"struct Test {}" }, allowUserDefinedStructs: true);
CompiledTypes.Should().HaveCount(1);
Stringify(FindClass("Test").BaseClass).Should().Be("{inh_ValueType}");
}
