- stringMatch:
                                exact: audiences
                            - stringMatch:
                                prefix: audiences-prefix-
                            - stringMatch:
                                suffix: -suffix-audiences
                            - stringMatch:
                                safeRegex:

  "spec": {
    "token": "tokenValue",
    "audiences": [
      "audiencesValue"
    ]
  },
  "status": {
    "authenticated": true,
    "user": {
      "username": "usernameValue",
      "uid": "uidValue",
      "groups": [
        "groupsValue"
      ],
      "extra": {
        "extraKey": [
          "extraValue"
        ]
      }
    },
    "audiences": [
      "audiencesValue"
    ],

	}{
		{
			name:        "audience is in the expected set",
			expectRet:   true,
			audToCheck:  []string{"aud1"},
			audExpected: []string{"aud1", "aud2"},
		},
		{
			name:        "audience is NOT in the expected set",
			expectRet:   false,
			audToCheck:  []string{"aud3"},
			audExpected: []string{"aud1", "aud2"},
		},
		{
			name:        "one of the audiences is in the expected set",

    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  audiences:
  - audiencesValue
  token: tokenValue
status:
  audiences:
  - audiencesValue
  authenticated: true
  error: errorValue
  user:
    extra:
      extraKey:
      - extraValue
    groups:
    - groupsValue
    uid: uidValue

			TokenFile: "/testTokenFile",
		},
		TokenSuccessCacheTTL: 10 * time.Second,
		TokenFailureCacheTTL: 0,
	}

	expectConfig := kubeauthenticator.Config{
		APIAudiences:            authenticator.Audiences{"http://foo.bar.com"},
		Anonymous:               false,
		BootstrapToken:          false,
		ClientCAContentProvider: nil, // this is nil because you can't compare functions
		TokenAuthFile:           "/testTokenFile",

	seenAudiences := sets.NewString()
	for i, audience := range audiences {
		fldPath := fldPath.Index(i)
		if len(audience) == 0 {
			allErrs = append(allErrs, field.Required(fldPath, "audience can't be empty"))
		}
		if seenAudiences.Has(audience) {
			allErrs = append(allErrs, field.Duplicate(fldPath, audience))
		}
		seenAudiences.Insert(audience)
	}

    blockOwnerDeletion: true
    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  audiences:
  - audiencesValue
  boundObjectRef:
    apiVersion: apiVersionValue
    kind: kindValue
    name: nameValue
    uid: uidValue
  expirationSeconds: 4
status:
  expirationTimestamp: "2002-01-01T01:01:01Z"

        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "audiences": [
      "audiencesValue"
    ],
    "expirationSeconds": 4,
    "boundObjectRef": {
      "kind": "kindValue",
      "apiVersion": "apiVersionValue",
      "name": "nameValue",
      "uid": "uidValue"
    }

		return listAud, nil
	}

	return nil, err
}

type jwtPayload struct {
	// Aud is JWT token audience - used to identify 3p tokens.
	// It is empty for the default K8S tokens.
	Aud []string `json:"aud"`
}

// ExtractJwtAud extracts the audiences from a JWT token. If aud cannot be parse, the bool will be set
// to false. This distinguishes aud=[] from not parsed.

			jwtRule:   `{"issuer": "foo", "jwks_uri": "baz", "audiences": ["aud1", "aud2"]}`,
		},
		{
			name:      "invalid jwt rule",
			expectErr: true,
			jwtRule:   "invalid",
		},
		{
			name:      "jwt rule with invalid audiences",
			expectErr: true,
			// audiences must be a string array
			jwtRule: `{"issuer": "foo", "jwks_uri": "baz", "audiences": "aud1"}`,
		},
	}

	for _, tt := range tests {