permissions:
  statuses: write

env:
  UV_SYSTEM_PYTHON: 1

jobs:
  smokeshow:
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest

    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.9'

     * with specified mechanism.
     * 
     * @param source
     *            the {@link SSPContext} to be wrapped
     * @param mech
     *            the mechanism is being used for this context.
     */
    SpnegoContext ( Configuration config, SSPContext source, ASN1ObjectIdentifier[] mech ) {
        this.mechContext = source;
        this.mechs = mech;

        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/plain")
        .build(),
    )
    newEventSource()
    listener.assertFailure("Invalid content-type: text/plain")
  }

  @Test
  fun badResponseCode() {
    server.enqueue(
      MockResponse.Builder()
        .body(
          """

		user2 = *GetUser("transaction-nested-2", Config{})
	)

	if err := transaction(context.Background(), DB, func(ctx context.Context, tx *gorm.DB) error {
		tx.Create(&user)

		if err := tx.First(&User{}, "name = ?", user.Name).Error; err != nil {
			t.Fatalf("Should find saved record")
		}

		if err := transaction(ctx, tx, func(ctx context.Context, tx1 *gorm.DB) error {
			tx1.Create(&user1)

      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  build:
    name: Go ${{ matrix.go-version }} on ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        go-version: [1.22.x]
        os: [ubuntu-latest]

    path.write_bytes(b"<file content>")

    client = TestClient(app)
    with path.open("rb") as file:
        response = client.post("/files/", files={"file": file})
    assert response.status_code == 200, response.text
    assert response.json() == {"file_size": 14}


def test_post_upload_file(tmp_path):
    path = tmp_path / "test.txt"
    path.write_bytes(b"<file content>")

    client = TestClient(app)

                        "200": {
                            "description": "Successful Response",
                            "content": {"application/json": {"schema": {}}},
                        },
                        "422": {
                            "description": "Validation Error",
                            "content": {
                                "application/json": {
                                    "schema": {

   * ObjectOutputStream)}.
   */
  static int readCount(ObjectInputStream stream) throws IOException {
    return stream.readInt();
  }

  /**
   * Stores the contents of a map in an output stream, as part of serialization. It does not support
   * concurrent maps whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of entries, first key, first value, second key,
   * second value, and so on.

        required: false
        default: 'false'

jobs:
  fastapi-people:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v4
      # Ref: https://github.com/actions/runner/issues/2033

 */
package jcifs.internal.smb2.create;


import jcifs.Encodable;


/**
 * @author mbechler
 *
 */
public interface CreateContextRequest extends Encodable {

    /**
     * @return context name
     */
    byte[] getName ();