branch: 'master',
                    date: '1970-01-01',
                    commits: ['123456']
                ],
                [
                    id: '1450575490',
                    branch: 'master',
                    date: '1970-01-01',
                    commits: ['123456']
                ]
            ],
            totalTime: [
                [

// Copyright 2021 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 base

        's'  | 'Should have at least 5 lines'
    }

    def "fails when missing the success marker"() {
        when:
        ModelReportParser.parse("""-----------
Report
--------------
1
2
3
4
5
6
+ model
BUILD SUCCESSFUsL
""")
        then:
        def ex = thrown(AssertionError)
        ex.message.startsWith "Expected to find an end of report marker '${ModelReportParser.END_OF_REPORT_MARKER}'"

package sort_test

import (
	"fmt"
	"math"
	"sort"
)

func ExampleInts() {
	s := []int{5, 2, 6, 3, 1, 4} // unsorted
	sort.Ints(s)
	fmt.Println(s)
	// Output: [1 2 3 4 5 6]
}

func ExampleIntsAreSorted() {
	s := []int{1, 2, 3, 4, 5, 6} // sorted ascending
	fmt.Println(sort.IntsAreSorted(s))

	s = []int{6, 5, 4, 3, 2, 1} // sorted descending
	fmt.Println(sort.IntsAreSorted(s))

// Test that when the compiler expands append inline it does not
// overwrite a value before it needs it (issue 3369).

package main

func main() {
	s := make([]byte, 5, 6)
	copy(s, "12346")
	s = append(s[:len(s)-1], '5', s[len(s)-1])
	if string(s) != "123456" {
		panic(s)
	}

	fmt.Println(*a, *b, *c, *d, *e, *f) // Forces it to spill b
	sink = scratch[*b+1]                // scratch[5+1] == 1
	*f, *a = *a, *f
	*e, *b = *b, *e
	*d, *c = *c, *d
}

func main() {
	a, b, c, d, e, f := 1, 2, 3, 4, 5, 6
	F(&a, &b, &c, &d, &e, &f)
	fmt.Println(a, b, c, d, e, f)
	fmt.Println(sink)

// is not a requirement for correctness and not checked in this test.
// We do check the emitted symbol contents are correct, though.

package main

func main() {
	F([10]int{1, 2, 3, 4, 5, 6}, [20]int{1, 2, 3, 4, 5, 6})
}

//go:noinline
func F(x, y interface{}) {
	x1 := x.([10]int)
	y1 := y.([20]int)
	for i := range y1 {
		if i < 6 {
			if x1[i] != i+1 || y1[i] != i+1 {
				panic("FAIL")
			}

	expect(t, a, []int{1})
	a = appendThree_ssa(a, 2, 3, 4)
	expect(t, a, []int{1, 2, 3, 4})
	a = appendThree_ssa(a, 5, 6, 7)
	expect(t, a, []int{1, 2, 3, 4, 5, 6, 7})
	if &a[0] != &store[0] {
		t.Errorf("unnecessary grow")
	}
	a = appendOne_ssa(a, 8)
	expect(t, a, []int{1, 2, 3, 4, 5, 6, 7, 8})
	if &a[0] == &store[0] {
		t.Errorf("didn't grow")
	}
}

func TestAppend(t *testing.T) {
	testAppend(t)

		},
		{
			desc: "numeric-zero",
			in:   "0",
			want: 0,
		},
		{
			desc: "numeric-large",
			in:   "12345678",
			want: 12345678,
		},
		{
			desc: "numeric-negative",
			in:   "-12345678",
			want: -12345678,
		},
		{
			desc: "float",
			in:   "1.23456",
			want: 1.23456,
		},
		{
			desc: "float-zero",
			in:   "0.00",
			want: 0.00,
		},
		{
			desc: "float-negative",

}

void
callGoStackCheck(void)
{
	extern void goStackCheck(void);
	goStackCheck();
}

int
returnAfterGrow(void)
{
	extern int goReturnVal(void);
	goReturnVal();
	return 123456;
}

int
returnAfterGrowFromGo(void)
{
	extern int goReturnVal(void);
	return goReturnVal();
}

void
callGoWithString(void)
{
	extern void goWithString(GoString);