private final int inputIndex;

    public PotentialInput(int inputIndex) {
        this.inputIndex = inputIndex;
    }

    public Object get(List<ModelView<?>> views) {
        return views.get(inputIndex).getInstance();
    }

  override fun isCleartextTrafficPermitted(hostname: String): Boolean =
    when {
      Build.VERSION.SDK_INT >= 24 -> NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted(hostname)
      Build.VERSION.SDK_INT >= 23 -> NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted
      else -> true
    }

  override fun buildCertificateChainCleaner(trustManager: X509TrustManager): CertificateChainCleaner =

public class NativeOsMemoryInfo implements OsMemoryInfo {

    @Override
    public OsMemoryStatus getOsSnapshot() {
        try {
            Memory memory = NativeServices.getInstance().get(Memory.class);
            MemoryInfo memoryInfo = memory.getMemoryInfo();
            return new OsMemoryStatusSnapshot(memoryInfo.getTotalPhysicalMemory(), memoryInfo.getAvailablePhysicalMemory());

  @Override
  @CheckForNull
  public <T extends @NonNull B> T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  @Override
  @CheckForNull
  public <T extends @NonNull B> T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CanIgnoreReturnValue
  @CheckForNull

                else -> userHome().resolve(".gradle-kotlin-dsl/log")
            }
        }

    private
    fun now() = GregorianCalendar.getInstance().time

    private
    const val cleanupAfterDays = 1

    private
    const val logFilesExpireAfterDays = 7

    private
    fun cleanupLogDirectory(logDir: File) =

class ReleasingPortAllocator implements PortAllocator, TestRule {
    final PortAllocator delegate
    List<Integer> portsAllocated = new ArrayList<>()

    ReleasingPortAllocator() {
        this(FixedAvailablePortAllocator.getInstance())
    }

    ReleasingPortAllocator(PortAllocator delegate) {
        this.delegate = delegate
    }

    @Override
    int assignPort() {
        int port = delegate.assignPort()

        val id = instanceIds.size
        instanceIds[instance] = id
        return id
    }
}


class ReadIdentities {

    private
    val instanceIds = HashMap<Int, Any>()

    fun getInstance(id: Int) = instanceIds[id]

    fun putInstance(id: Int, instance: Any) {
        instanceIds[id] = instance
    }
}


class CircularReferences {

    private

        byte[] dataHmac = getHmac(dataChecksum, codeHmac);
        SecretKeySpec dataKey = new SecretKeySpec(dataHmac, KerberosConstants.RC4_ALGORITHM);

        cipher = Cipher.getInstance(KerberosConstants.RC4_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, dataKey);

        int plainDataLength = data.length - KerberosConstants.CHECKSUM_SIZE;

        }
        ModelType<T> type = getSubject().getType();
        ModelView<? extends T> view = node.asMutable(type, getDescriptor());
        try {
            execute(node, view.getInstance(), inputs);
        } finally {
            view.close();
        }
    }

    protected abstract void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs);

        ModelView<? extends T> subjectView = modelNode.asMutable(getSubject().getType(), descriptor);
        try {
            execute(invoker, subjectView.getInstance(), inputs);
        } finally {
            subjectView.close();
        }
    }

    protected abstract void execute(ModelRuleInvoker<?> invoker, T subject, List<ModelView<?>> inputs);