// Missing trailing slash -> should complain about directory ending
                    Arguments.of("smb://server/share", "/share", true),
                    // Not a server root -> invalid list operation
                    Arguments.of("smb://server/share/", "/share/", false));
        }

        @ParameterizedTest(name = "invalid path: {0}")
        @MethodSource("invalidShareEnumCases")

type Condition struct {
	Operand *ConditionOperand `parser:"  @@"`
	Not     *Condition        `parser:"| \"NOT\" @@"`
}

// ConditionOperand is a operand followed by an optional operation expression.
type ConditionOperand struct {
	Operand      *Operand      `parser:"@@"`
	ConditionRHS *ConditionRHS `parser:"@@?"`
}

// ConditionRHS represents the right-hand-side of Compare, Between, In

# 回應標頭 { #response-headers }

## 使用 `Response` 參數 { #use-a-response-parameter }

你可以在你的*路徑操作函式（path operation function）*中宣告一個 `Response` 型別的參數（就像處理 Cookie 一樣）。

然後你可以在那個*暫時性的* `Response` 物件上設定標頭。

{* ../../docs_src/response_headers/tutorial002_py310.py hl[1, 7:8] *}

接著你可以像平常一樣回傳任何你需要的物件（`dict`、資料庫模型等）。

如果你宣告了 `response_model`，它仍會用來過濾並轉換你回傳的物件。

FastAPI 會使用那個暫時性的回應來擷取標頭（還有 Cookie 與狀態碼），並把它們放到最終回應中；最終回應包含你回傳的值，且會依任何 `response_model` 進行過濾。

import jcifs.internal.util.SMBUtil;
import jcifs.smb.NtStatus;

/**
 * SMB2 Read response message.
 *
 * This response contains the data that was read from the file
 * along with information about the read operation.
 *
 * @author mbechler
 */
public class Smb2ReadResponse extends ServerMessageBlock2Response {

    /**
     * Protocol overhead size for SMB2 read response
     */

	flag.Uint64Var(&value, "value", 0, "attribute value expects the value to be uint64")
	flag.BoolVar(&set, "set", false, "this is a set attribute operation")

	flag.Parse()

	if set && value == 0 {
		log.Fatalln("setting an attribute requires a non-zero value")
	}

	if !set && value > 0 {
		log.Fatalln("to set a value please specify --set along with --value")

 * returns a new instance.
 *
 * This collection is optimized for safe concurrent access over a very small number of elements.
 *
 * This collection and is expected to hold fewer than 10 elements. Each operation is _O(N)_, and so
 * building an instance with _N_ elements is _O(N**2)_.
 */
internal sealed class Tags {
  /**
   * Returns a tags instance that maps [key] to [value]. If [value] is null, this returns a tags

有些情況你可能需要修改自動產生的 OpenAPI 結構（schema）。

本章將示範如何做。

## 一般流程 { #the-normal-process }

一般（預設）的流程如下。

`FastAPI` 應用程式（實例）有一個 `.openapi()` 方法，會回傳 OpenAPI 結構。

在建立應用物件時，會同時註冊一個 `/openapi.json`（或你在 `openapi_url` 設定的路徑）的路徑操作（path operation）。

這個路徑只會回傳一個 JSON 回應，內容就是應用的 `.openapi()` 方法結果。

預設情況下，`.openapi()` 會先檢查 `.openapi_schema` 屬性是否已有內容，有的話就直接回傳。

若沒有，則會呼叫 `fastapi.openapi.utils.get_openapi` 這個工具函式來產生。

`get_openapi()` 函式會接收以下參數：

	if err == io.EOF {
		err = io.ErrUnexpectedEOF
	}
	r.err = err
	return r.current, err
}

// next will read one entry from the stream.
// Generally not recommended for fast operation.
func (r *metacacheReader) next() (metaCacheEntry, error) {
	r.checkInit()
	if r.err != nil {
		return metaCacheEntry{}, r.err
	}
	var m metaCacheEntry
	var err error
	if r.current.name != "" {

  TF_Graph* graph = TF_NewGraph();

  // Make a placeholder operation.
  TF_Operation* feed = Placeholder(graph, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  // Make a constant operation with the scalar "2".
  TF_Operation* two = ScalarConst(2, graph, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  // Add operation.
  TF_Operation* add = Add(feed, two, graph, s);

        return new InvertedMinMaxPriorityQueue<>(comparator);
      }
    };

    public abstract Queue<Integer> create(Comparator<Integer> comparator);
  }

  /**
   * Does a CPU intensive operation on Integer and returns a BigInteger Used to implement an
   * ordering that spends a lot of cpu.
   */
  static class ExpensiveComputation implements Function<Integer, BigInteger> {
    @Override