* @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap(Class<T> type);

    /**
     * Get the domain of the user account.
     * @return the domain the user account is in
     */
    String getUserDomain();

    /**
     * Check if these are anonymous credentials.
     * @return whether these are anonymous credentials
     */
    boolean isAnonymous();

            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                SmbComWriteAndXResponse response = invocation.getArgument(1);
                response.count = 1;
                return null;
            }
        }).when(smbFile).send(any(SmbComWriteAndX.class), any(SmbComWriteAndXResponse.class));

        smbRandomAccessFile.write(42);

	}

	// As the session policy exists, even if the parent is the root account, it
	// must be restricted by it. So, we set `.IsOwner` to false here
	// unconditionally.
	//
	// We also set `DenyOnly` arg to false here - this is an IMPORTANT corner
	// case: DenyOnly is used only for allowing an account to do actions related
	// to its own account (like create service accounts for itself, among

            final byte[] buf = buffer.array();
            int len;
            int amount = 0;
            while ((len = ChannelUtil.read(channel, buffer, amount)) != -1) {
                out.write(buf, 0, len);
                buffer.clear();
                amount += len;
            }
            out.flush();
            return amount;
        } catch (final IOException e) {
            throw new IORuntimeException(e);

}

// AddServiceAccount - add a new service account
func (store *IAMStoreSys) AddServiceAccount(ctx context.Context, cred auth.Credentials) (updatedAt time.Time, err error) {
	cache := store.lock()
	defer store.unlock()

	accessKey := cred.AccessKey
	parentUser := cred.ParentUser

	// Found newly requested service account, to be an existing account -

            bytesReader.reset(synonym.output.bytes, synonym.output.offset, synonym.output.length);
            final int code = bytesReader.readVInt();
            final int count = code >>> 1;
            for (int i = 0; i < count; i++) {
                synonymMap.words.get(bytesReader.readVInt(), scratchBytes);
                if (scratchChars.chars.length < scratchBytes.length) {

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * {@code ObjectCountHashMap} uses arrays to store key objects and count values. Comparing to using
 * a traditional {@code HashMap} implementation which stores keys and count values as map entries,
 * {@code ObjectCountHashMap} minimizes object allocation and reduces memory footprint.
 *

  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  private void testSupplierThreadSafe(Function<Supplier<Boolean>, Supplier<Boolean>> memoizer)
      throws Throwable {
    AtomicInteger count = new AtomicInteger(0);
    AtomicReference<Throwable> thrown = new AtomicReference<>(null);
    int numThreads = 3;
    Thread[] threads = new Thread[numThreads];
    long timeout = SECONDS.toNanos(60);

  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  private void testSupplierThreadSafe(Function<Supplier<Boolean>, Supplier<Boolean>> memoizer)
      throws Throwable {
    AtomicInteger count = new AtomicInteger(0);
    AtomicReference<Throwable> thrown = new AtomicReference<>(null);
    int numThreads = 3;
    Thread[] threads = new Thread[numThreads];
    long timeout = SECONDS.toNanos(60);

    assertThrows(NullPointerException.class, () -> copyOf((Iterator<String>) c));
  }

  private static class CountingIterable implements Iterable<String> {
    int count = 0;

    @Override
    public Iterator<String> iterator() {
      count++;
      return Iterators.forArray("a", "b", "a");
    }
  }

  public void testCopyOf_plainIterable() {
    CountingIterable iterable = new CountingIterable();