}

    @Override
    public void writeExternal(final ObjectOutput s) throws IOException {
        s.writeInt(size);
        for (Entry e = header.next; e != header; e = e.next) {
            s.writeObject(e.element);
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    public void readExternal(final ObjectInput s) throws IOException, ClassNotFoundException {
        final int size = s.readInt();

        assertEquals(-128, response.getServerData().serverTimeZone);
        assertEquals(8, response.getServerData().encryptionKeyLength);
    }

    @Test
    public void testReadBytesWireFormatWithoutExtendedSecurity() throws UnsupportedEncodingException {
        response.getServerData().scapabilities = 0;
        response.getServerData().encryptionKeyLength = 8;
        // Domain name in OEM encoding (ASCII) with null terminator

        assertDoesNotThrow(() -> cache.resolveSids(handle, policy, sids));
    }

    @Test
    @DisplayName("resolveSids(DcerpcHandle,...) throws SmbException on unexpected retval")
    void resolveSids_throwsOnUnexpectedRetval() throws Exception {
        SIDCacheImpl cache = new SIDCacheImpl(mock(CIFSContext.class));
        DcerpcHandle handle = mock(DcerpcHandle.class);

     * @param req the HTTP servlet request
     * @param resp the HTTP servlet response
     * @param file the SMB file to download
     * @throws IOException if an I/O error occurs
     */
    protected void doFile(final HttpServletRequest req, final HttpServletResponse resp, final SmbFile file) throws IOException {
        final byte[] buf = new byte[8192];
        String url, type;
        int n;

     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }

    /**
     * Gets the type flags of this security descriptor.
     *

            generateContents(tempDir, count);

            return tempDir;
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

    private static void generateContents(final File dir, final int count) throws Exception {
        if (count <= 0) {
            return;
        }

        final String content = getHtmlContent(count);

    return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override
      public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (blocklist.contains(name)) {
          throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
        }
        if (name.startsWith(concurrentPackage)) {
          Class<?> c = findLoadedClass(name);

                    if (lmHash.length == 0 && ntHash.length == 0) {
                        throw new RuntimeException("Null setup prohibited.");
                    }
                } else if (DISABLE_PLAIN_TEXT_PASSWORDS) {
                    throw new RuntimeException("Plain text passwords are disabled");
                } else if (useUnicode) {
                    // plain text

  /**
   * @throws IllegalArgumentException if another entry in the bucket has the same key
   * @throws BucketOverflowException if this bucket has too many entries, which may indicate a hash
   *     flooding attack
   */
  private static void checkNoConflictInValueBucket(
      Object value, Entry<?, ?> entry, @Nullable ImmutableMapEntry<?, ?> valueBucketHead)
      throws BucketOverflowException {

        return 0;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) throws SMBProtocolDecodingException {
        if (len > this.outputBuffer.length) {
            throw new SMBProtocolDecodingException("Payload exceeds buffer size");
        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;
    }