// https://www.iana.org/domains/root/db/schwarz.html
schwarz

// science : dot Science Limited
// https://www.iana.org/domains/root/db/science.html
science

// scot : Dot Scot Registry Limited
// https://www.iana.org/domains/root/db/scot.html
scot

// search : Charleston Road Registry Inc.
// https://www.iana.org/domains/root/db/search.html
search

// seat : SEAT, S.A. (Sociedad Unipersonal)

gov.ng
gov.nl
gov.nr
gov.om
gov.ph
gov.pk
gov.pl
gov.pn
gov.pr
gov.ps
gov.pt
gov.py
gov.qa
gov.rs
gov.ru
gov.rw
gov.sa
gov.sb
gov.sc
gov.scot
gov.sd
gov.sg
gov.sh
gov.sl
gov.so
gov.ss
gov.sx
gov.sy
gov.tj
gov.tl
gov.tm
gov.tn
gov.to
gov.tr
gov.tt
gov.tw
gov.ua
gov.uk
gov.vc

gov.ng
gov.nl
gov.nr
gov.om
gov.ph
gov.pk
gov.pl
gov.pn
gov.pr
gov.ps
gov.pt
gov.py
gov.qa
gov.rs
gov.ru
gov.rw
gov.sa
gov.sb
gov.sc
gov.scot
gov.sd
gov.sg
gov.sh
gov.sl
gov.so
gov.ss
gov.sx
gov.sy
gov.tj
gov.tl
gov.tm
gov.tn
gov.to
gov.tr
gov.tt
gov.tw
gov.ua
gov.uk
gov.vc

    void cacheCapacityAndRetrievalOrder() {
        BufferCacheImpl impl = new BufferCacheImpl(2, 3);
        byte[] a = new byte[1];
        byte[] c = new byte[2];
        byte[] d = new byte[4];

        impl.releaseBuffer(a); // goes to slot 0
        impl.releaseBuffer(c); // goes to slot 1
        impl.releaseBuffer(d); // dropped (cache full)

 */
@SuppressSignatureCheck
class YubikeyClientAuth {
  fun run() {
    // The typical PKCS11 slot, may vary with different hardware.
    val slot = 0

    val config = "--name=OpenSC\nlibrary=/Library/OpenSC/lib/opensc-pkcs11.so\nslot=$slot\n"

    // May fail with ProviderException with root cause like
    // sun.security.pkcs11.wrapper.PKCS11Exception: CKR_SLOT_ID_INVALID

   * the capacity, it is doubled in size unless some other thread
   * holds the lock. If a hashed slot is empty, and lock is
   * available, a new Cell is created. Otherwise, if the slot
   * exists, a CAS is tried.  Retries proceed by "double hashing",
   * using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads

   * the capacity, it is doubled in size unless some other thread
   * holds the lock. If a hashed slot is empty, and lock is
   * available, a new Cell is created. Otherwise, if the slot
   * exists, a CAS is tried.  Retries proceed by "double hashing",
   * using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads

import configurations.applyDefaults
import configurations.applyTestDefaults
import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import io.mockk.mockk
import io.mockk.slot
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.DslContext
import model.CIBuildModel

import java.util.Enumeration;
import java.util.Iterator;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * Adapter to convert an {@link Enumeration} to an {@link Iterator}.
 *
 * @author shot
 * @param <T> the element type
 */
public class EnumerationIterator<T> implements Iterator<T> {

    private Enumeration<T> enumeration = null;

    /**

import java.io.IOException;
import java.io.OutputStream;

import org.codelibs.core.exception.IORuntimeException;

/**
 * Utility class for {@link OutputStream} operations.
 *
 * @author shot
 */
public abstract class OutputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected OutputStreamUtil() {
    }

    /**
     * Creates a {@link FileOutputStream}.
     *