</testcase>
	</testsuite>
</testsuites>`
	suites, _ := fetchXML(strings.NewReader(sourceXML))
	pruneXML(suites, 32)
	var output bytes.Buffer
	writer := bufio.NewWriter(&output)
	_ = streamXML(writer, suites)
	_ = writer.Flush()
	assert.Equal(t, outputXML, string(output.Bytes()), "xml was not pruned correctly")
}

func TestPruneTESTS(t *testing.T) {
	sourceXML := `<?xml version="1.0" encoding="UTF-8"?>

            assert result.groupedOutput.task(':1:log').output == "Error from 1\nOutput from 1\nDone with 1\nDone with 1"
            assert result.groupedOutput.task(':2:log').output == "Error from 2\nOutput from 2\nDone with 2\nDone with 2"
            assert result.groupedOutput.task(':3:log').output == "Error from 3\nOutput from 3\nDone with 3\nDone with 3"
        } else {

.vscode

# This is where the result of the go build goes
/output*/
/_output*/
/_output

# Emacs save files
*~
\#*\#
.\#*

# Vim-related files
[._]*.s[a-w][a-z]
[._]s[a-w][a-z]
*.un~
Session.vim
.netrwhist

# cscope-related files
cscope.*

# Go test binaries
*.test
/hack/.test-cmd-auth

# JUnit test output from ginkgo e2e tests
/junit*.xml

# Mercurial files
**/.hg

				t.Fatalf("failed%s mode %s: wanted %q\noutput:\n%s", bt,
					s.mode, s.expected, outs)
			}
			for _, need := range s.musthave {
				if !strings.Contains(outs, need) {
					t.Fatalf("failed mode %s: output does not contain %q\noutput:\n%s",
						s.mode, need, outs)
				}
			}
			if s.expected == "" && s.musthave == nil && outs != "" {
				t.Errorf("failed mode %s: wanted no output\noutput:\n%s", s.mode, outs)
			}
		}
	}

# input
spec_summaries="${KUBE_ROOT}/_output/specsummaries.json"
# output
results_json="${tmpdir}/results.json"
summary_json="${tmpdir}/summary.json"
failures_json="${tmpdir}/failures.json"

# rebuild dependencies if necessary
function ensure_dependencies() {
  local -r ginkgo="${KUBE_ROOT}/_output/bin/ginkgo"
  local -r e2e_test="${KUBE_ROOT}/_output/bin/e2e.test"

* [`build/copy-output.sh`](copy-output.sh): This will copy the contents of `_output/dockerized/bin` from the Docker container to the local `_output/dockerized/bin`. It will also copy out specific file patterns that are generated as part of the build process. This is run automatically as part of `build/run.sh`.

	}

	// Actually run the test and make sure output is correct.
	cmd = testenv.Command(t, gotool, "run", filepath.Join("testdata", filename))
	if output, err = cmd.CombinedOutput(); err != nil {
		t.Fatalf("Failed: %v:\nOut: %s\n", err, output)
	}
	out, err := os.ReadFile(filepath.Join("testdata", outname))
	if err != nil {
		t.Fatalf("Could not find %s\n", outname)
	}
	if string(out) != string(output) {

     ;;
  esac
done

# Below the output of golangci-lint is going to be piped into sed to add
# a prefix to each output line. This helps make the output more visible
# in the Prow log viewer ("error" is a key word there) and ensures that
# only those lines get included as failure message in a JUnit file
# by "make verify".
#
# The downside is that the automatic detection whether to colorize output

		"7:9: declared and not used: n",
		"7:12: declared and not used: err",
	}
	outStr := string(out)
	for _, want := range wantErrs {
		if !strings.Contains(outStr, want) {
			log.Fatalf("failed to match %q\noutput: %q", want, outStr)
		}
	}

			if err != nil {
				t.Fatalf("Failed to create path element: %v", err)
			}
			output, err := PathElementString(pe)
			if err != nil {
				t.Fatalf("Failed to create string from path element: %v", err)
			}
			if test != output {
				t.Fatalf("Expected round-trip:\ninput: %v\noutput: %v", test, output)
			}
		})
	}
}

func TestPathElementIgnoreUnknown(t *testing.T) {