* This method calculates the appropriate delay for the current time
     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**
     * Calculates the delay in milliseconds based on current time and configured rules.

        assertEquals(testKey, leaseContext.getLeaseKey());
        assertEquals(testState, leaseContext.getLeaseState());
        assertEquals(0, leaseContext.getLeaseFlags());
    }

    @Test
    @DisplayName("Should calculate correct size")
    void testSize() {
        int expectedSize = 16 + 4 + 4 + 32; // header + name + padding + data
        assertEquals(expectedSize, leaseContext.size());
    }

    @Test

        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeCalculationTests {

        @Test
        @DisplayName("Should calculate size8 without alignment")
        void testSize8NoAlignment() {
            assertEquals(8, ServerMessageBlock2.size8(8));
            assertEquals(16, ServerMessageBlock2.size8(9));

            assertEquals(8L * 4096L * 512L, smbInfoAllocation.getCapacity());
            assertEquals(8L * 2048L * 512L, smbInfoAllocation.getFree());
        }

        @Test
        @DisplayName("Should calculate capacity correctly")
        void testCapacityCalculation() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[24];
            buffer[4] = 0x04; // sectPerAlloc = 4
            buffer[8] = 0x00;

            result = null;
        } else if (!Files.exists(src.getPath())) {
            Files.deleteIfExists(target);
            result = "";
        } else {
            String current = ChecksumAlgorithmHelper.calculate(
                            src.getPath(), List.of(new Sha1ChecksumAlgorithmFactory()))
                    .get(Sha1ChecksumAlgorithmFactory.NAME);
            String existing = sourceState.get();

            assertEquals(0, context.getSalt().length);
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 3, 5, 10 })
        @DisplayName("Should calculate size correctly for different hash algo counts")
        void testSizeCalculation(int hashAlgoCount) {
            // Arrange
            int[] hashAlgos = new int[hashAlgoCount];
            byte[] salt = new byte[16];

                    validCount++;
                }
            }

            assertEquals(3, validCount);
            assertTrue(offset > 0);
        }

        @Test
        @DisplayName("Should calculate combined size for multiple contexts")
        void testCombinedSizeCalculation() {
            CreateContextRequest[] contexts = new CreateContextRequest[5];
            int[] expectedSizes = { 16, 24, 32, 40, 48 };

|               16 |              13 |                 3 |                1.23 |
|               16 |              14 |                 2 |                1.14 |

You can calculate _approximate_ storage usage ratio using the formula - total drives (N) / data drives (D).

### Allowed values for STANDARD storage class

import org.apache.maven.project.MavenProject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static java.util.Objects.requireNonNull;

/**
 * <p>
 * Calculates the task segments in the build
 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @since 3.0
 */
@Named
@Singleton

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

        @Test
        @DisplayName("Should calculate used space correctly")
        void shouldCalculateUsedSpaceCorrectly() {
            // Given
            long capacity = 1024L * 1024L * 1024L * 100L; // 100GB
            long free = 1024L * 1024L * 1024L * 40L; // 40GB