this.end = end;
    }

    @Override
    public int size() {
      return end - start;
    }

    @Override
    public boolean isEmpty() {
      return false;
    }

    @Override
    public Integer get(int index) {
      checkElementIndex(index, size());
      return array[start + index];
    }

    @Override
    /*

public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {

  }

  private abstract static class FailToForward extends ForwardingObject implements Runnable {
    @Override
    public void run() {}
  }

  private abstract static class ForwardToDelegate extends ForwardingObject implements Runnable {
    @Override
    public void run() {
      delegate().run();
    }

    @Override
    protected abstract Runnable delegate();
  }

    }

    @Override
    public Iterator<T> iterator() {
      return Iterators.unmodifiableIterator(iterable.iterator());
    }

    @Override
    public void forEach(Consumer<? super T> action) {
      iterable.forEach(action);
    }

    @SuppressWarnings("unchecked") // safe upcast, assuming no one has a crazy Spliterator subclass
    @Override
    public Spliterator<T> spliterator() {

        }
      }
    };
  }

  @Override
  public int size() {
    Set<E> delegate = delegateOrNull();
    return (delegate != null) ? delegate.size() : size;
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public @Nullable Object[] toArray() {
    if (needsAllocArrays()) {
      return new Object[0];

    private static final long FAILURE_RECOVERY_TIME = 600000; // 10 minutes

    @Override
    public SmbTransportImpl getSmbTransport(final CIFSContext tc, final Address address, final int port, final boolean nonPooled) {
        return getSmbTransport(tc, address, port, tc.getConfig().getLocalAddr(), tc.getConfig().getLocalPort(), null, nonPooled);
    }

    @Override

    override val subprojects = objectMapper.readValue<List<Map<String, Any>>>(jsonFile.readText()).map { toSubproject(it) }

    private val nameToSubproject = subprojects.map { it.name to it }.toMap()

    override fun getSubprojectsForFunctionalTest(testConfig: TestCoverage) = subprojects.filter { it.hasTestsOf(testConfig.testType) }

    override fun getSubprojectByName(name: String) = nameToSubproject[name]

      this.interfaceType = interfaceType;
    }

    @Override
    protected @Nullable Object handleInvocation(
        Object proxy, Method method, @Nullable Object[] args) {
      return interfaceMethodCalled(interfaceType, method);
    }

    @Override
    public int hashCode() {
      return identity;
    }

    @Override
    public boolean equals(@Nullable Object obj) {

            return roles;
        }

        @Override
        public boolean getApiAccessTokenRequiredAsBoolean() {
            return false;
        }
    }

    static class MockSystemHelper extends SystemHelper {
        @Override
        public long getCurrentTimeAsLong() {
            return System.currentTimeMillis();
        }

        @Override
        public String getSearchRoleByRole(String role) {

    connection.connectionListener.connectionAcquired(connection, call)
    return connection
  }

  override fun trackFailure(
    call: RealCall,
    e: IOException?,
  ) {
    // Do nothing.
  }

  override fun noNewExchanges() {
    // Do nothing.
  }

  override fun cancel() {
    canceled = true
    // Close the raw socket so we don't end up doing synchronous I/O.