</div>
            </div>
        </section>
    </div>
    <jsp:include page="/WEB-INF/view/common/admin/footer.jsp"></jsp:include>
</div>
<jsp:include page="/WEB-INF/view/common/admin/foot.jsp"></jsp:include>
</body>

  }

  @GwtIncompatible("internals")
  public void testControlsArraySize() {
    ImmutableSet.Builder<String> builder = new ImmutableSet.Builder<String>();
    for (int i = 0; i < 10; i++) {
      builder.add("foo");
    }
    builder.add("bar");
    RegularImmutableSet<String> set = (RegularImmutableSet<String>) builder.build();
    assertTrue(set.elements.length <= 2 * set.size());
  }

  @GwtIncompatible("internals")

                </div>
            </la:form>
        </section>
    </div>
    <jsp:include page="/WEB-INF/view/common/admin/footer.jsp"></jsp:include>
</div>
<jsp:include page="/WEB-INF/view/common/admin/foot.jsp"></jsp:include>
</body>

	"k8s.io/apimachinery/pkg/types"

	"istio.io/istio/pkg/test/util/assert"
)

func TestWithProcFs(t *testing.T) {
	n := NewPodNetnsProcFinder(fakeFs())
	pod := &corev1.Pod{ObjectMeta: metav1.ObjectMeta{
		Name:      "foo",
		Namespace: "bar",
		UID:       types.UID("863b91d4-4b68-4efa-917f-4b560e3e86aa"),
	}}
	podUIDNetns, err := n.FindNetnsForPods(map[types.UID]*corev1.Pod{
		pod.UID: pod,
	})
	if err != nil {
		panic(err)
	}

   * doesn't work: Because nullness analyses typically infer the nullness of local variables,
   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case

   * doesn't work: Because nullness analyses typically infer the nullness of local variables,
   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case

    assert response.json() == {"detail": "Incorrect username or password"}


@needs_py39
def test_login_incorrect_username(client: TestClient):
    response = client.post("/token", data={"username": "foo", "password": "secret"})
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "Incorrect username or password"}


@needs_py39
def test_no_token(client: TestClient):

                    "type": "value_error.missing",
                }
            ]
        }
    )


@needs_py39
def test_post_body_json(client: TestClient):
    response = client.post("/files/", json={"file": "Foo"})
    assert response.status_code == 422, response.text
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "missing",

    return current_user


@app.get("/users/me/items/")
async def read_own_items(
    current_user: User = Security(get_current_active_user, scopes=["items"]),
):
    return [{"item_id": "Foo", "owner": current_user.username}]


@app.get("/status/")
async def read_system_status(current_user: User = Depends(get_current_user)):

But the details between *concurrency* and *parallelism* are quite different.

To see the difference, imagine the following story about burgers:

### Concurrent Burgers

You go with your crush to get fast food, you stand in line while the cashier takes the orders from the people in front of you. 😍

<img src="/img/async/concurrent-burgers/concurrent-burgers-01.png" class="illustration">