}
				if cg != nil {
					if strings.ContainsAny(abspath, "\r\n") {
						// This should have been checked when the file path was first resolved,
						// but we double check here just to be sure.
						fatalf("internal error: ParseGo: abspath contains unexpected newline character: %q", abspath)
					}
					f.Preamble += fmt.Sprintf("#line %d %q\n", sourceLine(cg), abspath)
					f.Preamble += commentText(cg) + "\n"

	// Convert to absolute path
	absPath, err := filepath.Abs(path)
	if err != nil {
		return t, fmt.Errorf("Unable to get absolute path of %s. %w", path, err)
	}

	// Version is minio non-standard, we will use minio binary's
	// ModTime as release time.
	fi, err := Stat(absPath)
	if err != nil {
		return t, fmt.Errorf("Unable to get ModTime of %s. %w", absPath, err)
	}

	// Return the ModTime

func checkCrossDeviceMounts(endpoints Endpoints) (err error) {
	var absPaths []string
	for _, endpoint := range endpoints {
		if endpoint.IsLocal {
			var absPath string
			absPath, err = filepath.Abs(endpoint.Path)
			if err != nil {
				return err
			}
			absPaths = append(absPaths, absPath)
		}
	}
	return mountinfo.CheckCrossDevice(absPaths)
}

  else:
    output = subprocess.check_output(cmd, stderr=stderr)
  return output.decode('UTF-8').strip()


def cygpath(path):
  """Convert path from posix to windows."""
  return os.path.abspath(path).replace('\\', '/')


def get_python_path(environ_cp, python_bin_path):
  """Get the python site package paths."""
  python_paths = []
  if environ_cp.get('PYTHONPATH'):

    public void test_getCssPath() {
        Path cssPath = ResourceUtil.getCssPath("style.css");
        assertNotNull(cssPath);
        assertTrue(cssPath.toString().contains("css"));
    }

    @Test
    public void test_getJavaScriptPath() {
        Path jsPath = ResourceUtil.getJavaScriptPath("script.js");
        assertNotNull(jsPath);
        assertTrue(jsPath.toString().contains("js"));
    }

    @Test

	var basePath string
	if isGroup {
		basePath = iamConfigPolicyDBGroupsPrefix
	} else {
		switch userType {
		case svcUser:
			basePath = iamConfigPolicyDBServiceAccountsPrefix
		case stsUser:
			basePath = iamConfigPolicyDBSTSUsersPrefix
		default:
			basePath = iamConfigPolicyDBUsersPrefix
		}
	}
	ctx, cancel := context.WithCancel(ctx)

        final Path imagePath = ResourceUtil.getImagePath(themeName);
        closeQuietly(imagePath);
        final Path cssPath = ResourceUtil.getCssPath(themeName);
        closeQuietly(cssPath);
        final Path jsPath = ResourceUtil.getJavaScriptPath(themeName);
        closeQuietly(jsPath);
    }

    /**
     * Extracts the theme name from the artifact name.
     *
     * @param artifact the theme artifact

// Stat implements ftpDriver
func (driver *ftpDriver) Stat(ctx *ftp.Context, objPath string) (fi os.FileInfo, err error) {
	stopFn := globalFtpMetrics.log(ctx, objPath)
	defer stopFn(0, err)

	if objPath == SlashSeparator {
		return &minioFileInfo{
			p:     SlashSeparator,
			isDir: true,
		}, nil
	}

	bucket, object := path2BucketObject(objPath)
	if bucket == "" {
		return nil, errors.New("bucket name cannot be empty")

func CheckCrossDevice(absPaths []string) error {
	return checkCrossDevice(absPaths, procMountsPath)
}

// Check cross device is an internal function.
func checkCrossDevice(absPaths []string, mountsPath string) error {
	mounts, err := readProcMounts(mountsPath)
	if err != nil {
		return err
	}
	for _, path := range absPaths {
		if err := mounts.checkCrossMounts(path); err != nil {

        assertNull(dfsResolver.resolve(mockContext, "anyDomain", "anyRoot", "anyPath"));
    }

    @Test
    void testResolve_NullRoot() throws CIFSException {
        when(mockConfig.isDfsDisabled()).thenReturn(false);
        assertNull(dfsResolver.resolve(mockContext, "anyDomain", null, "anyPath"));
    }

    @Test
    void testResolve_IpcRoot() throws CIFSException {