*/
    @Override
    public Requirement clone() {
        try {
            return (Requirement) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new UnsupportedOperationException(e);
        }
    }

                    th.send(treq, RequestParam.NO_RETRY);
                }
            }
        }
        catch ( CIFSException e ) {
            throw SmbException.wrap(e);
        }
    }


    SmbFileOutputStream ( SmbFile file, SmbTreeHandleImpl th, SmbFileHandleImpl handle, int openFlags, int access, int sharing )
            throws CIFSException {

      extensionContext: ExtensionContext,
    ) {
      var failed = false
      try {
        invocation.proceed()
      } catch (e: TestAbortedException) {
        throw e
      } catch (e: Throwable) {
        failed = true
        rethrowIfNotExpected(e)
      } finally {
        resetPlatform()
      }
      if (!failed) {
        failIfExpected()
      }
    }

          return null
        }

        override fun contentLength(): Long {
          return Int.MAX_VALUE + 1L
        }

        override fun source(): BufferedSource {
          throw AssertionError()
        }
      }
    assertFailsWith<IOException> {
      body.bytes()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(

          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            @Throws(IOException::class)
            override fun close() {
              throw IOException("Broken!")
            }
          }.buffer()
        }
      }
    assertThat(body.source().readUtf8()).isEqualTo("hello")
    body.close()
  }

  @Test
  fun unicodeText() {

        inLen = 0;
        while(( n = is.read( in, inLen, IN_SIZE - inLen )) != -1 ) {
            inLen += n;
        }
        if( inLen < 100 || inLen == IN_SIZE ) {
            throw new IOException( "Error reading jcifs/smb1/util/mime.map resource" );
        }
        is.close();
    }

    public String getMimeType( String extension ) throws IOException {

   *     enter the {@link State#RUNNING} state. e.g. if the {@code state} is {@code
   *     State#TERMINATED} when this method is called then this will throw an IllegalStateException.
   * @since 15.0
   */
  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *

      UnhashableObject that = (UnhashableObject) object;
      return this.value == that.value;
    }
    return false;
  }

  @Override
  public int hashCode() {
    throw new UnsupportedOperationException();
  }

  // needed because otherwise Object.toString() calls hashCode()
  @Override
  public String toString() {
    return "DontHashMe" + value;
  }

  @Override

  fun onlyRoute() = routes.single()

  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    if (route == null) throw NullPointerException("route == null")
    responses += response
    routes += route
    if (!schemeMatches(response) || credential == null) return null
    val header =
      when (response.code) {

    }

    private static Method subscriberMethod() {
      try {
        return DummySubscriber.class.getMethod("handle", Object.class);
      } catch (NoSuchMethodException e) {
        throw new AssertionError(e);
      }
    }
  }