mirror of
https://github.com/golang/go
synced 2024-11-14 18:10:27 -07:00
dcb1c5f5d4
start on Decl, but not working yet R=austin DELTA=762 (201 added, 205 deleted, 356 changed) OCL=34335 CL=34349
346 lines
8.2 KiB
Go
346 lines
8.2 KiB
Go
// Copyright 2009 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 eval
|
|
|
|
import (
|
|
"bignum";
|
|
"testing";
|
|
)
|
|
|
|
var undefined = "undefined"
|
|
var typeAsExpr = "type .* used as expression"
|
|
var badCharLit = "character literal"
|
|
var illegalEscape = "illegal char escape"
|
|
var opTypes = "illegal (operand|argument) type|cannot index into"
|
|
var badAddrOf = "cannot take the address"
|
|
var constantTruncated = "constant [^ ]* truncated"
|
|
var constantUnderflows = "constant [^ ]* underflows"
|
|
var constantOverflows = "constant [^ ]* overflows"
|
|
var implLimit = "implementation limit"
|
|
var mustBeUnsigned = "must be unsigned"
|
|
var divByZero = "divide by zero"
|
|
|
|
var hugeInteger = bignum.Int(1).Shl(64);
|
|
|
|
var exprTests = []test {
|
|
Val("i", 1),
|
|
CErr("zzz", undefined),
|
|
// TODO(austin) Test variable in constant context
|
|
//CErr("t", typeAsExpr),
|
|
|
|
Val("'a'", bignum.Int('a')),
|
|
Val("'\\uffff'", bignum.Int('\uffff')),
|
|
Val("'\\n'", bignum.Int('\n')),
|
|
CErr("''+x", badCharLit),
|
|
// Produces two parse errors
|
|
//CErr("'''", ""),
|
|
CErr("'\n'", badCharLit),
|
|
CErr("'\\z'", illegalEscape),
|
|
CErr("'ab'", badCharLit),
|
|
|
|
Val("1.0", bignum.Rat(1, 1)),
|
|
Val("1.", bignum.Rat(1, 1)),
|
|
Val(".1", bignum.Rat(1, 10)),
|
|
Val("1e2", bignum.Rat(100, 1)),
|
|
|
|
Val("\"abc\"", "abc"),
|
|
Val("\"\"", ""),
|
|
Val("\"\\n\\\"\"", "\n\""),
|
|
CErr("\"\\z\"", illegalEscape),
|
|
CErr("\"abc", "string not terminated"),
|
|
|
|
Val("\"abc\" \"def\"", "abcdef"),
|
|
CErr("\"abc\" \"\\z\"", illegalEscape),
|
|
|
|
Val("(i)", 1),
|
|
|
|
Val("ai[0]", 1),
|
|
Val("(&ai)[0]", 1),
|
|
Val("ai[1]", 2),
|
|
Val("ai[i]", 2),
|
|
Val("ai[u]", 2),
|
|
CErr("ai[f]", opTypes),
|
|
CErr("ai[0][0]", opTypes),
|
|
CErr("ai[2]", "index 2 exceeds"),
|
|
CErr("ai[1+1]", "index 2 exceeds"),
|
|
CErr("ai[-1]", "negative index"),
|
|
RErr("ai[i+i]", "index 2 exceeds"),
|
|
RErr("ai[-i]", "negative index"),
|
|
CErr("i[0]", opTypes),
|
|
CErr("f[0]", opTypes),
|
|
|
|
Val("aai[0][0]", 1),
|
|
Val("aai[1][1]", 4),
|
|
CErr("aai[2][0]", "index 2 exceeds"),
|
|
CErr("aai[0][2]", "index 2 exceeds"),
|
|
|
|
Val("sli[0]", 1),
|
|
Val("sli[1]", 2),
|
|
CErr("sli[-1]", "negative index"),
|
|
RErr("sli[-i]", "negative index"),
|
|
RErr("sli[2]", "index 2 exceeds"),
|
|
|
|
Val("s[0]", uint8('a')),
|
|
Val("s[1]", uint8('b')),
|
|
CErr("s[-1]", "negative index"),
|
|
RErr("s[-i]", "negative index"),
|
|
RErr("s[3]", "index 3 exceeds"),
|
|
|
|
CErr("1(2)", "cannot call"),
|
|
CErr("fn(1,2)", "too many"),
|
|
CErr("fn()", "not enough"),
|
|
CErr("fn(true)", opTypes),
|
|
CErr("fn(true)", "function call"),
|
|
// Single argument functions don't say which argument.
|
|
//CErr("fn(true)", "argument 1"),
|
|
Val("fn(1)", 2),
|
|
Val("fn(1.0)", 2),
|
|
CErr("fn(1.5)", constantTruncated),
|
|
Val("fn(i)", 2),
|
|
CErr("fn(u)", opTypes),
|
|
|
|
CErr("void()+2", opTypes),
|
|
CErr("oneTwo()+2", opTypes),
|
|
|
|
Val("cap(ai)", 2),
|
|
Val("cap(&ai)", 2),
|
|
Val("cap(aai)", 2),
|
|
Val("cap(sli)", 3),
|
|
CErr("cap(0)", opTypes),
|
|
CErr("cap(i)", opTypes),
|
|
CErr("cap(s)", opTypes),
|
|
|
|
Val("len(s)", 3),
|
|
Val("len(ai)", 2),
|
|
Val("len(&ai)", 2),
|
|
Val("len(aai)", 2),
|
|
Val("len(sli)", 2),
|
|
// TODO(austin) Test len of map
|
|
CErr("len(0)", opTypes),
|
|
CErr("len(i)", opTypes),
|
|
|
|
CErr("*i", opTypes),
|
|
Val("*&i", 1),
|
|
Val("*&(i)", 1),
|
|
CErr("&1", badAddrOf),
|
|
CErr("&c", badAddrOf),
|
|
Val("*(&ai[0])", 1),
|
|
|
|
Val("+1", bignum.Int(+1)),
|
|
Val("+1.0", bignum.Rat(1, 1)),
|
|
CErr("+\"x\"", opTypes),
|
|
|
|
Val("-42", bignum.Int(-42)),
|
|
Val("-i", -1),
|
|
Val("-f", -1.0),
|
|
// 6g bug?
|
|
//Val("-(f-1)", -0.0),
|
|
CErr("-\"x\"", opTypes),
|
|
|
|
// TODO(austin) Test unary !
|
|
|
|
Val("^2", bignum.Int(^2)),
|
|
Val("^(-2)", bignum.Int(^(-2))),
|
|
CErr("^2.0", opTypes),
|
|
CErr("^2.5", opTypes),
|
|
Val("^i", ^1),
|
|
Val("^u", ^uint(1)),
|
|
CErr("^f", opTypes),
|
|
|
|
Val("1+i", 2),
|
|
Val("1+u", uint(2)),
|
|
Val("3.0+i", 4),
|
|
Val("1+1", bignum.Int(2)),
|
|
Val("f+f", 2.0),
|
|
Val("1+f", 2.0),
|
|
Val("1.0+1", bignum.Rat(2, 1)),
|
|
Val("\"abc\" + \"def\"", "abcdef"),
|
|
CErr("i+u", opTypes),
|
|
CErr("-1+u", constantUnderflows),
|
|
// TODO(austin) Test named types
|
|
|
|
Val("2-1", bignum.Int(1)),
|
|
Val("2.0-1", bignum.Rat(1, 1)),
|
|
Val("f-2", -1.0),
|
|
// TOOD(austin) bignum can't do negative 0?
|
|
//Val("-0.0", XXX),
|
|
Val("2*2", bignum.Int(4)),
|
|
Val("2*i", 2),
|
|
Val("3/2", bignum.Int(1)),
|
|
Val("3/i", 3),
|
|
CErr("1/0", divByZero),
|
|
CErr("1.0/0", divByZero),
|
|
RErr("i/0", divByZero),
|
|
Val("3%2", bignum.Int(1)),
|
|
Val("i%2", 1),
|
|
CErr("3%0", divByZero),
|
|
CErr("3.0%0", opTypes),
|
|
RErr("i%0", divByZero),
|
|
|
|
// Examples from "Arithmetic operators"
|
|
Val("5/3", bignum.Int(1)),
|
|
Val("(i+4)/(i+2)", 1),
|
|
Val("5%3", bignum.Int(2)),
|
|
Val("(i+4)%(i+2)", 2),
|
|
Val("-5/3", bignum.Int(-1)),
|
|
Val("(i-6)/(i+2)", -1),
|
|
Val("-5%3", bignum.Int(-2)),
|
|
Val("(i-6)%(i+2)", -2),
|
|
Val("5/-3", bignum.Int(-1)),
|
|
Val("(i+4)/(i-4)", -1),
|
|
Val("5%-3", bignum.Int(2)),
|
|
Val("(i+4)%(i-4)", 2),
|
|
Val("-5/-3", bignum.Int(1)),
|
|
Val("(i-6)/(i-4)", 1),
|
|
Val("-5%-3", bignum.Int(-2)),
|
|
Val("(i-6)%(i-4)", -2),
|
|
|
|
// Examples from "Arithmetic operators"
|
|
Val("11/4", bignum.Int(2)),
|
|
Val("(i+10)/4", 2),
|
|
Val("11%4", bignum.Int(3)),
|
|
Val("(i+10)%4", 3),
|
|
Val("11>>2", bignum.Int(2)),
|
|
Val("(i+10)>>2", 2),
|
|
Val("11&3", bignum.Int(3)),
|
|
Val("(i+10)&3", 3),
|
|
Val("-11/4", bignum.Int(-2)),
|
|
Val("(i-12)/4", -2),
|
|
Val("-11%4", bignum.Int(-3)),
|
|
Val("(i-12)%4", -3),
|
|
Val("-11>>2", bignum.Int(-3)),
|
|
Val("(i-12)>>2", -3),
|
|
Val("-11&3", bignum.Int(1)),
|
|
Val("(i-12)&3", 1),
|
|
|
|
// TODO(austin) Test bit ops
|
|
|
|
// For shift, we try nearly every combination of positive
|
|
// ideal int, negative ideal int, big ideal int, ideal
|
|
// fractional float, ideal non-fractional float, int, uint,
|
|
// and float.
|
|
Val("2<<2", bignum.Int(2<<2)),
|
|
CErr("2<<(-1)", constantUnderflows),
|
|
CErr("2<<0x10000000000000000", constantOverflows),
|
|
CErr("2<<2.5", constantTruncated),
|
|
Val("2<<2.0", bignum.Int(2<<2.0)),
|
|
CErr("2<<i", mustBeUnsigned),
|
|
Val("2<<u", 2<<1),
|
|
CErr("2<<f", opTypes),
|
|
|
|
Val("-2<<2", bignum.Int(-2<<2)),
|
|
CErr("-2<<(-1)", constantUnderflows),
|
|
CErr("-2<<0x10000000000000000", constantOverflows),
|
|
CErr("-2<<2.5", constantTruncated),
|
|
Val("-2<<2.0", bignum.Int(-2<<2.0)),
|
|
CErr("-2<<i", mustBeUnsigned),
|
|
Val("-2<<u", -2<<1),
|
|
CErr("-2<<f", opTypes),
|
|
|
|
Val("0x10000000000000000<<2", hugeInteger.Shl(2)),
|
|
CErr("0x10000000000000000<<(-1)", constantUnderflows),
|
|
CErr("0x10000000000000000<<0x10000000000000000", constantOverflows),
|
|
CErr("0x10000000000000000<<2.5", constantTruncated),
|
|
Val("0x10000000000000000<<2.0", hugeInteger.Shl(2)),
|
|
CErr("0x10000000000000000<<i", mustBeUnsigned),
|
|
CErr("0x10000000000000000<<u", constantOverflows),
|
|
CErr("0x10000000000000000<<f", opTypes),
|
|
|
|
CErr("2.5<<2", opTypes),
|
|
CErr("2.0<<2", opTypes),
|
|
|
|
Val("i<<2", 1<<2),
|
|
CErr("i<<(-1)", constantUnderflows),
|
|
CErr("i<<0x10000000000000000", constantOverflows),
|
|
CErr("i<<2.5", constantTruncated),
|
|
Val("i<<2.0", 1<<2),
|
|
CErr("i<<i", mustBeUnsigned),
|
|
Val("i<<u", 1<<1),
|
|
CErr("i<<f", opTypes),
|
|
Val("i<<u", 1<<1),
|
|
|
|
Val("u<<2", uint(1<<2)),
|
|
CErr("u<<(-1)", constantUnderflows),
|
|
CErr("u<<0x10000000000000000", constantOverflows),
|
|
CErr("u<<2.5", constantTruncated),
|
|
Val("u<<2.0", uint(1<<2)),
|
|
CErr("u<<i", mustBeUnsigned),
|
|
Val("u<<u", uint(1<<1)),
|
|
CErr("u<<f", opTypes),
|
|
Val("u<<u", uint(1<<1)),
|
|
|
|
CErr("f<<2", opTypes),
|
|
|
|
// <, <=, >, >=
|
|
Val("1<2", 1<2),
|
|
Val("1<=2", 1<=2),
|
|
Val("2<=2", 2<=2),
|
|
Val("1>2", 1>2),
|
|
Val("1>=2", 1>=2),
|
|
Val("2>=2", 2>=2),
|
|
|
|
Val("i<2", 1<2),
|
|
Val("i<=2", 1<=2),
|
|
Val("i+1<=2", 2<=2),
|
|
Val("i>2", 1>2),
|
|
Val("i>=2", 1>=2),
|
|
Val("i+1>=2", 2>=2),
|
|
|
|
Val("u<2", 1<2),
|
|
Val("f<2", 1<2),
|
|
|
|
Val("s<\"b\"", true),
|
|
Val("s<\"a\"", false),
|
|
Val("s<=\"abc\"", true),
|
|
Val("s>\"aa\"", true),
|
|
Val("s>\"ac\"", false),
|
|
Val("s>=\"abc\"", true),
|
|
|
|
CErr("i<u", opTypes),
|
|
CErr("i<f", opTypes),
|
|
CErr("i<s", opTypes),
|
|
CErr("&i<&i", opTypes),
|
|
CErr("ai<ai", opTypes),
|
|
|
|
// ==, !=
|
|
Val("1==1", true),
|
|
Val("1!=1", false),
|
|
Val("1==2", false),
|
|
Val("1!=2", true),
|
|
|
|
Val("1.0==1", true),
|
|
Val("1.5==1", false),
|
|
|
|
Val("i==1", true),
|
|
Val("i!=1", false),
|
|
Val("i==2", false),
|
|
Val("i!=2", true),
|
|
|
|
Val("u==1", true),
|
|
Val("f==1", true),
|
|
|
|
Val("s==\"abc\"", true),
|
|
Val("s!=\"abc\"", false),
|
|
Val("s==\"abcd\"", false),
|
|
Val("s!=\"abcd\"", true),
|
|
|
|
Val("&i==&i", true),
|
|
Val("&i==&i2", false),
|
|
|
|
Val("fn==fn", true),
|
|
Val("fn==func(int)int{return 0}", false),
|
|
|
|
CErr("i==u", opTypes),
|
|
CErr("i==f", opTypes),
|
|
CErr("&i==&f", opTypes),
|
|
CErr("ai==ai", opTypes),
|
|
CErr("t==t", opTypes),
|
|
CErr("fn==oneTwo", opTypes),
|
|
}
|
|
|
|
func TestExpr(t *testing.T) {
|
|
runTests(t, "exprTests", exprTests);
|
|
}
|