assertArrayEquals(testFileId, Arrays.copyOfRange(buffer, 8, 24));

            // Verify total bytes written (structure + lock data)
            assertEquals(24 + 24, bytesWritten); // 24 for structure, 24 for lock
        }

        @Test
        @DisplayName("Should write request structure correctly with multiple locks")
        void testWriteBytesWireFormatMultipleLocks() {

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

/*
 * Source:
 * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/test/tck/JSR166TestCase.java?revision=1.90

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten, "Should write 4 bytes");
        // Check that structure size (4) is written as 2-byte little-endian
        assertEquals(4, buffer[offset] | (buffer[offset + 1] << 8), "Structure size should be 4");
        assertEquals(0, buffer[offset + 2], "Reserved bytes should be 0");

Free Software Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the
author to ask for permission. For software which is copyrighted by the
Free Software Foundation, write to the Free Software Foundation; we
sometimes make exceptions for this. Our decision will be guided by the

         */
        return 0;
    }

    /*
     * We overload this method from ServerMessageBlock because
     * we want writeAndXWireFormat to write the parameterWords
     * and bytes. This is so we can write batched smbs because
     * all but the first smb of the chaain do not have a header
     * and therefore we do not want to writeHeaderWireFormat. We
     * just recursivly call writeAndXWireFormat.

      editor = snapshot.edit() ?: return // edit() returns null if snapshot is not current.
      entry.writeTo(editor)
      editor.commit()
    } catch (_: IOException) {
      abortQuietly(editor)
    }
  }

  private fun abortQuietly(editor: DiskLruCache.Editor?) {
    // Give up because the cache cannot be written.
    try {
      editor?.abort()
    } catch (_: IOException) {
    }
  }

  /**

            throw e;
        }
    }

    /**
     * Performs RDMA write operation.
     *
     * @param buffer the buffer to write from
     * @param remoteAddress remote memory address
     * @param remoteKey remote access key
     * @param length number of bytes to write
     * @return number of bytes written
     * @throws IOException if operation fails
     */

            val nullawayAttributeValue = errorproneExtension.nullawayEnabled.map { if (it) NullawayState.ENABLED else NullawayState.DISABLED }

            // We don't care about nullaway in test fixtures or tests, they're written in Groovy anyway.
            NullawayAttributes.addToConfiguration(configurations.named(compileClasspathConfigurationName), nullawayAttributeValue)

            project.plugins.withType<JavaLibraryPlugin> {

/*
 * Written by Doug Lea and Martin Buchholz with assistance from
 * members of JCP JSR-166 Expert Group and released to the public
 * domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

/*
 * Source:
 * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/test/tck-jsr166e/AtomicDoubleTest.java?revision=1.8
 * (Modified to adapt to guava coding conventions)
 */

package com.google.common.util.concurrent;

 * {@snippet :
 * ContiguousSet.create(Range.closed(5, 42), DiscreteDomain.integers())
 * }
 *
 * <p>Note that because bounded ranges over {@code int} and {@code long} values are so common, this
 * particular example can be written as just:
 *
 * {@snippet :
 * ContiguousSet.closed(5, 42)
 * }
 *
 * <p><b>Warning:</b> Be extremely careful what you do with conceptually large instances (such as