interface Intf {
    fun run()
}

abstract class Ordinary

annotation class Anno

@Anno
class Generic<T> : Ordinary(), Intf {
    override fun run() {}
}

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

sealed class Operation {
    class Add(val firstValue: Int, val secondValue: Int) : Operation()
    class Subtract(val minuend: Int, val subtrahend: Int) : Operation()
    class Negate(val value: Int) : Operation()

env GO111MODULE=on

# If the working directory is a different GOROOT, then the 'std' module should be
# treated as an ordinary module (with an ordinary module prefix).
# It should not override packages in GOROOT, but should not fail the command.
# See golang.org/issue/30756.
go list -e -deps -f '{{.ImportPath}} {{.Dir}}' ./bytes
stdout ^std/bytes.*$PWD[/\\]bytes
stdout '^bytes/modified'

-- go.mod --
module std

go 1.12
-- bytes/bytes.go --

        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in <root>.Ordinary'
          INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Generic modality:FINAL visibility:public superTypes:[<root>.Ordinary; <root>.Intf]'

		// All paths that a dollar pattern matches end in a slash; no paths that
		// an ordinary pattern matches do. So only other dollar or multi
		// patterns can conflict with a dollar pattern. Furthermore, conflicting
		// dollar patterns must have the {$} in the same position.
		return apply(idx.segments[routingIndexKey{s: "/", pos: len(pat.segments) - 1}])
	}
	// For ordinary and multi patterns, the only conflicts can be with a multi,

# go list should work in ordinary conditions.
go list ./...
! stdout _data

# skip in conditions where chmod 0 may not work.
# plan9 should be fine, but copied from list_perm.txt unchanged.
[root] skip
[GOOS:windows] skip
[GOOS:plan9] skip

# go list should work with unreadable _data directory.
chmod 0 _data
go list ./...
! stdout _data

-- go.mod --
module m

-- x.go --
package m

-- _data/x.go --

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

#include "go_asm.h"
#include "go_tls.h"
#include "textflag.h"

// This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program.
TEXT _rt0_arm64_windows(SB),NOSPLIT|NOFRAME,$0
	B	·rt0_go(SB)

TEXT _rt0_arm64_windows_lib(SB),NOSPLIT|NOFRAME,$0
	MOVD	$_rt0_arm64_windows_lib_go(SB), R0
	MOVD	$0, R1

type (
        C[T any] interface{~int; M() T}

        _ C[bool]
        _ comparable
        _ interface {~[]byte | ~string}

        // Alias type declarations may refer to "constraint" types
        // like ordinary type declarations.
        _ = C[bool]
        _ = comparable
        _ = interface {~[]byte | ~string}

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

#include "go_asm.h"
#include "go_tls.h"
#include "textflag.h"

// This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program.
TEXT _rt0_arm_windows(SB),NOSPLIT|NOFRAME,$0

    }

    def "can re-add an ordinary value after removal"() {
        when:
        source.add("a")
        source.add("b")
        source.remove("a")

        then:
        source.iterator().collect() == ["b"]

        when:
        source.add("a")

        then:
        source.iterator().collect() == ["b", "a"]
    }

    def "can re-add an ordinary value after clear"() {
        when:

# This test requires external linking. Assume that if cgo is supported
# then external linking works.
[!cgo] skip 'requires a C linker'

# Only run on Unix systems.
[GOOS:windows] skip
[GOOS:plan9] skip

# Ordinary build should work.
go build
exec ./hello
stdout Hello

# Building with -linkmode=external should not say anything about
# runtime/cgo (issue #31544).
go build -ldflags=-linkmode=external
! stderr runtime/cgo