procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

compiler, libgo: Permit testing package when test imports it circularly.

Browse source 
From-SVN: r195931
This commit is contained in:
Ian Lance Taylor 2013-02-10 06:02:38 +00:00
parent 8e29a61c2d
commit d54fc07473
16 changed files with 84 additions and 264 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
gcc/go/gofrontend/gogo.cc
View file

@ -515,16 +515,23 @@ Gogo::add_import_init_fn(const std::string& package_name,
p != this->imported_init_fns_.end();
++p)
{
if (p->init_name() == init_name
&& (p->package_name() != package_name || p->priority() != prio))
if (p->init_name() == init_name)
{
error("duplicate package initialization name %qs",
Gogo::message_name(init_name).c_str());
inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
Gogo::message_name(p->package_name()).c_str(),
p->priority());
inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
Gogo::message_name(package_name).c_str(), prio);
// If a test of package P1, built as part of package P1,
// imports package P2, and P2 imports P1 (perhaps
// indirectly), then we will see the same import name with
// different import priorities. That is OK, so don't give
// an error about it.
if (p->package_name() != package_name)
{
error("duplicate package initialization name %qs",
Gogo::message_name(init_name).c_str());
inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
Gogo::message_name(p->package_name()).c_str(),
p->priority());
inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
Gogo::message_name(package_name).c_str(), prio);
}
return;
}
}

3
libgo/go/debug/macho/file_test.go
View file

@ -2,10 +2,9 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package macho_test
package macho
import (
. "debug/macho"
"reflect"
"testing"
)

5
libgo/go/encoding/binary/binary_test.go
View file

