buildScript """
            apply plugin: "java"
            ${mavenCentralRepository()}
            testing {
                suites {
                    test {
                        useTestNG('${TestNGCoverage.NEWEST}')
                        targets {
                            all {
                                testTask.configure {
                                    options {

  base: true
- name: app_sidecar_base_ubuntu_noble # newest ubuntu
  dockerfile: pkg/test/echo/docker/Dockerfile.app_sidecar_base
  base: true
- name: app_sidecar_base_ubuntu_bionic # oldest supported ubuntu
  dockerfile: pkg/test/echo/docker/Dockerfile.app_sidecar_base
  base: true
#  TODO(https://github.com/istio/istio/issues/38224)
- name: app_sidecar_base_rockylinux_9 # newest RHEL-based

        when:
        1 * one.missing >> false
        0 * componentSelectionRules.apply(_, _)

        then:
        chooser.selectNewestComponent(one, two) == one
    }

    def "chooses newest matching version without requiring metadata"() {
        given:
        def a = component('1.2')
        def b = component('1.3')
        def c = component('2.0')

func (cu containersByEvictUnit) NumEvictUnits() int {
	return len(cu)
}

// Newest first.
type byCreated []containerGCInfo

func (a byCreated) Len() int           { return len(a) }
func (a byCreated) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byCreated) Less(i, j int) bool { return a[i].createTime.After(a[j].createTime) }

// Newest first.
type sandboxByCreated []sandboxGCInfo

class NewestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    public NewestConflictResolverTest() throws Exception {
        super("newest");
    }

    // tests ------------------------------------------------------------------

    /**
     * Tests that <code>a:2.0</code> wins in the scenario:
     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0

	// Sort log files in oldest to newest order.
	sort.Strings(logs)
	// Container will create a new log file, and we'll rotate the latest log file.
	// Other than those 2 files, we can have at most MaxFiles-2 rotated log files.
	// Keep MaxFiles-2 files by removing old files.
	// We should remove from oldest to newest, so as not to break ongoing `kubectl logs`.
	maxRotatedFiles := c.policy.MaxFiles - 2

			// reset their weight.
			if proxier.initialSync {
				for _, dest := range curDests {
					if dest.Weight != newDest.Weight {
						err = proxier.ipvs.UpdateRealServer(appliedVirtualServer, newDest)
						if err != nil {
							proxier.logger.Error(err, "Failed to update destination", "newDest", newDest)
							continue
						}
					}
				}
			}

		DeleteCollectionWorkers: 1,
		ResourcePrefix:          "serviceaccounts",
	}
	// set issuer, podStore and secretStore to allow the token endpoint to be initialised
	rest, err := NewREST(restOptions, fakeTokenGenerator{"fake"}, nil, 0, panicGetter{}, panicGetter{}, nil, false)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return rest, server
}

		StorageConfig:           etcdStorage,
		Decorator:               generic.UndecoratedStorage,
		DeleteCollectionWorkers: 1,
		ResourcePrefix:          "persistentvolumes",
	}
	persistentVolumeStorage, statusStorage, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return persistentVolumeStorage, statusStorage, server
}

func newHostPathType(pathType string) *api.HostPathType {

		Decorator:               generic.UndecoratedStorage,
		DeleteCollectionWorkers: 1,
		ResourcePrefix:          "persistentvolumeclaims",
	}
	persistentVolumeClaimStorage, statusStorage, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return persistentVolumeClaimStorage, statusStorage, server
}