# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

-- go.work --
go 1.21

use (
    ./a
    ./b
)
-- a/go.mod --

# https://go.dev/issue/51473: to avoid the need for tests to rely on
# runtime.GOROOT, 'go test' should run the test with its own GOROOT/bin
# at the beginning of $PATH.

[short] skip

[!GOOS:plan9] env PATH=
[GOOS:plan9] env path=
go test .

[!GOOS:plan9] env PATH=$WORK${/}bin
[GOOS:plan9] env path=$WORK${/}bin
go test .

-- go.mod --
module example

go 1.19
-- example_test.go --
package example

import (
	"os"

     */
    interface BuildTree extends BuildSession {}

    /**
     * These services are created once per {@code org.gradle.api.initialization.Settings} the beginning of the build invocation
     * These services are closed at the end of the build invocation.
     *
     * <p>{@link BuildTree} and parent scope services are visible to {@link Build} scope services, but not vice versa.</p>

// license that can be found in the LICENSE file.

// Tests that when non-existent files are passed to the
// compiler, such as in:
//    go tool compile foo
// we don't print the beginning position:
//    foo:0: open foo: no such file or directory
// but instead omit it and print out:
//    open foo: no such file or directory

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"

 * <p>
 * The coordinates are expected to be zero indexed.
 */
public interface OffsetInFileLocation extends FileLocation {

    /**
     * The global offset from the beginning of the file.
     *
     * @return the zero-indexed the offset
     */
    int getOffset();

    /**
     * The content of the content starting from {@link #getOffset()}.
     *
     * @return the length

	}
	b := r.s[r.i]
	r.i++
	return b, nil
}

// UnreadByte implements the [io.ByteScanner] interface.
func (r *Reader) UnreadByte() error {
	if r.i <= 0 {
		return errors.New("strings.Reader.UnreadByte: at beginning of string")
	}
	r.prevRune = -1
	r.i--
	return nil
}

// ReadRune implements the [io.RuneReader] interface.
func (r *Reader) ReadRune() (ch rune, size int, err error) {
	if r.i >= int64(len(r.s)) {

    }

    /**
     * Moves the cursor to the beginning of the line below.
     *
     * @return this Ansi instance
     */
    public Ansi cursorDownLine() {
        return appendEscapeSequence('E');
    }

    /**
     * Moves the cursor to the beginning of the n-th line below. If the parameter n is negative it
     * moves the cursor to the beginning of the n-th line above.
     *

// Issue 20298: "imported and not used" error report order was non-deterministic.
// This test works by limiting the number of errors (-e=0)
// and checking that the errors are all at the beginning.

package p

import (
	"bufio"       // ERROR "imported and not used"
	"bytes"       // ERROR "imported and not used"
	"crypto/x509" // ERROR "imported and not used"

                // been published yet. In that case we adjust the constraint to include
                // source distributions beginning from the previous major version.
                "${previous(major)}.0"
            }
            else -> {
                // Otherwise include source distributions beginning from the previous minor version only.
                "$major.${previous(minor)}"
            }
        }
    }

	// method to return a handle that uses ordinary synchronous I/O.”
	// However, LockFileEx still requires an OVERLAPPED structure,
	// which contains the file offset of the beginning of the lock range.
	// We want to lock the entire file, so we leave the offset as zero.
	ol := new(syscall.Overlapped)

	err := windows.LockFileEx(syscall.Handle(f.Fd()), uint32(lt), reserved, allBytes, allBytes, ol)