if thisPass == pass {
			// Index operation
			testExpr(b, pae+"["+cni+"]")

			// Slice operation.
			// Low index 0 is a special case in ggen.c
			// so test both 0 and 1.
			testExpr(b, pae+"[0:"+cni+"]")
			testExpr(b, pae+"[1:"+cni+"]")
			testExpr(b, pae+"["+cni+":]")
			testExpr(b, pae+"["+cni+":"+cni+"]")
		}
	})

	fmt.Fprintln(b, "}")
	b.Flush()
}

	{"3<<2+4", 3<<2 + 4, true},
	{"3<<2+4", 3<<2 + 4, true},
	{"3<<(2+4)", 3 << (2 + 4), true},
	// Junk at EOF.
	{"3 x", 3, false},
	// Big number
	{"4611686018427387904", 4611686018427387904, true},
}

func TestExpr(t *testing.T) {
	p := NewParser(nil, nil, nil) // Expression evaluation uses none of these fields of the parser.
	for i, test := range exprTests {
		p.start(lex.Tokenize(test.input))
		result := int64(p.expr())

package clause_test

import (
	"database/sql"
	"fmt"
	"reflect"
	"sync"
	"testing"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils/tests"
)

func TestExpr(t *testing.T) {
	results := []struct {
		SQL    string
		Result string
		Vars   []interface{}
	}{{
		SQL:    "create table ? (? ?, ? ?)",

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types_test

import (
	"go/parser"
	"testing"

	. "go/types"
)

var testExprs = []testEntry{
	// basic type literals
	dup("x"),
	dup("true"),
	dup("42"),
	dup("3.1415"),
	dup("2.71828i"),
	dup(`'a'`),
	dup(`"foo"`),
	dup("`bar`"),
	dup("any"),

		if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
			t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
		}
	}
}

func TestExp2(t *testing.T) {
	testExp2(t, Exp2, "Exp2")
	testExp2(t, Exp2Go, "Exp2Go")
}

func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
	for i := 0; i < len(vf); i++ {
		if f := Exp2(vf[i]); !close(exp2[i], f) {

	if x.Equal(expected) != 1 {
		t.Errorf("%+v != %+v", x, expected)
	}
	x.Add(y, m)
	expected = &Nat{[]uint{7}}
	if x.Equal(expected) != 1 {
		t.Errorf("%+v != %+v", x, expected)
	}
}

func TestExp(t *testing.T) {
	m := modulusFromBytes([]byte{13})
	x := &Nat{[]uint{3}}
	out := &Nat{[]uint{0}}
	out.Exp(x, []byte{12}, m)
	expected := &Nat{[]uint{1}}
	if out.Equal(expected) != 1 {

			continue
		}
		// Cosh(-z)  == Cosh(z)
		if f := Cosh(-v.in); !cAlike(v.want, f) && !cAlike(v.in, -v.in) {
			t.Errorf("Cosh(%g) = %g, want %g", -v.in, f, v.want)
		}
	}
}
func TestExp(t *testing.T) {
	for i := 0; i < len(vc); i++ {
		if f := Exp(vc[i]); !cSoclose(exp[i], f, 1e-15) {
			t.Errorf("Exp(%g) = %g, want %g", vc[i], f, exp[i])
		}
	}
	for _, v := range expSC {

	},
}

func TestExp(t *testing.T) {
	for i, test := range expTests {
		x, ok1 := new(Int).SetString(test.x, 0)
		y, ok2 := new(Int).SetString(test.y, 0)

		var ok3, ok4 bool
		var out, m *Int

		if len(test.out) == 0 {

  %0 = "tfl.cos"(%arg0): (tensor<?xi32>) -> tensor<?xi32>
  func.return %0#0 : tensor<?xi32>
}

// -----

// CHECK-LABEL: testExp
func.func @testExp(tensor<? x f32>) -> tensor<? x f32> {
^bb0(%arg0: tensor<? x f32>):
  // CHECK: "tfl.exp"(%arg0)
  %0 = "tfl.exp"(%arg0): (tensor<? x f32>) -> tensor<? x f32>
  func.return %0 : tensor<? x f32>
}