return asHtml(path_AdminFailureurl_AdminFailureurlJsp).renderWith(data -> {
            searchPaging(data, form);
        });
    }

    /**
     * Resets the search criteria and pagination state.
     *
     * @param form the search form to reset
     * @return HTML response for the failure URL list page with cleared search
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })

	// Refer to https://cloud.google.com/storage/docs/transcoding#decompressive_transcoding
	// Need to set `Accept-Encoding` header to `gzip` when issuing a GetObject call, to be able
	// to download the object in compressed state.
	// Calling ReadCompressed with true accomplishes that.
	object := gcs.client.Bucket(gcs.Bucket).Object(gcs.getDest(key)).ReadCompressed(true)

	r, err = object.NewRangeReader(ctx, opts.startOffset, opts.length)

import org.opentest4j.TestAbortedException

/**
 * Marks a test as Platform aware, before the test runs a consistent Platform will be
 * established e.g. SecurityProvider for Conscrypt installed.
 *
 * Also allows a test file to state general platform assumptions, or for individual test.
 */
@Suppress("unused", "MemberVisibilityCanBePrivate")
open class PlatformRule
  @JvmOverloads
  constructor(
    val requiredPlatformName: String? = null,

            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("getters and basic state (happy path)")
    void testGettersAndState() {
        SmbSessionImpl session = newSession();

        // Basic getters
        assertSame(configuration, session.getConfig(), "getConfig delegates to transportContext");

        verify(mockConnection).connect();
        // Connection should be established after connect
    }

    /**
     * Test that disconnect() calls disconnect() on the underlying connection and resets state.
     */
    @Test
    void testDisconnect() throws Exception {
        // Act
        ntlmConnection.disconnect();

        // Assert
        verify(mockConnection).disconnect();

        .build()
    assertThat(headers["Test-Instant"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getInstant("Test-Instant")).isEqualTo(expected)
  }

  @Test fun setDate() {
    val expected = Date(1000)
    val headers =
      Headers
        .Builder()
        .add("testDate", Date(0L))
        .set("testDate", expected)
        .build()

			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *TierConfigMgr) Msgsize() (s int) {
	s = 1 + 6 + msgp.MapHeaderSize
	if z.Tiers != nil {
		for za0001, za0002 := range z.Tiers {
			_ = za0002

    // Security configuration
    private final SecureRandom secureRandom;
    private final int selectedHashAlgorithm;
    private final boolean enforceIntegrity;

    /**
     * Context for maintaining preauth integrity state per session.
     */
    public static class PreauthIntegrityContext {
        private final byte[] salt;
        private final int hashAlgorithm;
        private volatile byte[] currentHash;

     */
    @Test
    void testInit() throws ServletException {
        assertDoesNotThrow(() -> ntlmServlet.init(servletConfig));
        // Further assertions can be added here to check the internal state of the servlet if fields were protected/public
    }

    /**
     * Test the init method when CIFSException occurs.
     * Verifies that configuration properties are properly validated during initialization.
     */

        target.ensureOpen();
        target.close();
        verify(fileHandle, times(1)).close();
        verify(fileHandle, never()).release();
        verify(tree, atLeastOnce()).release();

        // Re-prepare state for second branch: not open but handle set
        when(fileHandle.isValid()).thenReturn(false);
        // Need to reopen logic to set handle again
        // Reset open flag by reconstructing target