f.Add(v)
	}

	var mu sync.Mutex
	var before, after []byte
	f.Cleanup(func() {
		sort.Slice(after, func(i, j int) bool { return after[i] < after[j] })
		got := string(before) + string(after)
		want := "abcabc"
		if got != want {
			f.Fatalf("got %q; want %q", got, want)
		}
	})

	f.Fuzz(func(t *testing.T, b []byte) {
		before = append(before, b...)
		t.Parallel()
		mu.Lock()
		after = append(after, b...)

     * @throws Exception
     */
    @Test
    public void testSubstringFromLast() throws Exception {
        assertEquals("ab", StringUtil.substringFromLast("abc", "c"));
        assertEquals("abcab", StringUtil.substringFromLast("abcabc", "c"));
        assertEquals("abc", StringUtil.substringFromLast("abc", ""));
        assertEquals("abc", StringUtil.substringFromLast("abc", null));

				if err != nil {
					t.Errorf("i=%d, firstN=%d, flush=%t: NewWriter: %v", i, firstN, flush, err)
					continue
				}
				for _, n := range tc {
					want = append(want, abcabc[:n]...)
					if _, err := w.Write(abcabc[:n]); err != nil {
						t.Errorf("i=%d, firstN=%d, flush=%t: Write: %v", i, firstN, flush, err)
						continue outer
					}
					if !flush {
						continue
					}

BE	^a$			a		(0,1)
BE	abc			abc		(0,3)
BE	abc			xabcy		(1,4)
BE	abc			ababc		(2,5)
BE	ab*c			abc		(0,3)
BE	ab*bc			abc		(0,3)
BE	ab*bc			abbc		(0,4)
BE	ab*bc			abbbbc		(0,6)
E	ab+bc			abbc		(0,4)
E	ab+bc			abbbbc		(0,6)
E	ab?bc			abbc		(0,4)
E	ab?bc			abc		(0,3)
E	ab?c			abc		(0,3)
BE	^abc$			abc		(0,3)
BE	^abc			abcc		(0,3)
BE	abc$			aabc		(1,4)
BE	^			abc		(0,0)
BE	$			abc		(3,3)
BE	a.c			abc		(0,3)

limitations under the License.
*/

// Package abac authorizes Kubernetes API actions using an Attribute-based access control scheme.
package abac

import (
	"bufio"
	"context"
	"fmt"
	"os"
	"strings"

	"k8s.io/klog/v2"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apiserver/pkg/authentication/user"
	"k8s.io/apiserver/pkg/authorization/authorizer"
	"k8s.io/kubernetes/pkg/apis/abac"

{"apiVersion": "abac.authorization.kubernetes.io/v1beta1", "kind": "Policy", "spec": {"user":"admin", "namespace": "*", "resource": "*", "apiGroup": "*", "nonResourcePath": "*"}}
{"apiVersion": "abac.authorization.kubernetes.io/v1beta1", "kind": "Policy", "spec": {"user":"{{kube_user}}", "namespace": "*", "resource": "*", "apiGroup": "*", "nonResourcePath": "*"}}

	// of a character.
	{"[a-c]*", "x", "\u65e5", "x\u65e5x"},
	{"[^\u65e5]", "x", "abc\u65e5def", "xxx\u65e5xxx"},

	// Start and end of a string.
	{"^[a-c]*", "x", "abcdabc", "xdabc"},
	{"[a-c]*$", "x", "abcdabc", "abcdx"},
	{"^[a-c]*$", "x", "abcdabc", "abcdabc"},
	{"^[a-c]*", "x", "abc", "x"},
	{"[a-c]*$", "x", "abc", "x"},
	{"^[a-c]*$", "x", "abc", "x"},
	{"^[a-c]*", "x", "dabce", "xdabce"},

:HA#281:E	(ab|a|c|bcd){1,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
#:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(3,6)(6,6)
:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
#:HA#283:E	(ab|a|c|bcd){3,}(d*)	ababcd	(0,6)(3,6)(6,6)
:HA#283:E	(ab|a|c|bcd){3,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
:HA#284:E	(ab|a|c|bcd){4,}(d*)	ababcd	NOMATCH
#:HA#285:E	(ab|a|c|bcd){0,10}(d*)	ababcd	(0,6)(3,6)(6,6)

import spock.lang.*

class PgpKeyIdSpec extends Specification  {

    protected key(arg) {
        new PgpKeyId(arg)
    }

    def "conversion is symmetrical"() {
        expect:
        key("ABCDABCD").asHex == "ABCDABCD"
    }

    def "conversion"() {
        expect:
        key(hex).asLong == decimal
        key(decimal).asHex == hex

        where:
        hex        | decimal
        "AAAAAAAA" | 2863311530

						{"/xyz%30..//abc", "/xyz%30..//abc"},
						{"/app/%2E./admin", "/app/%2E./admin"},
						{`/app\admin`, `/app\admin`},
						{`/app/\/\/\admin`, `/app/\/\/\admin`},
						{`/%2Fapp%5cadmin%5Cabc`, `/%2Fapp%5cadmin%5Cabc`},
						{`/%5Capp%2f%5c%2F%2e%2e%2fadmin%5c\abc`, `/%5Capp%2f%5c%2F%2e%2e%2fadmin%5c\abc`},
						{`/app//../admin`, `/app//../admin`},
						{`/app//../../admin`, `/app//../../admin`},
					},
				},