| // Copyright 2026 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package specgen |
| |
| import ( |
| "simd/archsimd/_gen/specgen/specexpr" |
| "strings" |
| "testing" |
| ) |
| |
| func TestNewSpecTemplate(t *testing.T) { |
| tests := []struct { |
| tmpl string |
| isTmpl bool |
| wantErr bool |
| }{ |
| { |
| tmpl: "", |
| isTmpl: false, |
| }, |
| { |
| tmpl: "Convert", |
| isTmpl: false, |
| }, |
| { |
| tmpl: "Convert{{.zL}}To{{.zB}}{{.zN}}", |
| isTmpl: true, |
| }, |
| { |
| tmpl: "Convert{{.zL", |
| wantErr: true, |
| }, |
| { |
| tmpl: "Convert{{if}}", |
| wantErr: true, |
| }, |
| } |
| |
| for _, tc := range tests { |
| got, err := newSpecTemplate(tc.tmpl) |
| if (err != nil) != tc.wantErr { |
| t.Errorf("newSpecTemplate(%q) returned error: %v, wantErr: %v", tc.tmpl, err, tc.wantErr) |
| continue |
| } |
| if tc.wantErr { |
| continue |
| } |
| if got.raw != tc.tmpl { |
| t.Errorf("newSpecTemplate(%q) raw = %q, want %q", tc.tmpl, got.raw, tc.tmpl) |
| } |
| if (got.tmpl != nil) != tc.isTmpl { |
| t.Errorf("newSpecTemplate(%q) isTmpl = %v, want %v", tc.tmpl, got.tmpl != nil, tc.isTmpl) |
| } |
| } |
| } |
| |
| func TestSpecTemplateExpand(t *testing.T) { |
| tmpl, err := newSpecTemplate("Convert{{.zL}}To{{.zB}}{{.zN}}") |
| if err != nil { |
| t.Fatalf("unexpected error parsing template: %v", err) |
| } |
| |
| data := map[string]any{ |
| "zL": specexpr.Int(4), |
| "zB": "Float", |
| "zN": specexpr.Int(32), |
| } |
| |
| got, err := tmpl.expand(data) |
| if err != nil { |
| t.Fatalf("unexpected error expanding template: %v", err) |
| } |
| want := "Convert4ToFloat32" |
| if got != want { |
| t.Errorf("expected expanded string %q, got %q", want, got) |
| } |
| } |
| |
| func TestSpecTemplateTitle(t *testing.T) { |
| tmpl, err := newSpecTemplate("ConvertTo{{.zE | title}}") |
| if err != nil { |
| t.Fatalf("unexpected error parsing template: %v", err) |
| } |
| |
| data := map[string]any{ |
| "zE": specexpr.Basic{Base: "float", Bits: 32}, |
| } |
| |
| got, err := tmpl.expand(data) |
| if err != nil { |
| t.Fatalf("unexpected error expanding template: %v", err) |
| } |
| want := "ConvertToFloat32" |
| if got != want { |
| t.Errorf("expected %q, got %q", want, got) |
| } |
| } |
| |
| func TestSpecTemplateConditionals(t *testing.T) { |
| tmplStr := `Doc for {{.Name}}. |
| {{if lt .zL .xL}} |
| Upper elements of the result are zeroed. |
| {{end}}` |
| |
| tmpl, err := newSpecTemplate(tmplStr) |
| if err != nil { |
| t.Fatalf("unexpected error parsing template: %v", err) |
| } |
| |
| // Case 1: zL < xL |
| data1 := map[string]any{ |
| "Name": "ConvertLo4ToFloat32", |
| "zL": specexpr.Int(4), |
| "xL": specexpr.Int(8), |
| } |
| got1, err := tmpl.expand(data1) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if !strings.Contains(got1, "Upper elements of the result are zeroed.") { |
| t.Errorf("expected conditional text when zL < xL, got: %q", got1) |
| } |
| |
| // Case 2: zL >= xL |
| data2 := map[string]any{ |
| "Name": "ConvertLo8ToFloat32", |
| "zL": specexpr.Int(8), |
| "xL": specexpr.Int(8), |
| } |
| got2, err := tmpl.expand(data2) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if strings.Contains(got2, "Upper elements of the result are zeroed.") { |
| t.Errorf("expected no conditional text when zL == xL, got: %q", got2) |
| } |
| } |
| |
| func TestSpecTemplateScalableWidthCompare(t *testing.T) { |
| tmpl, err := newSpecTemplate("{{if lt .zL .xL}}smaller{{else}}same-or-larger{{end}}") |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| |
| // zL = VW/32, xL = VW/16 => zL < xL |
| zL, err := specexpr.VW().Div(specexpr.Int(32)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| xL, err := specexpr.VW().Div(specexpr.Int(16)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| data := map[string]any{ |
| "zL": zL, |
| "xL": xL, |
| } |
| got, err := tmpl.expand(data) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got != "smaller" { |
| t.Errorf("expected 'smaller', got %q", got) |
| } |
| } |
| |
| func TestSpecTemplateMissingKey(t *testing.T) { |
| tmpl, err := newSpecTemplate("Convert{{.missing}}") |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| |
| _, err = tmpl.expand(map[string]any{}) |
| if err == nil { |
| t.Errorf("expected error on missing key, got nil") |
| } |
| } |
| |
| func TestCleanDocNewlines(t *testing.T) { |
| tests := []struct { |
| input string |
| want string |
| }{ |
| { |
| input: "hello\n\n\n\nworld\n", |
| want: "hello\n\nworld\n", |
| }, |
| { |
| input: "hello\n\n\n", |
| want: "hello\n", |
| }, |
| { |
| input: "", |
| want: "", |
| }, |
| } |
| |
| for _, tc := range tests { |
| got := cleanDocNewlines(tc.input) |
| if got != tc.want { |
| t.Errorf("cleanDocNewlines(%q) = %q, want %q", tc.input, got, tc.want) |
| } |
| } |
| } |
| |
| func TestReshapeDiagram(t *testing.T) { |
| vec := func(n, l int) specexpr.Vector { |
| return specexpr.Vector{Elem: specexpr.Basic{Base: "uint", Bits: specexpr.Int(n)}, Width: specexpr.Int(n * l)} |
| } |
| u8s := specexpr.Vector{Elem: specexpr.Basic{Base: "uint", Bits: 8}, Width: specexpr.VW()} |
| u16s := specexpr.Vector{Elem: specexpr.Basic{Base: "uint", Bits: 16}, Width: specexpr.VW()} |
| |
| tests := []struct { |
| name string |
| x, z specexpr.Vector |
| want string |
| }{ |
| { |
| // Basic, no elision case |
| name: "Uint32x4 -> Uint64x2", |
| x: vec(32, 4), |
| z: vec(64, 2), |
| want: "\t x[3] x[2] x[1] x[0]\n" + |
| "\t | 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |\n" + |
| "\t | 63 .... 0 | 63 .... 0 |\n" + |
| "\t z[1] z[0]", |
| }, |
| { |
| // Small to big, with elided middle |
| name: "Uint32x8 -> Uint64x4", |
| x: vec(32, 8), |
| z: vec(64, 4), |
| want: "\t x[7] x[6] ⋯ x[1] x[0]\n" + |
| "\t | 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |\n" + |
| "\t | 63 .... 0 | ⋯ | 63 .... 0 |\n" + |
| "\t z[3] ⋯ z[0]", |
| }, |
| { |
| // Big to small, with elided middle |
| name: "Uint64x4 -> Uint32x8", |
| x: vec(64, 4), |
| z: vec(32, 8), |
| want: "\t x[3] ⋯ x[0]\n" + |
| "\t | 63 .... 0 | ⋯ | 63 .... 0 |\n" + |
| "\t | 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |\n" + |
| "\t z[7] z[6] ⋯ z[1] z[0]", |
| }, |
| { |
| // Eliding elements within each big element |
| name: "Uint64x2 -> Uint8x16", |
| x: vec(64, 2), |
| z: vec(8, 16), |
| want: "\t x[1] x[0]\n" + |
| "\t | 63 .... 0 | 63 .... 0 |\n" + |
| "\t | 7 .. 0 | 7 .. 0 | ⋯ | 7 .. 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 | ⋯ | 7 .. 0 | 7 .. 0 |\n" + |
| "\t z[15] z[14] ⋯ z[9] z[8] z[7] z[6] ⋯ z[1] z[0]", |
| }, |
| { |
| // Eliding elements within each big element, and elided middle |
| name: "Uint8x64 -> Uint64x8", |
| x: vec(8, 64), |
| z: vec(64, 8), |
| want: "\t x[63] x[62] ⋯ x[57] x[56] ⋯ x[7] x[6] ⋯ x[1] x[0]\n" + |
| "\t | 7 .. 0 | 7 .. 0 | ⋯ | 7 .. 0 | 7 .. 0 | ⋯ | 7 .. 0 | 7 .. 0 | ⋯ | 7 .. 0 | 7 .. 0 |\n" + |
| "\t | 63 .... 0 | ⋯ | 63 .... 0 |\n" + |
| "\t z[7] ⋯ z[0]", |
| }, |
| { |
| // Scalable |
| name: "Uint8s -> Uint16s (Scalable)", |
| x: u8s, |
| z: u16s, |
| want: "\t ⋯ x[3] x[2] x[1] x[0]\n" + |
| "\t ⋯ | 7 .. 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |\n" + |
| "\t ⋯ | 15 .... 0 | 15 .... 0 |\n" + |
| "\t ⋯ z[1] z[0]", |
| }, |
| } |
| |
| for _, tc := range tests { |
| t.Run(tc.name, func(t *testing.T) { |
| got := reshapeDiagram(tc.x, tc.z) |
| if got != tc.want { |
| t.Errorf("reshapeDiagram(%s, %s):\ngot:\n%s\nwant:\n%s", tc.x, tc.z, got, tc.want) |
| } |
| }) |
| } |
| } |
