assertEquals("Expected structureSize = 17", exception.getMessage());
        }

        @Test
        @DisplayName("Should handle response at end of buffer")
        void testResponseAtEndOfBuffer() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[20]; // Exact size needed
            SMBUtil.writeInt2(17, buffer, 0);

        result = NtlmMessage.readSecurityBuffer(data, 0);
        assertEquals(0, result.length, "Should return empty array for zero length buffer.");

        // Test with offset pointing to end of array (should result in empty array if length is 0)
        buffer.putShort(0, (short) 0);
        buffer.putShort(2, (short) 0);
        buffer.putInt(4, data.length);

  @SuppressWarnings("unchecked")
  static final ImmutableMap<Object, Object> EMPTY =
      new RegularImmutableMap<>((Entry<Object, Object>[]) ImmutableMap.EMPTY_ENTRY_ARRAY, null, 0);

  /**
   * Closed addressing tends to perform well even with high load factors. Being conservative here
   * ensures that the table is still likely to be relatively sparse (hence it misses fast) while
   * saving space.
   */

        .hasMessageThat()
        .isEqualTo("end index (2) must not be greater than size (1)");
  }

  public void testCheckPositionIndexes_reversed() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkPositionIndexes(1, 0, 1));
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("end index (0) must not be less than start index (1)");
  }

        .hasMessageThat()
        .isEqualTo("end index (2) must not be greater than size (1)");
  }

  public void testCheckPositionIndexes_reversed() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkPositionIndexes(1, 0, 1));
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("end index (0) must not be less than start index (1)");
  }

   * Drains the queue as {@linkplain #drain(BlockingQueue, Collection, int, Duration)}, but with a
   * different behavior in case it is interrupted while waiting. In that case, the operation will
   * continue as usual, and in the end the thread's interruption status will be set (no {@code
   * InterruptedException} is thrown).
   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements

        // Test exact buffer boundaries
        byte[] buffer = new byte[100];
        validator.validateBufferAccess(buffer, 0, 100); // Exactly full buffer
        validator.validateBufferAccess(buffer, 100, 0); // Zero length at end
    }

			parity := total - data
			testConfigs = append(testConfigs, [2]uint8{data, parity})
		}
	}
	got := make(map[[2]uint8]map[ErasureAlgo]uint64, len(testConfigs))
	// Copied from output of fmt.Printf("%#v", got) at the end.

	if err := newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatalf("Initializing config.json failed")
	}

	// Register the API end points with Erasure/FS object layer.
	apiRouter := initTestAPIEndPoints(obj, []string{"PostPolicy"})

	credentials := globalActiveCred
	bucketName := minioMetaBucket
	objectName := "config/x"

        });
    }

    /**
     * Updates the status of expired jobs that haven't finished.
     * Jobs that have been running longer than the expired job interval
     * without an end time are marked as failed.
     */
    public void updateStatus() {
        final long expiry = ComponentUtil.getSystemHelper().getCurrentTimeAsLong() - expiredJobInterval;