doFirst {
        println('A task message which is logged at LIFECYCLE level')
        System.err.println('A task error message which is logged at WARN level')
    }
}

// START SNIPPET task-capture-stdout
task logInfo {
    logging.captureStandardOutput LogLevel.INFO
    doFirst {
        println 'A task message which is logged at INFO level'
    }
}
// END SNIPPET task-capture-stdout

task nestedBuildLog(type: GradleBuild) {

executable: gradle

// end::use-println[]

// tag::capture-stdout[]
logging.captureStandardOutput LogLevel.INFO
println 'A message which is logged at INFO level'
// end::capture-stdout[]

// tag::task-capture-stdout[]
tasks.register('logInfo') {
    logging.captureStandardOutput LogLevel.INFO
    doFirst {
        println 'A task message which is logged at INFO level'
    }
}
// end::task-capture-stdout[]

// tag::use-slf4j[]

// end::use-println[]

// tag::capture-stdout[]
logging.captureStandardOutput(LogLevel.INFO)
println("A message which is logged at INFO level")
// end::capture-stdout[]

// tag::task-capture-stdout[]
tasks.register("logInfo") {
    logging.captureStandardOutput(LogLevel.INFO)
    doFirst {
        println("A task message which is logged at INFO level")
    }
}

  unsetenv("TF_DUMP_GRAPH_PREFIX");

  std::string filepath = DumpMlirOpToFile("module", module_ref.get());
  EXPECT_EQ(filepath, "(TF_DUMP_GRAPH_PREFIX not specified)");
}

TEST(DumpMlirModuleTest, LogInfo) {
  mlir::MLIRContext context;
  mlir::OwningOpRef<mlir::ModuleOp> module_ref =
      mlir::ModuleOp::create(mlir::UnknownLoc::get(&context));
  setenv("TF_DUMP_GRAPH_PREFIX", "-", 1);

            'init callback quiet out')
        lifecycle(
            'LOGGER: evaluating :',
            'LOGGER: evaluating :project1',
            'LOGGER: evaluating :project2',
            'LOGGER: executing :project1:logInfo',
            'LOGGER: executing :project1:logLifecycle',
            'LOGGER: executing :project1:nestedBuildLog',
            'LOGGER: executing :project1:log'
        )
        info(

				CurrentTime:   time.Unix(1500, 0),
				KeyUsages:     test.requestedEKUs,
			}
			_, err = leafCert.Verify(verifyOpts)

			logInfo := true
			if len(test.expectedError) == 0 {
				if err != nil {
					t.Errorf("unexpected failure: %s", err)
				} else {
					logInfo = false
				}
			} else {
				if err == nil {
					t.Error("unexpected success")

	}

	api := operations.NewConsoleAPI(swaggerSpec)

	if !serverDebugLog {
		// Disable console logging if server debug log is not enabled
		noLog := func(string, ...interface{}) {}

		consoleapi.LogInfo = noLog
		consoleapi.LogError = noLog
		api.Logger = noLog
	}

	// Pass in console application config. This needs to happen before the
	// ConfigureAPI() call.

			addr, sock, srvWG := startServer(t, tr, "", done)
			defer srvWG.Wait()
			defer sock.Close()
			if tr == "unix" || tr == "unixgram" {
				defer os.Remove(addr)
			}
			s, err := Dial(tr, addr, LOG_INFO|LOG_USER, "syslog_test")
			if err != nil {
				t.Fatalf("Dial() failed: %v", err)
			}
			err = s.Info(msg)
			if err != nil {
				t.Fatalf("log failed: %v", err)
			}
			check(t, msg, <-done, tr)

func (w *Writer) Notice(m string) error {
	_, err := w.writeAndRetry(LOG_NOTICE, m)
	return err
}

// Info logs a message with severity [LOG_INFO], ignoring the severity
// passed to New.
func (w *Writer) Info(m string) error {
	_, err := w.writeAndRetry(LOG_INFO, m)
	return err
}

// Debug logs a message with severity [LOG_DEBUG], ignoring the severity
// passed to New.