createExternalNameService(controller, "svc5", "nsA",
			[]int32{1, 2, 3}, "foo.co", t, fx)

		converted := controller.Services()
		assert.Equal(t, len(converted), 1)

		eps := GetEndpointsForPort(converted[0], controller.Endpoints, 1)
		assert.Equal(t, len(eps), 0)
		assert.Equal(t, converted[0].Attributes, model.ServiceAttributes{
			ServiceRegistry:          "Kubernetes",
			Name:                     "svc5",

        then:
        with(javaLibrary.parsedIvy) {
            assert configurations.keySet() == ["compile", "default"] as Set // skipped runtime
            assertConfigurationDependsOn('compile', "org:foo:1.0")
        }
        with(javaLibrary.parsedModuleMetadata) {
            assert variants.collect { it.name } == ["apiElements"]
            assert variants[0].dependencies.collect { it.toString() } == ["org:foo:1.0"]
        }

        1 * structureVisitor.startVisit(_, _) >> { source, files ->
            assert files.toList() == [file1]
            true
        }
        1 * structureVisitor.visitCollection(_, _) >> { source, files ->
            assert files.toList() == [file1]
        }
        1 * structureVisitor.startVisit(_, _) >> { source, files ->
            assert files.toList() == [file2]
            true
        }

        actual.each {
            assert it.key instanceof String
            assert it.value instanceof String
        }
        assert actual == ImmutableMap.copyOf(expected)
    }

    private static void assertImmutable(Map<String, String> map) {
        try {
            map.put("immutableTest", "value")
            Assert.fail('Map is not immutable')

                    assert inputArtifactDependencies.every { it.exists() }

                    def output = outputs.file(input.name + ".txt")
                    def workspace = output.parentFile
                    assert workspace.directory && workspace.list().length == 0
                    println "Transforming \${input.name} to \${output.name}"

import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

public class AsmBackedClassGeneratorTest {
    @Rule

		waitUpdateAllocatedDevicesChan <- struct{}{}
	}()

	set, err := testManager.devicesToAllocate(podToAllocate, containerToAllocate, resourceName, 1, sets.New[string]())
	assert.NoError(t, err)
	assert.Equal(t, set, sets.New[string](deviceID))
}

func TestGetDeviceRunContainerOptions(t *testing.T) {
	res1 := TestResource{
		resourceName:     "domain1.com/resource1",

	"istio.io/istio/pkg/config/host"
	"istio.io/istio/pkg/config/protocol"
	"istio.io/istio/pkg/config/schema/gvk"
	"istio.io/istio/pkg/config/schema/kind"
	"istio.io/istio/pkg/config/visibility"
	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/util/sets"
)

const wildcardIP = "0.0.0.0"

func TestMergeVirtualServices(t *testing.T) {
	independentVs := config.Config{
		Meta: config.Meta{
			GroupVersionKind: gvk.VirtualService,

        assert actual instanceof ImmutableCollection
        assert immutableCollectionType.isInstance(actual)
        assertCollectionIs(actual, expected)
    }

    protected void assertCollectionIs(ImmutableCollection actual, Collection<String> expected) {
        assert actual == toImmutable(expected)
        actual.each {
            assert it instanceof String
        }
    }

limitations under the License.
*/

package validation

import (
	"fmt"
	"math"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"
	flowcontrolv1 "k8s.io/api/flowcontrol/v1"
	flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1"
	flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2"
	flowcontrolv1beta3 "k8s.io/api/flowcontrol/v1beta3"