val e = RuntimeException()
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onOpen(
          webSocket: WebSocket,
          response: Response,
        ): Unit = throw e
      },
    )
    newWebSocket()
    serverListener.assertOpen()
    serverListener.assertFailure(EOFException::class.java)
    serverListener.assertExhausted()
    clientListener.assertFailure(e)

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.pager;

import java.util.ArrayList;
import java.util.List;

import org.codelibs.fess.unit.UnitFessTestCase;

public class SearchLogPagerTest extends UnitFessTestCase {

    public void test_SearchLogPager() {
        SearchLogPager searchLogPager = new SearchLogPager();

        searchLogPager.clear();

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.pager;

import java.util.ArrayList;
import java.util.List;

import org.codelibs.fess.unit.UnitFessTestCase;

public class UserPagerTest extends UnitFessTestCase {

    public void test_UserPager() {
        UserPager userPager = new UserPager();

        userPager.clear();

    taskFilter: (Task) -> Boolean,
    /* pass the collected information in build-logic and main build to Build Scan */
    buildScanAction: (gradleRootProject: Project, infoCollectedInBuildLogic: Any, infoCollectedInMainBuild: Any) -> Unit
) {
    val gradleRootProject = when {
        project.name == "gradle" -> project.rootProject
        project.rootProject.name == "build-logic" -> rootProject.gradle.parent?.rootProject

abstract class PublishRelease(
    prepTask: String,
    promoteTask: String,
    requiredConfirmationCode: String,
    promotedBranch: String,
    init: PublishRelease.() -> Unit = {},
) : PublishGradleDistributionFullBuild(
        promotedBranch = promotedBranch,
        prepTask = prepTask,
        promoteTask = promoteTask,
        triggerName = "ReadyforRelease",

        projectScope.subproject(projectName)
    }

    fun uses(platform: PlatformBuilder) {
        uses.add(platform)
    }

    fun module(platformName: String, moduleConfiguration: ArchitectureModuleBuilder.() -> Unit) {
        val module = ArchitectureModuleBuilder(platformName, settings)
        modules.add(module)
        module.moduleConfiguration()
    }

    override fun build(): Platform {

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.testing.NullPointerTester;
import java.util.Set;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link Primitives}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullUnmarked
public class PrimitivesTest extends TestCase {
  public void testIsWrapperType() {

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

/**
 * Unit tests for {@link SmbFileFilter}. The filter interface is small; the
 * tests focus on the contract that implementations should honour and the
 * interaction with {@link SmbFile} instances. The tests make heavy use of

    val responseString = same.body.string()
    assertThat(responseString).isEmpty()
  }

  private fun response(
    url: String,
    bodyHex: ByteString,
    fn: Response.Builder.() -> Unit = {},
  ): Response =
    Response
      .Builder()
      .body(bodyHex.toResponseBody("text/plain".toMediaType()))
      .code(200)
      .message("OK")
      .request(Request.Builder().url(url).build())

import static org.junit.Assert.assertThrows;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit tests for {@link CountingInputStream}.
 *
 * @author Chris Nokleberg
 */
@NullUnmarked
public class CountingInputStreamTest extends IoTestCase {
  private CountingInputStream counter;

  @Override