lots o tests

v2/internal/binding/binding_test/binding_deepelements_test.go

@@ -0,0 +1,126 @@
+package binding_test
+
+// Issues 2303, 3442, 3709
+
+type DeepMessage struct {
+	Msg string
+}
+
+type DeepElements struct {
+	Single     []int
+	Double     [][]string
+	FourDouble [4][]float64
+	DoubleFour [][4]int64
+	Triple     [][][]int
+
+	SingleMap      map[string]int
+	SliceMap       map[string][]int
+	DoubleSliceMap map[string][][]int
+
+	ArrayMap        map[string][4]int
+	DoubleArrayMap1 map[string][4][]int
+	DoubleArrayMap2 map[string][][4]int
+	DoubleArrayMap3 map[string][4][4]int
+
+	OneStructs      []*DeepMessage
+	TwoStructs      [3][]*DeepMessage
+	ThreeStructs    [][][]DeepMessage
+	MapStructs      map[string][]*DeepMessage
+	MapTwoStructs   map[string][4][]DeepMessage
+	MapThreeStructs map[string][][7][]*DeepMessage
+}
+
+func (x DeepElements) Get() DeepElements {
+	return x
+}
+
+var DeepElementsTest = BindingTest{
+	name: "DeepElements",
+	structs: []interface{}{
+		&DeepElements{},
+	},
+	exemptions:  nil,
+	shouldError: false,
+	want: `
+export namespace binding_test {
+            
+                export class DeepMessage {
+                    Msg: string;
+            
+                    static createFrom(source: any = {}) {
+                        return new DeepMessage(source);
+                    }
+            
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Msg = source["Msg"];
+                    }
+                }
+                export class DeepElements {
+                    Single: number[];
+                    Double: string[][];
+                    FourDouble: number[][];
+                    DoubleFour: number[][];
+                    Triple: number[][][];
+                    SingleMap: Record<string, number>;
+                    SliceMap: Record<string, number[]>;
+                    DoubleSliceMap: Record<string, number[][]>;
+                    ArrayMap: Record<string, number[]>;
+                    DoubleArrayMap1: Record<string, number[][]>;
+                    DoubleArrayMap2: Record<string, number[][]>;
+                    DoubleArrayMap3: Record<string, number[][]>;
+                    OneStructs: DeepMessage[];
+                    TwoStructs: DeepMessage[][];
+                    ThreeStructs: DeepMessage[][][];
+                    MapStructs: Record<string, DeepMessage[]>;
+                    MapTwoStructs: Record<string, DeepMessage[][]>;
+                    MapThreeStructs: Record<string, DeepMessage[][][]>;
+            
+                    static createFrom(source: any = {}) {
+                        return new DeepElements(source);
+                    }
+            
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Single = source["Single"];
+                        this.Double = source["Double"];
+                        this.FourDouble = source["FourDouble"];
+                        this.DoubleFour = source["DoubleFour"];
+                        this.Triple = source["Triple"];
+                        this.SingleMap = source["SingleMap"];
+                        this.SliceMap = source["SliceMap"];
+                        this.DoubleSliceMap = source["DoubleSliceMap"];
+                        this.ArrayMap = source["ArrayMap"];
+                        this.DoubleArrayMap1 = source["DoubleArrayMap1"];
+                        this.DoubleArrayMap2 = source["DoubleArrayMap2"];
+                        this.DoubleArrayMap3 = source["DoubleArrayMap3"];
+                        this.OneStructs = this.convertValues(source["OneStructs"], DeepMessage);
+                        this.TwoStructs = this.convertValues(source["TwoStructs"], DeepMessage);
+                        this.ThreeStructs = this.convertValues(source["ThreeStructs"], DeepMessage);
+                        this.MapStructs = this.convertValues(source["MapStructs"], DeepMessage[], true);
+                        this.MapTwoStructs = this.convertValues(source["MapTwoStructs"], DeepMessage[][], true);
+                        this.MapThreeStructs = this.convertValues(source["MapThreeStructs"], DeepMessage[][][], true);
+                    }
+            
+                        convertValues(a: any, classs: any, asMap: boolean = false): any {
+                            if (!a) {
+                                return a;
+                            }
+                            if (a.slice && a.map) {
+                                return (a as any[]).map(elem => this.convertValues(elem, classs));
+                            } else if ("object" === typeof a) {
+                                if (asMap) {
+                                    for (const key of Object.keys(a)) {
+                                        a[key] = new classs(a[key]);
+                                    }
+                                    return a;
+                                }
+                                return new classs(a);
+                            }
+                            return a;
+                        }
+                }
+            
+            }
+`,
+}

v2/internal/binding/binding_test/binding_generics_test.go

