if tc.ok && len(errs) > 0 {
			t.Errorf("[%d] unexpected errors: %v", i, errs)
		} else if !tc.ok && len(errs) == 0 {
			t.Errorf("[%d] expected error type %v", i, tc.errtype)
		} else if len(errs) > 1 {
			t.Errorf("[%d] expected only one error, got %d", i, len(errs))
		} else if !tc.ok {
			if errs[0].Type != tc.errtype {
				t.Errorf("[%d] expected error type %v, got %v", i, tc.errtype, errs[0].Type)
			}

        "properties": {
          "field": {

pkg syscall (freebsd-arm64), func Dup2(int, int) error
pkg syscall (freebsd-arm64), func Fchdir(int) error
pkg syscall (freebsd-arm64), func Fchflags(int, int) error
pkg syscall (freebsd-arm64), func Fchmod(int, uint32) error
pkg syscall (freebsd-arm64), func Fchown(int, int, int) error
pkg syscall (freebsd-arm64), func FcntlFlock(uintptr, int, *Flock_t) error
pkg syscall (freebsd-arm64), func Flock(int, int) error

		{"(*Scanner).Scan", Method, 0},
		{"(Error).Error", Method, 0},
		{"(ErrorList).Err", Method, 0},
		{"(ErrorList).Error", Method, 0},
		{"(ErrorList).Len", Method, 0},
		{"(ErrorList).Less", Method, 0},
		{"(ErrorList).Sort", Method, 0},
		{"(ErrorList).Swap", Method, 0},
		{"Error", Type, 0},
		{"Error.Msg", Field, 0},
		{"Error.Pos", Field, 0},
		{"ErrorHandler", Type, 0},

            properties:
              failStrategy:
                description: |-
                  Specifies the failure behavior for the plugin due to fatal errors.

                  Valid Options: FAIL_CLOSE, FAIL_OPEN
                enum:
                - FAIL_CLOSE
                - FAIL_OPEN
                type: string
              imagePullPolicy:

    *   One MUST NOT access `tensorflow::errors::Code` fields. Accessing
        `tensorflow::error::Code` fields is fine.
        *   Use the constructors such as `tensorflow::errors:InvalidArgument` to
            create status using an error code without accessing it.
        *   Use the free functions such as
            `tensorflow::errors::IsInvalidArgument` if needed.

                              description: Minimum ejection duration.
                              type: string
                            consecutive5xxErrors:
                              description: Number of 5xx errors before a host is ejected
                                from the connection pool.
                              nullable: true
                              type: integer
                            consecutiveErrors:

`bad_indices_policy`, the op will either return an error or ignore the
out-of-bound indices. `bad_indices_policy` can be one of the following values:
1. "" or "DEFAULT": raises on CPU and ignore on GPU. This is because
   historically on CPU and GPU we handle errors in different ways, and for
   backward compatibility we keep the default behavior.
2. "ERROR": raises error; GPU does not support this value.

  - `kubectl` outputs warnings to stderr, and accepts a `--warnings-as-errors` option to treat warnings as fatal errors
  - `k8s.io/client-go` outputs warnings to stderr by default; override this per-client by setting `config.WarningHandler`, or per-process with `rest.SetDefaultWarningHandler()`

			t.Errorf("%s(%d) = %d, want %d\n", test.fnname, test.in, got, test.want)
		}
	}
	for _, test := range tests_int64mul {
		if got := test.fn(test.in); got != test.want {
			t.Errorf("%s(%d) = %d, want %d\n", test.fnname, test.in, got, test.want)
		}
	}
	for _, test := range tests_uint32 {
		if got := test.fn(test.in); got != test.want {