The gccgo compiler works like other gcc frontends. As of GCC 5 the gccgo
installation also includes a version of the <code>go</code> command,
which may be used to build Go programs as described at
-<a href="http://golang.org/cmd/go">http://golang.org/cmd/go</a>.
+<a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
</p>
<p>
</li>
<li>
-Support for <a href="http://golang.org/s/go14internal">internal packages</a>
+Support for <a href="https://golang.org/s/go14internal">internal packages</a>
is now provided for all repositories, not just the Go core.
</li>
// Test that the #cgo CFLAGS directive works,
// with and without platform filters.
-// See http://golang.org/issue/5224 for details.
+// See https://golang.org/issue/5224 for details.
package cgotest
/*
package cgotest
// Test that cgo reserves enough stack space during cgo call.
-// See http://golang.org/issue/3945 for details.
+// See https://golang.org/issue/3945 for details.
// #include <stdio.h>
//
// Test that pthread_cancel works as expected
// (NPTL uses SIGRTMIN to implement thread cancellation)
-// See http://golang.org/issue/6997
+// See https://golang.org/issue/6997
package cgotest
/*
import "testing"
// This test actually doesn't have anything to do with cgo. It is a
-// test of http://golang.org/issue/7234, a compiler/linker bug in
+// test of https://golang.org/issue/7234, a compiler/linker bug in
// handling string constants when using -linkmode=external. The test
// is in this directory because we routinely test -linkmode=external
// here.
// license that can be found in the LICENSE file.
// Test that setgid does not hang on GNU/Linux.
-// See http://golang.org/issue/3871 for details.
+// See https://golang.org/issue/3871 for details.
package cgotest
}
if (gerritChangeIdRE.test(t)) {
- return "http://golang.org/cl/" + t;
+ return "https://golang.org/cl/" + t;
}
var match = commitRE.exec(t);
if (pkgRE.test(t)) {
// TODO: make this smarter, using a list of packages + substring matches.
// Get the list from godoc itself in JSON format?
- return "http://golang.org/pkg/" + t;
+ return "https://golang.org/pkg/" + t;
}
return null;
uploadURL = flag.String("upload_url", defaultUploadURL, "Upload URL")
defaultCacheFile = filepath.Join(os.Getenv("HOME"), ".makerelease-request-token")
- defaultUploadURL = "http://golang.org/dl/upload"
+ defaultUploadURL = "https://golang.org/dl/upload"
)
const (
Language="1033"\r
Codepage="1252"\r
Version="$(var.WixGoVersion)"\r
- Manufacturer="http://golang.org"\r
+ Manufacturer="https://golang.org"\r
UpgradeCode="$(var.UpgradeCode)" >\r
\r
<Package\r
limited to a 4gb window.
* nacl/arm which is 32-bit ARMv7A architecture with 1GB address space.
-For background it is recommended that you read http://golang.org/s/go13nacl.
+For background it is recommended that you read https://golang.org/s/go13nacl.
Prerequisites
-------------
out: "",
},
{
- // http://golang.org/issue/4303
+ // https://golang.org/issue/4303
name: "contexts reconverging",
required: []string{
"A",
See $GOROOT/misc/cgo/stdio and $GOROOT/misc/cgo/gmp for examples. See
"C? Go? Cgo!" for an introduction to using cgo:
-http://golang.org/doc/articles/c_go_cgo.html.
+https://golang.org/doc/articles/c_go_cgo.html.
CFLAGS, CPPFLAGS, CXXFLAGS and LDFLAGS may be defined with pseudo #cgo
directives within these comments to tweak the behavior of the C or C++
compiler. Values defined in multiple directives are concatenated
together. The directive can include a list of build constraints limiting its
effect to systems satisfying one of the constraints
-(see http://golang.org/pkg/go/build/#hdr-Build_Constraints for details about the constraint syntax).
+(see https://golang.org/pkg/go/build/#hdr-Build_Constraints for details about the constraint syntax).
For example:
// #cgo CFLAGS: -DPNG_DEBUG=1
// incorrectly typed unsigned long. We work around that
// by disabling the builtin functions (this is safe as
// it won't affect the actual compilation of the C code).
- // See: http://golang.org/issue/6506.
+ // See: https://golang.org/issue/6506.
"-fno-builtin",
)
}
// used to match gc's struct layout. For example, on 386 Windows,
// gcc wants to 8-align int64s, but gc does not.
// Use __gcc_struct__ to work around http://gcc.gnu.org/PR52991 on x86,
-// and http://golang.org/issue/5603.
+// and https://golang.org/issue/5603.
func (p *Package) packedAttribute() string {
s := "__attribute__((__packed__"
if !p.GccIsClang && (goarch == "amd64" || goarch == "386") {
"10953742525620032441",
"17908251027575790097",
- // http://golang.org/issue/638
+ // https://golang.org/issue/638
"18699199384836356663",
"98920366548084643601728869055592650835572950932266967461790948584315647051443",
"*** %s still exists. ***\n"+
"It probably contains stale files that may confuse the build.\n"+
"Please (check what's there and) remove it and try again.\n"+
- "See http://golang.org/s/go14nopkg\n",
+ "See https://golang.org/s/go14nopkg\n",
pathf("%s/src/pkg", goroot))
}
// NOTE(rsc): On Windows, it is critically important that the
// gcc-compiled objects (cgoObjects) be listed after the ordinary
// objects in the archive. I do not know why this is.
- // http://golang.org/issue/2601
+ // https://golang.org/issue/2601
objects = append(objects, cgoObjects...)
// Add system object files.
// Sleeping when we observe the race seems to be the most reliable
// option we have.
//
- // http://golang.org/issue/3001
+ // https://golang.org/issue/3001
//
if err != nil && nbusy < 3 && strings.Contains(err.Error(), "text file busy") {
time.Sleep(100 * time.Millisecond << uint(nbusy))
// On OS X, some of the compilers behave as if -fno-common
// is always set, and the Mach-O linker in 6l/8l assumes this.
- // See http://golang.org/issue/3253.
+ // See https://golang.org/issue/3253.
if goos == "darwin" {
a = append(a, "-fno-common")
}
// NOTE(rsc): The importObj is a 5c/6c/8c object and on Windows
// must be processed before the gcc-generated objects.
- // Put it first. http://golang.org/issue/2601
+ // Put it first. https://golang.org/issue/2601
outObj = stringList(nonGccObjs, ofile)
return outGo, outObj, nil
_, err := exec.LookPath(v.cmd)
if err != nil {
fmt.Fprintf(os.Stderr,
- "go: missing %s command. See http://golang.org/s/gogetcmd\n",
+ "go: missing %s command. See https://golang.org/s/gogetcmd\n",
v.name)
return nil, err
}
// On amd64, 4-byte offsets will be sign-extended, so it is impossible to
// access more than 2GB of static data; fail at link time is better than
- // fail at runtime. See http://golang.org/issue/7980.
+ // fail at runtime. See https://golang.org/issue/7980.
// Instead of special casing only amd64, we treat this as an error on all
// 64-bit architectures so as to be future-proof.
if int32(o) < 0 && Thearch.Ptrsize > 4 && siz == 4 {
// generate .tbss section (except for OpenBSD where it's not supported)
// for dynamic internal linker or external linking, so that various
// binutils could correctly calculate PT_TLS size.
- // see http://golang.org/issue/5200.
+ // see https://golang.org/issue/5200.
if HEADTYPE != obj.Hopenbsd {
if Debug['d'] == 0 || Linkmode == LinkExternal {
Addstring(shstrtab, ".tbss")
func machosymorder() {
// On Mac OS X Mountain Lion, we must sort exported symbols
// So we sort them here and pre-allocate dynid for them
- // See http://golang.org/issue/4029
+ // See https://golang.org/issue/4029
for i := 0; i < len(dynexp); i++ {
dynexp[i].Reachable = true
}
// information during garbage collection. The symbol created is named
// "pclntab" for historical reasons; the scope of the table has grown to
// include more than just PC/line number correspondences.
-// The table format is documented at http://golang.org/s/go12symtab.
+// The table format is documented at https://golang.org/s/go12symtab.
func (p *Prog) pclntab() {
// Count number of functions going into the binary,
// so that we can size the initial index correctly.
}()
}
-See: http://golang.org/doc/go_faq.html#closures_and_goroutines
+See: https://golang.org/doc/go_faq.html#closures_and_goroutines
*/
package main
}
}
-// See http://golang.org/issue/2508
+// See https://golang.org/issue/2508
func TestRegression2508(t *testing.T) {
if testing.Short() {
t.Logf("test disabled with -short")
"testing"
)
-// http://golang.org/issue/6849.
+// https://golang.org/issue/6849.
func TestPrimeSmall(t *testing.T) {
for n := 2; n < 10; n++ {
p, err := rand.Prime(rand.Reader, n)
// tried to reuse the HTTP connection for a new
// request.
// See https://codereview.appspot.com/76400046
- // and http://golang.org/issue/3514
+ // and https://golang.org/issue/3514
if ri := c.rawInput; ri != nil &&
n != 0 && err == nil &&
c.input == nil && len(ri.data) > 0 && recordType(ri.data[0]) == recordTypeAlert {
`
// keyPEM is the same as rsaKeyPEM, but declares itself as just
-// "PRIVATE KEY", not "RSA PRIVATE KEY". http://golang.org/issue/4477
+// "PRIVATE KEY", not "RSA PRIVATE KEY". https://golang.org/issue/4477
var keyPEM = `-----BEGIN PRIVATE KEY-----
MIIBOwIBAAJBANLJhPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wo
k/4xIA+ui35/MmNartNuC+BdZ1tMuVCPFZcCAwEAAQJAEJ2N+zsR0Xn8/Q6twa4G
// databases.
//
// The sql package must be used in conjunction with a database driver.
-// See http://golang.org/s/sqldrivers for a list of drivers.
+// See https://golang.org/s/sqldrivers for a list of drivers.
//
// For more usage examples, see the wiki page at
-// http://golang.org/s/sqlwiki.
+// https://golang.org/s/sqlwiki.
package sql
import (
//
// Most users will open a database via a driver-specific connection
// helper function that returns a *DB. No database drivers are included
-// in the Go standard library. See http://golang.org/s/sqldrivers for
+// in the Go standard library. See https://golang.org/s/sqldrivers for
// a list of third-party drivers.
//
// Open may just validate its arguments without creating a connection
}
}
-// Issue: http://golang.org/issue/2784
+// Issue: https://golang.org/issue/2784
// This test didn't fail before because we got lucky with the fakedb driver.
// It was failing, and now not, in github.com/bradfitz/go-sql-test
func TestTxQuery(t *testing.T) {
// in the documentation for the Marshal and Unmarshal functions.
//
// See "JSON and Go" for an introduction to this package:
-// http://golang.org/doc/articles/json_and_go.html
+// https://golang.org/doc/articles/json_and_go.html
package json
import (
}
type percentSlashTag struct {
- V string `json:"text/html%"` // http://golang.org/issue/2718
+ V string `json:"text/html%"` // https://golang.org/issue/2718
}
type punctuationTag struct {
- V string `json:"!#$%&()*+-./:<=>?@[]^_{|}~"` // http://golang.org/issue/3546
+ V string `json:"!#$%&()*+-./:<=>?@[]^_{|}~"` // https://golang.org/issue/3546
}
type emptyTag struct {
}
// Addressable reports whether the corresponding expression
-// is addressable (http://golang.org/ref/spec#Address_operators).
+// is addressable (https://golang.org/ref/spec#Address_operators).
func (tv TypeAndValue) Addressable() bool {
return tv.mode == variable
}
}
}
-// This used to crash; http://golang.org/issue/3281
+// This used to crash; https://golang.org/issue/3281
func TestCloneCrash(t *testing.T) {
t1 := New("all")
Must(t1.New("t1").Parse(`{{define "foo"}}foo{{end}}`))
// Package draw provides image composition functions.
//
// See "The Go image/draw package" for an introduction to this package:
-// http://golang.org/doc/articles/image_draw.html
+// https://golang.org/doc/articles/image_draw.html
package draw
import (
// io.ErrUnexpectedEOF (meaning that the encoded stream hit io.EOF
// before the LZW decoder saw an explict end code), provided that
// the io.ReadFull call above successfully read len(m.Pix) bytes.
- // See http://golang.org/issue/9856 for an example GIF.
+ // See https://golang.org/issue/9856 for an example GIF.
if n, err := lzwr.Read(d.tmp[:1]); n != 0 || (err != io.EOF && err != io.ErrUnexpectedEOF) {
if err != nil {
return err
// initialization side effects.
//
// See "The Go image package" for more details:
-// http://golang.org/doc/articles/image_package.html
+// https://golang.org/doc/articles/image_package.html
package image
import (
// Check that math constants are accepted by compiler
// and have right value (assumes strconv.ParseFloat works).
-// http://golang.org/issue/201
+// https://golang.org/issue/201
type floatTest struct {
val interface{}
"10953742525620032441",
"17908251027575790097",
- // http://golang.org/issue/638
+ // https://golang.org/issue/638
"18699199384836356663",
"98920366548084643601728869055592650835572950932266967461790948584315647051443",
}
func TestQuotedPrintableEncoding(t *testing.T) {
- // From http://golang.org/issue/4411
+ // From https://golang.org/issue/4411
body := "--0016e68ee29c5d515f04cedf6733\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=text\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\nwords words words words words words words words words words words words wor=\r\nds words words words words words words words words words words words words =\r\nwords words words words words words words words words words words words wor=\r\nds words words words words words words words words words words words words =\r\nwords words words words words words words words words\r\n--0016e68ee29c5d515f04cedf6733\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=submit\r\n\r\nSubmit\r\n--0016e68ee29c5d515f04cedf6733--"
r := NewReader(strings.NewReader(body), "0016e68ee29c5d515f04cedf6733")
part, err := r.NextPart()
// already been accepted and closed by the server.
// Treat this as a successful connection--writes to
// the socket will see EOF. For details and a test
- // case in C see http://golang.org/issue/6828.
+ // case in C see https://golang.org/issue/6828.
if runtime.GOOS == "solaris" {
return nil
}
if redirectFailed {
// Special case for Go 1 compatibility: return both the response
// and an error if the CheckRedirect function failed.
- // See http://golang.org/issue/3795
+ // See https://golang.org/issue/3795
return resp, urlErr
}
t.Errorf("with redirects forbidden, expected a *url.Error with our 'no redirects allowed' error inside; got %#v (%q)", err, err)
}
if res == nil {
- t.Fatalf("Expected a non-nil Response on CheckRedirect failure (http://golang.org/issue/3795)")
+ t.Fatalf("Expected a non-nil Response on CheckRedirect failure (https://golang.org/issue/3795)")
}
res.Body.Close()
if res.Header.Get("Location") == "" {
}
}
-// Verify Response.ContentLength is populated. http://golang.org/issue/4126
+// Verify Response.ContentLength is populated. https://golang.org/issue/4126
func TestClientHeadContentLength(t *testing.T) {
defer afterTest(t)
ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
// We loosen this as spaces and commas are common in cookie values
// but we produce a quoted cookie-value in when value starts or ends
// with a comma or space.
-// See http://golang.org/issue/7243 for the discussion.
+// See https://golang.org/issue/7243 for the discussion.
func sanitizeCookieValue(v string) string {
v = sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
if len(v) == 0 {
func TestReverseProxyCancellation(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/9554")
+ t.Skip("skipping test; see https://golang.org/issue/9554")
}
const backendResponse = "I am the backend"
}
}
-// Tests for http://golang.org/issue/900
+// Tests for https://golang.org/issue/900
func TestMuxRedirectLeadingSlashes(t *testing.T) {
paths := []string{"//foo.txt", "///foo.txt", "/../../foo.txt"}
for _, path := range paths {
func TestServerTimeouts(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
reqNum := 0
// request) that will never happen.
func TestOnlyWriteTimeout(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
var conn net.Conn
func TestTLSHandshakeTimeout(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
ts := httptest.NewUnstartedServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
// side of their TCP connection, the server doesn't send a 400 Bad Request.
func TestClientWriteShutdown(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
// Tests that the server flushes its response headers out when it's
// ignoring the response body and waits a bit before forcefully
// closing the TCP connection, causing the client to get a RST.
-// See http://golang.org/issue/3595
+// See https://golang.org/issue/3595
func TestServerGracefulClose(t *testing.T) {
defer afterTest(t)
ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
<-conn.closec
}
-// http://golang.org/issue/5955
+// https://golang.org/issue/5955
// Note that this does not test the "request too large"
// exit path from the http server. This is intentional;
// not sending Connection: close is just a minor wire
// pause for a bit, hoping the client processes it before any
// subsequent RST.
//
-// See http://golang.org/issue/3595
+// See https://golang.org/issue/3595
func (c *conn) closeWriteAndWait() {
c.finalFlush()
if tcp, ok := c.rwc.(closeWriter); ok {
// Note that we don't request this for HEAD requests,
// due to a bug in nginx:
// http://trac.nginx.org/nginx/ticket/358
- // http://golang.org/issue/5522
+ // https://golang.org/issue/5522
//
// We don't request gzip if the request is for a range, since
// auto-decoding a portion of a gzipped document will just fail
- // anyway. See http://golang.org/issue/8923
+ // anyway. See https://golang.org/issue/8923
requestedGzip = true
req.extraHeaders().Set("Accept-Encoding", "gzip")
}
}
}
-// Test for http://golang.org/issue/2616 (appropriate issue number)
+// Test for https://golang.org/issue/2616 (appropriate issue number)
// This fails pretty reliably with GOMAXPROCS=100 or something high.
func TestStressSurpriseServerCloses(t *testing.T) {
defer afterTest(t)
// tests that persistent goroutine connections shut down when no longer desired.
func TestTransportPersistConnLeak(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
gotReqCh := make(chan bool)
// request.ContentLength is explicitly short
func TestTransportPersistConnLeakShortBody(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
}
}
-// This used to crash; http://golang.org/issue/3266
+// This used to crash; https://golang.org/issue/3266
func TestTransportIdleConnCrash(t *testing.T) {
defer afterTest(t)
tr := &Transport{}
}
}
-// From http://golang.org/issue/4454 ,
+// From https://golang.org/issue/4454 ,
// "client fails to handle requests with no body and chunked encoding"
func TestChunkedNoContent(t *testing.T) {
defer afterTest(t)
func TestIssue4191_InfiniteGetTimeout(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
const debug = false
func TestIssue4191_InfiniteGetToPutTimeout(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7237")
+ t.Skip("skipping test; see https://golang.org/issue/7237")
}
defer afterTest(t)
const debug = false
defer close(unblockc)
// Don't interfere with the next test on plan9.
- // Cf. http://golang.org/issues/11476
+ // Cf. https://golang.org/issues/11476
if runtime.GOOS == "plan9" {
defer time.Sleep(500 * time.Millisecond)
}
// Issue 6981
func TestTransportClosesBodyOnError(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/7782")
+ t.Skip("skipping test; see https://golang.org/issue/7782")
}
defer afterTest(t)
readBody := make(chan error, 1)
func TestGobError(t *testing.T) {
if runtime.GOOS == "plan9" {
- t.Skip("skipping test; see http://golang.org/issue/8908")
+ t.Skip("skipping test; see https://golang.org/issue/8908")
}
defer func() {
err := recover()
// see this happen, rather than expose the buggy effect to users, we
// close the fd and try again. If it happens twice more, we relent and
// use the result. See also:
- // http://golang.org/issue/2690
+ // https://golang.org/issue/2690
// http://stackoverflow.com/questions/4949858/
//
// The opposite can also happen: if we ask the kernel to pick an appropriate
// standard error. If non-nil, entry i becomes file descriptor 3+i.
//
// BUG(rsc): On OS X 10.6, child processes may sometimes inherit unwanted fds.
- // http://golang.org/issue/2603
+ // https://golang.org/issue/2603
ExtraFiles []*os.File
// SysProcAttr holds optional, operating system-specific attributes.
}
func TestExtraFilesFDShuffle(t *testing.T) {
- t.Skip("flaky test; see http://golang.org/issue/5780")
+ t.Skip("flaky test; see https://golang.org/issue/5780")
switch runtime.GOOS {
case "darwin":
- // TODO(cnicolaou): http://golang.org/issue/2603
+ // TODO(cnicolaou): https://golang.org/issue/2603
// leads to leaked file descriptors in this test when it's
// run from a builder.
closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
case "netbsd":
- // http://golang.org/issue/3955
+ // https://golang.org/issue/3955
closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
case "windows":
t.Skip("no operating system support; skipping")
// file descriptors...
case "darwin":
// TODO(bradfitz): broken? Sometimes.
- // http://golang.org/issue/2603
+ // https://golang.org/issue/2603
// Skip this additional part of the test for now.
case "netbsd":
// TODO(jsing): This currently fails on NetBSD due to
// the cloned file descriptors that result from opening
// /dev/urandom.
- // http://golang.org/issue/3955
+ // https://golang.org/issue/3955
case "plan9":
// TODO(0intro): Determine why Plan 9 is leaking
// file descriptors.
- // http://golang.org/issue/7118
+ // https://golang.org/issue/7118
case "solaris":
// TODO(aram): This fails on Solaris because libc opens
// its own files, as it sees fit. Darwin does the same,
- // see: http://golang.org/issue/2603
+ // see: https://golang.org/issue/2603
default:
// Now verify that there are no other open fds.
var files []*os.File
if off != tt.out || err != nil {
if e, ok := err.(*PathError); ok && e.Err == syscall.EINVAL && tt.out > 1<<32 {
// Reiserfs rejects the big seeks.
- // http://golang.org/issue/91
+ // https://golang.org/issue/91
break
}
t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
}
}
-func TestBug3486(t *testing.T) { // http://golang.org/issue/3486
+func TestBug3486(t *testing.T) { // https://golang.org/issue/3486
if runtime.GOOS == "darwin" {
switch runtime.GOARCH {
case "arm", "arm64":
# license that can be found in the LICENSE file.
# race.bash tests the standard library under the race detector.
-# http://golang.org/doc/articles/race_detector.html
+# https://golang.org/doc/articles/race_detector.html
set -e
:: license that can be found in the LICENSE file.
:: race.bash tests the standard library under the race detector.
-:: http://golang.org/doc/articles/race_detector.html
+:: https://golang.org/doc/articles/race_detector.html
@echo off
// Indirect Go func value (dummy) to obtain
// actual code address. (A Go func value is a pointer
- // to a C function pointer. http://golang.org/s/go11func.)
+ // to a C function pointer. https://golang.org/s/go11func.)
dummy := makeFuncStub
code := **(**uintptr)(unsafe.Pointer(&dummy))
// Indirect Go func value (dummy) to obtain
// actual code address. (A Go func value is a pointer
- // to a C function pointer. http://golang.org/s/go11func.)
+ // to a C function pointer. https://golang.org/s/go11func.)
dummy := methodValueCall
code := **(**uintptr)(unsafe.Pointer(&dummy))
// for that type.
//
// See "The Laws of Reflection" for an introduction to reflection in Go:
-// http://golang.org/doc/articles/laws_of_reflection.html
+// https://golang.org/doc/articles/laws_of_reflection.html
package reflect
import (
// method name. It is empty for upper case (exported) method names.
// The combination of PkgPath and Name uniquely identifies a method
// in a method set.
- // See http://golang.org/ref/spec#Uniqueness_of_identifiers
+ // See https://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
// Name is the field name.
// PkgPath is the package path that qualifies a lower case (unexported)
// field name. It is empty for upper case (exported) field names.
- // See http://golang.org/ref/spec#Uniqueness_of_identifiers
+ // See https://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
// directlyAssignable reports whether a value x of type V can be directly
// assigned (using memmove) to a value of type T.
-// http://golang.org/doc/go_spec.html#Assignability
+// https://golang.org/doc/go_spec.html#Assignability
// Ignoring the interface rules (implemented elsewhere)
// and the ideal constant rules (no ideal constants at run time).
func directlyAssignable(T, V *rtype) bool {
func main() {
// This test intends to test that sending SIGPROF to foreign threads
// before we make any cgo call will not abort the whole process, so
- // we cannot make any cgo call here. See http://golang.org/issue/9456.
+ // we cannot make any cgo call here. See https://golang.org/issue/9456.
atomic.StoreInt32((*int32)(unsafe.Pointer(&C.spinlock)), 1)
for atomic.LoadInt32((*int32)(unsafe.Pointer(&C.spinlock))) == 1 {
runtime.Gosched()
// WriteHeapDump writes a description of the heap and the objects in
// it to the given file descriptor.
-// The heap dump format is defined at http://golang.org/s/go13heapdump.
+// The heap dump format is defined at https://golang.org/s/go13heapdump.
func WriteHeapDump(fd uintptr)
remaining after the previous collection reaches this percentage. The default
is GOGC=100. Setting GOGC=off disables the garbage collector entirely.
The runtime/debug package's SetGCPercent function allows changing this
-percentage at run time. See http://golang.org/pkg/runtime/debug/#SetGCPercent.
+percentage at run time. See https://golang.org/pkg/runtime/debug/#SetGCPercent.
The GODEBUG variable controls debugging variables within the runtime.
It is a comma-separated list of name=val pairs setting these named variables:
The GOARCH, GOOS, GOPATH, and GOROOT environment variables complete
the set of Go environment variables. They influence the building of Go programs
-(see http://golang.org/cmd/go and http://golang.org/pkg/go/build).
+(see https://golang.org/cmd/go and https://golang.org/pkg/go/build).
GOARCH, GOOS, and GOROOT are recorded at compile time and made available by
constants or functions in this package, but they do not influence the execution
of the run-time system.
// finalizers, etc.) to a file.
// The format of the dumped file is described at
-// http://golang.org/s/go14heapdump.
+// https://golang.org/s/go14heapdump.
package runtime
// On Windows 64-bit we limit the arena to 32GB or 35 bits.
// Windows counts memory used by page table into committed memory
// of the process, so we can't reserve too much memory.
- // See http://golang.org/issue/5402 and http://golang.org/issue/5236.
+ // See https://golang.org/issue/5402 and https://golang.org/issue/5236.
// On other 64-bit platforms, we limit the arena to 512GB, or 39 bits.
// On 32-bit, we don't bother limiting anything, so we use the full 32-bit address.
// On Darwin/arm64, we cannot reserve more than ~5GB of virtual memory,
// This algorithm optimizes for heap growth to match GOGC and for CPU
// utilization between assist and background marking to be 25% of
// GOMAXPROCS. The high-level design of this algorithm is documented
-// at http://golang.org/s/go15gcpacing.
+// at https://golang.org/s/go15gcpacing.
var gcController = gcControllerState{
// Initial trigger ratio guess.
triggerRatio: 7 / 8.0,
)
// BUG(rsc): Profiles are incomplete and inaccurate on NetBSD and OS X.
-// See http://golang.org/issue/6047 for details.
+// See https://golang.org/issue/6047 for details.
// A Profile is a collection of stack traces showing the call sequences
// that led to instances of a particular event, such as allocation.
func skipTraceTestsIfNeeded(t *testing.T) {
switch runtime.GOOS {
case "solaris":
- t.Skip("skipping: solaris timer can go backwards (http://golang.org/issue/8976)")
+ t.Skip("skipping: solaris timer can go backwards (https://golang.org/issue/8976)")
case "darwin":
switch runtime.GOARCH {
case "arm", "arm64":
switch runtime.GOARCH {
case "arm":
- t.Skip("skipping: arm tests fail with 'failed to parse trace' (http://golang.org/issue/9725)")
+ t.Skip("skipping: arm tests fail with 'failed to parse trace' (https://golang.org/issue/9725)")
}
}
// M must have an associated P to execute Go code, however it can be
// blocked or in a syscall w/o an associated P.
//
-// Design doc at http://golang.org/s/go11sched.
+// Design doc at https://golang.org/s/go11sched.
const (
// Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
// Package race implements data race detection logic.
// No public interface is provided.
// For details about the race detector see
-// http://golang.org/doc/articles/race_detector.html
+// https://golang.org/doc/articles/race_detector.html
package race
)
// Layout of in-memory per-function information prepared by linker
-// See http://golang.org/s/go12symtab.
+// See https://golang.org/s/go12symtab.
// Keep in sync with linker
// and with package debug/gosym and with symtab.go in package runtime.
type _func struct {
if consumed > estimate {
t.Fatalf("Stack mem: want %v, got %v", estimate, consumed)
}
- // Due to broken stack memory accounting (http://golang.org/issue/7468),
+ // Due to broken stack memory accounting (https://golang.org/issue/7468),
// StackInuse can decrease during function execution, so we cast the values to int64.
inuse := int64(s1.StackInuse) - int64(s0.StackInuse)
t.Logf("Inuse %vMB for stack mem", inuse>>20)
// buf.pc, so that when we return we will execute
// the jump instruction and carry on. This means that
// stack unwinding may not work entirely correctly
- // (http://golang.org/issue/5723) but the user is
+ // (https://golang.org/issue/5723) but the user is
// running under gdb anyhow.
return
}
// changes of heap size, processor start/stop, etc and writes them to a buffer
// in a compact form. A precise nanosecond-precision timestamp and a stack
// trace is captured for most events.
-// See http://golang.org/s/go15trace for more info.
+// See https://golang.org/s/go15trace for more info.
package runtime
defer os.Exit(0)
// Look for our fd. It should be fd 3, but we work around an fd leak
- // bug here (http://golang.org/issue/2603) to let it be elsewhere.
+ // bug here (https://golang.org/issue/2603) to let it be elsewhere.
var uc *net.UnixConn
for fd := uintptr(3); fd <= 10; fd++ {
f := os.NewFile(fd, "unix-conn")
// its -bench flag is provided. Benchmarks are run sequentially.
//
// For a description of the testing flags, see
-// http://golang.org/cmd/go/#hdr-Description_of_testing_flags.
+// https://golang.org/cmd/go/#hdr-Description_of_testing_flags.
//
// A sample benchmark function looks like this:
// func BenchmarkHello(b *testing.B) {
{"39h9m14.425s", true, 39*Hour + 9*Minute + 14*Second + 425*Millisecond},
// large value
{"52763797000ns", true, 52763797000 * Nanosecond},
- // more than 9 digits after decimal point, see http://golang.org/issue/6617
+ // more than 9 digits after decimal point, see https://golang.org/issue/6617
{"0.3333333333333333333h", true, 20 * Minute},
// 9007199254740993 = 1<<53+1 cannot be stored precisely in a float64
{"9007199254740993ns", true, (1<<53 + 1) * Nanosecond},
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test len constants and non-constants, http://golang.org/issue/3244.
+// Test len constants and non-constants, https://golang.org/issue/3244.
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test that len non-constants are not constants, http://golang.org/issue/3244.
+// Test that len non-constants are not constants, https://golang.org/issue/3244.
package p
// license that can be found in the LICENSE file.
// Used to crash the compiler.
-// http://golang.org/issue/88
+// https://golang.org/issue/88
package main
// license that can be found in the LICENSE file.
// Used to crash the compiler.
-// http://golang.org/issue/158
+// https://golang.org/issue/158
package main
// license that can be found in the LICENSE file.
// Used to be rejected
-// http://golang.org/issue/188
+// https://golang.org/issue/188
package main
// license that can be found in the LICENSE file.
// Used to crash
-// http://golang.org/issue/204
+// https://golang.org/issue/204
package main
// license that can be found in the LICENSE file.
// Crashes 6g, 8g
-// http://golang.org/issue/238
+// https://golang.org/issue/238
package main
// function call arg reordering was picking out 1 call that
// didn't need to be in a temporary, but it was picking
// out the first call instead of the last call.
-// http://golang.org/issue/370
+// https://golang.org/issue/370
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test case for http://golang.org/issue/692
+// Test case for https://golang.org/issue/692
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test case for http://golang.org/issue/700
+// Test case for https://golang.org/issue/700
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/749
+// https://golang.org/issue/749
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/662
+// https://golang.org/issue/662
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/589
+// https://golang.org/issue/589
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/589
+// https://golang.org/issue/589
package main
// Both gccgo and gofmt correctly refuse this program as is and accept it
// when the semicolons are present.
-// This is a test case for issue 777 ( http://golang.org/issue/777 ).
+// This is a test case for issue 777 ( https://golang.org/issue/777 ).
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/799
+// https://golang.org/issue/799
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/808
+// https://golang.org/issue/808
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/807
+// https://golang.org/issue/807
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/806
+// https://golang.org/issue/806
// triggered out of registers on 8g
package bug283
// Test for issue 778: Map key values that are assignment
// compatible with the map key type must be accepted according
-// to the spec: http://golang.org/doc/go_spec.html#Indexes .
+// to the spec: https://golang.org/doc/go_spec.html#Indexes .
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/920
+// https://golang.org/issue/920
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/915
+// https://golang.org/issue/915
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/843
+// https://golang.org/issue/843
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/846
+// https://golang.org/issue/846
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/800
+// https://golang.org/issue/800
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/990
+// https://golang.org/issue/990
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/3119
+// https://golang.org/issue/3119
package main
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// http://golang.org/issue/3351
+// https://golang.org/issue/3351
package main
// license that can be found in the LICENSE file.
// Test that fields hide promoted methods.
-// http://golang.org/issue/4365
+// https://golang.org/issue/4365
package main