import static org.gradle.testing.fixture.JUnitCoverage.LATEST_JUPITER_VERSION
import static org.gradle.testing.fixture.TestNGCoverage.NEWEST

class TestNGFailOnNoTestIntegrationTest extends TestNGTestFrameworkIntegrationTest {

    static final String LATEST_TESTNG_VERSION = NEWEST

    def "test source and test task use same test framework"() {
        given:
        buildFile << """
            apply plugin:'java-library'

	if resource := "volumeattributesclasses"; apiResourceConfigSource.ResourceEnabled(storageapiv1alpha1.SchemeGroupVersion.WithResource(resource)) {
		volumeAttributesClassStorage, err := volumeattributesclassstore.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = volumeAttributesClassStorage
	}

	return storage, nil
}

  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')

	if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1.SchemeGroupVersion.WithResource(resource)) {
		poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = poddisruptionbudgetStorage
		storage[resource+"/status"] = poddisruptionbudgetStatusStorage
	}

	return storage, nil
}

		if utilfeature.DefaultFeatureGate.Enabled(features.StorageVersionMigrator) {
			svm, svmStatus, err := storagemigrationstore.NewREST(restOptionsGetter)
			if err != nil {
				return nil, err
			}
			storage[resource] = svm
			storage[resource+"/status"] = svmStatus
		} else {

import org.gradle.integtests.fixtures.TargetCoverage
import org.gradle.testing.AbstractJvmFailFastIntegrationSpec
import org.gradle.testing.fixture.TestNGCoverage
import org.hamcrest.CoreMatchers

@TargetCoverage({ [TestNGCoverage.NEWEST] })
class TestNGFailFastIntegrationTest extends AbstractJvmFailFastIntegrationSpec implements TestNGMultiVersionTest {

    def "parallel #parallel execution with #threadCount threads, #maxWorkers workers fails fast"() {

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

			klog.V(4).Infof("GetDefaultVolumeAttributesClass added: %s", class.Name)
		}
	}

	if len(defaultClasses) == 0 {
		return nil, nil
	}

	// Primary sort by creation timestamp, newest first
	// Secondary sort by class name, ascending order
	sort.Slice(defaultClasses, func(i, j int) bool {
		if defaultClasses[i].CreationTimestamp.UnixNano() == defaultClasses[j].CreationTimestamp.UnixNano() {

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