File file = newDir("some-dir");

    assertThat(Files.fileTraverser().breadthFirst(rootDir)).containsExactly(rootDir, file);
  }

  public void testFileTraverser_multipleFilesAndDirectories() throws Exception {
    File fileA = newFile("file-a");
    File fileB = newFile("file-b");
    File dir1 = newDir("dir-1");
    File dir2 = newDir("dir-2");

    Path file = newDir("some-dir");

    assertThat(MoreFiles.fileTraverser().breadthFirst(rootDir)).containsExactly(rootDir, file);
  }

  public void testFileTraverser_multipleFilesAndDirectories() throws Exception {
    Path fileA = newFile("file-a");
    Path fileB = newFile("file-b");
    Path dir1 = newDir("dir-1");
    Path dir2 = newDir("dir-2");

	}

	delete(istioMap, "cniVersion")

	var newMap map[string]any

	if _, ok := existingMap["type"]; ok {
		// Assume it is a regular network conf file
		delete(existingMap, "cniVersion")

		plugins := make([]map[string]any, 2)
		plugins[0] = existingMap
		plugins[1] = istioMap

		newMap = map[string]any{
			"name":       "k8s-pod-network",
			"cniVersion": "0.3.1",

    }

    private Resource alignToBaseDirectory(Resource resource, Path basedir) {
        if (resource != null) {
            String newDir = mayAlignToBaseDirectoryOrNull(resource.getDirectory(), basedir);
            if (newDir != null) {
                return resource.withDirectory(newDir);
            }
        }
        return resource;
    }

    private String alignToBaseDirectory(String path, Path basedir) {

        Model model = Model.newBuilder(true).properties(props).build();
        String xml = toXml(model);

        for (int i = 0; i < 10; i++) {
            String newStr = toXml(fromXml(xml));
            assertEquals(newStr, xml);
        }
    }

    @Test
    void testNamespaceInXmlNode() throws XMLStreamException {
        String xml = "<project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"

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

package p4

type Pair[T1 interface{ M() }, T2 ~int] struct {
	f1 T1
	f2 T2
}

func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] {
	return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}

func (p Pair[_, X2]) Second() X2 {
	return p.f2
}

     * artifact, closer to the entry point, is selected
     */
    @Configuration(name = "closer-first", value = "true")
    private boolean closerFirst = true;

    /**
     * newer artifact is selected
     */
    @Configuration(name = "newer-first", value = "true")
    private boolean newerFirst = true;

    public MetadataGraphEdge apply(MetadataGraphEdge e1, MetadataGraphEdge e2) {
        int depth1 = e1.getDepth();

// Legacy envs
const (
	legacyEnvAuditLoggerHTTPEndpoint = "MINIO_AUDIT_LOGGER_HTTP_ENDPOINT"
	legacyEnvLoggerHTTPEndpoint      = "MINIO_LOGGER_HTTP_ENDPOINT"
)

// SetLoggerHTTPAudit - helper for migrating older config to newer KV format.
func SetLoggerHTTPAudit(scfg config.Config, k string, args http.Config) {
	if !args.Enabled {
		// Do not enable audit targets, if not enabled
		return
	}
	scfg[config.AuditWebhookSubSys][k] = config.KVS{

pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
pkg p4, method (Pair[$0, $1]) Second() $1
pkg p4, method (Pair[$0, $1]) First() $0
pkg p4, type Pair[$0 interface{ M }, $1 interface{ ~int }] struct
pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0

)

// prepareUpdateMessage - prepares the update message, only if a
// newer version is available.
func prepareUpdateMessage(downloadURL string, older time.Duration) string {
	if downloadURL == "" || older <= 0 {
		return ""
	}

	// Compute friendly duration string to indicate time
	// difference between newer and current release.
	t := time.Time{}