searchRenderData.setAllRecordCount(Long.MIN_VALUE);
        searchRenderData.setCurrentStartRecordNumber(Long.MIN_VALUE);
        searchRenderData.setCurrentEndRecordNumber(Long.MIN_VALUE + 10);
        searchRenderData.setPageSize(Integer.MIN_VALUE);
        searchRenderData.setAllPageCount(Integer.MIN_VALUE);
        searchRenderData.setCurrentPageNumber(Integer.MIN_VALUE);

        void shouldHandleMinimumLongValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(Long.MIN_VALUE, Long.MIN_VALUE);

            // When & Then
            assertEquals(Long.MIN_VALUE, allocInfo.getCapacity());
            assertEquals(Long.MIN_VALUE, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should calculate used space correctly")

    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);
      }
    }

        assertEquals(Long.MAX_VALUE, dictionaryItem.getId());
    }

    public void test_getId_minValue() {
        // Test with minimum Long value
        dictionaryItem.id = Long.MIN_VALUE;
        assertEquals(Long.MIN_VALUE, dictionaryItem.getId());
    }

    public void test_multipleInstances() {
        // Test that different instances have independent ID values

   *       Long.MIN_VALUE}
   *   <li>{@link Math#absExact(long)}, which throws {@link ArithmeticException} when passed {@code
   *       Long.MIN_VALUE}
   *   <li>this method, {@code LongMath.saturatedAbs(long)}, which returns {@code Long.MAX_VALUE}
   *       when passed {@code Long.MIN_VALUE}
   * </ul>
   *

        // The comparator b2 - b1 with MAX_VALUE and MIN_VALUE causes overflow
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(Integer.MIN_VALUE), executionOrder.get(0));
        assertEquals(Integer.valueOf(Integer.MAX_VALUE), executionOrder.get(1));

        when(messageBlock.getMid()).thenReturn(maxMid);

        messageBlock.setMid(maxMid);
        assertEquals(maxMid, messageBlock.getMid());

        // Test with MIN_VALUE
        long minMid = Long.MIN_VALUE;
        doNothing().when(messageBlock).setMid(minMid);
        when(messageBlock.getMid()).thenReturn(minMid);

        messageBlock.setMid(minMid);

        // Test with minimum integer value
        int minFlags = Integer.MIN_VALUE;
        AvFlags minAvFlags = new AvFlags(minFlags);
        assertNotNull(minAvFlags, "AvFlags object should not be null for min flags");
        assertEquals(minFlags, minAvFlags.getFlags(), "Flags should match Integer.MIN_VALUE");

        // Test with a negative integer
        int negativeFlags = -12345;

        // Test case 5: Min int value
        int minIntValue = Integer.MIN_VALUE;
        NdrLong ndrLongMin = new NdrLong(minIntValue);
        assertEquals(minIntValue, ndrLongMin.value, "Constructor should correctly initialize with Integer.MIN_VALUE.");
    }

    @Test
    void encode_shouldCallEncNdrLongWithCorrectValue() throws NdrException {
        int testValue = 98765;

    }

    @Test
    void constructor_withMinimumShortValue() {
        // Arrange
        short level = Short.MIN_VALUE;

        // Act
        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, mockNdrObject);

        // Assert
        assertEquals(Short.MIN_VALUE, queryPolicy.level);
    }

    @Test
    void constructor_withMaximumShortValue() {
        // Arrange