log.Fatal(err)
	}
}

func ExampleTempDir_suffix() {
	parentDir := os.TempDir()
	logsDir, err := ioutil.TempDir(parentDir, "*-logs")
	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(logsDir) // clean up

	// Logs can be cleaned out earlier if needed by searching
	// for all directories whose suffix ends in *-logs.
	globPattern := filepath.Join(parentDir, "*-logs")

var iptablesTrace = log.RegisterScope("iptables", "trace logs for iptables")

// ReadNFLOGSocket reads from the nflog socket, sending output to logs.
// This is intended for debugging only.
func ReadNFLOGSocket(ctx context.Context) {
	if !TraceLoggingEnabled {
		return
	}
	iptablesTrace.Infof("starting nftable log")

	func (c *B) Failed() bool

	// Fatal is equivalent to Log() followed by FailNow(). 
	func (c *B) Fatal(args ...any)

	// Fatalf is equivalent to Logf() followed by FailNow(). 
	func (c *B) Fatalf(format string, args ...any)

	// Log formats its arguments using default formatting, analogous ...
	func (c *B) Log(args ...any)

	// Logf formats its arguments according to the format, analogous ...

     * Convenience method that sets descriptions and logs started() event.
     *
     * @param status The initial status message. Can be null or empty.
     * @return this logger instance
     */
    ProgressLogger start(String description, String status);

    /**
     * Logs the start of the operation, with no initial status.
     */
    void started();

    /**
     * Logs the start of the operation, with the given status.

}

// Sync implements zapcore.Core. It sends log messages with HTTP POST.
func (u *udsCore) Sync() error {
	logs := u.logsFromBuffer()
	msg, err := json.Marshal(logs)
	if err != nil {
		return fmt.Errorf("failed to sync uds log: %v", err)
	}
	resp, err := u.client.Post(u.url, "application/json", bytes.NewReader(msg))
	if err != nil {
		return fmt.Errorf("failed to send logs to uds server %v: %v", u.url, err)
	}

      // expected
    }

    val logs = ShadowLog.getLogsForTag("testHttpLoggingInterceptor")
    assertThat(logs.map { it.type }).containsOnly(Log.INFO)
    assertThat(logs.map { it.msg }).containsExactly(
      "--> GET http://google.com/robots.txt",
      "<-- HTTP FAILED: java.net.UnknownHostException: shortcircuit",
    )
    // We should consider if these logs should retain Exceptions

// that it logs (using [log.Printf]) each write to standard error,
// printing the prefix and the hexadecimal data written.
func NewWriteLogger(prefix string, w io.Writer) io.Writer {
	return &writeLogger{prefix, w}
}

type readLogger struct {
	prefix string
	r      io.Reader
}

func (l *readLogger) Read(p []byte) (n int, err error) {
	n, err = l.r.Read(p)
	if err != nil {

	<-afterSecondLog // Delay the "PASS: TestInterruptor" line until after "CONT  TestLog".
}

func TestLog(t *testing.T) {
	t.Parallel()

	t.Logf("this is the first TestLog log")
	close(afterFirstLog)
	<-afterSubTest
	t.Logf("this is the second TestLog log")
	close(afterSecondLog)

slf4jLogger.info("An info log message logged using SLF4j")
// end::use-slf4j[]

// tag::use-logger[]
logger.quiet("An info log message which is always logged.")
logger.error("An error log message.")
logger.warn("A warning log message.")
logger.lifecycle("A lifecycle info log message.")
logger.info("An info log message.")
logger.debug("A debug log message.")
logger.trace("A trace log message.") // Gradle never logs TRACE level logs

#!/bin/bash

touch $(ls -d ./fess-*/logs)/fess-crawler.log
tail -f ./fess-*/logs/*.log &

mvn test -P integrationTests -Dtest.fess.url="http://localhost:8080" -Dtest.search_engine.url="http://localhost:9201"
ret=$?

if [ $ret != 0 ] ; then
  for f in `find ./target -type f | grep surefire-reports | grep -v /TEST-` ; do
    cat $f
  done
fi