func TestCheckBinaryTypedExprInt8EqlString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) == "abc"`, env,
		`cannot convert "abc" to type int8`,
		`invalid operation: 127 == "abc" (mismatched types int8 and string)`,
	)
}
Test Int8 == String
package eval
import (
	"testing"
	"reflect"
)
func TestCheckBinaryTypedExprInt8AddInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + 4`, env,
		`constant 131 overflows int8`,
	)
}
func TestCheckBinaryTypedExprInt8AddRune(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + '@'`, env,
		`constant 191 overflows int8`,
	)
}
func TestCheckBinaryTypedExprInt8AddFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + 2.0`, env,
		`constant 129 overflows int8`,
	)
}
func TestCheckBinaryTypedExprInt8AddComplex(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + 8.0i`, env,
		`constant 0+8i truncated to real`,
	)
}
func TestCheckBinaryTypedExprInt8AddBool(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + true`, env,
		`cannot convert true to type int8`,
		`invalid operation: 127 + true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8AddString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + "abc"`, env,
		`cannot convert "abc" to type int8`,
		`invalid operation: 127 + "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8AddNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + nil`, env,
		`cannot convert nil to type int8`,
	)
}
func TestCheckBinaryTypedExprInt8AddInt8(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + int8(0x7f)`, env,
		`constant 254 overflows int8`,
	)
}
func TestCheckBinaryTypedExprInt8AddInt16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + int16(0x7fff)`, env,
		`invalid operation: 127 + 32767 (mismatched types int8 and int16)`,
	)
}
func TestCheckBinaryTypedExprInt8AddInt32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + int32(0x7fffffff)`, env,
		`invalid operation: 127 + 2147483647 (mismatched types int8 and int32)`,
	)
}
func TestCheckBinaryTypedExprInt8AddInt64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + int64(0x7fffffffffffffff)`, env,
		`invalid operation: 127 + 9223372036854775807 (mismatched types int8 and int64)`,
	)
}
func TestCheckBinaryTypedExprInt8AddUint8(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + uint8(0xff)`, env,
		`invalid operation: 127 + 255 (mismatched types int8 and uint8)`,
	)
}
func TestCheckBinaryTypedExprInt8AddUint16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + uint16(0xffff)`, env,
		`invalid operation: 127 + 65535 (mismatched types int8 and uint16)`,
	)
}
func TestCheckBinaryTypedExprInt8AddUint32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + uint32(0xffffffff)`, env,
		`invalid operation: 127 + 4294967295 (mismatched types int8 and uint32)`,
	)
}
func TestCheckBinaryTypedExprInt8AddUint64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + uint64(0xffffffffffffffff)`, env,
		`invalid operation: 127 + 18446744073709551615 (mismatched types int8 and uint64)`,
	)
}
func TestCheckBinaryTypedExprInt8AddFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + float32(0xffffffff)`, env,
		`invalid operation: 127 + 4.29497e+09 (mismatched types int8 and float32)`,
	)
}
func TestCheckBinaryTypedExprInt8AddFloat64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + float64(0xffffffff)`, env,
		`invalid operation: 127 + 4.29497e+09 (mismatched types int8 and float64)`,
	)
}
func TestCheckBinaryTypedExprInt8AddComplex64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + complex64(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 + (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex64)`,
	)
}
func TestCheckBinaryTypedExprInt8AddComplex128(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + complex128(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 + (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex128)`,
	)
}
func TestCheckBinaryTypedExprInt8AddRune32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + rune(0x7fffffff)`, env,
		`invalid operation: 127 + rune(2147483647) (mismatched types int8 and rune)`,
	)
}
func TestCheckBinaryTypedExprInt8AddStringT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + string("abc")`, env,
		`invalid operation: 127 + "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8AddBoolT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) + bool(true)`, env,
		`invalid operation: 127 + true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8SubInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) - 4`, env, int8(0x7f) - 4, reflect.TypeOf(int8(0x7f) - 4))
}
func TestCheckBinaryTypedExprInt8SubRune(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) - '@'`, env, int8(0x7f) - '@', reflect.TypeOf(int8(0x7f) - '@'))
}
func TestCheckBinaryTypedExprInt8SubFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) - 2.0`, env, int8(0x7f) - 2.0, reflect.TypeOf(int8(0x7f) - 2.0))
}
func TestCheckBinaryTypedExprInt8SubComplex(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - 8.0i`, env,
		`constant 0+8i truncated to real`,
	)
}
func TestCheckBinaryTypedExprInt8SubBool(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - true`, env,
		`cannot convert true to type int8`,
		`invalid operation: 127 - true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8SubString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - "abc"`, env,
		`cannot convert "abc" to type int8`,
		`invalid operation: 127 - "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8SubNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - nil`, env,
		`cannot convert nil to type int8`,
	)
}
func TestCheckBinaryTypedExprInt8SubInt8(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) - int8(0x7f)`, env, int8(0x7f) - int8(0x7f), reflect.TypeOf(int8(0x7f) - int8(0x7f)))
}
func TestCheckBinaryTypedExprInt8SubInt16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - int16(0x7fff)`, env,
		`invalid operation: 127 - 32767 (mismatched types int8 and int16)`,
	)
}
func TestCheckBinaryTypedExprInt8SubInt32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - int32(0x7fffffff)`, env,
		`invalid operation: 127 - 2147483647 (mismatched types int8 and int32)`,
	)
}
func TestCheckBinaryTypedExprInt8SubInt64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - int64(0x7fffffffffffffff)`, env,
		`invalid operation: 127 - 9223372036854775807 (mismatched types int8 and int64)`,
	)
}
func TestCheckBinaryTypedExprInt8SubUint8(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - uint8(0xff)`, env,
		`invalid operation: 127 - 255 (mismatched types int8 and uint8)`,
	)
}
func TestCheckBinaryTypedExprInt8SubUint16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - uint16(0xffff)`, env,
		`invalid operation: 127 - 65535 (mismatched types int8 and uint16)`,
	)
}
func TestCheckBinaryTypedExprInt8SubUint32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - uint32(0xffffffff)`, env,
		`invalid operation: 127 - 4294967295 (mismatched types int8 and uint32)`,
	)
}
func TestCheckBinaryTypedExprInt8SubUint64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - uint64(0xffffffffffffffff)`, env,
		`invalid operation: 127 - 18446744073709551615 (mismatched types int8 and uint64)`,
	)
}
func TestCheckBinaryTypedExprInt8SubFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - float32(0xffffffff)`, env,
		`invalid operation: 127 - 4.29497e+09 (mismatched types int8 and float32)`,
	)
}
func TestCheckBinaryTypedExprInt8SubFloat64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - float64(0xffffffff)`, env,
		`invalid operation: 127 - 4.29497e+09 (mismatched types int8 and float64)`,
	)
}
func TestCheckBinaryTypedExprInt8SubComplex64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - complex64(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 - (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex64)`,
	)
}
func TestCheckBinaryTypedExprInt8SubComplex128(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - complex128(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 - (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex128)`,
	)
}
func TestCheckBinaryTypedExprInt8SubRune32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - rune(0x7fffffff)`, env,
		`invalid operation: 127 - rune(2147483647) (mismatched types int8 and rune)`,
	)
}
func TestCheckBinaryTypedExprInt8SubStringT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - string("abc")`, env,
		`invalid operation: 127 - "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8SubBoolT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) - bool(true)`, env,
		`invalid operation: 127 - true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8AndInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) & 4`, env, int8(0x7f) & 4, reflect.TypeOf(int8(0x7f) & 4))
}
func TestCheckBinaryTypedExprInt8AndRune(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) & '@'`, env, int8(0x7f) & '@', reflect.TypeOf(int8(0x7f) & '@'))
}
func TestCheckBinaryTypedExprInt8AndFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) & 2.0`, env, int8(0x7f) & 2.0, reflect.TypeOf(int8(0x7f) & 2.0))
}
func TestCheckBinaryTypedExprInt8AndComplex(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & 8.0i`, env,
		`constant 0+8i truncated to real`,
	)
}
func TestCheckBinaryTypedExprInt8AndBool(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & true`, env,
		`cannot convert true to type int8`,
		`invalid operation: 127 & true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8AndString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & "abc"`, env,
		`cannot convert "abc" to type int8`,
		`invalid operation: 127 & "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8AndNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & nil`, env,
		`cannot convert nil to type int8`,
	)
}
func TestCheckBinaryTypedExprInt8AndInt8(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) & int8(0x7f)`, env, int8(0x7f) & int8(0x7f), reflect.TypeOf(int8(0x7f) & int8(0x7f)))
}
func TestCheckBinaryTypedExprInt8AndInt16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & int16(0x7fff)`, env,
		`invalid operation: 127 & 32767 (mismatched types int8 and int16)`,
	)
}
func TestCheckBinaryTypedExprInt8AndInt32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & int32(0x7fffffff)`, env,
		`invalid operation: 127 & 2147483647 (mismatched types int8 and int32)`,
	)
}
func TestCheckBinaryTypedExprInt8AndInt64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & int64(0x7fffffffffffffff)`, env,
		`invalid operation: 127 & 9223372036854775807 (mismatched types int8 and int64)`,
	)
}
func TestCheckBinaryTypedExprInt8AndUint8(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & uint8(0xff)`, env,
		`invalid operation: 127 & 255 (mismatched types int8 and uint8)`,
	)
}
func TestCheckBinaryTypedExprInt8AndUint16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & uint16(0xffff)`, env,
		`invalid operation: 127 & 65535 (mismatched types int8 and uint16)`,
	)
}
func TestCheckBinaryTypedExprInt8AndUint32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & uint32(0xffffffff)`, env,
		`invalid operation: 127 & 4294967295 (mismatched types int8 and uint32)`,
	)
}
func TestCheckBinaryTypedExprInt8AndUint64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & uint64(0xffffffffffffffff)`, env,
		`invalid operation: 127 & 18446744073709551615 (mismatched types int8 and uint64)`,
	)
}
func TestCheckBinaryTypedExprInt8AndFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & float32(0xffffffff)`, env,
		`invalid operation: 127 & 4.29497e+09 (mismatched types int8 and float32)`,
	)
}
func TestCheckBinaryTypedExprInt8AndFloat64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & float64(0xffffffff)`, env,
		`invalid operation: 127 & 4.29497e+09 (mismatched types int8 and float64)`,
	)
}
func TestCheckBinaryTypedExprInt8AndComplex64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & complex64(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 & (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex64)`,
	)
}
func TestCheckBinaryTypedExprInt8AndComplex128(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & complex128(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 & (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex128)`,
	)
}
func TestCheckBinaryTypedExprInt8AndRune32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & rune(0x7fffffff)`, env,
		`invalid operation: 127 & rune(2147483647) (mismatched types int8 and rune)`,
	)
}
func TestCheckBinaryTypedExprInt8AndStringT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & string("abc")`, env,
		`invalid operation: 127 & "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8AndBoolT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) & bool(true)`, env,
		`invalid operation: 127 & true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8RemInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) % 4`, env, int8(0x7f) % 4, reflect.TypeOf(int8(0x7f) % 4))
}
func TestCheckBinaryTypedExprInt8RemRune(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) % '@'`, env, int8(0x7f) % '@', reflect.TypeOf(int8(0x7f) % '@'))
}
func TestCheckBinaryTypedExprInt8RemFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) % 2.0`, env, int8(0x7f) % 2.0, reflect.TypeOf(int8(0x7f) % 2.0))
}
func TestCheckBinaryTypedExprInt8RemComplex(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % 8.0i`, env,
		`constant 0+8i truncated to real`,
		`division by zero`,
	)
}
func TestCheckBinaryTypedExprInt8RemBool(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % true`, env,
		`cannot convert true to type int8`,
		`invalid operation: 127 % true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8RemString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % "abc"`, env,
		`cannot convert "abc" to type int8`,
		`invalid operation: 127 % "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8RemNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % nil`, env,
		`cannot convert nil to type int8`,
	)
}
func TestCheckBinaryTypedExprInt8RemInt8(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) % int8(0x7f)`, env, int8(0x7f) % int8(0x7f), reflect.TypeOf(int8(0x7f) % int8(0x7f)))
}
func TestCheckBinaryTypedExprInt8RemInt16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % int16(0x7fff)`, env,
		`invalid operation: 127 % 32767 (mismatched types int8 and int16)`,
	)
}
func TestCheckBinaryTypedExprInt8RemInt32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % int32(0x7fffffff)`, env,
		`invalid operation: 127 % 2147483647 (mismatched types int8 and int32)`,
	)
}
func TestCheckBinaryTypedExprInt8RemInt64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % int64(0x7fffffffffffffff)`, env,
		`invalid operation: 127 % 9223372036854775807 (mismatched types int8 and int64)`,
	)
}
func TestCheckBinaryTypedExprInt8RemUint8(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % uint8(0xff)`, env,
		`invalid operation: 127 % 255 (mismatched types int8 and uint8)`,
	)
}
func TestCheckBinaryTypedExprInt8RemUint16(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % uint16(0xffff)`, env,
		`invalid operation: 127 % 65535 (mismatched types int8 and uint16)`,
	)
}
func TestCheckBinaryTypedExprInt8RemUint32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % uint32(0xffffffff)`, env,
		`invalid operation: 127 % 4294967295 (mismatched types int8 and uint32)`,
	)
}
func TestCheckBinaryTypedExprInt8RemUint64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % uint64(0xffffffffffffffff)`, env,
		`invalid operation: 127 % 18446744073709551615 (mismatched types int8 and uint64)`,
	)
}
func TestCheckBinaryTypedExprInt8RemFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % float32(0xffffffff)`, env,
		`invalid operation: 127 % 4.29497e+09 (mismatched types int8 and float32)`,
	)
}
func TestCheckBinaryTypedExprInt8RemFloat64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % float64(0xffffffff)`, env,
		`invalid operation: 127 % 4.29497e+09 (mismatched types int8 and float64)`,
	)
}
func TestCheckBinaryTypedExprInt8RemComplex64(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % complex64(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 % (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex64)`,
	)
}
func TestCheckBinaryTypedExprInt8RemComplex128(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % complex128(0xffffffff + 0xffffffff * 1i)`, env,
		`invalid operation: 127 % (4.29497e+09+4.29497e+09i) (mismatched types int8 and complex128)`,
	)
}
func TestCheckBinaryTypedExprInt8RemRune32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % rune(0x7fffffff)`, env,
		`invalid operation: 127 % rune(2147483647) (mismatched types int8 and rune)`,
	)
}
func TestCheckBinaryTypedExprInt8RemStringT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % string("abc")`, env,
		`invalid operation: 127 % "abc" (mismatched types int8 and string)`,
	)
}
func TestCheckBinaryTypedExprInt8RemBoolT(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) % bool(true)`, env,
		`invalid operation: 127 % true (mismatched types int8 and bool)`,
	)
}
func TestCheckBinaryTypedExprInt8EqlInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) == 4`, env, int8(0x7f) == 4, reflect.TypeOf(int8(0x7f) == 4))
}
func TestCheckBinaryTypedExprInt8EqlRune(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) == '@'`, env, int8(0x7f) == '@', reflect.TypeOf(int8(0x7f) == '@'))
}
func TestCheckBinaryTypedExprInt8EqlFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `int8(0x7f) == 2.0`, env, int8(0x7f) == 2.0, reflect.TypeOf(int8(0x7f) == 2.0))
}
func TestCheckBinaryTypedExprInt8EqlComplex(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) == 8.0i`, env,
		`constant 0+8i truncated to real`,
	)
}
func TestCheckBinaryTypedExprInt8EqlBool(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `int8(0x7f) == true`, env,
		`cannot convert true to type int8`,
		`invalid operation: 127 == true (mismatched types int8 and bool)`,
	)
}