super(out);
    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {
            throw new IOException("NetBIOS socket output buffer requires 4 bytes available before off");
        }

        off -= 4;

      throw new UnsupportedOperationException();
    }

    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable V putIfAbsent(K key, V value) {
      throw new UnsupportedOperationException();
    }

    @Override

     *
     * @throws CIFSException if an error occurs while opening the file
     */
    public void open() throws CIFSException {
        try (SmbFileHandleImpl fh = ensureOpen()) {}
    }

    /**
     * @param file
     * @param openFlags
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {

  }

  @Benchmark
  void oldRepeat(long reps) {
    for (int i = 0; i < reps; i++) {
      String x = oldRepeat(originalString, count);
      if (x.length() != (originalString.length() * count)) {
        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or

        try {
            server.start();
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

    public void stop() {
        try {
            server.stop();
            server.join();
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        } finally {
            if (tempDocRoot) {
                docRoot.delete();

     */
    public EmptyIterator() {
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

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

    @Override
    public T next() {
        throw new ClUnsupportedOperationException("next");
    }

            @Override
            public void deleteBefore(long time) {
                throw new RuntimeException("Crawling error");
            }
        };

        SearchLogService searchLogService = new SearchLogService() {
            @Override
            public void deleteBefore(int days) {
                throw new RuntimeException("Search error");
            }
        };

  @Override
  public final boolean addAll(int index, Collection<? extends E> newElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final E set(int index, E element) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final void add(int index, E element) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final E remove(int index) {

  }

  /** Returns a plan for the first attempt at [route]. This throws if no plan is possible. */
  @Throws(IOException::class)
  internal fun planConnectToRoute(
    route: Route,
    routes: List<Route>? = null,
  ): ConnectPlan {
    if (route.address.sslSocketFactory == null) {
      if (ConnectionSpec.CLEARTEXT !in route.address.connectionSpecs) {
        throw UnknownServiceException("CLEARTEXT communication not enabled for client")

        InputStream failingStream = new InputStream() {
            @Override
            public int read() throws IOException {
                throw new IOException("Test exception");
            }
        };

        try {
            stopwordsFile.reload(null, failingStream);
            fail("Should throw DictionaryException");
        } catch (DictionaryException e) {