// Split by line, then ensure each line can fit into Log's maximum length.
      var i = 0
      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)
        newline = if (newline != -1) newline else length
        do {
          val end = minOf(newline, i + MAX_LOG_LENGTH)

        DfsReferralDataImpl dr = new DfsReferralDataImpl() {

            @Override
            public int getPathConsumed () {
                return 2 + hostname.length() + root.length() + path.length();
            }


            @Override
            public String getServer () {
                return getTestServer();
            }


            @Override

        checkArgument(
            fromUpperBounds.length == toUpperBounds.length
                && fromLowerBounds.length == toLowerBounds.length,
            "Incompatible type: %s vs. %s",
            fromWildcardType,
            to);
        for (int i = 0; i < fromUpperBounds.length; i++) {
          populateTypeMappings(mappings, fromUpperBounds[i], toUpperBounds[i]);
        }

            return new SuggestIndexResponse(items.length, items.length, result.getFailures(), System.currentTimeMillis() - start);
        } catch (final Exception e) {
            throw new SuggestIndexException("Failed to write items[" + items.length + "] to " + index, e);
        }
    }

    public SuggestDeleteResponse delete(final String id) {

                        ( session.auth.hashesExternal ||
                        session.auth.password.length() > 0 )) {

            if( session.transport.server.encryptedPasswords ) {
                // encrypted
                password = session.auth.getAnsiHash( session.transport.server.encryptionKey );
                passwordLength = password.length;
            } else if( DISABLE_PLAIN_TEXT_PASSWORDS ) {

            int idx = 0;
            if (idx < tok.length) {
                majorVersion = getNextIntegerToken(tok[idx++]);
                if (majorVersion == null) {
                    fallback = true;
                }
            } else {
                fallback = true;
            }
            if (idx < tok.length) {
                minorVersion = getNextIntegerToken(tok[idx++]);

    void set ( byte[] b ) {
        this.b = b == null ? new byte[0] : b;
    }


    byte[] get () {
        return this.b;
    }


    int length () {
        if ( this.b == null )
            return 0;
        return this.b.length;
    }


    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#clone()
     */
    @Override

    for (int i = 0; i < reps; i++) {
      for (int n = 0; n < chars.length; n++) {
        dummy ^= Ascii.isUpperCase(chars[n]);
      }
    }
    return dummy;
  }

  static String charSequenceToUpperCase(CharSequence chars) {
    char[] newChars = new char[chars.length()];
    for (int i = 0; i < newChars.length; i++) {
      newChars[i] = Ascii.toUpperCase(chars.charAt(i));
    }

        return t;
    }

    int type, length;


    /**
     * @param dst
     * @param dstIndex
     * @return written bytes
     */
    public int writeWireFormat ( byte[] dst, int dstIndex ) {
        this.length = writeTrailerWireFormat(dst, dstIndex + HEADER_LENGTH);
        writeHeaderWireFormat(dst, dstIndex);
        return HEADER_LENGTH + this.length;
    }

        for ( int ii = 0; ii < iaddrs.length; ii++ ) {
            addrs[ ii ] = new UniAddress(iaddrs[ ii ]);
        }
        return addrs;
    }


    private static UniAddress[] wrapNetbiosAddresses ( NetbiosAddress[] addr ) {
        UniAddress[] addrs = new UniAddress[addr.length];
        for ( int i = 0; i < addr.length; i++ ) {