}
				// since this mount point is nested, remember it so that we can check that following ones aren't nested beneath this one
				prevNestedMPs = append(prevNestedMPs, mp+string(os.PathSeparator))
				retval = append(retval, mp[len(myMPSlash):])
			}
		}
		return nil
	}

	var retErr error
	podutil.VisitContainers(&pod.Spec, podutil.AllFeatureEnabledContainers(), func(c *v1.Container, containerType podutil.ContainerType) bool {

	writeCopy(len(abc), 59*len(abc))
	want.WriteString(strings.Repeat(abc, 60))

	writeString(fox)
	writeCopy(len(fox), 9*len(fox))
	want.WriteString(strings.Repeat(fox, 10))

	writeString(".")
	writeCopy(1, 9)
	want.WriteString(strings.Repeat(".", 10))

	writeString(strings.ToUpper(poem))
	writeCopy(len(poem), 7*len(poem))
	want.WriteString(strings.Repeat(strings.ToUpper(poem), 8))

	writeCopy(dd.histSize(), 10)

			config: Config{
				MaxEventSize: defaultConfig.MaxEventSize,
				MaxBatchSize: 1,
			},
			events: []*auditinternal.Event{
				{Annotations: map[string]string{"key": strings.Repeat("A", int(50))}},
				{Annotations: map[string]string{"key": strings.Repeat("A", int(50))}},
			},
			wantBatchCount: 2,
		},
	}
	for _, tc := range testCases {
		tc := tc
		t.Run(tc.desc, func(t *testing.T) {
			t.Parallel()

            MsrpcShareEnum rpc = new MsrpcShareEnum(handle.getServerWithDfs());
            handle.sendrecv(rpc);
            assertEquals(0, rpc.retval);
        }
    }


    @Test
    public void exclusiveConnection () throws IOException {
        try ( DcerpcHandle handle = DcerpcHandle

	retval := discovery.DiscoveryResponse{}
	if len(responses) == 0 {
		return &retval, nil
	}

	for _, response := range responses {
		// Combine all the shards as one, even if that means losing information about
		// the control plane version from each shard.
		retval.ControlPlane = response.ControlPlane
		retval.Resources = append(retval.Resources, response.Resources...)
	}

			expected:      "a",
		},
		{
			name:          "the file length is longer than max and contains newlines",
			max:           blockSize,
			longerThanMax: true,
			expected:      strings.Repeat("a", blockSize/2-1) + "\n" + strings.Repeat("a", blockSize/2),
		},
		{
			name:          "the max is longer than file length ",
			max:           4613,
			longerThanMax: false,
			expected:      string(testBytes),
		},
	}

	}{
		{
			name:     "Certificate renewal for a PKI certificate",
			certName: "apiserver",
			createCertFunc: func() *x509.Certificate {
				return writeTestCertificate(t, dir, "apiserver", testCACert, testCAKey, testCertOrganization, notBefore, notAfter)
			},
			expectedOrganization: testCertOrganization,
		},
		{
			name:     "Certificate renewal for a certificate embedded in a kubeconfig file",

	// CAName defines the name for the CA on which this certificate depends
	CAName string

	// CABaseName defines the base name for the CA that should be used for certificate renewal
	CABaseName string

	// readwriter defines a CertificateReadWriter to be used for certificate renewal
	readwriter certificateReadWriter

	// certConfigMutators holds the mutator functions that can be applied to the input cert config object

		// start with a generic forbidden error
		retval := admission.NewForbidden(a, errors.New("Not allowed by PodSecurity")).(*apierrors.StatusError)
		// use message/reason/details/code from admission library if populated
		if result.Result != nil {
			if len(result.Result.Message) > 0 {
				retval.ErrStatus.Message = result.Result.Message
			}
			if len(result.Result.Reason) > 0 {
				retval.ErrStatus.Reason = result.Result.Reason
			}

		}
	}

	return nil
}

func resourceTypesAsStrings(resourceTypes []annotation.ResourceTypes) []string {
	retval := []string{}
	for _, resourceType := range resourceTypes {
		if s := resourceType.String(); s != "Unknown" {
			retval = append(retval, s)
		}
	}
	return retval