// license that can be found in the LICENSE file.

package syntax

import (
	"testing"
)

func TestDump(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in short mode")
	}

	ast, _ := ParseFile(*src_, func(err error) { t.Error(err) }, nil, CheckBranches)

	if ast != nil {
		Fdump(testOut(), ast)
	}

      <w>debuggee</w>
      <w>deserializes</w>
      <w>destructured</w>
      <w>hacky</w>
      <w>impls</w>
      <w>inlined</w>
      <w>kapt</w>
      <w>kotlinc</w>
      <w>mutators</w>
      <w>parcelable</w>
      <w>parceler</w>
      <w>parcelers</w>
      <w>parcelize</w>
      <w>repl</w>
      <w>testdata</w>
      <w>uast</w>
      <w>unbox</w>
      <w>unboxed</w>
      <w>unmute</w>
    </words>

	src := `package foo

import (
	"fmt"
	"time"
)

func bar() {
	fmt.Println(time.Now())
}`

	// Parse src but stop after processing the imports.
	f, err := parser.ParseFile(fset, "", src, parser.ImportsOnly)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Print the imports from the file's AST.
	for _, s := range f.Imports {
		fmt.Println(s.Path.Value)
	}

	// bug, this test failed with a runtime panic.
	src := "package p\ntype T struct {\n\tF int `json:\"f\"` // a field\n}\n"

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "", src, 0)
	if err != nil {
		panic(err)
	}

	for n := range ast.Preorder(f) {
		if id, ok := n.(*ast.Ident); ok && id.Name == "F" {
			break
		}
	}

        """
        try:
            return cls(root_name, cElementTree.fromstring(data))
        except _ETREE_EXCEPTIONS as error:
            raise InvalidXMLError(
                '"{}" XML is not parsable. Message: {}'.format(
                    root_name, error.message
                )
            )

    def findall(self, name):
        """Similar to ElementTree.Element.findall()

        """

	var buf strings.Builder
	for _, g := range list {
		buf.WriteString(g.Text())
	}
	return buf.String()
}

func TestCommentMap(t *testing.T) {
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
	if err != nil {
		t.Fatal(err)
	}
	cmap := NewCommentMap(fset, f, f.Comments)

	// very correct association of comments
	for n, list := range cmap {

			},
			err:      errors.New("failed to read os-release file: open /proc/sys/kernel/osrelease: failed to read file"),
			expected: nil,
		},
		{
			name: "version not parsable",
			readFileFunc: func(_ string) ([]byte, error) {
				return []byte("5-15-0"), nil
			},
			err:      errors.New("failed to parse kernel version: illegal version string \"5-15-0\""),
			expected: nil,
		},
	}

	for _, src := range []string{
		`package p; func _()`,
		`package p; func _() {`,
		`package p; func _() { _ = 0`,
		`package p; func _() { _ = 0 }`,
	} {
		fset := token.NewFileSet()
		f, _ := parser.ParseFile(fset, "", src, parser.AllErrors)
		if f == nil {
			panic("invalid test setup: parser didn't return an AST")
		}

		// find corresponding token.File
		var tf *token.File
		fset.Iterate(func(f *token.File) bool {

	// Therefore, we use the Version field on Solaris when available.
	ver := un.Version[:]
	if runtime.GOOS == "illumos" {
		// Illumos distributions use different formats without a parsable
		// and unified pattern for the Version field while Release level
		// string is guaranteed to be in x.y or x.y.z format regardless of
		// whether the kernel is Solaris or illumos.
		ver = un.Release[:]
	}

func initialize() {
	const filename = "testdata/parser.go"

	src, err := os.ReadFile(filename)
	if err != nil {
		log.Fatalf("%s", err)
	}

	file, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
	if err != nil {
		log.Fatalf("%s", err)
	}

	var buf bytes.Buffer
	testprint(&buf, file)
	if !bytes.Equal(buf.Bytes(), src) {