final TimeUnit timeUnit = TimeUnit.valueOf(getInitParameter(TIME_TO_LIVE_TIME_UNIT_PROPERTY, "MINUTES", String.class));
        final int maxTotal = getInitParameter(MAX_TOTAL_CONNECTION_PROPERTY, 200, Integer.class);
        final int defaultMaxPerRoute = getInitParameter(DEFAULT_MAX_CONNECTION_PER_ROUTE_PROPERTY, 20, Integer.class);

	if err := ps.Subscribe(MaskAll, ch2, doneCh2, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	close(doneCh1)
	// Allow for the above statement to take effect.
	time.Sleep(100 * time.Millisecond)
	ps.Lock()
	if len(ps.subs) != 1 {
		t.Fatal("expected 1 subscriber")
	}
	ps.Unlock()
	close(doneCh2)
}

type maskString string

func (m maskString) Mask() uint64 {
	return 1
}

  }

  static <N, V> UndirectedGraphConnections<N, V> of(ElementOrder<N> incidentEdgeOrder) {
    switch (incidentEdgeOrder.type()) {
      case UNORDERED:
        return new UndirectedGraphConnections<>(
            new HashMap<N, V>(INNER_CAPACITY, INNER_LOAD_FACTOR));
      case STABLE:
        return new UndirectedGraphConnections<>(
            new LinkedHashMap<N, V>(INNER_CAPACITY, INNER_LOAD_FACTOR));
      default:

    testBytesB = Arrays.copyOf(testBytesA, size);
    int indexToDifferAt = -1;
    switch (whereToDiffer) {
      case ONE_PERCENT_IN:
        indexToDifferAt = (int) (size * 0.01);
        break;
      case LAST_BYTE:
        indexToDifferAt = size - 1;
        break;
      case NOT_AT_ALL:
    }
    if (indexToDifferAt != -1) {
      testBytesA[indexToDifferAt] = (byte) (testBytesB[indexToDifferAt] - 1);

    exec.execute(task);
    runLatch.await();
    taskLatch.countDown();

    ExecutionException e = assertThrows(ExecutionException.class, () -> task.get(5, SECONDS));
    assertThat(e).hasCauseThat().isInstanceOf(IllegalStateException.class);

    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

    assertThat(ClassPath.getClassName("abc/d/Abc.class")).isEqualTo("abc.d.Abc");
  }

  public void testResourceInfo_of() {
    assertThat(resourceInfo(ClassPathTest.class)).isInstanceOf(ClassInfo.class);
    assertThat(resourceInfo(ClassPath.class)).isInstanceOf(ClassInfo.class);
    assertThat(resourceInfo(Nested.class)).isInstanceOf(ClassInfo.class);
  }

  public void testGetSimpleName() {

func (n NoncurrentVersionExpiration) Validate() error {
	if !n.set {
		return nil
	}
	val := int(n.NoncurrentDays)
	switch {
	case val == 0 && n.NewerNoncurrentVersions == 0:
		// both fields can't be zero
		return errXMLNotWellFormed

	case val < 0, n.NewerNoncurrentVersions < 0:
		// negative values are not supported
		return errXMLNotWellFormed
	}
	return nil
}

/**
 * A static BuildAction that does not capture the Task instance, enabling Configuration Cache
 * compatibility.
 *
 * This class is based on bundled code from the BND Gradle Plugin.
 * https://github.com/bndtools/bnd/blob/master/gradle-plugins/biz.aQute.bnd.gradle/src/main/java/aQute/bnd/gradle/BundleTaskExtension.java
 */
class BndBuildAction(
  private val properties: MapProperty<String, Any>,
  private val classpath: ConfigurableFileCollection,

        switch (messageType) {
        case WitnessNotificationMessage.WITNESS_RESOURCE_CHANGE:
            decodeResourceChangeMessage(buf, message);
            break;
        case WitnessNotificationMessage.WITNESS_CLIENT_MOVE:
            decodeClientMoveMessage(buf, message);
            break;
        case WitnessNotificationMessage.WITNESS_SHARE_MOVE:

    }
  }

  @Test fun closeReservedSetThrows() {
    data.write("880203ec".decodeHex()) // Close with code 1004
    data.write("880203ed".decodeHex()) // Close with code 1005
    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {
      data.write(("8802" + format("%04X", i)).decodeHex()) // Close with code 'i'
    }
    var count = 0
    while (!data.exhausted()) {