val newMaxFrameSize = 16777215
    val writer = Http2Writer(Buffer(), true)
    writer.applyAndAckSettings(Settings().set(Settings.MAX_FRAME_SIZE, newMaxFrameSize))
    assertThat(writer.maxDataLength()).isEqualTo(newMaxFrameSize)
    writer.frameHeader(0, newMaxFrameSize, Http2.TYPE_DATA, FLAG_NONE)
  }

  @Test fun streamIdHasReservedBit() {
    val writer = Http2Writer(Buffer(), true)

    return byteSink.wasStreamClosed();
  }

  @Override
  public Writer openStream() throws IOException {
    // using TestByteSink's output stream to get option behavior, so flush to it on every write
    return new FilterWriter(new OutputStreamWriter(byteSink.openStream(), UTF_8)) {
      @Override
      public void write(int c) throws IOException {
        super.write(c);
        flush();
      }

      @Override

				// Check same i
			} else {
				if lri.Writer {
					writers++
				} else {
					readers++
				}
				// Move to next
				i++
			}
		}
		if modified {
			l.lockMap[k] = lris
		}
	}
	t := time.Now()
	l.lastCleanup.Store(&t)
	l.readers.Store(readers)
	l.writers.Store(writers)
}

func newLocker() *localLocker {
	return &localLocker{

	return other
}

// WriteCSV - encodes to CSV data.
func (r *Record) WriteCSV(writer io.Writer, opts sql.WriteCSVOpts) error {
	w := csv.NewWriter(writer)
	w.Comma = opts.FieldDelimiter
	w.AlwaysQuote = opts.AlwaysQuote
	w.Quote = opts.Quote
	w.QuoteEscape = opts.QuoteEscape
	if err := w.Write(r.csvRecord); err != nil {
		return err
	}
	w.Flush()
	return w.Error()
}

      throws IOException {
    StringWriter writer = new StringWriter();
    try (OutputStream encodingStream = encoding.encodingStream(writer)) {
      encodingStream.write(decoded.getBytes(UTF_8));
    }
    assertThat(writer.toString()).isEqualTo(encoded);
  }

  @GwtIncompatible // Reader
  private static void testStreamingDecodes(BaseEncoding encoding, String encoded, String decoded)
      throws IOException {

        try {
            Files.createDirectories(resumeProperties.getParent());
            try (Writer writer = Files.newBufferedWriter(resumeProperties)) {
                properties.store(writer, null);
            }
        } catch (IOException e) {
            String message = "Could not create " + RESUME_PROPERTIES_FILENAME + " file.";

}

// Decode reads from readers, reconstructs data if needed and writes the data to the writer.
// A set of preferred drives can be supplied. In that case they will be used and the data reconstructed.
func (e Erasure) Decode(ctx context.Context, writer io.Writer, readers []io.ReaderAt, offset, length, totalLength int64, prefer []bool) (written int64, derr error) {
	if offset < 0 || length < 0 {

                // Add newline at end for Windows 'for /f' command compatibility
                try (Writer writer = Files.newBufferedWriter(outputFile, StandardCharsets.UTF_8)) {
                    writer.write(result);
                    if (!result.isEmpty()) {
                        writer.write(System.lineSeparator());
                    }
                }
            } else {
                System.out.print(result);

    @Override
    public void write(Writer output, Map<String, Object> options, PersistedToolchains toolchains) throws IOException {
        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(toolchains, "toolchains cannot be null");

        try (Writer out = output) {
            new MavenToolchainsStaxWriter().write(out, toolchains.getDelegate());

type Dialector interface {
	Name() string
	Initialize(*DB) error
	Migrator(db *DB) Migrator
	DataTypeOf(*schema.Field) string
	DefaultValueOf(*schema.Field) clause.Expression
	BindVarTo(writer clause.Writer, stmt *Statement, v interface{})
	QuoteTo(clause.Writer, string)
	Explain(sql string, vars ...interface{}) string
}

// Plugin GORM plugin interface
type Plugin interface {
	Name() string
	Initialize(*DB) error
}