OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File("encoded.out")), "utf-8");
                    writer.write(content);
                    writer.close();
                }
            }
        """

        def file = file("src/main/java/Main.java")
        file.parentFile.mkdirs()
        file.withWriter(encoding) { writer ->
            writer.write(code)
        }

// errors if any.
func (pr execProber) Probe(e exec.Cmd) (probe.Result, string, error) {
	var dataBuffer bytes.Buffer
	writer := ioutils.LimitWriter(&dataBuffer, maxReadLength)

	e.SetStderr(writer)
	e.SetStdout(writer)
	err := e.Start()
	if err == nil {
		err = e.Wait()
	}
	data := dataBuffer.Bytes()

	klog.V(4).Infof("Exec probe response: %q", string(data))
	if err != nil {

        try {
            objectWriter.write(message);
        } catch (ObjectStreamException e) {
            throw new RecoverableMessageIOException(String.format("Could not write message %s to '%s'.", message, remoteAddress), e);
        } catch (ClassNotFoundException e) {
            throw new RecoverableMessageIOException(String.format("Could not write message %s to '%s'.", message, remoteAddress), e);

	}
	if !v.Valid() {
		return v, fmt.Errorf("unknown or unsupported trace version go 1.%d", v)
	}
	return v, nil
}

// WriteHeader writes a header for a trace version v to w.
func WriteHeader(w io.Writer, v Version) (int, error) {
	return fmt.Fprintf(w, headerFmt, v)

	case StatePruning:
		p.bar.SetTemplateString(inProgress + `Pruning removed resources`)
		p.bar.Write()
	case StateComplete:
		p.bar.SetTemplateString(`{{ green "✅" }} Installation complete`)
		p.bar.Write()
	case StateUninstallComplete:
		p.bar.SetTemplateString(`{{ green "✅" }} Uninstall complete`)
		p.bar.Write()
	}
}

func (p *Log) NewComponent(component string) *ManifestLog {
	ml := &ManifestLog{

	//  1. If LogWriter is present, log to it.
	//  2. If DebugDir is present, log to a file within it.
	//  3. If both LogWriter and DebugDir are present, log to a multi writer.
	//  4. If neither LogWriter nor DebugDir are present, log to a noop logger.
	var logWriters []io.Writer
	logFile, err := debugLogFile(dir.DebugDir())
	if err != nil {
		logFile = nil
	}
	if logFile != nil {
		logWriters = append(logWriters, logFile)
	}

		w.WriteHeader(200)
		if _, err := w.Write([]byte("x")); err == nil {
			t.Errorf("Write to body after 101 Switching Protocols unexpectedly succeeded")
		}

		c, _, err := NewResponseController(w).Hijack()
		if err != nil {
			t.Errorf("Hijack: %v", err)
			return
		}
		defer c.Close()
		if _, err := c.Write([]byte(wantBody)); err != nil {
			t.Errorf("Write to hijacked body: %v", err)
		}

	-coverprofile cover.out
	    Write a coverage profile to the file after all tests have passed.
	    Sets -cover.

	-cpuprofile cpu.out
	    Write a CPU profile to the specified file before exiting.
	    Writes test binary as -c would.

	-memprofile mem.out
	    Write an allocation profile to the file after all tests have passed.
	    Writes test binary as -c would.

	-memprofilerate n

				// concurrently, check for it before we
				// write the filler byte.
				select {
				case err := <-doneCh:
					if err != nil {
						write([]byte{1})
						write([]byte(err.Error()))
					} else {
						write([]byte{0})
					}
					return
				default:
				}

				// Response not ready, write a filler byte.
				write([]byte{32})
				if canWrite {
					w.(http.Flusher).Flush()

}

// traceFrequency writes a batch with a single EvFrequency event.
//
// freq is the number of trace clock units per second.
func traceFrequency(gen uintptr) {
	w := unsafeTraceWriter(gen, nil)

	// Ensure we have a place to write to.
	w, _ = w.ensure(1 + traceBytesPerNumber /* traceEvFrequency + frequency */)

	// Write out the string.
	w.byte(byte(traceEvFrequency))