// encounters an error reading the zip file.
//
// Note that CheckZip does not read individual files, so [Unzip] may still fail
// when CheckZip is successful due to I/O errors.
func CheckZip(m module.Version, zipFile string) (CheckedFiles, error) {
	f, err := os.Open(zipFile)
	if err != nil {
		return CheckedFiles{}, err
	}
	defer f.Close()
	_, cf, err := checkZip(m, f)
	return cf, err
}

            .dependsOn(notRequired, scope: 'provided')
            .publish()

        buildFile << """
dependencies {
    conf 'test:target:1.0'
}
"""
        expect:
        succeeds 'checkDep'
        resolve.expectDefaultConfiguration("runtime")
        resolve.expectGraph {
            root(':', ':testproject:') {
                module('test:target:1.0') {
                    module('test:test5:1.0') {

            }
            'org.test:moduleB:1.0'() {
                expectGetMetadata()
                expectGetArtifact()
            }
        }

        then:
        succeeds 'checkDep'
        def expectedVariant = variantToTest
        resolve.expectGraph {
            root(':', ':test:') {
                edge('org.test:moduleB', 'org.test:moduleB:1.0') {
                    maybeByConstraint()

        buildFile << """
            dependencies {
                compile "group:moduleA"
                compile platform("group:bom:1.0")
            }
        """

        when:
        succeeds 'checkDep'

        then:
        resolve.expectGraph {
            root(':', ':testproject:') {
                module("group:bom:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")

                expectGetArtifact(classifier: 'jdk8')
            }
            'org.test:moduleB:1.0' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDep'
        def expectedLibraryAttributes = expectedJavaLibraryAttributes(useMaven() || gradleMetadataPublished)
        resolve.expectGraph {
            root(':', ':test:') {
                module('org.test:moduleA:1.0') {

            .dependsOn(ivyModule)
            .publish()

        buildFile << """
dependencies {
    conf 'org.test:maven:1.0'
}
"""
        expect:
        succeeds 'checkDep'
        resolve.expectGraph {
            root(':', ':testproject:') {
                module('org.test:maven:1.0:runtime') {
                    module('org.test:ivy:1.0') {

            dependencies {
                conf 'org:${chain[0]}:1.0'
            }
        """
        expectChainInteractions(REPO_TYPES, chain, testVariant)

        then:
        succeeds 'checkDep'
        resolve.expectGraph {
            root(':', ':test:') {
                module("org:${chain[0]}:1.0:${RepositoryInteractionDependencyResolveIntegrationTest.expectedConfiguration(chain[0], testVariant)}") {

static void ValidateAPI(const TF_FilesystemPluginOps* ops) {
  CheckAPI(ops->filesystem_ops_api, TF_FILESYSTEM_OPS_API, "filesystem");

  if (ops->random_access_file_ops != nullptr)
    CheckAPI(ops->random_access_file_ops_api, TF_RANDOM_ACCESS_FILE_OPS_API,
             "random access file");

  if (ops->writable_file_ops != nullptr)
    CheckAPI(ops->writable_file_ops_api, TF_WRITABLE_FILE_OPS_API,
             "writable file");

	tcases := []struct {
		name        string
		mask        []int
		checkBit    int
		expectedSet bool
	}{
		{
			name:        "Check if bit 0 in mask 00 is set",
			mask:        nil,
			checkBit:    0,
			expectedSet: false,
		},
		{
			name:        "Check if bit 0 in mask 01 is set",
			mask:        []int{0},
			checkBit:    0,
			expectedSet: true,
		},
		{

		return false
	}

	// If format.json is available and request sent the right disk-id, we allow the request
	return true
}

// checkID - check if the disk-id in the request corresponds to the underlying disk.
func (s *storageRESTServer) checkID(wantID string) bool {
	if s.getStorage() == nil {
		return false
	}
	if wantID == "" {
		// Request sent empty disk-id, we allow the request