}
        saveInfo(messages -> messages.addSuccessDeleteDocFromIndex(GLOBAL));
        verifyToken(() -> asHtml(path_AdminSuggest_AdminSuggestJsp).useForm(SuggestForm.class));
        return redirect(getClass());
    }

    @Execute
    @Secured({ ROLE })
    public HtmlResponse deleteQueryWords() {
        if (!suggestHelper.deleteQueryWords()) {

    protected
    fun jarClassPathWith(vararg classes: KClass<*>): ClassPath =
        jarClassPathWith("cp.jar", *classes)

    protected
    fun jarClassPathWith(path: String, vararg classes: KClass<*>): ClassPath = classPathOf(
        file(path).also { jar ->
            zipTo(jar, classEntriesFor(classes))
        }
    )

    protected
    fun classPathWith(vararg classes: KClass<*>): ClassPath = classPathOf(

import java.util.Set;

public abstract class AbstractAuthentication implements AuthenticationInternal {
    private final String name;
    private final Class<? extends Credentials> supportedCredentialType;
    private final Class<? extends Authentication> type;

    private Credentials credentials;

    private final Set<HostAndPort> hosts;

    public AbstractAuthentication(String name, Class<? extends Authentication> type) {

import org.junit.Rule
import spock.lang.Specification

class DefaultGroovyJavaJointCompileSpecFactoryTest extends Specification {

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "produces correct spec type" () {
        CompileOptions options = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())
        options.fork = fork

        addInvocationHooksToMetaClass(closure.getDelegate().getClass(), resolver);
    }

    @SuppressWarnings("unused") // resolved via a method handle
    public static void addInvocationHooksToMetaClassIfInstrumented(Class<?> javaClass, String callableName) {
        // In BeanDynamicObject we can't filter interceptors, so we have to apply all interceptors

    /**
     * Checks if [this] class has [superClass] as its superclass somewhere in the inheritance hierarchy.
     *
     * N.B. The class is not considered to be a subclass of itself, so `myClass.isSubClassOf(myClass)` is always `false`.
     */
    public fun KaClassOrObjectSymbol.isSubClassOf(superClass: KaClassOrObjectSymbol): Boolean =

	newClass := &storage.VolumeAttributesClass{
		ObjectMeta: metav1.ObjectMeta{
			Name:            "valid-class-2",
			ResourceVersion: "4",
		},
		DriverName: "fake",
		Parameters: map[string]string{
			"foo": "bar",
		},
	}

	Strategy.PrepareForUpdate(ctx, newClass, class)

	errs = Strategy.ValidateUpdate(ctx, newClass, class)
	if len(errs) == 0 {
		t.Errorf("Expected a validation error")
	}

    public void testReadUTF8() throws Exception {
        assertThat(FileUtil.readUTF8(getPath("hoge_utf8.txt")), is("あ"));
    }

    private String getPath(final String fileName) {
        return getClass().getName().replace('.', '/').replaceFirst(getClass().getSimpleName(), fileName);
    }

internal fun KaSession.checkContainingJvmClassName(
    ktFile: KtFile,
    ktClass: KtClassOrObject?,
    symbol: KaCallableSymbol,
    testServices: TestServices
) {
    if (ktFile.isScript()) return
    val expectedClassName = when {
        symbol.symbolKind == KaSymbolKind.LOCAL ->
            null
        ktClass != null ->
            // member
            ktClass.getClassId()?.asFqNameString()
        else ->
            // top-level

      assertThrows(IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    } finally {
      Thread.currentThread().setContextClassLoader(oldContextLoader);
    }
  }

  @AndroidIncompatible // .class files aren't available
  public void testNulls() {
    new NullPointerTester()
        .setDefault(URL.class, classfile(ResourcesTest.class))
        .testAllPublicStaticMethods(Resources.class);