then:
        urls[0].url == 'https://github.com/gradle/gradle/commit/123456'
    }

    def "transforms two commit ids to urls"() {
        when:
        def urls = new TestPageGenerator().createGitHubLinks(['123456', 'abcdefg'])

        then:
        urls[0].url == 'https://github.com/gradle/gradle/commit/123456'

        Describables.of("one", "two").capitalizedDisplayName == "One two"

        Describables.of(123, 456).displayName == "123 456"
        Describables.of(123, 456).toString() == "123 456"
        Describables.of(123, 456).capitalizedDisplayName == "123 456"

        Describables.of("one", "two", "three").displayName == "one two three"

	}
}

func test4() {
	var a, b V
	m := make(map[V]int)

	copy((*[20]byte)(unsafe.Pointer(&a))[:], "Hello World, Gopher!")
	a.A1, a.A2, a.A3, a.B, a.C = 1, 2, 3, 4, 5
	b.A1, b.A2, b.A3, b.B, b.C = 1, 2, 3, 4, 5

	if a != b {
		panic("broken equality: a != b")
	}

	m[a] = 1
	m[b] = 2
	if len(m) == 2 {
		panic("broken hash: len(m) == 2")
	}
	if m[a] != 2 {

// See issue 39927.

// This test run under GODEBUG=clobberfree=1. The check
// *x[i] == 12345 depends on this debug mode to clobber
// the value if the object is freed prematurely.

package main

import (
	"fmt"
	"runtime"
	"testshared/gcdata/p"
)

var x p.T

func main() {
	for i := range x {
		x[i] = new(int)
		*x[i] = 12345
	}
	runtime.GC()
	runtime.GC()
	runtime.GC()
	for i := range x {

            new DirectorySnapshot(childDir.absolutePath, childDir.name, FileMetadata.AccessType.DIRECT, TestHashCodes.hashCodeFrom(2345), [
                new RegularFileSnapshot(childFile.absolutePath, childFile.name, TestHashCodes.hashCodeFrom(9876), DefaultFileMetadata.file(123, 456, FileMetadata.AccessType.DIRECT))
            ]),

func (z *IntPtr) M() int64 { return int64(*z) }

var bad bool

func test(name string, i I) {
	m := i.M()
	if m != 12345 {
		println(name, m)
		bad = true
	}
}

func ptrs() {
	var bigptr BigPtr = BigPtr{ 10000, 2000, 300, 45 }
	var smallptr SmallPtr = SmallPtr{ 12345 }
	var intptr IntPtr = 12345

//	test("bigptr", bigptr)
	test("&bigptr", &bigptr)
//	test("smallptr", smallptr)
	test("&smallptr", &smallptr)

func f() net.Addr {
	a := &net.IPAddr{ip1}
	sub(&net.UDPAddr{ip2, 12345})
	c := &net.TCPAddr{IP: ip3, Port: 54321}
	d := &net.TCPAddr{ip4, 0}
	p := 1234
	e := &net.TCPAddr{ip4, p}
	return &net.TCPAddr{ip5}, nil
}
`,
		Out: `package main

import "net"

func f() net.Addr {
	a := &net.IPAddr{IP: ip1}
	sub(&net.UDPAddr{IP: ip2, Port: 12345})
	c := &net.TCPAddr{IP: ip3, Port: 54321}
	d := &net.TCPAddr{IP: ip4}

For example, if the directory `6-stdlib/99-minor` is present,
then an `api/next` file with the line

    pkg net/http, function F #12345

should have a corresponding file named `doc/next/6-stdlib/99-minor/net/http/12345.md`.
At a minimum, that file should contain either a full sentence or a TODO,
ideally referring to a person with the responsibility to complete the note.

			withToken:       true,
			command:         "user",
			additionalFlags: []string{"--token=123456"},
		},
		{
			name:            "user subCommand withToken",
			withToken:       true,
			command:         "user",
			clusterName:     "my-cluster-with-token",
			additionalFlags: []string{"--token=123456"},
		},
		{
			name:                   "user subCommand with validity period",

	var values = []any{
		true,
		int(123),
		int8(123),
		int16(-12345),
		int32(123456),
		int64(-1234567),
		uint(123),
		uint8(123),
		uint16(12345),
		uint32(123456),
		uint64(1234567),
		uintptr(12345678),
		float32(1.2345),
		float64(1.2345678),
		complex64(1.2345 + 2.3456i),
		complex128(1.2345678 + 2.3456789i),
		[]byte("hello"),
		string("hello"),
	}