return *(*uint32)(unsafe.Pointer(p + _HPET_MAIN_COUNTER)), true
}

//go:systemstack
func initHPETTimecounter(idx int) {
	const digits = "0123456789"

	var devPath [len(hpetDevPath)]byte
	copy(devPath[:], hpetDevPath)
	devPath[9] = digits[idx]

	fd := open(&devPath[0], 0 /* O_RDONLY */ |_O_CLOEXEC, 0)
	if fd < 0 {
		atomic.Casuintptr(&hpetDevMap[idx], 0, ^uintptr(0))
		return
	}

        when:
        def file = ClasspathUtil.getClasspathForResource(jarUrlWithResourceName, "Test.class")

        then:
        FILE.getPath() == file.getPath()
    }

    @Issue("https://github.com/gradle/gradle/issues/23625")
    def "getClasspathForResource for jar scheme with prefix resource name"() {
        given:

                int diff = STRING_COMPARATOR.compare(task1.getPath().getName(), task2.getPath().getName());
                if (diff != 0) {
                    return diff;
                }
                Path parent1 = task1.getPath().getParent();
                Path parent2 = task2.getPath().getParent();
                if (parent1 == null && parent2 != null) {
                    return -1;

  return StatusFromTF_Status(plugin_status.get());
}

Status RegisterFilesystemPlugin(const std::string& dso_path) {
  // Step 1: Load plugin
  Env* env = Env::Default();
  void* dso_handle;
  TF_RETURN_IF_ERROR(env->LoadDynamicLibrary(dso_path.c_str(), &dso_handle));

  // Step 2: Load symbol for `TF_InitPlugin`
  void* dso_symbol;
  TF_RETURN_WITH_CONTEXT_IF_ERROR(

        return InstanceModelView.of(modelNode.getPath(), MODEL_ELEMENT_MODEL_TYPE, new ModelElement() {
            @Override
            public String toString() {
                return getDisplayName();
            }

            @Override
            public String getName() {
                return modelNode.getPath().getName();
            }

            @Override

			// fakePkgName if we are looking at cmd documentation.
			name := pkgName(dirpath + "/" + d.Name())
			return name == pkgname
		}
		return false
	}

	// get package AST
	pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments)
	if err != nil {
		println("parse", dirpath, err.Error())
		panic("go ParseDir fail: " + err.Error())
	}
	return pkgs
}

            } catch (CommandLineArgumentException e) {
                //we expect that all options must be applicable for each task
                throw new TaskConfigurationException(task.getPath(), "Problem configuring task " + task.getPath() + " from command line.", e);
            }

            for (OptionDescriptor commandLineOptionDescriptor : commandLineOptions) {
                final String name = commandLineOptionDescriptor.getName();

		{"subdir5", "subdir5", false},
		{"subdir5/deleted.txt", "", true},
	}

	for _, tc := range testCases {
		gotPath, gotOK := OverlayPath(tc.path)
		if gotPath != tc.wantPath || gotOK != tc.wantOK {
			t.Errorf("OverlayPath(%q): got %v, %v; want %v, %v",
				tc.path, gotPath, gotOK, tc.wantPath, tc.wantOK)
		}
	}
}

func TestOpen(t *testing.T) {
	initOverlay(t, `
{
    "Replace": {

        ModelType<?> type = reference.getType();
        return "{type: " + (type == null ? null : type.getDisplayName()) + ", path: " + getPath() + ", scope: " + getScope() + ", state: " + getState() + "}";
    }

    @Nullable
    @Override
    public ModelPath getPath() {
        return reference.getPath();
    }

    public ModelType<?> getType() {
        return reference.getType();
    }

                includeEmptyDirs = false
            }
        }
        into("docs") {
            from(docsPath)
            exclude("samples/**")
        }
    }

    /**
     * Offline version of the complete documentation of Gradle.
     */
    fun Project.docsDistributionSpec() = copySpec {
        val docsPath by configurations.getting

        from("${repoRoot()}/LICENSE")
        from("src/toplevel")