SMBUtil.writeInt2(0, buffer, 56); // offset
        SMBUtil.writeInt2(0, buffer, 58); // length

        // Negotiate context offset (0 for non-3.1.1)
        SMBUtil.writeInt4(0, buffer, 60);

        return buffer;
    }

    /**
     * Creates a larger buffer suitable for testing negotiate contexts.
     */
    private byte[] createLargeBufferForContexts() {

  private fun newWebSocket(
    path: String,
    listener: WebSocketListener,
  ): WebSocket {
    val request =
      Request
        .Builder()
        .url(HOST + path)
        .build()
    return client.newWebSocket(request, listener)
  }

  fun run() {
    try {
      val count = getTestCount()
      println("Test count: $count")
      for (number in 1..count) {
        runTest(number, count)
      }

    }
    return helper;
  }

  @Benchmark
  int toString(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      MoreObjects.ToStringHelper helper = newHelper();
      for (int j = 0; j < dataSize; ++j) {
        dataset.addEntries(helper);
      }
      dummy ^= helper.toString().hashCode();
    }
    return dummy;
  }

    private final int i;

    MyInt(int i) {
      this.i = i;
    }

    @Override
    public int hashCode() {
      return i;
    }

    @Override
    public boolean equals(Object o) {
      return o instanceof MyInt && ((MyInt) o).i == i;
    }
  }

  public void testAsFunction_simplistic() {
    String canonical = "a";
    String not = new String("a");

     * else a dependency collection request will be done.
     *
     * @return the id of the path scope
     */
    String pathScope() default "";

    /**
     * The request type, in case the default one is not correct.
     * Valid values are {@code collect}, {@code flatten}, or {@code resolve}.
     *
     * @return the request type
     */
    String requestType() default "";

    ],
)
def get_app(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.request_files.{request.param}")

    return mod.app


@pytest.fixture(name="client")
def get_client(app: FastAPI):
    client = TestClient(app)
    return client


def test_post_form_no_body(client: TestClient):
    response = client.post("/files/")
    assert response.status_code == 422, response.text

}

func parseGoroutineType2(path string) (map[time.Duration][]string, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	bf := bytes.Buffer{}

	save := func(s string) {
		bf.WriteString(s + "\n")
	}
	reset := func() {
		bf.Reset()
	}

	ret := make(map[time.Duration][]string)

     */
    public XmlWriterException(String message, Location location, Exception e) {
        super(message, e);
        this.location = location;
    }

    public Location getLocation() {
        return location;
    }

    // methods ----------------------------------------------------------------

    /**
     * Gets a conflict resolver of the specified type.
     *
     * @param type the type of conflict resolver to obtain
     * @return the conflict resolver
     * @throws ConflictResolverNotFoundException
     *          if the specified type was not found
     */
    ConflictResolver getConflictResolver(String type) throws ConflictResolverNotFoundException;

     **/
    ToolchainPrivate createToolchain(ToolchainModel model) throws MisconfiguredToolchainException;

    /**
     * Returns the default instance of the particular type of toolchain, can return <code>null</code>
     * if not applicable.
     * TODO keep around??
     **/
    ToolchainPrivate createDefaultToolchain();