/**
     * Did not execute flag - indicates request was not executed
     */
    int DCERPC_DID_NOT_EXECUTE = 0x20;
    /**
     * Maybe flag - indicates 'maybe' call semantics requested
     */
    int DCERPC_MAYBE = 0x40; /* `maybe' call semantics requested */
    /**
     * Object UUID flag - if true, a non-nil object UUID is present
     */
    int DCERPC_OBJECT_UUID = 0x80; /* if true, a non-nil object UUID */

    }

    @Test
    void testEncode() throws NdrException {
        // Test the encode method
        long testValue = 987654321098765L;
        NdrHyper ndrHyper = new NdrHyper(testValue);

        // Call the encode method with the mocked NdrBuffer
        ndrHyper.encode(mockNdrBuffer);

        // Verify that enc_ndr_hyper was called exactly once with the correct value

The key factor is that a dependency should be a "callable".

A "**callable**" in Python is anything that Python can "call" like a function.

So, if you have an object `something` (that might _not_ be a function) and you can "call" it (execute it) like:

```Python
something()
```

or

```Python
something(some_argument, some_keyword_argument="foo")
```

    .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager())
    .build();

// Connect 'em all together. Certificates are exchanged in the handshake.
Call call = client.newCall(new Request.Builder()
    .url(server.url("/"))
    .build());
Response response = call.execute();
System.out.println(response.handshake().peerPrincipal());
RecordedRequest recordedRequest = server.takeRequest();

        // Set structure size to 2
        SMBUtil.writeInt2(2, buffer, bufferIndex);

        // Call readBytesWireFormat multiple times
        for (int i = 0; i < 5; i++) {
            int result = response.readBytesWireFormat(buffer, bufferIndex);
            assertEquals(2, result, "Should consistently return 2 on call " + (i + 1));
        }
    }

    @Test
    @DisplayName("Test edge case with maximum buffer index")

   */
  @CanIgnoreReturnValue
  @Nullable V putEdgeValue(EndpointPair<N> endpoints, V value);

  /**
   * Removes {@code node} if it is present; all edges incident to {@code node} will also be removed.
   *
   * @return {@code true} if the graph was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean removeNode(N node);

  /**
   * Removes the edge connecting {@code nodeU} to {@code nodeV}, if it is present.

## Optionale Parameter

Auf die gleiche Weise können Sie optionale Query-Parameter deklarieren, indem Sie deren Defaultwert auf `None` setzen:

{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}

In diesem Fall wird der Funktionsparameter `q` optional, und standardmäßig `None` sein.

/// check

        }
    }

    /**
     * Only call this method while holding a tree handle
     *
     * @return the connected tree type
     */
    public int getTreeType() {
        try (SmbTreeImpl t = getTree()) {
            return t.getTreeType();
        }
    }

    /**
     *
     * Only call this method while holding a tree handle
     *

public final class okhttp3/coroutines/ExecuteAsyncKt {
	public static final fun executeAsync (Lokhttp3/Call;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;

	updatedAt, err := globalBucketMetadataSys.Update(ctx, bucket, bucketSSEConfig, configData)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Call site replication hook.
	//
	// We encode the xml bytes as base64 to ensure there are no encoding
	// errors.
	cfgStr := base64.StdEncoding.EncodeToString(configData)