f float64 = d
)

// multiple initialization
const (
	a1, a2, a3 = 7, 3.1415926, "foo"
	b1, b2, b3 = b3, b1, 42
	c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
	d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
	_p0 = assert(a1 == 7)
	_p1 = assert(a2 == 3.1415926)
	_p2 = assert(a3 == "foo")
	_p3 = assert(b1 == 42)
	_p4 = assert(b2 == 42)
	_p5 = assert(b3 == 42)
)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "fmt"

func f0() string {
	const f = 3.141592;
	return fmt.Sprintf("%v", float64(f));
}


func f1() string {
	const f = 3.141592;
	x := float64(float32(f));  // appears to change the precision of f
	_ = x;
	return fmt.Sprintf("%v", float64(f));
}


func main() {
	r0 := f0();

	g := Gcd(x, y)
	fmt.Println("The gcd of", x, "and", y, "is", g)

	// Manipulate the Foo global variable

	// Output its current value
	fmt.Println("Foo =", GetFoo())

	// Change its value
	SetFoo(3.1415926)

	// See if the change took effect
	fmt.Println("Foo =", GetFoo())
}
-- main.swig --
%module main

%inline %{
extern int    gcd(int x, int y);
extern double Foo;
%}
-- main_test.go --

	enc := gob.NewEncoder(&medium)
	dec := gob.NewDecoder(&medium)
	for _, test := range encodingTests {
		medium.Reset() // empty buffer for each test case (in case of failures)
		var tx Rat
		tx.SetString(test + ".14159265")
		if err := enc.Encode(&tx); err != nil {
			t.Errorf("encoding of %s failed: %s", &tx, err)
			continue
		}
		var rx Rat
		if err := dec.Decode(&rx); err != nil {
			t.Errorf("decoding of %s failed: %s", &tx, err)

		}
	}

	expectedRows := [][]interface{}{
		{
			"foo",
			"12h",
			int64(7),
			nil,
			nil,
			"string",
			"3.1415926",
			"7",
			"true",
			float64(3.1415926),
			true,
		},
	}
	for i, r := range tbl.Rows {
		if !reflect.DeepEqual(r.Cells, expectedRows[i]) {
			t.Errorf("got row %d with cells %#v, expected %#v", i, r.Cells, expectedRows[i])

package exports

import "go/ast"

// Issue 3682: Correctly read dotted identifiers from export data.
const init1 = 0

func init() {}

const (
	C0  int     = 0
	C1          = 3.14159265
	C2          = 2.718281828i
	C3          = -123.456e-789
	C4          = +123.456e+789
	C5          = 1234i
	C6          = "foo\n"
	C7          = `bar\n`
	C8          = 42
	C9  int     = 42
	C10 float64 = 42

# golang.org/issue/14176#issuecomment-179895769
# golang.org/issue/14192
# -I arguments to compiler could end up not in GOPATH order,
# leading to unexpected import resolution in the compiler.

env GO111MODULE=off
env GOPATH=$WORK/p1${:}$WORK/p2
mkdir $WORK/p1/src/foo $WORK/p2/src/baz
mkdir $WORK/p2/pkg/${GOOS}_${GOARCH} $WORK/p1/src/bar
cp foo.go $WORK/p1/src/foo/foo.go
cp baz.go $WORK/p2/src/baz/baz.go
cp foo.a $WORK/p2/pkg/${GOOS}_${GOARCH}/foo.a

	fmt.Println(string(b32))

	b64 := []byte("float64:")
	b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
	fmt.Println(string(b64))

	// Output:
	// float32:3.1415927E+00
	// float64:3.1415926535E+00
}

func ExampleAppendInt() {
	b10 := []byte("int (base 10):")
	b10 = strconv.AppendInt(b10, -42, 10)
	fmt.Println(string(b10))

	b16 := []byte("int (base 16):")

	// in the output) and 2 is the number of decimal places to show.
	pi := math.Pi
	fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
	// Result: 3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00

	// Complex numbers format as parenthesized pairs of floats, with an 'i'
	// after the imaginary part.
	point := 110.7 + 22.5i
	fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)

                }
            }
        """

        buildFile << """
            plugins {
                `my-plugin`
            }
        """

        when:
        if (['1.4', '1.5', '1.6'].contains(kotlinLanguageVersion)) {
            executer.expectDeprecationWarning("w: Language version $kotlinLanguageVersion is deprecated and its support will be removed in a future version of Kotlin")
        }