}
            if (sortingRequired) {
                children.sort(FileSystemLocationSnapshot.BY_NAME);
            }
            Hasher hasher = Hashing.newHasher();
            hasher.putHash(DIR_SIGNATURE);
            for (FileSystemLocationSnapshot child : children) {
                hasher.putString(child.getName());
                hasher.putHash(child.getHash());
            }

	resourceClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceClass{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

func TestUpdate(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()

	csiNode := validNewCSINode("foo")
	csiNode.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
	test.TestCreate(
		// valid
		csiNode,
		// invalid
		&storageapi.CSINode{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
			Spec: storageapi.CSINodeSpec{
				Drivers: []storageapi.CSINodeDriver{
					{
						Name:         "invalid-name-!@#$%^&*()",
						NodeID:       "invalid-node-!@#$%^&*()",

	deleteReclaimPolicy := api.PersistentVolumeReclaimDelete
	test.TestCreate(
		// valid
		storageClass,
		// invalid
		&storageapi.StorageClass{
			ObjectMeta:    metav1.ObjectMeta{Name: "*BadName!"},
			ReclaimPolicy: &deleteReclaimPolicy,
		},
	)
}

func TestUpdate(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()

type Ucontext C.ucontext_t

type Timespec C.struct_timespec
type Timeval C.struct_timeval
type Itimerval C.struct_itimerval

type Umtx_time C.struct__umtx_time

type KeventT C.struct_kevent

type bintime C.struct_bintime
type vdsoTimehands C.struct_vdso_timehands
type vdsoTimekeep C.struct_vdso_timekeep

const (
	_VDSO_TK_VER_CURR = C.VDSO_TK_VER_CURR

	vdsoTimehandsSize = C.sizeof_struct_vdso_timehands

Status CreateFileForDumping(llvm::StringRef name,
                            std::unique_ptr<raw_ostream>* os,
                            std::string* filepath, llvm::StringRef dirname) {
  std::string dir;
  if (!dirname.empty())
    dir = std::string(dirname);
  else
    dir = GetDumpDirFromEnvVar();

  if (dir.empty()) {
    return Status(absl::StatusCode::kInvalidArgument,

    public Provider<RegularFile> getRunScriptFile() {
        return installDirectory.file(executable.getLocationOnly().map(executableFile -> OperatingSystem.forName(targetPlatform.get().getOperatingSystem().getName()).getScriptName(executableFile.getAsFile().getName())));
    }

    @Inject
    protected FileSystem getFileSystem() {
        throw new UnsupportedOperationException();
    }

    @Inject

	validConfigMap := validNewConfigMap()
	validConfigMap.ObjectMeta = metav1.ObjectMeta{
		GenerateName: "foo-",
	}

	test.TestCreate(
		validConfigMap,
		&api.ConfigMap{
			ObjectMeta: metav1.ObjectMeta{Name: "badName"},
			Data: map[string]string{
				"key": "value",
			},
		},
		&api.ConfigMap{
			ObjectMeta: metav1.ObjectMeta{Name: "name-2"},
			Data: map[string]string{
				"..dotfile": "do: nothing\n",
			},
		},

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
source "${KUBE_ROOT}/test/kubemark/cloud-provider-config.sh"
source "${KUBE_ROOT}/cluster/${CLOUD_PROVIDER}/util.sh"

            src = new Path(getProject());
        }
        return src.createPath();
    }

    def void execute() {
        if (src) {
            src.list().each { String dirName ->
                File dir = getProject().resolveFile(dirName);
                getDirectoryScanner(dir).includedFiles.each { String fileName ->