public void TestRawStatements()
{
var c = new ClassType("test");
var x2 = "a" + new RawStatement("b");
var x3 = new RawStatement("a") + "b";
var s1 = new RawStatements()
{
Statements = { "xxx" }
};
var s2 = new RawStatements("asd", new RawStatement("tttt"));
s1.Add(s2);
s1.Add(new TypescriptTypeReference(c));
s1.Add(":");
s1.Add(c);
var g = new OutputGenerator();
g.Generate(s1);
Assert.AreEqual("xxxasdtttttest:test", g.Formatter.Output.ToString());
var test2 = new RawStatements("t1 ", c, " t2");
g.Formatter.Output.Clear();
g.Generate(test2);
Assert.AreEqual("t1 test t2", g.Output);
}
private static void PrintQuote(LoanQuote quote)
{
var outputGenerator = new OutputGenerator();
string output = outputGenerator.Generate(quote);
Console.WriteLine(output);
}
private static Tuple <string, string> runTest(bool sourceClasses, bool destClasses, bool optimize, bool optimizeSource = false)
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = sourceClasses;
rg.NamingStrategy.InterfacePrefixForClasses = "";
rg.NamingStrategy.InterfacePrefix = "";
rg.GenerateTypes(new[] { typeof(Test3), typeof(Test3A) });
var models = rg.Module;
if (optimizeSource)
{
models = Optimizer.RemoveEmptyDeclarations(models);
}
var o1 = new OutputGenerator();
o1.Generate(models);
var o1Output = o1.Output;
var ko = new KnockoutGenerator();
var observables = new TypescriptModule("Observables");
ko.GenerateObservableModule(models, observables, !destClasses);
if (optimize)
{
observables = Optimizer.RemoveEmptyDeclarations(observables);
}
var o2 = new OutputGenerator();
o2.Generate(observables);
return(Tuple.Create(o1.Output, o2.Output));
}
public void TestGenerics2()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
//nonsense?!? rg.GenerateInterface(typeof(Test1<int>));
rg.GenerateInterface(typeof(Test1 <>));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(
@"
module GeneratedModule {
interface iTest1<T> {
T1: iGenList<string>;
T2: iGenList<number>;
T3: iGenList<iGenList<boolean>>;
T4: iGenList<T[]>[];
}
interface iGenList<TI> {
Values: iGenTest<TI>[];
}
interface iGenTest<T> {
Value: T;
}
}".Trim(), g.Output.Trim());
}
public void TestClassGenericToIntf()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
rg.GenerateInterface(typeof(PagedAminUser));
rg.GenerateInterface(typeof(PagedCompany));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(
@"
module GeneratedModule {
interface iPagedModel<T> {
TotalCount: number;
Values: T[];
}
interface iPagedAminUser extends iPagedModel<iAdminUser> {
}
interface iAdminUser {
Name: string;
Login: string;
}
interface iPagedCompany extends iPagedModel<iCompanyModel> {
}
interface iCompanyModel {
VAT: string;
Name: string;
}
}".Trim(), g.Output.Trim());
}
public void TestModule()
{
var m = new TypescriptModule("testModule");
var cls = new ClassType("class1");
cls.Members.Add(new PropertyMember("Property1")
{
MemberType = PrimitiveType.Boolean
});
m.Members.Add(cls);
m.Members.Last().IsExporting = true;
m.Members.Add(new RawStatements()
{
Statements = { "function test() : ", cls, " { return null; }" }
});
var g = new OutputGenerator();
g.Generate(m);
Assert.AreEqual(@"
module testModule {
export class class1 {
Property1: boolean;
}
function test() : class1 { return null; }
}
".Trim(), g.Output.Trim());
}
private string testGen(ClassType cls)
{
var g = new OutputGenerator();
g.Generate(cls);
return(g.Formatter.Output.ToString());
}
public void TestComments()
{
var m = new TypescriptModule("testModule")
{
Comment = "module"
};
var cls = new ClassType("class1");
cls.Members.Add(new PropertyMember("Property1")
{
MemberType = PrimitiveType.Boolean, Comment = "property\nsecond line"
});
m.Members.Add(cls);
m.Members.Last().Comment = "class";
m.Members.Last().IsExporting = true;
m.Members.Add(new RawStatements()
{
Statements = { "function test() : ", cls, " { return null; }" }
});
m.Members.Last().Comment = "raw";
cls.Members.Add(new FunctionMember("fn",
new RawStatements("/*comment*/\n", "dosomething();\n", "//comment"))
{
Comment = "function",
Parameters =
{
new FunctionParameter("x")
{
ParameterType = PrimitiveType.Boolean, Comment = "param"
}
}
});
cls.Members.Last().Comment = "function";
var g = new OutputGenerator();
g.GenerateComments = true;
g.Generate(m);
Assert.AreEqual(null,
Helper.StringCompare(@"
/* module */
module testModule {
/* class */
export class class1 {
/* property
* second line
*/
Property1: boolean;
/* function */
fn(/* param */x: boolean) {
/*comment*/
dosomething();
//comment
}
}
/* raw */
function test() : class1 { return null; }
}
", g.Output));
}
public void TestInterfacesToObservableClasses()
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = false;
rg.GenerateTypes(new[] { typeof(Test1B), typeof(Test1) });
var o1 = new OutputGenerator();
o1.Generate(rg.Module);
Assert.AreEqual(Helper.StringCompare(@"
module GeneratedModule {
interface ITest1 {
Prop1: string;
Prop2: number;
}
interface ITest1B extends ITest1 {
Prop3: boolean;
Ref: ITest1;
PropArray: string[];
SelfArray: ITest1B[];
}
}
", o1.Output), null);
var ko = new KnockoutGenerator();
var observables = new TypescriptModule("Observables");
ko.GenerateObservableModule(rg.Module, observables, interfaces: false);
var o = new OutputGenerator();
o.Generate(observables);
Assert.AreEqual(null, Helper.StringCompare(@"
module Observables {
class test1B implements IObservableTest1 {
// implementation of IObservableTest1
Prop1 = ko.observable<string>();
Prop2 = ko.observable<number>();
Prop3 = ko.observable<boolean>();
Ref = ko.observable<test1>();
PropArray = ko.observableArray<string>();
SelfArray = ko.observableArray<test1B>();
}
interface IObservableTest1 {
Prop1: KnockoutObservable<string>;
Prop2: KnockoutObservable<number>;
}
class test1 {
Prop1 = ko.observable<string>();
Prop2 = ko.observable<number>();
}
}
", o.Output));
}
private string test(bool classes)
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.CommentSource = false;
rg.GenerationStrategy.GenerateClasses = classes;
rg.GenerateFromType(typeof(Test3));
var module = rg.Module;
module = Optimizer.RemoveEmptyDeclarations(module);
var o = new OutputGenerator();
o.Generate(module);
return(o.Output);
}
public void TestClassesToObservableInterfaces()
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = true;
rg.GenerateTypes(new[] { typeof(Test1B), typeof(Test1) });
var o1 = new OutputGenerator();
o1.Generate(rg.Module);
Assert.AreEqual(@"
module GeneratedModule {
class Test1 {
Prop1: string;
Prop2: number;
}
class Test1B extends Test1 {
Prop3: boolean;
Ref: Test1;
PropArray: string[];
SelfArray: Test1B[];
}
}
".Trim(), o1.Output.Trim());
var ko = new KnockoutGenerator();
var observables = new TypescriptModule("Observables");
ko.GenerateObservableModule(rg.Module, observables, true);
var o = new OutputGenerator();
o.Generate(observables);
Assert.AreEqual(@"
module Observables {
interface iObservableTest1 {
Prop1: KnockoutObservable<string>;
Prop2: KnockoutObservable<number>;
}
interface iObservableTest1B extends iObservableTest1 {
Prop3: KnockoutObservable<boolean>;
Ref: KnockoutObservable<iObservableTest1>;
PropArray: KnockoutObservableArray<string>;
SelfArray: KnockoutObservableArray<iObservableTest1B>;
}
}
".Trim(), o.Output.Trim());
}
public void TestGenericsInstance()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
rg.GenerateInterface(typeof(GenTest <int>));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(null, Helper.StringCompare(
@"
module GeneratedModule {
interface iGenTest_Int32 {
Value: number;
}
}", g.Output));
}
public void TestSystemTypesGeneration()
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = true;
rg.GenerateClass(typeof(SystemTypesClass));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(@"
module GeneratedModule {
class SystemTypesClass<T> {
GenericProperty: SystemTypesClass<any>;
}
class SystemTypesClass extends SystemTypesClass<number> {
}
}
".Trim(), g.Output.Trim());
}
public void TestReflectionInheritanceOptimalization2()
{
var rg = new ReflectionGenerator();
rg.GenerateInterface(typeof(Test3A));
var module = rg.GenerationStrategy.TargetModule;
module = Optimizer.RemoveEmptyDeclarations(module);
var g = new OutputGenerator();
g.Generate(module);
Assert.AreEqual(null, Helper.StringCompare(
@"module GeneratedModule {
interface ITest3A {
Prop1: number;
}
}", g.Output));
}
public void TestEnum()
{
var e = new EnumType("xTypes");
e.Members.Add(new EnumMember("Type1", null));
e.Members.Add(new EnumMember("Type2", 42));
e.Members.Add(new EnumMember("Type3", null)
{
Value = new RawStatements("0x40")
});
e.Members.Add(new EnumMember("Type4", null));
var g = new OutputGenerator();
g.Generate(e);
Assert.AreEqual(@"enum xTypes {
Type1,
Type2 = 42,
Type3 = 0x40,
Type4
}", g.Formatter.Output.ToString());
}
public void TestMethods()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
rg.GenerationStrategy.GenerateMethods = true;
rg.GenerateInterface(typeof(TestGenMethods <>));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(@"
module GeneratedModule {
interface iTestGenMethods<T> {
Test1(input: T): string;
Test2<T2>(input: T2, withDefault?: string = '42'): boolean;
Test3(x: number, ...args: string[]): void;
}
}".Trim(), g.Output.Trim());
}
public void TestReflectionInheritanceOptimalization1()
{
var rg = new ReflectionGenerator();
rg.GenerateInterface(typeof(ITest3B));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(null, Helper.StringCompare(
@"module GeneratedModule {
interface ITest3A {
Prop1: number;
}
interface ITest3B extends ITest3A {
Prop2: string;
Prop2b: ITest3A;
}
}", g.Output));
}
public void TestIntf()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
rg.GenerateInterface(typeof(TestingClass));
var g = new OutputGenerator();
g.GenerateComments = false;
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(null, Helper.StringCompare(@"
module GeneratedModule {
interface IMyInterface {
Property2: string;
}
interface iTestingClassBase extends IMyInterface {
Property1: number;
/* Property Property2 skipped, because it is already implemented by interface IMyInterface*/
}
interface iTestingClass extends iTestingClassBase {
Property3: MyEnum;
Property4?: number;
Property5: string[];
Property6: iTestingClass;
Property7: iTestingClass[];
Property8: iTestingClass[];
}
enum MyEnum {
Value1 = 0,
Value2 = 1,
Value3 = 10,
Value4 = 11
}
}", g.Output));
}
public void TestInheritanceReordering()
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = true;
rg.GenerateClass(typeof(C));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(@"
module GeneratedModule {
class A {
MyProperty: B;
}
class B extends A {
PropertyOnB: number;
}
class C extends B {
PropertyOnC: string;
}
}
".Trim(), g.Output.Trim());
}
