//                                                                           Roll-back
    //                                                                           =========
    @Override
    public void rollback() {
        for (MultipartFormFile formFile : elementsFile.values()) {
            formFile.destroy();
        }
    }

    // ===================================================================================

            }

            @Override
            public String getSystemProperty(final String key) {
                return systemPropMap.get(key);
            }
        };

        // Test fallback to legacy aad.permission.fields key
        systemPropMap.put("aad.permission.fields", "mail,displayName");
        String[] fields = fessConfig.getEntraIdPermissionFields();
        assertEquals(2, fields.length);

	if !ok {
		// Prefix usage is empty
		return map[string]uint64{}, nil
	}

	cache := dataUsageCache{}

	prefixUsageCache.InitOnce(30*time.Second,
		// No need to fail upon Update() error, fallback to old value.
		cachevalue.Opts{ReturnLastGood: true, NoWait: true},
		func(ctx context.Context) (map[string]uint64, error) {
			m := make(map[string]uint64)
			for _, pool := range z.serverPools {

        // Then
        assertEquals(3, lanmanCompatibility, "Should delegate LanMan compatibility");
        assertTrue(allowNTLMFallback, "Should delegate NTLM fallback setting");
        assertFalse(useRawNTLM, "Should delegate raw NTLM setting");
        assertTrue(disablePlainTextPasswords, "Should delegate plain text password setting");

        }

        if (isSearchField(field)) {
            return fieldBuilder.buildQuery(field, text, boost);
        }

        // Fallback: treat as default field query
        context.addFieldLog(Constants.DEFAULT_FIELD, text);
        return buildDefaultQueryBuilder(fessConfig, context, defaultBuilder);
    }

        } else {
          routes += route
        }
      }

      if (routes.isNotEmpty()) {
        break
      }
    }

    if (routes.isEmpty()) {
      // We've exhausted all Proxies so fallback to the postponed routes.
      routes += postponedRoutes
      postponedRoutes.clear()
    }

    return Selection(routes)
  }

  /** Prepares the proxy servers to try. */
  private fun resetNextProxy(

    private Collection<WeakMojoExecutionListener> getProvidedListeners() {
        // the same instance can be provided multiple times under different Key's
        // deduplicate instances to avoid redundant beforeXXX/afterXXX callbacks
        IdentityHashMap<WeakMojoExecutionListener, Object> listeners = new IdentityHashMap<>();
        for (Object provided : getScopeState().provided()) {

        assertEquals(ChatIntent.SEARCH, result.getIntent());
        assertEquals(originalQuery, result.getQuery());
        assertNotNull(result.getReasoning());
        assertTrue(result.getReasoning().contains("Fallback"));
    }

    @Test
    public void test_fallbackSearch_withEmptyQuery() {
        final IntentDetectionResult result = IntentDetectionResult.fallbackSearch("");

 * authentication context without requiring users to explicitly enter credentials.
 *
 * The authenticator supports various configuration options including delegation,
 * basic authentication fallback, and localhost authentication bypass.
 */
public class SpnegoAuthenticator implements SsoAuthenticator {

    /** Logger for this class. */

                            duration.scenario ==
                                scenario.scenario
                        }
                    }.firstOrNull()
                    // Fallback for new performance tests (don't use 0 to avoid division by zero)
                    ?: PerformanceTestDuration(scenario.scenario, 1)
            })
            .entries