shape_test.go

     1  // Copyright 2026 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package specexpr
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  )
    11  
    12  func TestParseTypeName(t *testing.T) {
    13  	tests := []struct {
    14  		name string
    15  		want Type
    16  	}{
    17  		// Basic types
    18  		{"int", Basic{Base: "int", Bits: 0}},
    19  		{"int8", Basic{Base: "int", Bits: 8}},
    20  		{"int16", Basic{Base: "int", Bits: 16}},
    21  		{"int32", Basic{Base: "int", Bits: 32}},
    22  		{"int64", Basic{Base: "int", Bits: 64}},
    23  		{"uint", Basic{Base: "uint", Bits: 0}},
    24  		{"uint8", Basic{Base: "uint", Bits: 8}},
    25  		{"uint16", Basic{Base: "uint", Bits: 16}},
    26  		{"uint32", Basic{Base: "uint", Bits: 32}},
    27  		{"uint64", Basic{Base: "uint", Bits: 64}},
    28  		{"uintptr", Basic{Base: "uintptr", Bits: 0}},
    29  		{"byte", Basic{Base: "uint", Bits: 8}},
    30  		{"rune", Basic{Base: "int", Bits: 32}},
    31  		{"float32", Basic{Base: "float", Bits: 32}},
    32  		{"float64", Basic{Base: "float", Bits: 64}},
    33  		{"complex64", Basic{Base: "complex", Bits: 64}},
    34  		{"complex128", Basic{Base: "complex", Bits: 128}},
    35  		{"bool", Basic{Base: "bool", Bits: 0}},
    36  		{"string", Basic{Base: "string", Bits: 0}},
    37  
    38  		// Fixed vectors (x<lanes>)
    39  		{"Int8x16", Vector{Elem: Basic{Base: "int", Bits: 8}, Width: Int(128)}},
    40  		{"Int16x8", Vector{Elem: Basic{Base: "int", Bits: 16}, Width: Int(128)}},
    41  		{"Int32x4", Vector{Elem: Basic{Base: "int", Bits: 32}, Width: Int(128)}},
    42  		{"Int64x2", Vector{Elem: Basic{Base: "int", Bits: 64}, Width: Int(128)}},
    43  		{"Int32x8", Vector{Elem: Basic{Base: "int", Bits: 32}, Width: Int(256)}},
    44  		{"Int32x16", Vector{Elem: Basic{Base: "int", Bits: 32}, Width: Int(512)}},
    45  		{"Uint8x16", Vector{Elem: Basic{Base: "uint", Bits: 8}, Width: Int(128)}},
    46  		{"Uint64x4", Vector{Elem: Basic{Base: "uint", Bits: 64}, Width: Int(256)}},
    47  		{"Float32x4", Vector{Elem: Basic{Base: "float", Bits: 32}, Width: Int(128)}},
    48  		{"Float64x2", Vector{Elem: Basic{Base: "float", Bits: 64}, Width: Int(128)}},
    49  		{"Float64x4", Vector{Elem: Basic{Base: "float", Bits: 64}, Width: Int(256)}},
    50  		{"Mask8x16", Vector{Elem: Basic{Base: "Mask", Bits: 8}, Width: Int(128)}},
    51  		{"Mask16x16", Vector{Elem: Basic{Base: "Mask", Bits: 16}, Width: Int(256)}},
    52  		{"Mask64x8", Vector{Elem: Basic{Base: "Mask", Bits: 64}, Width: Int(512)}},
    53  
    54  		// Scalable vectors (s)
    55  		{"Int8s", Vector{Elem: Basic{Base: "int", Bits: 8}, Width: VW()}},
    56  		{"Int32s", Vector{Elem: Basic{Base: "int", Bits: 32}, Width: VW()}},
    57  		{"Uint64s", Vector{Elem: Basic{Base: "uint", Bits: 64}, Width: VW()}},
    58  		{"Float32s", Vector{Elem: Basic{Base: "float", Bits: 32}, Width: VW()}},
    59  		{"Float64s", Vector{Elem: Basic{Base: "float", Bits: 64}, Width: VW()}},
    60  		{"Mask8s", Vector{Elem: Basic{Base: "Mask", Bits: 8}, Width: VW()}},
    61  		{"Mask32s", Vector{Elem: Basic{Base: "Mask", Bits: 32}, Width: VW()}},
    62  	}
    63  
    64  	for _, tc := range tests {
    65  		t.Run(tc.name, func(t *testing.T) {
    66  			got, err := ParseTypeName(tc.name)
    67  			if err != nil {
    68  				t.Fatalf("ParseTypeName(%q) unexpected error: %v", tc.name, err)
    69  			}
    70  			if !reflect.DeepEqual(got, tc.want) {
    71  				t.Errorf("ParseTypeName(%q) = %+v; want %+v", tc.name, got, tc.want)
    72  			}
    73  		})
    74  	}
    75  }
    76  
    77  func TestParseTypeNameErrors(t *testing.T) {
    78  	bad := []string{
    79  		"",
    80  		"   ",
    81  		"int48",
    82  		"any",
    83  		"Mask",
    84  		"Mask8",
    85  		"Int",
    86  		"Int9999999999999999999999x1", // Overflow
    87  		"Int1x9999999999999999999999",
    88  		"Int32x-1",
    89  		"Int32x0",
    90  		"Int32x1",   // width = 32, invalid
    91  		"Int32x3",   // width = 96, invalid
    92  		"Int32w128", // w forms rejected
    93  	}
    94  
    95  	for _, s := range bad {
    96  		t.Run(s, func(t *testing.T) {
    97  			got, err := ParseTypeName(s)
    98  			if err == nil {
    99  				t.Errorf("ParseTypeName(%q) succeeded (%+v), want error", s, got)
   100  			}
   101  		})
   102  	}
   103  }
   104
View as plain text