xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/pkg/v3/mimedb"
	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
)

// Maximum write offset for incoming SFTP blocks.
// Set to 100MiB to prevent hostile DOS attacks.
const ftpMaxWriteOffset = 100 << 20

type sftpDriver struct {
	permissions *ssh.Permissions
	endpoint    string
}

//msgp:ignore sftpMetrics
type sftpMetrics struct{}

	fx.WaitOrFail(t, "xds")

	sc.CreateOrUpdate(generateService("svc1", testNS, map[string]string{}, // labels
		map[string]string{}, // annotations
		[]int32{80},
		map[string]string{"app": "a"}, // selector
		"10.0.0.1",
	))
	fx.WaitOrFail(t, "xds")

	createOrUpdateNamespace(t, s, testNS, "")
	createOrUpdateNamespace(t, s, systemNS, "")

	tracker.WaitOrdered(testNS, systemNS)

						name:        "client-pod",
						namespace:   "test",
						ip:          "10.0.0.1",
						port:        80,
						clusterID:   "cluster-1",
						metaNetwork: "network-1",
					}
					// expect self
					client.ExpectWithWeight(client, "", xdstest.LocLbEpInfo{
						Weight: 1,
						LbEps: []xdstest.LbEpInfo{
							{Address: "10.0.0.1", Weight: 1},
						},
					})
					for subset, eps := range tc.expectations {

		if !got && tt.ipp != invalid {
			t.Errorf("(%v == %v) = false, want true", tt.ipp, invalid)
		}
	}
}

var nextPrevTests = []struct {
	ip   Addr
	next Addr
	prev Addr
}{
	{mustIP("10.0.0.1"), mustIP("10.0.0.2"), mustIP("10.0.0.0")},
	{mustIP("10.0.0.255"), mustIP("10.0.1.0"), mustIP("10.0.0.254")},
	{mustIP("127.0.0.1"), mustIP("127.0.0.2"), mustIP("127.0.0.0")},

	// Prior to CVE-2022-30632, this would cause a stack exhaustion given a
	// large number of separators (more than 4,000,000). There is now a limit
	// of 10,000.
	_, err := Glob("/*" + strings.Repeat("/", 10001))
	if err != ErrBadPattern {
		t.Fatalf("Glob returned err=%v, want ErrBadPattern", err)
	}
}

func TestGlobError(t *testing.T) {
	bad := []string{`[]`, `nonexist/[]`}
	for _, pattern := range bad {

        setup:
        def customMetaDataProvider = Mock(ProcessMetaDataProvider)
        def processIdentifier = RandomStringUtils.randomAlphanumeric(1000)
        1 * customMetaDataProvider.processIdentifier >> processIdentifier
        def customManager = new DefaultFileLockManager(customMetaDataProvider, 5000, contentionHandler, generator)

        jar.manifest.mainAttributes.getValue('version') == "$expectedVersion"

        where:
        manifestContent << ["", "version: 0.0.1"]
        expectedVersion << ["1.0", "0.0.1"]
    }

    def "attribute value evaluates lazily"() {
        given:
        buildFile << """
            def versionNumber = objects.property(String)
            versionNumber.set("1.0")

			ipFamilies: ipv4only,
			service: v1.Service{
				Spec: v1.ServiceSpec{
					ClusterIP: "10.0.0.1",
				},
			},
			expectedEndpointFamily: ipv4,
		},
		{
			name:       "v4 service, in a dual stack cluster",
			ipFamilies: ipv4ipv6,
			service: v1.Service{
				Spec: v1.ServiceSpec{
					ClusterIP: "10.0.0.1",
				},
			},
			expectedEndpointFamily: ipv4,
		},
		{

			}
		})
	}
}

func TestAddrFromSlice(t *testing.T) {
	tests := []struct {
		ip       []byte
		wantAddr Addr
		wantOK   bool
	}{
		{
			ip:       []byte{10, 0, 0, 1},
			wantAddr: mustIP("10.0.0.1"),
			wantOK:   true,
		},
		{
			ip:       []byte{0xfe, 0x80, 15: 0x01},
			wantAddr: mustIP("fe80::01"),
			wantOK:   true,
		},
		{
			ip:       []byte{0, 1, 2},

func.func @select(
    %arg0: tensor<1x3xi1>,
    %arg1: tensor<1x3x!quant.uniform<i8:f32, 2.000000e+00:-1>>,
    %arg2: tensor<1x3x!quant.uniform<i8:f32, 2.000000e+00:-1>>
  ) -> tensor<1x3x!quant.uniform<i8:f32, 2.000000e+00:-1>> {
  %0 = "stablehlo.select"(%arg0, %arg1, %arg2) : (
    tensor<1x3xi1>,
    tensor<1x3x!quant.uniform<i8:f32, 2.000000e+00:-1>>,