assertThat(j.join(ImmutableMap.of("", ""))).isEqualTo(":");

    Map<@Nullable String, @Nullable String> mapWithNulls = new LinkedHashMap<>();
    mapWithNulls.put("a", null);
    mapWithNulls.put(null, "b");

    assertThrows(NullPointerException.class, () -> j.join(mapWithNulls));

    assertThat(j.useForNull("00").join(mapWithNulls)).isEqualTo("a:00;00:b");

        // Intentionally notNull because Super POM may not contain a modelId
        Objects.requireNonNull(modelId, "modelId cannot null");

        rawModels.put(modelId, rawModel);

        return this;
    }

    @Override
    public List<Profile> getActivePomProfiles(String modelId) {
        return activePomProfiles.get(modelId);
    }

        if (!recessivePlugins.isEmpty() || !plugins.isEmpty()) {
            LinkedHashMap<String, Plugin> mergedPlugins = new LinkedHashMap<>();
            recessivePlugins.forEach(p -> mergedPlugins.put(p.getPrefix(), p));
            plugins.forEach(p -> mergedPlugins.put(p.getPrefix(), p));
            metadata.setPlugins(new ArrayList<>(mergedPlugins.values()));
        }

        // just carry-on as-is
        if (recessive.getVersioning() != null) {

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


class User(BaseModel):
    username: str
    full_name: str | None = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, user: User, importance: int = Body()):
    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}

from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


@app.put("/items/{item_id}")
async def update_item(
    item_id: int,
    item: Annotated[
        Item,
        Body(
            examples=[
                {
                    "name": "Foo",

            }
        }
        paramMap.put(Param.Client.SMB_AUTHENTICATIONS, smbAuthList.toArray(new SmbAuthentication[smbAuthList.size()]));
        if (logger.isDebugEnabled()) {
            smbAuthList.forEach(smbAuth -> logger
                    .debug("SmbAuthentication: " + smbAuth.getServer() + ":" + smbAuth.getPort() + " " + smbAuth.getUsername()));
        }
        paramMap.put(Param.Client.SMB1_AUTHENTICATIONS,

     * Builder} and its comparator.
     */
    @Override
    public ImmutableSortedSet<E> build() {
      @SuppressWarnings("unchecked") // we're careful to put only E's in here
      E[] contentsArray = (E[]) contents;
      ImmutableSortedSet<E> result = construct(comparator, size, contentsArray);
      this.size = result.size(); // we eliminated duplicates in-place in contentsArray

	return t2[:0]
}

func (p *ArrayOf[T]) putA(v []T) {
	var zero T // nil
	for i, t := range v {
		//nolint:staticcheck // SA6002 IT IS A GENERIC VALUE!
		p.ePool.Put(t)
		v[i] = zero
	}
	if v != nil {
		v = v[:0]
		p.aPool.Put(&v)
	}
}

func (p *ArrayOf[T]) newE() T {
	return p.ePool.Get()
}

// Array provides a wrapper for an underlying array of serializable objects.

   *
   * <p><b>Java 8+ users:</b> If passing a single element {@code e}, the {@code Stream} equivalent
   * of this method is {@code Stream.generate(() -> e)}. Otherwise, put the elements in a collection
   * and use {@code Stream.generate(() -> collection).flatMap(Collection::stream)}.
   */
  @SafeVarargs
  public static <T extends @Nullable Object> Iterable<T> cycle(T... elements) {

        Map<String, ExecutionPlanItem> lastInExistingPhases = new HashMap<>();
        for (ExecutionPlanItem executionPlanItem : getExecutionPlanItems()) {
            lastInExistingPhases.put(executionPlanItem.getLifecyclePhase(), executionPlanItem);
        }

        ExecutionPlanItem lastSeenExecutionPlanItem = null;

        for (String phase : totalPhaseSet) {