"Should throw IllegalArgumentException for non-hex character in UUID string");
        }

        @Test
        @DisplayName("Constructor with too short UUID string should parse available data")
        void testConstructorWithStringTooShort() {
            // Arrange - UUID string missing last two characters
            String shortUuid = "00112233-4455-6677-8899-AABBCCDDEE";

      // timed out. e.g. if we weren't event able to grab the lock within the timeout we would never
      // even check the guard. I don't think we care too much about this use case but it could lead
      // to a confusing error message.
      throw new TimeoutException("Timed out waiting for " + this + " to reach the RUNNING state.");
    }
  }

  @Override

   * @param reason Reason for shutting down, no longer than 123 bytes of UTF-8 encoded data (**not** characters) or null.
   * @throws IllegalArgumentException if [code] is invalid or [reason] is too long.
   */
  fun close(
    code: Int,
    reason: String?,
  ): Boolean

  /**
   * Immediately and violently release resources held by this web socket, discarding any enqueued

      name = name.substring(0, name.length() - 1);
    }

    checkArgument(name.length() <= MAX_LENGTH, "Domain name too long: '%s':", name);
    this.name = name;

    this.parts = ImmutableList.copyOf(DOT_SPLITTER.split(name));
    checkArgument(parts.size() <= MAX_PARTS, "Domain has too many parts: '%s'", name);
    checkArgument(validateSyntax(parts), "Not a valid domain name: '%s'", name);
  }

  /**

        });

        assertThrows(CIFSException.class, () -> {
            preauthService.initializeSession("test", new byte[8], PreauthIntegrityService.HASH_ALGO_SHA512); // Too small
        });
    }

    @Test
    @DisplayName("Test unsupported hash algorithm")
    public void testUnsupportedHashAlgorithm() {
        byte[] salt = preauthService.generatePreauthSalt();

        @Test
        @DisplayName("Should throw exception with insufficient buffer")
        void testReadBytesWireFormatInsufficientBuffer() {
            // Given
            byte[] buffer = new byte[1]; // Too small

            // When & Then
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readBytesWireFormat(buffer, 0));
        }

        @Test

    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle malformed buffer gracefully")
        void testReadDataWireFormatMalformedBuffer() {
            byte[] buffer = new byte[3]; // Too small for valid DFS referral

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                response.readDataWireFormat(buffer, 0, buffer.length);
            });
        }

        @Test

We already know that this method is related to the **items** because that word is in the `ItemsService` (taken from the tag), but we still have the tag name prefixed in the method name too. 😕

We will probably still want to keep it for OpenAPI in general, as that will ensure that the operation IDs are **unique**.

    if (in.read() == -1) {
      // oh, there's the end of the stream
      return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

  private static byte[] combineBuffers(Queue<byte[]> bufs, int totalLen) {
    if (bufs.isEmpty()) {
      return new byte[0];
    }

        // Assert
        assertNotNull(trace, "Instance should be created");
    }

    @Test
    @DisplayName("Constructor with delegate: acquire() forwards to delegate and release() too")
    void constructor_withDelegate_acquireAndReleaseForwarded() {
        // Arrange: delegate we can spy on for interaction verification
        CIFSContext ctx = mock(CIFSContext.class);