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