@ -2,11 +2,10 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package binary_test
package binary
import (
"bytes"
. "encoding/binary"
"io"
"math"
"reflect"
@ -239,7 +238,7 @@ func BenchmarkReadStruct(b *testing.B) {
bsr := &byteSliceReader{}
var buf bytes.Buffer
Write(&buf, BigEndian, &s)
n := DataSize(reflect.ValueOf(s))
n := dataSize(reflect.ValueOf(s))
b.SetBytes(int64(n))
t := s
b.ResetTimer()

15
libgo/go/encoding/binary/export_test.go
View file

@ -1,15 +0,0 @@
// Copyright 2012 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 binary
import "reflect"
// Export for testing.
func DataSize(v reflect.Value) int {
return dataSize(v)
}
var Overflow = overflow

7
libgo/go/encoding/binary/varint_test.go
View file

@ -2,11 +2,10 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package binary_test
package binary
import (
"bytes"
. "encoding/binary"
"io"
"testing"
)
@ -135,8 +134,8 @@ func testOverflow(t *testing.T, buf []byte, n0 int, err0 error) {
}
func TestOverflow(t *testing.T) {
testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x2}, -10, Overflow)
testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x1, 0, 0}, -13, Overflow)
testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x2}, -10, overflow)
testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x1, 0, 0}, -13, overflow)
}
func TestNonCanonicalZero(t *testing.T) {

13
libgo/go/image/image_test.go
View file

@ -2,15 +2,14 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package image_test
package image
import (
. "image"
"image/color"
"testing"
)
type timage interface {
type image interface {
Image
Opaque() bool
Set(int, int, color.Color)
@ -24,7 +23,7 @@ func cmp(t *testing.T, cm color.Model, c0, c1 color.Color) bool {
}
func TestImage(t *testing.T) {
testImage := []timage{
testImage := []image{
NewRGBA(Rect(0, 0, 10, 10)),
NewRGBA64(Rect(0, 0, 10, 10)),
NewNRGBA(Rect(0, 0, 10, 10)),
@ -52,11 +51,11 @@ func TestImage(t *testing.T) {
t.Errorf("%T: at (6, 3), want a non-zero color, got %v", m, m.At(6, 3))
continue
}
if !m.SubImage(Rect(6, 3, 7, 4)).(timage).Opaque() {
if !m.SubImage(Rect(6, 3, 7, 4)).(image).Opaque() {
t.Errorf("%T: at (6, 3) was not opaque", m)
continue
}
m = m.SubImage(Rect(3, 2, 9, 8)).(timage)
m = m.SubImage(Rect(3, 2, 9, 8)).(image)
if !Rect(3, 2, 9, 8).Eq(m.Bounds()) {
t.Errorf("%T: sub-image want bounds %v, got %v", m, Rect(3, 2, 9, 8), m.Bounds())
continue
@ -97,7 +96,7 @@ func Test16BitsPerColorChannel(t *testing.T) {
continue
}
}
testImage := []timage{
testImage := []image{
NewRGBA64(Rect(0, 0, 10, 10)),
NewNRGBA64(Rect(0, 0, 10, 10)),
NewAlpha16(Rect(0, 0, 10, 10)),

3
libgo/go/image/ycbcr_test.go
View file

@ -2,10 +2,9 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package image_test
package image
import (
. "image"
"image/color"
"testing"
)

3
libgo/go/regexp/all_test.go
View file

@ -2,11 +2,10 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package regexp_test
package regexp
import (
"reflect"
. "regexp"
"strings"
"testing"
)

144
libgo/go/regexp/example_test.go
View file

@ -1,144 +0,0 @@
package regexp_test
import (
"fmt"
"regexp"
)
func Example() {
// Compile the expression once, usually at init time.
// Use raw strings to avoid having to quote the backslashes.
var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)
fmt.Println(validID.MatchString("adam[23]"))
fmt.Println(validID.MatchString("eve[7]"))
fmt.Println(validID.MatchString("Job[48]"))
fmt.Println(validID.MatchString("snakey"))
// Output:
// true
// true
// false
// false
}
func ExampleMatchString() {
matched, err := regexp.MatchString("foo.*", "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString("bar.*", "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString("a(b", "seafood")
fmt.Println(matched, err)
// Output:
// true <nil>
// false <nil>
// false error parsing regexp: missing closing ): `a(b`
}
func ExampleRegexp_FindString() {
re := regexp.MustCompile("fo.?")
fmt.Printf("%q\n", re.FindString("seafood"))
fmt.Printf("%q\n", re.FindString("meat"))
// Output:
// "foo"
// ""
}
func ExampleRegexp_FindStringIndex() {
re := regexp.MustCompile("ab?")
fmt.Println(re.FindStringIndex("tablett"))
fmt.Println(re.FindStringIndex("foo") == nil)
// Output:
// [1 3]
// true
}
func ExampleRegexp_FindStringSubmatch() {
re := regexp.MustCompile("a(x*)b(y|z)c")
fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))
// Output:
// ["axxxbyc" "xxx" "y"]
// ["abzc" "" "z"]
}
func ExampleRegexp_FindAllString() {
re := regexp.MustCompile("a.")
fmt.Println(re.FindAllString("paranormal", -1))
fmt.Println(re.FindAllString("paranormal", 2))
fmt.Println(re.FindAllString("graal", -1))
fmt.Println(re.FindAllString("none", -1))
// Output:
// [ar an al]
// [ar an]
// [aa]
// []
}
func ExampleRegexp_FindAllStringSubmatch() {
re := regexp.MustCompile("a(x*)b")
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))
// Output:
// [["ab" ""]]
// [["axxb" "xx"]]
// [["ab" ""] ["axb" "x"]]
// [["axxb" "xx"] ["ab" ""]]
}
func ExampleRegexp_FindAllStringSubmatchIndex() {
re := regexp.MustCompile("a(x*)b")
// Indices:
// 01234567 012345678
// -ab-axb- -axxb-ab-
fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1))
// Output:
// [[1 3 2 2]]
// [[1 5 2 4]]
// [[1 3 2 2] [4 7 5 6]]
// [[1 5 2 4] [6 8 7 7]]
// []
}
func ExampleRegexp_ReplaceAllLiteralString() {
re := regexp.MustCompile("a(x*)b")
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}"))
// Output:
// -T-T-
// -$1-$1-
// -${1}-${1}-
}
func ExampleRegexp_ReplaceAllString() {
re := regexp.MustCompile("a(x*)b")
fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))
// Output:
// -T-T-
// --xx-
// ---
// -W-xxW-
}
func ExampleRegexp_SubexpNames() {
re := regexp.MustCompile("(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)")
fmt.Println(re.MatchString("Alan Turing"))
fmt.Printf("%q\n", re.SubexpNames())
reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1])
fmt.Println(reversed)
fmt.Println(re.ReplaceAllString("Alan Turing", reversed))
// Output:
// true
// ["" "first" "last"]
// ${last} ${first}
// Turing Alan
}

