}

    @Test
    void constructor_shouldInitializeFieldsCorrectly() {
        // Given
        int acctFlags = 123;

        // When
        MsrpcEnumerateAliasesInDomain msrpc = new MsrpcEnumerateAliasesInDomain(mockDomainHandle, acctFlags, mockSamArray);

        // Then
        // Verify that the 'sam' field is set correctly

        lenient().when(mockSmbNamedPipe.openPipe()).thenReturn(mockSmbPipeHandle);
        lenient().when(mockSmbPipeHandle.unwrap(SmbPipeHandleInternal.class)).thenReturn(mockSmbPipeHandleInternal);
        lenient().when(mockSmbNamedPipe.getContext()).thenReturn(mockContext);
        lenient().when(mockSmbNamedPipe.getLocator()).thenReturn(mockSmbResourceLocator);

}'''
        def newSnapshot = snapshot('6.6')
        def expectedFileContent = releasedVersionsFile.text.replace('20200702230251+0000', newSnapshot.buildTime)

        when:
        ReleasedVersionsHelperKt.updateReleasedVersionFile(releasedVersionsFile, newSnapshot) == ''

        then:
        releasedVersionsFile.text == expectedFileContent
    }

    ReleasedVersion releasedVersion(String version, long date = System.currentTimeMillis()) {

   * {@code short[]}, or {@code int[]}. The value of {@code entry} should fit in the size of the
   * assigned array element, when seen as an unsigned value. So if {@code table} is a {@code byte[]}
   * then we should have {@code 0 ≤ entry ≤ 255}, and if {@code table} is a {@code short[]} then we
   * should have {@code 0 ≤ entry ≤ 65535}. It is the caller's responsibility to ensure this.
   */

# Note that we must use nightly here as these are used in nightly jobs
# For release jobs, we will pin these on the release branch
keras-nightly ~= 3.12.0.dev
tb-nightly ~= 2.20.0.a
# For new protobuf, if V.x.y is gencode version, then runtime version U must be
# V <= U <= V+1
# More info at https://protobuf.dev/support/cross-version-runtime-guarantee/
protobuf >= 5.28.0, < 7.0
# Test dependencies
grpcio >= 1.68.1, < 2.0 ; python_version <= "3.13"

///

### What is "Mounting" { #what-is-mounting }

"Mounting" means adding a complete "independent" application in a specific path, that then takes care of handling all the sub-paths.

   *
   * Since these fields are non-final that means that TimeoutFuture is not being 'safely published',
   * thus a motivated caller may be able to expose the reference to another thread that would then
   * call cancel() and be unable to cancel the delegate.
   * There are a number of ways to solve this, none of which are very pretty, and it is currently

func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.
	// If resp.Body is not closed, the Client's underlying RoundTripper
	// (typically Transport) may not be able to reuse a persistent TCP
	// connection to the server for a subsequent "keep-alive" request.
	if respBody != nil {
		// Drain any remaining Body and then close the connection.
		// Without this closing connection would disallow re-using

# For example:
#
#	make v1.2.3.zip
#	make v1.2.3.test
#
# and then if changes are needed, check them into master
# and run 'make v1.2.3.rm' and repeat.
#
# Note that once published a snapshot zip file should never
# be modified. We record the sha256 hashes of the zip files
# in fips140.sum, and the cmd/go/internal/fips140 test checks
# that the zips match.
#
# When the zip file is finalized, run 'make updatesum' to update
# fips140.sum.

   *     remote server accepted the request before the failure.
   * @throws IllegalStateException when the call has already been executed.
   */
  @Throws(IOException::class)
  fun execute(): Response

  /**
   * Schedules the request to be executed at some point in the future.
   *
   * The [dispatcher][OkHttpClient.dispatcher] defines when the request will run: usually