// Set-based lookup should be significantly faster
        // Note: This is a rough check - exact performance depends on JVM, hardware, etc.
        // We expect Set lookup to be at least as fast as array lookup for large datasets
        assertTrue("Set-based lookup should be faster or comparable to array-based lookup for large datasets",

        queryFieldConfig.setSearchFields(fields);

        // Test field at the end (worst case for array lookup, but same for Set)
        String testField = "field999";

        // Warm up
        for (int i = 0; i < 100; i++) {
            queryCommand.isSearchField(testField);
        }

        // Measure Set-based lookup
        long startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {

	return word == "JMP" || word == "CALL" || word == "Call" || word == "Br" || word == "BrIf"
}

func archX86(linkArch *obj.LinkArch) *Arch {
	register := make(map[string]int16)
	// Create maps for easy lookup of instruction names etc.
	for i, s := range x86.Register {
		register[s] = int16(i + x86.REG_AL)
	}
	// Pseudo-registers.
	register["SB"] = RSB
	register["FP"] = RFP
	register["PC"] = RPC

        // Retrieve direct groups synchronously (parent group lookup is deferred)
        processDirectMemberOf(user, groupList, roleList, groupIdsForParentLookup, "https://graph.microsoft.com/v1.0/me/memberOf");

        if (logger.isDebugEnabled()) {
            logger.debug("[updateMemberOf] Direct groups retrieved. Total groups: {}, Total roles: {}, Group IDs for parent lookup: {}",

    this.allowsSelfLoops = builder.allowsSelfLoops;
    this.nodeOrder = builder.nodeOrder.cast();
    this.edgeOrder = builder.edgeOrder.cast();
    // Prefer the heavier "MapRetrievalCache" for nodes if lookup is expensive. This optimizes
    // methods that access the same node(s) repeatedly, such as Graphs.removeEdgesConnecting().
    this.nodeConnections =
        (nodeConnections instanceof TreeMap)

        scriptEngineFactory.add("name1", engine1);
        scriptEngineFactory.add("name2", engine2);

        // Both engines have same class name, so second should replace first for class name lookup
        ScriptEngine retrievedByClass = scriptEngineFactory.getScriptEngine("testscriptengine");
        assertEquals(engine2, retrievedByClass);

        // But original names should still work

    "path": "platforms/core-runtime/serialization",
    "unitTests": true,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "service-lookup",
    "path": "platforms/core-runtime/service-lookup",
    "unitTests": false,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "service-provider",

		if r >= utf8.RuneSelf {
			r, size = utf8.DecodeLastRune(s[0:i])
		}
		i -= size
		if f(r) == truth {
			return i
		}
	}
	return -1
}

// asciiSet is a 256-byte lookup table for fast ASCII character membership testing.
// Each element corresponds to an ASCII character value, with true indicating the
// character is in the set. Using bool instead of byte allows the compiler to

     * This method handles the resolution of SPNEGO credentials by checking
     * if the user is an admin user or needs to be authenticated through LDAP.
     *
     * @param resolver The credential resolver to use for user lookup
     */
    @Override
    public void resolveCredential(final LoginCredentialResolver resolver) {
        resolver.resolve(SpnegoCredential.class, credential -> {

    @Test
    public void test_getDataStore_nullName() {
        DataStore retrieved = dataStoreFactory.getDataStore(null);
        assertNull(retrieved);
    }

    // Test getDataStore with case insensitive lookup
    @Test
    public void test_getDataStore_caseInsensitive() {
        TestDataStore dataStore = new TestDataStore("TestStore");
        dataStoreFactory.add("MyStore", dataStore);