this.ntlmsspFlags &= msg2.getFlags();
            final Type3Message msg3 = createType3Message(msg2);
            msg3.setupMIC(this.type1Bytes, token);

            final byte[] out = msg3.toByteArray();

            if (log.isTraceEnabled()) {
                log.trace(msg3.toString());
                log.trace(Hexdump.toHexString(token));
            }

            this.masterKey = msg3.getMasterKey();

      out.write(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {
      out.write(b, off, len);
    }

    byte[] bytes() {
      return out.toByteArray();
    }

    void assertBytes(byte[] expected) {
      assertArrayEquals(expected, bytes());
    }

    @Override
    public HashCode hash() {
      return HashCode.fromBytesNoCopy(bytes());

        final Object obj = binaryTransformer.getData(accessResultData);
        assertNotNull(obj);
        assertTrue(obj instanceof InputStream);
        assertEquals("xyz", new String(IOUtils.toByteArray((InputStream) obj)));
    }

    public void test_getData_wrongName() throws Exception {
        final AccessResultDataImpl accessResultData = new AccessResultDataImpl();

    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    new ObjectOutputStream(bytes).writeObject(object);
    return new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray())).readObject();
  }

                final Type1Message type1 = new Type1Message(src);
                final Type2Message type2 = new Type2Message(tc, type1, challenge, null);
                msg = new String(Base64.encode(type2.toByteArray()), "US-ASCII");
                resp.setHeader("WWW-Authenticate", "NTLM " + msg);
            } else if (src[8] == 3) {
                final Type3Message type3 = new Type3Message(src);

     */
    public void setSuppliedWorkstation(final String suppliedWorkstation) {
        this.suppliedWorkstation = suppliedWorkstation;
    }

    @Override
    public byte[] toByteArray() {
        try {
            int flags = getFlags();
            int size = 8 * 4 + ((flags & NTLMSSP_NEGOTIATE_VERSION) != 0 ? 8 : 0);

            byte[] domain = {};

                return; // no NTLM
            }
            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                connection.setRequestProperty(authProperty, authMethod + ' ' + Base64.encode(type1.toByteArray()));
                connection.connect(); // send type 1
                response = parseResponseCode();
                if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {
                    return;

        assertArgumentNotNull("is", is);

        final ByteArrayOutputStream os = new ByteArrayOutputStream(BUF_SIZE);
        CopyUtil.copy(is, os);
        return os.toByteArray();
    }

    /**
     * A method that wraps exception handling for {@link InputStream#available()}.
     *
     * @param is the input stream (must not be {@literal null})
     * @return the available size

            final ObjectOutputStream oos = new ObjectOutputStream(baos);
            try {
                oos.writeObject(obj);
            } finally {
                oos.close();
            }
            return baos.toByteArray();
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**
     * Converts a byte array to an object.
     *

        this.mechanismListMIC = mechanismListMIC;
    }

    /**
     * Encodes this SPNEGO token to a byte array
     * @return the encoded token bytes
     */
    public abstract byte[] toByteArray();

    /**
     * Parses the provided token bytes to populate this SPNEGO token
     * @param token the token bytes to parse
     * @throws IOException if parsing fails
     */