-- foldingRange-0 --
package folding //@fold("package")

import (<>)

import _ "os"

// bar is a function.<>
func bar(<>) string {<>}

-- foldingRange-1 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {<>}
	/* This is a multiline<>

	/* This is a multiline<>
	_ = []int{<>}
	_ = [2]string{<>}
	_ = map[string]int{<>}
	type T struct {<>}
	_ = T{<>}
	x, y := make(<>), make(<>)
	select {<>}
	// This is a multiline comment<>
	return `
this string
is not indented`
}

-- foldingRange-2 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:<>
	case false:<>
	default:<>
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:<>
	case <-y:<>
	default:<>
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-3 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {<>} else {<>}
	case false:
		fmt.Println(<>)
	default:
		fmt.Println(<>)
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {<>} else {<>}
	case <-y:
		fmt.Println(<>)
	default:
		fmt.Println(<>)
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-4 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {
			fmt.Println(<>)
		} else {
			fmt.Println(<>)
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {
			fmt.Println(<>)
		} else {
			fmt.Println(<>)
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-cmd --
3:9-6:0
10:22-11:32
12:10-12:9
12:20-75:0
14:10-25:1
15:12-20:3
16:12-18:2
17:16-17:21
18:11-20:2
19:16-19:22
21:13-22:22
22:15-22:21
23:10-24:24
24:15-24:23
26:24-28:11
30:24-33:32
34:12-38:1
39:16-41:1
42:21-46:1
47:17-51:1
52:8-56:1
57:15-57:23
57:32-57:40
58:10-69:1
59:18-64:3
60:11-62:2
61:16-61:28
62:11-64:2
63:16-63:29
65:11-66:18
66:15-66:17
67:10-68:24
68:15-68:23
70:32-71:30

-- foldingRange-comment-0 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.<>
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {
			fmt.Println("true")
		} else {
			fmt.Println("false")
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline<>

	/* This is a multiline<>
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {
			fmt.Println("true from x")
		} else {
			fmt.Println("false from x")
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment<>
	return `
this string
is not indented`
}

-- foldingRange-imports-0 --
package folding //@fold("package")

import (<>)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {
			fmt.Println("true")
		} else {
			fmt.Println("false")
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {
			fmt.Println("true from x")
		} else {
			fmt.Println("false from x")
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-lineFolding-0 --
package folding //@fold("package")

import (<>
)

import _ "os"

// bar is a function.<>
func bar() string {<>
}

-- foldingRange-lineFolding-1 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {<>
	}
	/* This is a multiline<>

	/* This is a multiline<>
	_ = []int{<>,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{<>,
	}
	type T struct {<>
	}
	_ = T{<>,
	}
	x, y := make(chan bool), make(chan bool)
	select {<>
	}
	// This is a multiline comment<>
	return `
this string
is not indented`
}

-- foldingRange-lineFolding-2 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:<>
	case false:<>
	default:<>
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:<>
	case <-y:<>
	default:<>
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-lineFolding-3 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {<>
		} else {<>
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {<>
		} else {<>
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

-- foldingRange-lineFolding-comment-0 --
package folding //@fold("package")

import (
	"fmt"
	_ "log"
)

import _ "os"

// bar is a function.<>
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {
			fmt.Println("true")
		} else {
			fmt.Println("false")
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline<>

	/* This is a multiline<>
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {
			fmt.Println("true from x")
		} else {
			fmt.Println("false from x")
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment<>
	return `
this string
is not indented`
}

-- foldingRange-lineFolding-imports-0 --
package folding //@fold("package")

import (<>
)

import _ "os"

// bar is a function.
// With a multiline doc comment.
func bar() string {
	/* This is a single line comment */
	switch {
	case true:
		if true {
			fmt.Println("true")
		} else {
			fmt.Println("false")
		}
	case false:
		fmt.Println("false")
	default:
		fmt.Println("default")
	}
	/* This is a multiline
	block
	comment */

	/* This is a multiline
	block
	comment */
	// Followed by another comment.
	_ = []int{
		1,
		2,
		3,
	}
	_ = [2]string{"d",
		"e",
	}
	_ = map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	type T struct {
		f string
		g int
		h string
	}
	_ = T{
		f: "j",
		g: 4,
		h: "i",
	}
	x, y := make(chan bool), make(chan bool)
	select {
	case val := <-x:
		if val {
			fmt.Println("true from x")
		} else {
			fmt.Println("false from x")
		}
	case <-y:
		fmt.Println("y")
	default:
		fmt.Println("default")
	}
	// This is a multiline comment
	// that is not a doc comment.
	return `
this string
is not indented`
}

