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