22
libgo/go/regexp/exec_test.go
View file

@ -2,11 +2,9 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package regexp_test
package regexp
import (
. "regexp"
"bufio"
"compress/bzip2"
"fmt"
@ -220,22 +218,22 @@ var run = []func(*Regexp, *Regexp, string) ([]int, string){
}
func runFull(re, refull *Regexp, text string) ([]int, string) {
refull.SetLongest(false)
refull.longest = false
return refull.FindStringSubmatchIndex(text), "[full]"
}
func runPartial(re, refull *Regexp, text string) ([]int, string) {
re.SetLongest(false)
re.longest = false
return re.FindStringSubmatchIndex(text), ""
}
func runFullLongest(re, refull *Regexp, text string) ([]int, string) {
refull.SetLongest(true)
refull.longest = true
return refull.FindStringSubmatchIndex(text), "[full,longest]"
}
func runPartialLongest(re, refull *Regexp, text string) ([]int, string) {
re.SetLongest(true)
re.longest = true
return re.FindStringSubmatchIndex(text), "[longest]"
}
@ -247,22 +245,22 @@ var match = []func(*Regexp, *Regexp, string) (bool, string){
}
func matchFull(re, refull *Regexp, text string) (bool, string) {
refull.SetLongest(false)
refull.longest = false
return refull.MatchString(text), "[full]"
}
func matchPartial(re, refull *Regexp, text string) (bool, string) {
re.SetLongest(false)
re.longest = false
return re.MatchString(text), ""
}
func matchFullLongest(re, refull *Regexp, text string) (bool, string) {
refull.SetLongest(true)
refull.longest = true
return refull.MatchString(text), "[full,longest]"
}
func matchPartialLongest(re, refull *Regexp, text string) (bool, string) {
re.SetLongest(true)
re.longest = true
return re.MatchString(text), "[longest]"
}
@ -542,7 +540,7 @@ Reading:
}
}
re, err := CompileInternal(pattern, syn, true)
re, err := compile(pattern, syn, true)
if err != nil {
if shouldCompile {
t.Errorf("%s:%d: %#q did not compile", file, lineno, pattern)

15
libgo/go/regexp/export_test.go
View file

@ -1,15 +0,0 @@
// Copyright 2012 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 regexp
import "regexp/syntax"
func (re *Regexp) SetLongest(b bool) {
re.longest = b
}
func CompileInternal(expr string, mode syntax.Flags, longest bool) (*Regexp, error) {
return compile(expr, mode, longest)
}

4
libgo/go/regexp/find_test.go
View file

@ -2,11 +2,9 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package regexp_test
package regexp
import (
. "regexp"
"fmt"
"strings"
"testing"

66
libgo/go/regexp/syntax/parse.go
View file

@ -191,7 +191,7 @@ func (p *parser) newLiteral(r rune, flags Flags) *Regexp {
// minFoldRune returns the minimum rune fold-equivalent to r.
func minFoldRune(r rune) rune {
if r < MinFold || r > MaxFold {
if r < minFold || r > maxFold {
return r
}
min := r
@ -1553,7 +1553,7 @@ func (p *parser) parseClass(s string) (rest string, err error) {
}
}
if p.flags&FoldCase == 0 {
class = AppendRange(class, lo, hi)
class = appendRange(class, lo, hi)
} else {
class = appendFoldedRange(class, lo, hi)
}
@ -1608,11 +1608,11 @@ func appendLiteral(r []rune, x rune, flags Flags) []rune {
if flags&FoldCase != 0 {
return appendFoldedRange(r, x, x)
}
return AppendRange(r, x, x)
return appendRange(r, x, x)
}
// appendRange returns the result of appending the range lo-hi to the class r.
func AppendRange(r []rune, lo, hi rune) []rune {
func appendRange(r []rune, lo, hi rune) []rune {
// Expand last range or next to last range if it overlaps or abuts.
// Checking two ranges helps when appending case-folded
// alphabets, so that one range can be expanding A-Z and the
@ -1639,39 +1639,39 @@ func AppendRange(r []rune, lo, hi rune) []rune {
const (
// minimum and maximum runes involved in folding.
// checked during test.
MinFold = 0x0041
MaxFold = 0x1044f
minFold = 0x0041
maxFold = 0x1044f
)
// appendFoldedRange returns the result of appending the range lo-hi
// and its case folding-equivalent runes to the class r.
func appendFoldedRange(r []rune, lo, hi rune) []rune {
// Optimizations.
if lo <= MinFold && hi >= MaxFold {
if lo <= minFold && hi >= maxFold {
// Range is full: folding can't add more.
return AppendRange(r, lo, hi)
return appendRange(r, lo, hi)
}
if hi < MinFold || lo > MaxFold {
if hi < minFold || lo > maxFold {
// Range is outside folding possibilities.
return AppendRange(r, lo, hi)
return appendRange(r, lo, hi)
}
if lo < MinFold {
// [lo, MinFold-1] needs no folding.
r = AppendRange(r, lo, MinFold-1)
lo = MinFold
if lo < minFold {
// [lo, minFold-1] needs no folding.
r = appendRange(r, lo, minFold-1)
lo = minFold
}
if hi > MaxFold {
// [MaxFold+1, hi] needs no folding.
r = AppendRange(r, MaxFold+1, hi)
hi = MaxFold
if hi > maxFold {
// [maxFold+1, hi] needs no folding.
r = appendRange(r, maxFold+1, hi)
hi = maxFold
}
// Brute force. Depend on AppendRange to coalesce ranges on the fly.
// Brute force. Depend on appendRange to coalesce ranges on the fly.
for c := lo; c <= hi; c++ {
r = AppendRange(r, c, c)
r = appendRange(r, c, c)
f := unicode.SimpleFold(c)
for f != c {
r = AppendRange(r, f, f)
r = appendRange(r, f, f)
f = unicode.SimpleFold(f)
}
}
@ -1682,7 +1682,7 @@ func appendFoldedRange(r []rune, lo, hi rune) []rune {
// It assume x is clean.
func appendClass(r []rune, x []rune) []rune {
for i := 0; i < len(x); i += 2 {
r = AppendRange(r, x[i], x[i+1])
r = appendRange(r, x[i], x[i+1])
}
return r
}
@ -1702,12 +1702,12 @@ func appendNegatedClass(r []rune, x []rune) []rune {
for i := 0; i < len(x); i += 2 {
lo, hi := x[i], x[i+1]
if nextLo <= lo-1 {
r = AppendRange(r, nextLo, lo-1)
r = appendRange(r, nextLo, lo-1)
}
nextLo = hi + 1
}
if nextLo <= unicode.MaxRune {
r = AppendRange(r, nextLo, unicode.MaxRune)
r = appendRange(r, nextLo, unicode.MaxRune)
}
return r
}
@ -1717,21 +1717,21 @@ func appendTable(r []rune, x *unicode.RangeTable) []rune {
for _, xr := range x.R16 {
lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
if stride == 1 {
r = AppendRange(r, lo, hi)
r = appendRange(r, lo, hi)
continue
}
for c := lo; c <= hi; c += stride {
r = AppendRange(r, c, c)
r = appendRange(r, c, c)
}
}
for _, xr := range x.R32 {
lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
if stride == 1 {
r = AppendRange(r, lo, hi)
r = appendRange(r, lo, hi)
continue
}
for c := lo; c <= hi; c += stride {
r = AppendRange(r, c, c)
r = appendRange(r, c, c)
}
}
return r
@ -1744,14 +1744,14 @@ func appendNegatedTable(r []rune, x *unicode.RangeTable) []rune {
lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
if stride == 1 {
if nextLo <= lo-1 {
r = AppendRange(r, nextLo, lo-1)
r = appendRange(r, nextLo, lo-1)
}
nextLo = hi + 1
continue
}
for c := lo; c <= hi; c += stride {
if nextLo <= c-1 {
r = AppendRange(r, nextLo, c-1)
r = appendRange(r, nextLo, c-1)
}
nextLo = c + 1
}
@ -1760,20 +1760,20 @@ func appendNegatedTable(r []rune, x *unicode.RangeTable) []rune {
lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
if stride == 1 {
if nextLo <= lo-1 {
r = AppendRange(r, nextLo, lo-1)
r = appendRange(r, nextLo, lo-1)
}
nextLo = hi + 1
continue
}
for c := lo; c <= hi; c += stride {
if nextLo <= c-1 {
r = AppendRange(r, nextLo, c-1)
r = appendRange(r, nextLo, c-1)
}
nextLo = c + 1
}
}
if nextLo <= unicode.MaxRune {
r = AppendRange(r, nextLo, unicode.MaxRune)
r = appendRange(r, nextLo, unicode.MaxRune)
}
return r
}

17
libgo/go/regexp/syntax/parse_test.go
View file

@ -2,12 +2,11 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package syntax_test
package syntax
import (
"bytes"
"fmt"
. "regexp/syntax"
"testing"
"unicode"
)
@ -413,13 +412,13 @@ func TestFoldConstants(t *testing.T) {
if unicode.SimpleFold(i) == i {
continue
}
if last == -1 && MinFold != i {
t.Errorf("MinFold=%#U should be %#U", MinFold, i)
if last == -1 && minFold != i {
t.Errorf("minFold=%#U should be %#U", minFold, i)
}
last = i
}
if MaxFold != last {
t.Errorf("MaxFold=%#U should be %#U", MaxFold, last)
if maxFold != last {
t.Errorf("maxFold=%#U should be %#U", maxFold, last)
}
}
@ -430,11 +429,11 @@ func TestAppendRangeCollapse(t *testing.T) {
// Note that we are not calling cleanClass.
var r []rune
for i := rune('A'); i <= 'Z'; i++ {
r = AppendRange(r, i, i)
r = AppendRange(r, i+'a'-'A', i+'a'-'A')
r = appendRange(r, i, i)
r = appendRange(r, i+'a'-'A', i+'a'-'A')
}
if string(r) != "AZaz" {
t.Errorf("AppendRange interlaced A-Z a-z = %s, want AZaz", string(r))
t.Errorf("appendRange interlaced A-Z a-z = %s, want AZaz", string(r))
}
}

3
libgo/go/regexp/syntax/prog_test.go
View file

@ -2,10 +2,9 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package syntax_test
package syntax
import (
. "regexp/syntax"
"testing"
)

3
libgo/go/regexp/syntax/simplify_test.go
View file

@ -2,9 +2,8 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package syntax_test
package syntax
import . "regexp/syntax"
import "testing"
var simplifyTests = []struct {