fun setClient(client: Boolean) {
    if (this.client == client) return
    this.client = client
    writer = Http2Writer(bytesOut, client)
  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  /** Count of frames sent or received.  */
  fun frameCount(): Int = frameCount

	creatorFAT    = 0
	creatorUnix   = 3
	creatorNTFS   = 11
	creatorVFAT   = 14
	creatorMacOSX = 19

	// Version numbers.
	zipVersion20 = 20 // 2.0
	zipVersion45 = 45 // 4.5 (reads and writes zip64 archives)

	// Limits for non zip64 files.
	uint16max = (1 << 16) - 1
	uint32max = (1 << 32) - 1

	// Extra header IDs.
	//
	// IDs 0..31 are reserved for official use by PKWARE.

    }

    /**
     * Verify that writeParameterWordsWireFormat writes the file id and the
     * unsigned time correctly.  The last write time is zero which should be
     * encoded as four 0xFF bytes by {@code writeUTime}.
     */
    @ParameterizedTest(name = "fid={0}, lastWriteTime={1}")
    @MethodSource("validParams")
    @DisplayName("happy: writeParameterWordsWireFormat writes correct bytes")

    }

    /**
     * Writes setup data in wire format
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     * @return number of bytes written
     */
    protected abstract int writeSetupWireFormat(byte[] dst, int dstIndex);

    /**
     * Writes parameters in wire format
     * @param dst destination buffer

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
                PrintWriter writer = new PrintWriter(baos, false, Constants.CHARSET_UTF_8)) {
            exception.printStackTrace(writer);
            writer.flush();
            append(buf, "exception", () -> StringEscapeUtils.escapeJson(new String(baos.toByteArray(), Constants.CHARSET_UTF_8)));

        return FormatType.OTHER;
    }

    /**
     * Writes text content to the HTTP response with specified content type and encoding.
     * @param text The text content to write.
     * @param contentType The content type for the response.
     * @param encoding The character encoding for the response.
     */
    protected void write(final String text, final String contentType, final String encoding) {

                writeFesenCat(zos, diagnosticId);
                writeFesenJson(zos, diagnosticId);
            }
        });
    }

    /**
     * Writes OpenSearch JSON API responses to the ZIP output stream.
     *
     * @param zos the ZIP output stream to write to
     * @param id the diagnostic ID for organizing files in the ZIP
     */
    protected void writeFesenJson(final ZipOutputStream zos, final String id) {

	w := NewWriter(io.Discard)
	dw, err := w.Create("dir/")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := dw.Write(nil); err != nil {
		t.Errorf("Write(nil) to directory: got %v, want nil", err)
	}
	if _, err := dw.Write([]byte("hello")); err == nil {
		t.Error(`Write("hello") to directory: got nil error, want non-nil`)
	}
}

func TestWriterDirAttributes(t *testing.T) {
	var buf bytes.Buffer

	if !corruptedMultipart {
		var writer io.Writer
		var err error
		if noFilename {
			writer, err = w.CreateFormField("file")
		} else {
			writer, err = w.CreateFormFile("file", "upload.txt")
		}
		if err != nil {
			// return nil, err
			return nil, err
		}
		writer.Write(objData)
		// Close before creating the new request.
		w.Close()
	}

		b = append(b, ' ')
		w.Write(b)
	}
	w.Flush()
	// Output: 1 2 3 4
}

// ExampleWriter_ReadFrom demonstrates how to use the ReadFrom method of Writer.
func ExampleWriter_ReadFrom() {
	var buf bytes.Buffer
	writer := bufio.NewWriter(&buf)

	data := "Hello, world!\nThis is a ReadFrom example."
	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {