`
	var err error
	dir := t.TempDir()
	mountsPath := filepath.Join(dir, "mounts")
	if err = os.WriteFile(mountsPath, []byte(successCase), 0o666); err != nil {
		t.Fatal(err)
	}
	// Failure case where we detected successfully cross device mounts.
	{
		absPaths := []string{"/path/to/1"}
		if err = checkCrossDevice(absPaths, mountsPath); err == nil {
			t.Fatal("Expected to fail, but found success")
		}

        IOException ioe = null;

        switch (this.state) {
        case 0: /* not connected - just return */
        case 5:
        case 6:
            return false;
        case 2:
            hard = true;
        case 3: /* connected - go ahead and disconnect */
            if (this.response_map.size() != 0 && !hard && inUse) {

		copy(t, s)
		for i := range len(s) {
			if s[i] == ' ' {
				t[i] = '+'
			}
		}
		return string(t)
	}

	j := 0
	for i := range len(s) {
		switch c := s[i]; {
		case c == ' ':
			t[j] = '+'
			j++
		case shouldEscape(c):
			t[j] = '%'
			t[j+1] = "0123456789ABCDEF"[c>>4]
			t[j+2] = "0123456789ABCDEF"[c&15]
			j += 3
		default:
			t[j] = s[i]
			j++
		}
	}
	return string(t)
}

            case WitnessAsyncNotifyMessage.WitnessNotificationMessage.WITNESS_CLIENT_MOVE:
            case WitnessAsyncNotifyMessage.WitnessNotificationMessage.WITNESS_SHARE_MOVE:
                if (message.getDestinationNode() != null) {
                    notification.setNewNodeAddress(message.getDestinationNode());
                }
                break;

            this.type = bufferStream.readInt();
            switch (this.type) {
            case KERB_CHECKSUM_HMAC_MD5:
                this.checksum = new byte[16];
                break;
            case HMAC_SHA1_96_AES128:
            case HMAC_SHA1_96_AES256:
                this.checksum = new byte[12];
                break;
            default:

        return switch (artifactRepositoryPolicy) {
            case RepositoryPolicy.CHECKSUM_POLICY_FAIL -> RepositoryPolicy.CHECKSUM_POLICY_FAIL;
            case RepositoryPolicy.CHECKSUM_POLICY_IGNORE -> RepositoryPolicy.CHECKSUM_POLICY_IGNORE;
            case RepositoryPolicy.CHECKSUM_POLICY_WARN -> RepositoryPolicy.CHECKSUM_POLICY_WARN;
            default ->

	*dst = dsync.LockResp{Code: dsync.RespOK}
	switch err {
	case nil:
	case errLockNotInitialized:
		dst.Code = dsync.RespLockNotInitialized
	case errLockConflict:
		dst.Code = dsync.RespLockConflict
	case errLockNotFound:
		dst.Code = dsync.RespLockNotFound
	default:
		dst.Code = dsync.RespErr
		dst.Err = err.Error()
	}
	return dst, nil

                addedToBuffer = true;
            }

            // this has to be a separate "if" statement, to capture the case of: "-Dfoo=bar"
            if (addedToBuffer && arg.endsWith("\"")) {
                // if we're building an argument, keep doing so.
                // if this is the case of "-Dfoo=bar", then we need to adjust the buffer.
                if (!currentArg.isEmpty()) {

# Dependencias en decoradores de *path operation* { #dependencies-in-path-operation-decorators }

En algunos casos realmente no necesitas el valor de retorno de una dependencia dentro de tu *path operation function*.

O la dependencia no devuelve un valor.

Pero aún necesitas que sea ejecutada/resuelta.

            switch (LM_COMPATIBILITY) {
            case 0:
            case 1:
            case 2:
                macSigningKey = new byte[40];
                auth.getUserSessionKey(transport.server.encryptionKey, macSigningKey, 0);
                System.arraycopy(auth.getUnicodeHash(transport.server.encryptionKey), 0, macSigningKey, 16, 24);
                break;
            case 3:
            case 4:
            case 5: