// The radix is used as an array index, so try a negative value.
    assertThrows(NumberFormatException.class, () -> UnsignedLongs.parseUnsignedLong("0", -1));
  }

  public void testToString() {
    String[] tests = {
      "0",
      "ffffffffffffffff",
      "7fffffffffffffff",
      "ff1a618b7f65ea12",
      "5a4316b8c153ac4d",

    }

    @Test
    @DisplayName("Test setUid with boundary values")
    void testSetUidWithBoundaryValues() {
        // Test with various uid values
        int[] uids = { 0, 1, Integer.MAX_VALUE, Integer.MIN_VALUE };

        for (int uid : uids) {
            doNothing().when(messageBlock).setUid(uid);
            messageBlock.setUid(uid);
            verify(messageBlock).setUid(uid);

Harshavardhana <******@****.***> 1643143764 -0800

### Eşzamanlı Burgerler { #concurrent-burgers }

Aşkınla fast food almaya gidiyorsun, kasiyer senden önceki insanların siparişlerini alırken sıraya giriyorsun. 😍

<img src="/img/async/concurrent-burgers/concurrent-burgers-01.png" class="illustration">

Sonra sıra size geliyor, sen ve aşkın için 2 çok havalı burger sipariş ediyorsun. 🍔🍔

<img src="/img/async/concurrent-burgers/concurrent-burgers-02.png" class="illustration">

    multimap.put(null, -1);
    multimap.put("bar", 3);
    multimap.put("bar", 1);
    multimap.put("foo", 1);

    assertThat(multimap.toString())
        .isEqualTo("{foo=[3, -1, 2, null, 4, 1], null=[null, 0, -1], bar=[1, 2, null, 3]}");
  }

  public void testPutMultimapOrdered() {
    SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
    multimap.putAll(initializeMultimap5());

        if (startOffset >= endOffset) {
            return;
        }

        int posInc = afterSynonymProduced ? 0 : 1;
        if (endOffset - startOffset < n) {
            queue.add(new MyToken(block.substring(startOffset, endOffset), startOffset, endOffset, posInc));
            return;
        }

  }

  @Override
  public void close() throws IOException {
    reader.close();
  }

  @Override
  public int read() throws IOException {
    return (read(singleByte) == 1) ? toUnsignedInt(singleByte[0]) : -1;
  }

  // TODO(chrisn): Consider trying to encode/flush directly to the argument byte
  // buffer when possible.
  @Override
  public int read(byte[] b, int off, int len) throws IOException {

     *
     * @throws IOException if a network error occurs
     */

    @Override
    public void write(final int b) throws IOException {
        tmp[0] = (byte) b;
        write(tmp, 0, 1);
    }

    /**
     * Writes b.length bytes from the specified byte array to this
     * file output stream.
     *
     * @throws IOException if a network error occurs
     */

    @Override

                .resolveSids(any(CIFSContext.class), anyString(), any(SID[].class), anyInt(), eq(-1));

        assertThrows(CIFSException.class, () -> sidResolver.resolveSids(mockContext, testServerName, testSids, 0, -1));
    }

    @Test
    void testResolveSidsWithOffsetAndLength_OutOfBounds() throws CIFSException {
        doThrow(new CIFSException("Array index out of bounds")).when(sidResolver)

        // When & Then - test boundary conditions
        // Negative length or offset should not cause issues (len <= 0 returns early)
        assertDoesNotThrow(() -> outputStream.write(data, 0, -1)); // negative length, returns early
        assertDoesNotThrow(() -> outputStream.write(data, 0, 0)); // zero length, returns early

        // These should pass through to the underlying implementation