// Test subclass to control DISABLED flag
    private static class TestDfs extends Dfs {
        private boolean disabled;

        public void setDisabled(boolean disabled) {
            this.disabled = disabled;
        }

        @Override
        public HashMap getTrustedDomains(NtlmPasswordAuthentication auth) throws SmbAuthException {
            if (disabled || auth.domain == "?")
                return null;

        assertFalse(config.isUseBatching(), "Batching should be disabled");

        // Even with batching disabled, getBatchLimit should return a value
        int limit = config.getBatchLimit("TreeConnectAndX.Transaction");
        assertTrue(limit >= 0, "Batch limit should still return a value even when batching is disabled");
    }

    /**
     * Test configuration when Unicode is disabled
     */
    @Test

		eclaims, s3Err := checkClaimsFromToken(req, ucred)
		if s3Err != ErrNone {
			return nil, nil, false, errAuthentication
		}

		maps.Copy(claims.MapClaims, eclaims)

		// if root access is disabled, disable all its service accounts and temporary credentials.
		if ucred.ParentUser == globalActiveCred.AccessKey && !globalAPIConfig.permitRootAccess() {
			return nil, nil, false, errAccessKeyDisabled
		}

    /**
     * Indicates whether network access to remote repositories has been disabled.
     *
     * @return {@code true} if remote access has been disabled, {@code false} otherwise.
     */
    @Override
    boolean isOffline();

    /**
     * Enables/disables network access to remote repositories.
     *
     * @param offline {@code true} to disable remote access, {@code false} to allow network access.

        assertNotNull(dfsImpl);
    }

    // Tests for isTrustedDomain
    @Test
    void testIsTrustedDomain_DfsDisabled() throws SmbAuthException {
        // Scenario: DFS is disabled in the configuration.
        when(mockConfig.isDfsDisabled()).thenReturn(true);
        assertFalse(dfsImpl.isTrustedDomain(mockContext, "anydomain.com"));
    }

    @Test

    static final long TTL = Config.getLong("jcifs.smb1.smb.client.dfs.ttl", 300);
    static final boolean DISABLED = Config.getBoolean("jcifs.smb1.smb.client.dfs.disabled", false);

    /**
     * Sentinel cache entry indicating a negative cache result
     */
    protected static CacheEntry FALSE_ENTRY = new Dfs.CacheEntry(0L);

    /**

    }

    /**
     * Test that SMB1 is disabled by default
     */
    @Test
    public void testSMB1Disabled() throws CIFSException {
        BaseConfiguration config = new BaseConfiguration(true);

        // SMB1 versions should not be allowed
        assertTrue("SMB1 should be disabled", config.getMinimumVersion().atLeast(DialectVersion.SMB202));

	for {
		if !globalCallhomeConfig.Enabled() {
			// Stop the processing as callhome got disabled
			return false
		}

		select {
		case <-ctx.Done():
			// indicates that we do not need to run callhome anymore
			return false
		case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)

        assertNotNull(exception1);
        assertEquals(message1, exception1.getMessage());
        assertNull(exception1.getCause());

        // Test with suppression disabled and writable stack trace
        String message2 = "Test with suppression disabled";
        CrawlerSystemException exception2 = constructor.newInstance(message2, false, true);
        assertNotNull(exception2);
        assertEquals(message2, exception2.getMessage());

import mockwebserver3.junit5.StartStop
import okhttp3.Protocol.HTTP_1_1
import okhttp3.Protocol.HTTP_2
import okhttp3.Provider.CONSCRYPT
import okhttp3.Provider.JSSE
import okhttp3.TlsExtensionMode.DISABLED
import okhttp3.TlsExtensionMode.STANDARD
import okhttp3.TlsVersion.TLS_1_2
import okhttp3.TlsVersion.TLS_1_3
import okhttp3.testing.PlatformRule
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.HeldCertificate