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

// This file implements a regression test harness for syntax errors.
// The files in the testdata directory are parsed and the reported
// errors are compared against the errors declared in those files.
//
// Errors are declared in place in the form of "error comments",
// just before (or on the same line as) the offending token.
//

//
// The tree consists of err itself, followed by the errors obtained by repeatedly
// calling its Unwrap() error or Unwrap() []error method. When err wraps multiple
// errors, As examines err followed by a depth-first traversal of its children.
//
// An error matches target if the error's concrete value is assignable to the value
// pointed to by target, or if the error has a method As(any) bool such that

// representation. A nil error is converted to an empty string, and all other
// errors are converted to a JSON-marshaled parseError struct, with ErrorList
// set for errors of type scanner.ErrorList, and ErrorString set to the error's
// string representation for all other errors.
func parseErrorToString(err error) string {
	if err == nil {
		return ""
	}
	var p parseError

 * ExecutionException}, the error's {@linkplain #getCause() cause} comes from a failed task,
 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk

 * ExecutionException}, the error's {@linkplain #getCause() cause} comes from a failed task,
 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk

package syscall

import (
	"errors"
	"internal/oserror"
	"runtime"
	"unsafe"
)

const ImplementsGetwd = true
const bitSize16 = 2

// ErrorString implements Error's String method by returning itself.
//
// ErrorString values can be tested against error values using [errors.Is].
// For example:
//
//	_, _, err := syscall.Syscall(...)
//	if errors.Is(err, fs.ErrNotExist) ...
type ErrorString string

// by returning the item, and collapses all NoMatchErrors to a single one (since they should all be the same)
func collapseAggregateErrors(errors []error) error {
	if len(errors) == 0 {
		return nil
	}
	if len(errors) == 1 {
		return errors[0]
	}

	allNoMatchErrors := true
	for _, err := range errors {
		allNoMatchErrors = allNoMatchErrors && IsNoMatchError(err)
	}

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"
)

import (
	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

// We reset the line numbering to test that
// the formatting works independent of line directives
//line :19

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"

	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

import (

	errors := Strategy.Validate(context.TODO(), obj)
	if len(errors) != 2 {
		t.Errorf("Expected 2 validation errors for invalid object, got %d", len(errors))
	}

	oldObj := newServiceCIDR()
	newObj := oldObj.DeepCopy()
	newObj.Spec.CIDRs = []string{"bad cidr"}
	errors = Strategy.ValidateUpdate(context.TODO(), newObj, oldObj)
	if len(errors) != 2 {

package errors_test

import (
	"errors"
	"reflect"
	"testing"
)

func TestJoinReturnsNil(t *testing.T) {
	if err := errors.Join(); err != nil {
		t.Errorf("errors.Join() = %v, want nil", err)
	}
	if err := errors.Join(nil); err != nil {
		t.Errorf("errors.Join(nil) = %v, want nil", err)
	}
	if err := errors.Join(nil, nil); err != nil {
		t.Errorf("errors.Join(nil, nil) = %v, want nil", err)
	}
}