class SettingsTest {
  @Test
  fun unsetField() {
    val settings = Settings()
    assertThat(settings.isSet(Settings.MAX_CONCURRENT_STREAMS)).isFalse()
    assertThat(settings.getMaxConcurrentStreams()).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  fun setFields() {
    val settings = Settings()
    settings[Settings.HEADER_TABLE_SIZE] = 8096
    assertThat(settings.headerTableSize).isEqualTo(8096)

from pydantic import BaseModel


class Model(BaseModel):
    name: str


app = FastAPI()


@app.get("/valid1", responses={"500": {"model": int}})
def valid1():
    pass


@app.get("/valid2", responses={"500": {"model": List[int]}})
def valid2():
    pass


@app.get("/valid3", responses={"500": {"model": Model}})
def valid3():
    pass

type MockClient struct {
	// Results is a map of podName to the results of the expected test on the pod
	Results map[string][]byte
	kube.CLIClient
}

func (c MockClient) NewPortForwarder(_, _, _ string, _, _ int) (kube.PortForwarder, error) {
	return MockPortForwarder{}, nil
}

func (c MockClient) AllDiscoveryDo(_ context.Context, _, _ string) (map[string][]byte, error) {
	return c.Results, nil
}

    for (int i = 0; i < 10000; i++) {
      stripedLock.get(new Object()).lock();
      // nothing special (e.g. an exception) happens
    }
  }

  public void testBulkGetReturnsSorted() {
    for (Striped<?> striped : allImplementations()) {
      Map<Object, Integer> indexByLock = Maps.newHashMap();
      for (int i = 0; i < striped.size(); i++) {

    for (int i = 0; i < 10000; i++) {
      stripedLock.get(new Object()).lock();
      // nothing special (e.g. an exception) happens
    }
  }

  public void testBulkGetReturnsSorted() {
    for (Striped<?> striped : allImplementations()) {
      Map<Object, Integer> indexByLock = Maps.newHashMap();
      for (int i = 0; i < striped.size(); i++) {

    public synchronized PagingList<SynonymItem> selectList(final int offset, final int size) {
        if (synonymItemList == null) {
            reload(null);
        }

        if (offset >= synonymItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<SynonymItem> emptyList(), offset, size, synonymItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > synonymItemList.size()) {

     * whenever they pass `true` for the matching `has*Bound` parameter.
     */
    if (hasLowerBound) {
      int unused =
          comparator.compare(
              uncheckedCastNullableTToT(lowerEndpoint), uncheckedCastNullableTToT(lowerEndpoint));
    }
    if (hasUpperBound) {
      int unused =
          comparator.compare(

    protected static final int NUM = 20;

    private AccessTokenHelper accessTokenHelper;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        accessTokenHelper = new AccessTokenHelper();
    }

    public void test_generateAccessToken() {
        List<String> tokens = new ArrayList<String>();
        for (int i = 0; i < NUM; i++) {

  @Override
  @SuppressWarnings("unchecked")
  public final Entry<AnEnum, String>[] createArray(int length) {
    return (Entry<AnEnum, String>[]) new Entry<?, ?>[length];
  }

  @Override
  public final AnEnum[] createKeyArray(int length) {
    return new AnEnum[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

    return ImmutableList.of(element);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    dst[offset] = element;
    return offset + 1;
  }

  @Override
  public final int hashCode() {
    return element.hashCode();
  }

  @Override
  public String toString() {
    return '[' + element.toString() + ']';
  }