// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test a source file does not need a final newline.
// Compiles but does not run.

// No newline at the end of this file.

# Check that a newline is printed after the buffer's contents.
cd fail
! go test .
! stderr .
stdout '^exitcode=1\n'
stdout '^FAIL\s+example/fail'

# In local directory mode output is streamed, so we don't know
# whether the test printed anything at all, so we print the exit code
# (just in case it failed without emitting any output at all),
# and that happens to add the needed newline as well.
! go test
! stderr .

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// These error messages are for the invalid literals on lines 19 and 20:

// ERROR "newline in character literal|newline in rune literal"
// ERROR "invalid character literal \(missing closing '\)|rune literal not terminated"

const (
	_ = ''     // ERROR "empty character literal or unescaped ' in character literal|empty rune literal"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that a comment ending a source file does not need a final newline.
// Compiles but does not run.

package eof1

// parser after missing type. There should be exactly
// one error each time, with now follow errors.

package p

type T /* ERROR unexpected newline */

type Map map[int] /* ERROR unexpected newline */

// Examples from go.dev/issue/23434:

func g() {
	m := make(map[string] /* ERROR unexpected ! */ !)
	for {
		x := 1
		print(x)
	}
}

func f() {

		n++
	} else {
		n, err = rr.reader.Read(p)
	}

	if err != nil {
		return n, err
	}

	// Do nothing if record-delimiter is already newline.
	if string(rr.recordDelimiter) == "\n" {
		return n, nil
	}

	// Change record delimiters to newline.
	if len(rr.recordDelimiter) == 1 {
		for idx := 0; idx < len(p); {
			i := bytes.Index(p[idx:], rr.recordDelimiter)
			if i < 0 {
				break
			}

package main

func main() {
	var cu0 uint16 = '\u1234';
	var cU1 uint32 = '\U00101234';
	_, _ = cu0, cU1;
}
/*
bug13.go:4: missing '
bug13.go:4: syntax error
bug13.go:5: newline in string
bug13.go:5: missing '
bug13.go:6: newline in string

     */
    ExecutionResult assertOutputContains(String expectedOutput);

    /**
     * Asserts that the given content includes the given log message.
     *
     * @param content The content to check
     * @param expectedOutput The expected log message, with line endings normalized to a newline character.

package p

// accept Allman/BSD-style declaration but complain
// (implicit semicolon between signature and body)
func _() int
{ /* ERROR "unexpected semicolon or newline before {" */
	{ return 0 }
}

func _() {}

func _(); { /* ERROR "unexpected semicolon or newline before {" */ }

        writeOptionHeader(option);
        newLine();
        return this;
    }

    public JavadocOptionFileWriterContext writeValueOption(String option, String value) throws IOException {
        writeOptionHeader(option);
        writeValue(value);
        newLine();
        return this;
    }