AtomicInteger count = new AtomicInteger();
    Exception e = new IllegalStateException("exception to trigger failure on first load()");
    CacheLoader<Integer, String> failOnceFunction =
        new CacheLoader<Integer, String>() {

          @Override
          public String load(Integer key) throws Exception {
            if (count.getAndIncrement() == 0) {
              throw e;
            }

    assertThat(frqC).isNotSameInstanceAs(sepFrqC);
    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())
    // then FRQ does not bother to load Finalizer.class through a separate ClassLoader. That happens

     * This method is called automatically by the dependency injection framework
     * and loads the initial related query configurations.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing {}", this.getClass().getSimpleName());
        }
        load();
    }

    /**

set maven.installation.conf default ${maven.conf}

[plexus.core]
load       ${maven.conf}/logging
optionally ${maven.home}/lib/ext/redisson/*.jar
optionally ${maven.home}/lib/ext/hazelcast/*.jar
optionally ${user.home}/.m2/ext/*.jar
optionally ${maven.home}/lib/ext/*.jar
load       ${maven.home}/lib/maven-*.jar

        Doc(
            """
            Load and use Google Fonts.
            """
        ),
    ] = True,
) -> HTMLResponse:
    """
    Generate and return the HTML response that loads ReDoc for the alternative
    API docs (normally served at `/redoc`).

    You would only call this function yourself if you needed to override some parts,
    for example the URLs to use to load ReDoc's JavaScript and CSS.

* worker processes: worker processes (do not translate to "procesos trabajadores" or "procesos de trabajo")
* worker: worker (do not translate to "trabajador")
* load balancer: load balancer (do not translate to "balanceador de carga")
* load balance: load balance (do not translate to "balancear carga")
* self hosting: self hosting (do not translate to "auto alojamiento")

        assertEquals(user, chain3.lastDeletedUser);
    }

    // Test load with no chains
    @Test
    public void test_load_noChains() {
        User user = createTestUser("testuser");
        User result = authenticationManager.load(user);
        assertEquals(user, result);
    }

    // Test load with single chain
    @Test
    public void test_load_singleChain() {

        this.filterCacheExpireAfterWrite = filterCacheExpireAfterWrite;
    }

    /**
     * Sets the maximum load size for the cache.
     * @param maxLoadSize The maximum load size.
     */
    public void setMaxLoadSize(final int maxLoadSize) {
        this.maxLoadSize = maxLoadSize;
    }

			group := path.Dir(item)
			if err := iamOS.loadGroup(ctx, group, cache.iamGroupsMap); err != nil && err != errNoSuchGroup {
				return fmt.Errorf("unable to load the group: %w", err)
			}
		}
		if took := time.Since(groupsLoadStartTime); took > maxIAMLoadOpTime {
			logger.Info("Groups load took %.2fs (for %d items)", took.Seconds(), len(groupsList))
		}
	}

	bootstrapTraceMsgFirstTime("loading user policy mapping")

            logger.info("Rejecting request due to high CPU load: path={}, cpu={}%, threshold={}%", path, cpuPercent, threshold);
        }

        if (isApiPath) {
            sendApiResponse(httpResponse);
        } else {
            httpResponse.sendError(429);
        }
    }

    /**
     * Checks if the given path should be excluded from load control.
     * @param path the request path