* domain. Add DFS roots to the list.
             */
            try {
                entries = doDfsRootEnum();
                for (final FileEntry entry : entries) {
                    e = entry;
                    if (!map.containsKey(e)) {
                        map.put(e, e);
                    }
                }
            } catch (final IOException ioe) {

                "LEGACY_KERBEROS_MECHANISM", "1.2.840.48018.1.2.2", "NTLMSSP_MECHANISM", "1.3.6.1.4.1.311.2.2.10");

        for (Map.Entry<String, String> e : expected.entrySet()) {
            Field f = SpnegoConstants.class.getField(e.getKey());
            int m = f.getModifiers();

            assertTrue(Modifier.isPublic(m), e.getKey() + " must be public");

     */
    public String term;

    /**
     * Related queries string containing associated search queries.
     */
    public String queries;

    /**
     * User who created the related query entry.
     */
    public String createdBy;

    /**
     * Timestamp when the related query was created.
     */
    public String createdTime;

    /**
     * Version number for optimistic locking.
     */

    /**
     * Flag to restart the directory enumeration from the beginning.
     */
    public static final byte SMB2_RESTART_SCANS = 0x1;

    /**
     * Flag to return only a single directory entry.
     */
    public static final byte SMB2_RETURN_SINGLE_ENTRY = 0x2;

    /**
     * Flag indicating that the file index field contains a valid index.
     */
    public static final byte SMB2_INDEX_SPECIFIED = 0x4;

			} else {
				break
			}
			n++
		}

		// Prompt for decryption key if no --key or --private-key are provided
		if len(privateKeys) == 0 && !*stdin {
			reader := bufio.NewReader(os.Stdin)
			fmt.Print("Enter Decryption Key: ")

			text, _ := reader.ReadString('\n')
			// convert CRLF to LF
			*keyHex = strings.ReplaceAll(text, "\n", "")
			*keyHex = strings.TrimSpace(*keyHex)
		}
	}

	var inputs []string

		return errFileNotFound
	}
	if cache.status == scanStateSuccess || cache.status == scanStateStarted {
		if time.Since(cache.lastUpdate) > metacacheMaxRunningAge {
			// We got a stale entry, mark error on handling server.
			err := fmt.Errorf("timeout: list %s not updated", cache.id)
			cache.error = err.Error()
			cache.status = scanStateError
			rpc.UpdateMetacacheListing(ctx, cache)
			return err
		}

	// Returns the last time this disk (re)-connected
	LastConn() time.Time

	// Indicates if disk is local or not.
	IsLocal() bool

	// Returns hostname if disk is remote.
	Hostname() string

	// Returns the entire endpoint.
	Endpoint() Endpoint

	// Close the disk, mark it purposefully closed, only implemented for remote disks.
	Close() error

	// Returns the unique 'uuid' of this disk.
	GetDiskID() (string, error)

# The Runnable type is so generic that it produces too many false positives.
TYPE java.lang.Runnable

FIELD com.google.common.base.Converter.reverse
FIELD com.google.common.collect.AbstractBiMap.EntrySet.iterator.$.entry com.google.common.collect.AbstractBiMap.EntrySet.iterator.$.next.$
FIELD com.google.common.collect.AbstractMapBasedMultimap.map

    Map<Object, Object> result = cache.getAll(asList(lookupKeys));
    assertThat(result.keySet()).containsExactlyElementsIn(asList(lookupKeys));
    for (Entry<Object, Object> entry : result.entrySet()) {
      Object key = entry.getKey();
      Object value = entry.getValue();
      assertSame(value, result.get(key));
      assertNull(result.get(value));
      assertSame(value, cache.asMap().get(key));

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresent() {
    assertEquals(v0(), getMap().replace(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresentNoChange() {
    assertEquals(v0(), getMap().replace(k0(), v0()));