expect:
        def union1 = Specs.union(spec1, spec2)
        union1 instanceof OrSpec
        union1.specs == [spec1, spec2]

        def union2 = Specs.union([spec1, spec2])
        union2 instanceof OrSpec
        union2.specs == [spec1, spec2]
    }

    def "union of none is none"() {
        expect:
        Specs.union(Specs.satisfyNone()) == Specs.satisfyNone()

	},
	{
		// Check a pointer to a union if the union has any
		// pointer fields.
		name:    "union1",
		c:       `typedef union { char **p; unsigned long i; } u29; void f29(u29 *pu) {}`,
		imports: []string{"unsafe"},
		body:    `var b C.char; p := &b; C.f29((*C.u29)(unsafe.Pointer(&p)))`,
		fail:    true,
	},
	{
		// Don't check a pointer to a union if the union does
		// not have any pointer fields.

}

func (u *Union) Len() int         { return len(u.terms) }
func (u *Union) Term(i int) *Term { return u.terms[i] }

func (u *Union) Underlying() Type { return u }
func (u *Union) String() string   { return TypeString(u, nil) }

// A Term represents a term in a Union.
type Term term

// NewTerm returns a new union term.
func NewTerm(tilde bool, typ Type) *Term { return &Term{tilde, typ} }

}

func (u *Union) Len() int         { return len(u.terms) }
func (u *Union) Term(i int) *Term { return u.terms[i] }

func (u *Union) Underlying() Type { return u }
func (u *Union) String() string   { return TypeString(u, nil) }

// A Term represents a term in a [Union].
type Term term

// NewTerm returns a new union term.
func NewTerm(tilde bool, typ Type) *Term { return &Term{tilde, typ} }

	t90|t91|t92|t93|t94|t95|t96|t97|t98|t99|
        int // ERROR "cannot handle more than 100 union terms"
}

type u102 interface {
        int /* ERROR "cannot handle more than 100 union terms" */ |string|u100a
}

type u200 interface {
        u100a /* ERROR "cannot handle more than 100 union terms" */ |u100b

import java.util.Set;
import java.util.stream.Collectors;

class Unions {
    private final ExcludeFactory factory;

    public Unions(ExcludeFactory factory) {
        this.factory = factory;
    }

    /**
     * Tries to compute an union of 2 specs.
     * The result MUST be a simplification, otherwise this method returns null.
     */

)

// Union returns an audit Backend which logs events to a set of backends. The returned
// Sink implementation blocks in turn for each call to ProcessEvents.
func Union(backends ...Backend) Backend {
	if len(backends) == 1 {
		return backends[0]
	}
	return union{backends}
}

type union struct {
	backends []Backend
}

func (u union) ProcessEvents(events ...*auditinternal.Event) bool {

limitations under the License.
*/

// Package union implements an authorizer that combines multiple subauthorizer.
// The union authorizer iterates over each subauthorizer and returns the first
// decision that is either an Allow decision or a Deny decision. If a
// subauthorizer returns a NoOpinion, then the union authorizer moves onto the
// next authorizer or, if the subauthorizer was the last authorizer, returns

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package union

import (
	"context"

	utilerrors "k8s.io/apimachinery/pkg/util/errors"
	"k8s.io/apiserver/pkg/authentication/authenticator"
)

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package union

import (
	"net/http"

	utilerrors "k8s.io/apimachinery/pkg/util/errors"
	"k8s.io/apiserver/pkg/authentication/authenticator"
)