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;
}
}
// 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"
)
// 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"
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()
+++ /dev/null
-// 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
// 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"
)
}
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) {
// 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)
}
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)),
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
continue
}
}
- testImage := []timage{
+ testImage := []image{
NewRGBA64(Rect(0, 0, 10, 10)),
NewNRGBA64(Rect(0, 0, 10, 10)),
NewAlpha16(Rect(0, 0, 10, 10)),
// 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"
)
// 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"
)
+++ /dev/null
-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
-}
// 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"
}
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]"
}
}
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]"
}
}
}
- 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)
+++ /dev/null
-// 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)
-}
// 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"
// 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
}
}
if p.flags&FoldCase == 0 {
- class = AppendRange(class, lo, hi)
+ class = appendRange(class, lo, hi)
} else {
class = appendFoldedRange(class, lo, hi)
}
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
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)
}
}
// 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
}
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
}
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
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
}
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
}
// 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"
)
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)
}
}
// 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))
}
}
// 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"
)
// 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 {
projects / gcc.git / commitdiff