String ip = "192.168.1.7";

        // Block the IP
        for (int i = 1; i <= 5; i++) {
            assertTrue(rateLimiter.checkAttempt("user" + i, ip));
            rateLimiter.recordFailure("user" + i, ip);
        }

        // Should be blocked
        assertFalse(rateLimiter.checkAttempt("user6", ip), "IP should be blocked");

        // Manually unblock

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class BlockTableRenderer {
    public void renderTo(Iterable<BlockDoc> blocks, Element parent) {
        Document document = parent.getOwnerDocument();

        // <thead>
        //   <tr>
        //     <td>Block</td>
        //     <td>Description</td>
        //   </tr>
        // </thead>
        Element thead = document.createElement("thead");

// you want the latter, use TFE_TensorHandleBackingDeviceName. This function
// will block till the operation that produces `h` has completed.
TF_CAPI_EXPORT extern const char* TFE_TensorHandleDeviceName(
    TFE_TensorHandle* h, TF_Status* status);

// Returns the name of the device in whose memory `h` resides.
//
// This function will block till the operation that produces `h` has completed.

		}

		offset := ei.V2Obj.EcBSize * blockNum
		if offset >= m.size {
			return nil, fmt.Errorf("block %d out of range. offset %d > size %d", blockNum, offset, m.size)
		}
		m.blockOffset = offset
		m.blocks = (m.size + ei.V2Obj.EcBSize - 1) / ei.V2Obj.EcBSize
		if m.blocks > 0 {
			m.blocks--
		}
		if blockNum < m.blocks {
			m.size = ei.V2Obj.EcBSize
		} else {
			m.size -= offset
		}

    @Test
    public void testClearBlacklist() throws Exception {
        validator.addToBlacklist("\\share\\blocked");
        validator.clearBlacklist();

        // Should allow previously blacklisted path
        String allowed = validator.validatePath("\\share\\blocked\\file.txt");
        assertEquals("\\share\\blocked\\file.txt", allowed);
    }

    @Test
    public void testClearWhitelist() throws Exception {

     * } finally {
     *   close(is);
     * }
     * </pre>
     * <p>
     * If an exception occurs in the try block, there is a possibility that an exception will also occur in the finally block's {@link #close(Closeable)}. If the exception is thrown from the finally block, the original exception from the try block will be lost.
     * </p>
     *
     * @param closeable the closeable object
     * @see Closeable#close()
     */

	Distribution []int `json:"distribution"`
	// Checksums holds all bitrot checksums of all erasure encoded blocks
	Checksums []ChecksumInfo `json:"checksum,omitempty"`
}

// Equal equates current erasure info with newer erasure info.
// returns false if one of the following check fails
// - erasure algorithm is different
// - data blocks are different
// - parity blocks are different

            logger.debug("Rate limit check: clientIp={}, path={}", clientIp, httpRequest.getRequestURI());
        }

        // Check if IP is blocked
        if (rateLimitHelper.isBlocked(clientIp)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Request blocked: clientIp={}", clientIp);
            }
            sendBlockedResponse(httpResponse);
            return;
        }

        // Check rate limit

    @Test
    public void test_blockIp() {
        rateLimitHelper.blockIp("192.168.1.100", 1000L);
        assertEquals(1, rateLimitHelper.getBlockedIpCount());

        rateLimitHelper.unblockIp("192.168.1.100");
        assertEquals(0, rateLimitHelper.getBlockedIpCount());
    }

    @Test
    public void test_cleanup() {
        rateLimitHelper.blockIp("192.168.1.100", 1L);

        parent.appendChild(summarySection);

        Element title = document.createElement("title");
        summarySection.appendChild(title);
        title.appendChild(document.createTextNode("Script blocks"));

        Collection<BlockDoc> classBlocks = classDoc.getClassBlocks();
        if (!classBlocks.isEmpty()) {
            Element table = document.createElement("table");
            summarySection.appendChild(table);