import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/** Returns a random portion of the requested bytes on each call. */
@NullUnmarked
class RandomAmountInputStream extends FilterInputStream {
  private final Random random;

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.close();
  }

  private static boolean isAndroid() {
    return System.getProperty("java.runtime.name", "").contains("Android");
  }

  private static boolean isWindows() {
    return OS_NAME.value().startsWith("Windows");
  }

    // Returns -1 if the DOS code is not mapped.
    private static int findNtStatusOrMinusOne(int dosCode) {
        for (int[] pair : DosError.DOS_ERROR_CODES) {
            // each pair is [dosCode, ntStatus]
            if (pair != null && pair.length == 2 && pair[0] == dosCode) {
                return pair[1];
            }
        }
        return -1;
    }

        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
  ): Response =

    /**
     * Gets the chained AndX command
     * @return the andx
     */
    public final ServerMessageBlock getAndx() {
        return this.andx;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#getNext()
     */
    @Override
    public ServerMessageBlock getNext() {
        return this.andx;
    }

    /**
     * {@inheritDoc}

     * <p>If multiple configurations exist with the same name, returns the first one
     * ordered by sort order ascending.</p>
     *
     * @param name the name of the data configuration to retrieve
     * @return an OptionalEntity containing the DataConfig if found, empty otherwise
     * @throws IllegalArgumentException if name is null or empty
     */
    public OptionalEntity<DataConfig> getDataConfigByName(final String name) {

                    }
                    return result;
                default:
                    return 0;
            }
        }

        public StringItem getStringPart() {
            return stringPart;
        }

        public Item getDigitPart() {
            return digitPart;
        }

        @Override
        public int getType() {
            return COMBINATION_ITEM;
        }

    }

    @Test
    @DisplayName("Test readSetupWireFormat returns 0")
    void testReadSetupWireFormat() {
        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] buffer = new byte[256];
        int read = trans2SetFileInfo.readSetupWireFormat(buffer, 0, buffer.length);

        // Should always return 0
        assertEquals(0, read);
    }

    @Test

    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**
   * Returns the {@link HashCode} based on the data written to this stream. The result is
   * unspecified if this method is called more than once on the same instance.
   */
  public HashCode hash() {
    return hasher.hash();
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:

 * should also handle resource cleanup when the {@link #close()} method is called.</p>
 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *
     * @return a map containing the document's data, or null if there are no more documents to read.
     */
    Map<String, Object> read();

    @Override
    void close();