}
            return true
        }
    }

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    @get:CompileClasspath
    abstract val classpath: ConfigurableFileCollection

    @get:Input
    abstract val excludes: ListProperty<String>

    @get:Input
    abstract val includes: ListProperty<String>

    init {
        excludes.convention(DEFAULT_EXCLUDES)

                    val v1 = rootProject.project(":v1")
                    val v1Jar = v1.tasks.named("jar")
                    val v2 = rootProject.project(":v2")
                    val v2Jar = v2.tasks.named("jar")
                    val newUpgradedPropertiesFile = layout.buildDirectory.file("gradle-api-info/new-upgraded-properties.json")

    ) {
      val settings = response.settings
      stream.connection.setSettings(settings)

      if (response.socketPolicy === NoResponse) {
        return
      }

      val bodyDelayNanos = response.bodyDelayNanos
      val trailers = response.trailers
      val body = response.body
      val streamHandler = response.streamHandler
      val outFinished = (
        body == null &&

  val fastFallback: Boolean = builder.fastFallback

  @get:JvmName("authenticator")
  val authenticator: Authenticator = builder.authenticator

  @get:JvmName("followRedirects")
  val followRedirects: Boolean = builder.followRedirects

  @get:JvmName("followSslRedirects")
  val followSslRedirects: Boolean = builder.followSslRedirects

  @get:JvmName("cookieJar")

import model.Stage
import model.TestCoverage

const val DEFAULT_FUNCTIONAL_TEST_BUCKET_SIZE = 50
const val DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE = 20
const val DEFAULT_MACOS_FUNCTIONAL_TEST_BUCKET_SIZE = 20

class FunctionalTestProject(
    val model: CIBuildModel,
    functionalTestBucketProvider: FunctionalTestBucketProvider,
    val testCoverage: TestCoverage,
    val stage: Stage
) : Project({

import okio.Timeout

/** A logical bidirectional stream. */
@Suppress("NAME_SHADOWING")
class Http2Stream internal constructor(
  val id: Int,
  val connection: Http2Connection,
  outFinished: Boolean,
  inFinished: Boolean,
  headers: Headers?,
) {
  internal val lock: ReentrantLock = ReentrantLock()
  val condition: Condition = lock.newCondition()

import java.util.Date

/**
 * A received response or failure recorded by the response recorder.
 */
class RecordedResponse(
  @JvmField val request: Request,
  val response: Response?,
  val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

    // TODO(lowasser): make this GWT-compatible
    return fromIntBits(value * checkNotNull(val).value);
  }

  /**
   * Returns the result of dividing this by {@code val}.
   *
   * @throws ArithmeticException if {@code val} is zero
   * @since 14.0
   */
  public UnsignedInteger dividedBy(UnsignedInteger val) {
    return fromIntBits(UnsignedInts.divide(value, checkNotNull(val).value));
  }

    // TODO(lowasser): make this GWT-compatible
    return fromIntBits(value * checkNotNull(val).value);
  }

  /**
   * Returns the result of dividing this by {@code val}.
   *
   * @throws ArithmeticException if {@code val} is zero
   * @since 14.0
   */
  public UnsignedInteger dividedBy(UnsignedInteger val) {
    return fromIntBits(UnsignedInts.divide(value, checkNotNull(val).value));
  }

		t.Fatalf("unexpected error: %v", err)
	}
	val := maskString("hello")
	ps.Publish(val)

	msg1 := <-ch1
	msg2 := <-ch2
	if msg1 != val && msg2 != val {
		t.Fatalf("expected both subscribers to have%s , found %s and  %s", val, msg1, msg2)
	}
}

func TestMultiPubSubMask(t *testing.T) {
	ps := New[Maskable, Maskable](3)