* <li>If <code>type</code> is a parameterized type, its raw type is returned.</li>
     * <li>If <code>type</code> is a wildcard type, its (first) upper bound is returned.</li>
     * <li>If <code>type</code> is an array, the raw class of its elements is returned.</li>
     * <li>Otherwise, <code>null</code> is returned.</li>
     * </ul>
     *
     * @param type

        AppConfigurationEntry e = entries[0];
        Map<String, ?> returned = e.getOptions();

        // Assert
        assertNotNull(returned, "Returned options should not be null");
        assertEquals("true", returned.get("useKeyTab"));
        assertEquals("true", returned.get("storeKey"));
        assertEquals("******@****.***", returned.get("principal"));
        // Ensure no unexpected extra options

  /**
   * Returns a view that associates each column key with the corresponding map from row keys to
   * values. Changes to the returned map will update this table. The returned map does not support
   * {@code put()} or {@code putAll()}, or {@code setValue()} on its entries.
   *
   * <p>In contrast, the maps returned by {@code columnMap().get()} have the same behavior as those

			}
			if !returned {
				funcReturnedMu.Lock()
				returned = funcReturned
				funcReturnedMu.Unlock()
				outCh <- entry
				if returned {
					xioutil.SafeClose(outCh)
				}
			}
			entry.reusable = returned
			saveCh <- entry
		}
		if !returned {
			xioutil.SafeClose(outCh)
		}
		xioutil.SafeClose(saveCh)
	}()

	entries, err = filteredResults()
	if err == nil {

    /**
     * Returns an {@link Iterable} that wraps a {@link SingleValueIterator} for use in a for-each statement.
     *
     * @param <E> the element type
     * @param value the single value returned by the iterator
     * @return an {@link Iterable} wrapping a {@link SingleValueIterator}
     */
    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);
    }

        // Assert: Verify that the returned user name is the expected one
        assertEquals(expectedUserName, actualUserName, "getRemoteUser should return the principal's name.");
    }

    /**
     * Test method for {@link NtlmHttpServletRequest#getUserPrincipal()}.
     * Verifies that the method returns the correct principal object.
     */
    @Test
    void testGetUserPrincipal() {

// read operation that read at least one byte. If a write has happened since
// the last read, if the last read returned an error, or if the read read zero
// bytes, UnreadByte returns an error.
func (b *Buffer) UnreadByte() error {
	if b.lastRead == opInvalid {
		return errUnreadByte
	}
	b.lastRead = opInvalid
	if b.off > 0 {
		b.off--
	}
	return nil
}

   * ClosingFuture, ClosingFuture)} to start this combination.
   *
   * @param <V1> the type returned by the first future
   * @param <V2> the type returned by the second future
   * @param <V3> the type returned by the third future
   * @param <V4> the type returned by the fourth future
   * @param <V5> the type returned by the fifth future
   */
  public static final class Combiner5<
          V1 extends @Nullable Object,

		var returned bool
		for entry := range in {
			if returned {
				// past limit
				continue
			}
			returned = done.Load()
			if returned {
				resCh = nil
				continue
			}
			if yes := o.shouldSkip(ctx, entry); yes {
				// when we have not enough results, record the skipped entry
				if o.Limit > 0 && results.len() < o.Limit {
					results.lastSkippedEntry = entry.name
				}
				continue
			}

     *
     * @return the selectedPreauthHash
     */
    public int getSelectedPreauthHash() {
        return this.selectedPreauthHash;
    }

    /**
     * Gets the capabilities returned by the server.
     *
     * @return the server returned capabilities
     */
    public final int getCapabilities() {
        return this.capabilities;
    }

    /**