@@ -0,0 +1,154 @@
+package binding_test
+
+import "github.com/wailsapp/wails/v2/internal/binding/binding_test/binding_test_import/float_package"
+
+// Issues 3900, 3371, 2323 (no TS generics though)
+
+type ListData[T interface{}] struct {
+	Total     int64 `json:"Total"`
+	TotalPage int64 `json:"TotalPage"`
+	PageNum   int   `json:"PageNum"`
+	List      []T   `json:"List,omitempty"`
+}
+
+func (x ListData[T]) Get() ListData[T] {
+	return x
+}
+
+var Generics1Test = BindingTest{
+	name: "Generics1",
+	structs: []interface{}{
+		&ListData[string]{},
+	},
+	exemptions:  nil,
+	shouldError: false,
+	want: `
+export namespace binding_test {
+        
+                export class ListData_string_ {
+                    Total: number;
+                    TotalPage: number;
+                    PageNum: number;
+                    List?: string[];
+        
+                    static createFrom(source: any = {}) {
+                        return new ListData_string_(source);
+                    }
+        
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Total = source["Total"];
+                        this.TotalPage = source["TotalPage"];
+                        this.PageNum = source["PageNum"];
+                        this.List = source["List"];
+                    }
+                }
+        
+        }
+`,
+}
+
+var Generics2Test = BindingTest{
+	name: "Generics2",
+	structs: []interface{}{
+		&ListData[float_package.SomeStruct]{},
+		&ListData[*float_package.SomeStruct]{},
+	},
+	exemptions:  nil,
+	shouldError: false,
+	want: `
+export namespace binding_test {
+        
+                export class ListData__github_com_wailsapp_wails_v2_internal_binding_binding_test_binding_test_import_float_package_SomeStruct_ {
+                    Total: number;
+                    TotalPage: number;
+                    PageNum: number;
+                    List?: float_package.SomeStruct[];
+        
+                    static createFrom(source: any = {}) {
+                        return new ListData__github_com_wailsapp_wails_v2_internal_binding_binding_test_binding_test_import_float_package_SomeStruct_(source);
+                    }
+        
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Total = source["Total"];
+                        this.TotalPage = source["TotalPage"];
+                        this.PageNum = source["PageNum"];
+                        this.List = this.convertValues(source["List"], float_package.SomeStruct);
+                    }
+        
+                        convertValues(a: any, classs: any, asMap: boolean = false): any {
+                            if (!a) {
+                                return a;
+                            }
+                            if (a.slice && a.map) {
+                                return (a as any[]).map(elem => this.convertValues(elem, classs));
+                            } else if ("object" === typeof a) {
+                                if (asMap) {
+                                    for (const key of Object.keys(a)) {
+                                        a[key] = new classs(a[key]);
+                                    }
+                                    return a;
+                                }
+                                return new classs(a);
+                            }
+                            return a;
+                        }
+                }
+                export class ListData_github_com_wailsapp_wails_v2_internal_binding_binding_test_binding_test_import_float_package_SomeStruct_ {
+                    Total: number;
+                    TotalPage: number;
+                    PageNum: number;
+                    List?: float_package.SomeStruct[];
+        
+                    static createFrom(source: any = {}) {
+                        return new ListData_github_com_wailsapp_wails_v2_internal_binding_binding_test_binding_test_import_float_package_SomeStruct_(source);
+                    }
+        
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Total = source["Total"];
+                        this.TotalPage = source["TotalPage"];
+                        this.PageNum = source["PageNum"];
+                        this.List = this.convertValues(source["List"], float_package.SomeStruct);
+                    }
+        
+                        convertValues(a: any, classs: any, asMap: boolean = false): any {
+                            if (!a) {
+                                return a;
+                            }
+                            if (a.slice && a.map) {
+                                return (a as any[]).map(elem => this.convertValues(elem, classs));
+                            } else if ("object" === typeof a) {
+                                if (asMap) {
+                                    for (const key of Object.keys(a)) {
+                                        a[key] = new classs(a[key]);
+                                    }
+                                    return a;
+                                }
+                                return new classs(a);
+                            }
+                            return a;
+                        }
+                }
+        
+        }
+        
+        export namespace float_package {
+        
+                export class SomeStruct {
+                    string: string;
+        
+                    static createFrom(source: any = {}) {
+                        return new SomeStruct(source);
+                    }
+        
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.string = source["string"];
+                    }
+                }
+        
+        }
+`,
+}

v2/internal/binding/binding_test/binding_ignored_test.go

@@ -0,0 +1,47 @@
+package binding_test
+
+import (
+	"unsafe"
+)
+
+// Issues 3755, 3809
+
+type Ignored struct {
+	Valid      bool
+	Total      func() int `json:"Total"`
+	UnsafeP    unsafe.Pointer
+	Complex64  complex64 `json:"Complex"`
+	Complex128 complex128
+	StringChan chan string
+}
+
+func (x Ignored) Get() Ignored {
+	return x
+}
+
+var IgnoredTest = BindingTest{
+	name: "Ignored",
+	structs: []interface{}{
+		&Ignored{},
+	},
+	exemptions:  nil,
+	shouldError: false,
+	want: `
+export namespace binding_test {
+            
+                export class Ignored {
+                    Valid: boolean;
+            
+                    static createFrom(source: any = {}) {
+                        return new Ignored(source);
+                    }
+            
+                    constructor(source: any = {}) {
+                        if ('string' === typeof source) source = JSON.parse(source);
+                        this.Valid = source["Valid"];
+                    }
+                }
+            
+            }
+`,
+}

v2/internal/binding/binding_test/binding_test.go

@@ -51,6 +51,10 @@ func TestBindings_GenerateModels(t *testing.T) {
 		SpecialCharacterFieldTest,
 		WithoutFieldsTest,
 		NoFieldTagsTest,
+		Generics1Test,
+		Generics2Test,
+		IgnoredTest,
+		DeepElementsTest,
 	}
 
 	testLogger := &logger.Logger{}

v2/internal/binding/generate_test.go

@@ -128,6 +128,16 @@ func Test_goTypeToJSDocType(t *testing.T) {
 			input: "main.SomeType",
 			want:  "main.SomeType",
 		},
+		{
+			name:  "primitive_generic",
+			input: "main.ListData[string]",
+			want:  "main.ListData_string_",
+		},
+		{
+			name:  "stdlib_generic",
+			input: "main.ListData[*net/http.Request]",
+			want:  "main.ListData_net_http_Request_",
+		},
 	}
 	var importNamespaces slicer.StringSlicer
 	for _, tt := range tests {