func NewVerifier(opts x509.VerifyOptions, auth authenticator.Request, allowedCommonNames sets.String) authenticator.Request {
	return NewDynamicCAVerifier(StaticVerifierFn(opts), auth, StaticStringSlice(allowedCommonNames.List()))
}

// NewDynamicCAVerifier create a request.Authenticator by verifying a client cert on the request, then delegating to the wrapped auth

                @Inject
                public abstract Problems getProblems();

                @Override
                public void execute() {
                    Exception wrappedException = new Exception("Wrapped cause");
                    // Create and report a problem
                    // This needs to be Java 6 compatible, as we are in a worker

		},
		"UpgradeFailure error should return true": {
			err:      &UpgradeFailureError{},
			expected: true,
		},
		"Wrapped Non-UpgradeFailure error should return false": {
			err:      fmt.Errorf("%s: %w", "first error", errors.New("Non-upgrade error")),
			expected: false,
		},
		"Wrapped UpgradeFailure error should return true": {
			err:      fmt.Errorf("%s: %w", "first error", &UpgradeFailureError{}),
			expected: true,

import static org.gradle.internal.io.IoFunction.wrap

class IoFunctionTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ String t -> "wrapped:$t" }).apply("lajos") == "wrapped:lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ String t ->
            assert t == "lajos"
            throw exception

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

/**
 * Wrapped InterruptedException.
 *
 * @author shinsuke
 *
 */
public class InterruptedRuntimeException extends RuntimeException {

    private static final long serialVersionUID = 1L;

            new RuntimeException("lajos"),
            new Error("lajos"),
            new UncheckedIOException(new IOException("lajos"))
        ]
        type = original.class
    }

    def "IOException is thrown wrapped in UncheckedIOException"() {
        def original = new IOException("lajos")
        when:
        executeWithException(original)
        then:
        def ex = thrown UncheckedIOException
        ex.cause === original

 * limitations under the License.
 */

package org.gradle.internal

import spock.lang.Specification

class ErroringActionTest extends Specification {

    def "checked exceptions are wrapped"() {
        when:
        new ErroringAction() {
            @Override
            void doExecute(Object thing) {
                throw new Exception()
            }
        }.execute("foo")

        then:

            [fromStringList(), "execute(command)", "", ""],
            [fromObjectList(), "execute(command)", "", ""],
            // Spread calls
            [fromString(), "execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "execute(command as String)", "", ""],
        ]
    }

            [fromObjectList(), "ProcessGroovyMethods.execute(command)", "", ""],
            // Spread calls
            [fromString(), "ProcessGroovyMethods.execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "ProcessGroovyMethods.execute(command as String)", "", ""],
        ]
    }

	klog.V(3).Infof("Setting up a downwardAPI volume %v for pod %v/%v at %v", b.volName, b.pod.Namespace, b.pod.Name, dir)
	// Wrap EmptyDir. Here we rely on the idempotency of the wrapped plugin to avoid repeatedly mounting
	wrapped, err := b.plugin.host.NewWrapperMounter(b.volName, wrappedVolumeSpec(), b.pod, *b.opts)
	if err != nil {