if users2[idx].Manager == nil {
			t.Fatalf("Failed to load Manager")
		}
		// manager
		CheckUser(t, *user.Manager, *users2[idx].Manager)
		// user pet
		if users2[idx].NamedPet == nil {
			t.Fatalf("Failed to load NamedPet")
		}
		CheckPet(t, *user.NamedPet, *users2[idx].NamedPet)
		// manager pet
		if users2[idx].Manager.NamedPet == nil {
			t.Fatalf("Failed to load NamedPet")
		}

			info.Metrics = p.getMetrics()
		}
		info.Metrics.TotalWrites = p.totalWrites.Load()
		info.Metrics.TotalDeletes = p.totalDeletes.Load()
		info.Metrics.TotalWaiting = uint32(p.health.waiting.Load())
		info.Metrics.TotalErrorsTimeout = p.totalErrsTimeout.Load()
		info.Metrics.TotalErrorsAvailability = p.totalErrsAvailability.Load()
		if p.health.isFaulty() {

	if values == nil {
		values = make(url.Values)
	}
	values.Set(storageRESTDiskID, *client.diskID.Load())
	respBody, err := client.restClient.CallWithHTTPMethod(ctx, http.MethodGet, rpcMethod, values, body, length)
	if err != nil {
		return nil, toStorageErr(err)
	}
	return respBody, nil
}

options:
  # make root approval non-recursive
  no_parent_owners: true
approvers:
  - release-engineering-approvers
  - release-managers
  - release-team-subproject-leads
  - satyampsoni # 1.32 Release Notes Lead
reviewers:
  - release-managers
  - release-team-subproject-leads
  - satyampsoni # 1.32 Release Notes Lead
labels:
  - sig/release

        updateConfigListenerMap.put("PathMapping", () -> Integer.toString(ComponentUtil.getPathMappingHelper().load()));
        updateConfigListenerMap.put("RelatedContent", () -> Integer.toString(ComponentUtil.getRelatedContentHelper().load()));
        updateConfigListenerMap.put("RelatedQuery", () -> Integer.toString(ComponentUtil.getRelatedQueryHelper().load()));

    // Test load with exception
    public void test_load_withException() {
        TestAuthenticationChain chain = new TestAuthenticationChain();
        chain.loadThrowsException = true;
        User user = createTestUser("testuser", "Test User");

        try {
            chain.load(user);
            fail("Expected exception to be thrown");
        } catch (RuntimeException e) {

  /**
   * The instance that actually does the work; delegates to VarHandle, Unsafe, or a Java-8
   * compatible pure-Java fallback.
   */
  private static final LittleEndianBytes byteArray = makeGetter();

  /**
   * Load 8 bytes into long in a little endian manner, from the substring between position and
   * position + 8. The array must have at least 8 bytes from offset (inclusive).
   *
   * @param input the input bytes

    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;
            }

        assertEquals(user, chain3.lastDeletedUser);
    }

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

    // Test load with single chain
    public void test_load_singleChain() {
        User user = createTestUser("testuser");

			dump := make([]byte, len(enc))
			b.Run("UpdateObjectVersion", func(b *testing.B) {
				b.SetBytes(int64(size))
				b.ResetTimer()
				b.ReportAllocs()
				for b.Loop() {
					// Load...
					xl = xlMetaV2{}
					err := xl.Load(enc)
					if err != nil {
						b.Fatal(err)
					}
					// Update modtime for resorting...
					fi.ModTime = fi.ModTime.Add(-time.Second)
					// Update a random version.