| Server IP : 88.223.91.47 / Your IP : 216.73.217.167 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /opt/golang/1.22.0/src/cmd/asm/internal/asm/ |
Upload File : |
// Copyright 2015 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 asm
import (
"cmd/asm/internal/lex"
"strings"
"testing"
"text/scanner"
)
type exprTest struct {
input string
output int64
atEOF bool
}
var exprTests = []exprTest{
// Simple
{"0", 0, true},
{"3", 3, true},
{"070", 8 * 7, true},
{"0x0f", 15, true},
{"0xFF", 255, true},
{"9223372036854775807", 9223372036854775807, true}, // max int64
// Unary
{"-0", 0, true},
{"~0", -1, true},
{"~0*0", 0, true},
{"+3", 3, true},
{"-3", -3, true},
{"-9223372036854775808", -9223372036854775808, true}, // min int64
// Binary
{"3+4", 3 + 4, true},
{"3-4", 3 - 4, true},
{"2|5", 2 | 5, true},
{"3^4", 3 ^ 4, true},
{"3*4", 3 * 4, true},
{"14/4", 14 / 4, true},
{"3<<4", 3 << 4, true},
{"48>>3", 48 >> 3, true},
{"3&9", 3 & 9, true},
// General
{"3*2+3", 3*2 + 3, true},
{"3+2*3", 3 + 2*3, true},
{"3*(2+3)", 3 * (2 + 3), true},
{"3*-(2+3)", 3 * -(2 + 3), true},
{"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())
if result != test.output {
t.Errorf("%d: %q evaluated to %d; expected %d", i, test.input, result, test.output)
}
tok := p.next()
if test.atEOF && tok.ScanToken != scanner.EOF {
t.Errorf("%d: %q: at EOF got %s", i, test.input, tok)
} else if !test.atEOF && tok.ScanToken == scanner.EOF {
t.Errorf("%d: %q: expected not EOF but at EOF", i, test.input)
}
}
}
type badExprTest struct {
input string
error string // Empty means no error.
}
var badExprTests = []badExprTest{
{"0/0", "division by zero"},
{"3/0", "division by zero"},
{"(1<<63)/0", "divide of value with high bit set"},
{"3%0", "modulo by zero"},
{"(1<<63)%0", "modulo of value with high bit set"},
{"3<<-4", "negative left shift count"},
{"3<<(1<<63)", "negative left shift count"},
{"3>>-4", "negative right shift count"},
{"3>>(1<<63)", "negative right shift count"},
{"(1<<63)>>2", "right shift of value with high bit set"},
{"(1<<62)>>2", ""},
{`'\x80'`, "illegal UTF-8 encoding for character constant"},
{"(23*4", "missing closing paren"},
{")23*4", "unexpected ) evaluating expression"},
{"18446744073709551616", "value out of range"},
}
func TestBadExpr(t *testing.T) {
for i, test := range badExprTests {
err := runBadTest(i, test, t)
if err == nil {
if test.error != "" {
t.Errorf("#%d: %q: expected error %q; got none", i, test.input, test.error)
}
continue
}
if !strings.Contains(err.Error(), test.error) {
t.Errorf("#%d: expected error %q; got %q", i, test.error, err)
continue
}
}
}
func runBadTest(i int, test badExprTest, t *testing.T) (err error) {
p := NewParser(nil, nil, nil) // Expression evaluation uses none of these fields of the parser.
p.start(lex.Tokenize(test.input))
return tryParse(t, func() {
p.expr()
})
}