/**
 * Tests for the {@link ASN1Util} class.
 */
class ASN1UtilTest {

    // --- as(Class, Object) ---

    @Test
    void testAs_Object_Success() throws PACDecodingException {
        // Test successful casting
        String expected = "test string";
        Object obj = expected;
        String result = ASN1Util.as(String.class, obj);
        assertSame(expected, result);
    }

    @Test

        final StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("textExtractor", TextExtractor.class);
        textExtractor = container.getComponent("textExtractor");
    }

    /**
     * Test successful text extraction with default encoding (UTF-8).
     */
    public void test_getText_withDefaultEncoding() {
        final String testContent = "Test content テスト 日本語";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

    // The response structure is empty (0 bytes) for reconnect
    // No data is returned in a successful reconnect response

    /**
     * Create a new durable handle reconnect response
     */
    public DurableHandleReconnectResponse() {
        // No data fields for reconnect response
    }

    @Override

    @Test
    void readRDataWireFormat_shouldSetNbtAddress_whenAddressIsNonZero_groupNameFalse_nodeTypeZero()
            throws NoSuchFieldException, IllegalAccessException {
        // Prepare superclass fields for successful parsing
        setSuperclassFieldsForSuccessfulParsing();

        byte[] src = new byte[10];
        int srcIndex = 0;

        // Simulate groupName = false (0x00), nodeType = 0 (0x00) -> src[srcIndex] = 0x00

     */
    default boolean isEditable() {
        return false;
    }

    /**
     * Refreshes the user's information from the underlying data source.
     * @return True if refresh was successful, false otherwise.
     */
    default boolean refresh() {
        return false;
    }

    void testInitialState() {
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());
        assertTrue(circuitBreaker.allowsRequests());
    }

    @Test
    @DisplayName("Test successful calls in CLOSED state")
    void testSuccessfulCalls() throws Exception {
        String result = circuitBreaker.call(() -> "success");
        assertEquals("success", result);

    }

    private long sequenceNumber;
    private int returnCode;
    private long recommendedHeartbeatInterval;
    private String error;

    /**
     * Checks if the heartbeat was successful.
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return returnCode == 0;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */

    }

    private String registrationId;
    private int returnCode;
    private byte[] contextHandle;
    private String error;

    /**
     * Checks if the registration was successful.
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return returnCode == 0;
    }

    /**
     * Gets a human-readable error description.
     *
     * @return the error description

        this.maxFragmentedSize = RdmaCapabilities.DEFAULT_MAX_FRAGMENTED_SIZE;
    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful, false otherwise
     */
    public boolean isSuccess() {
        return status == 0;
    }

    /**
     * Get negotiation status
     *
     * @return status code (0 = success)

     *
     * Current strategy is based on failure count. In the future, this could be enhanced to consider:
     * - Recent event frequency (successful notifications)
     * - Time since last successful notification
     * - Events per unit time for more adaptive behavior
     *
     * @param handle notification handle
     * @return polling interval in milliseconds
     */