func (config *TierConfigMgr) getDriver(ctx context.Context, tierName string) (d WarmBackend, err error) {
	config.Lock()
	defer config.Unlock()

	var ok bool
	// Lookup in-memory drivercache
	d, ok = config.drivercache[tierName]
	if ok {
		return d, nil
	}

	// Initialize driver from tier config matching tierName
	t, ok := config.Tiers[tierName]
	if !ok {

pkg go/constant, type Value interface, String() string
pkg go/constant, type Value interface, unexported methods
pkg go/importer, func Default() types.Importer
pkg go/importer, func For(string, Lookup) types.Importer
pkg go/importer, type Lookup func(string) (io.ReadCloser, error)
pkg go/parser, func ParseExprFrom(*token.FileSet, string, interface{}, Mode) (ast.Expr, error)
pkg go/types, const Bool = 1
pkg go/types, const Bool BasicKind

    "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",

pkg os/user, type Group struct, Name string
pkg os/user, type UnknownGroupError string
pkg os/user, type UnknownGroupIdError string
pkg reflect, func StructOf([]StructField) Type
pkg reflect, method (StructTag) Lookup(string) (string, bool)
pkg runtime, func CallersFrames([]uintptr) *Frames
pkg runtime, func KeepAlive(interface{})
pkg runtime, func SetCgoTraceback(int, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer)

     * 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 -> {

			// ~1.5-3x faster than Rabin-Karp since n is small.
			c0 := b[last]
			c1 := b[last-1] // There are at least 2 chars to match
		loop:
			for ; i < len(s); i++ {
				if s[i] == c0 && s[i-1] == c1 {
					for k := 2; k < n; k++ {
						if s[i-k] != b[last-k] {
							continue loop
						}
					}
					return i - last
				}
			}
		}
		return -1
	}
}

	shutdownCtx    context.Context
	serviceMetrics *metrics
}

// Enabled returns if AuthNPlugin is enabled.
func Enabled(kvs config.KVS) bool {
	return kvs.Get(URL) != ""
}

// LookupConfig lookup AuthNPlugin from config, override with any ENVs.
func LookupConfig(kv config.KVS, transport *http.Transport, closeRespFn func(io.ReadCloser), serverRegion string) (Args, error) {
	args := Args{}

pkg net, method (*Resolver) LookupHost(context.Context, string) ([]string, error)
pkg net, method (*Resolver) LookupIPAddr(context.Context, string) ([]IPAddr, error)
pkg net, method (*Resolver) LookupMX(context.Context, string) ([]*MX, error)
pkg net, method (*Resolver) LookupNS(context.Context, string) ([]*NS, error)
pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)

        SmbResourceLocatorImpl bad = locator("smb://badhost/");
        CIFSException ex = assertThrows(CIFSException.class, bad::getAddress);
        assertTrue(ex.getMessage().contains("Failed to lookup address"));
    }

    @Test
    @DisplayName("hashCode/equals based on address or server fallback")
    void testEqualsAndHashCode() throws Exception {
        UniAddress a = mock(UniAddress.class);

    @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);