return new SuggestItem(new String[] { this.getElevateWord() }, readingArray, fields.toArray(new String[fields.size()]), 1, 0,
                this.getBoost(), this.getTags().toArray(new String[this.getTags().size()]),
                this.getRoles().toArray(new String[this.getRoles().size()]), null, SuggestItem.Kind.USER);
    }

        assertNotNull(region, "Memory region should not be null");
        assertEquals(buffer, region.getBuffer(), "Buffer should match");
        assertEquals(1024, region.getSize(), "Size should match buffer size");
        assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ), "Should have local read access");
        assertTrue(region.hasAccess(RdmaAccess.LOCAL_WRITE), "Should have local write access");

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

    // ------------------------------------------------------------------------------------------
    @Test
    void testRuntimeClasspathTransform() throws Exception {

        futures.isEmpty()
            ? Collections.<@Nullable Present<V>>emptyList()
            : Lists.<@Nullable Present<V>>newArrayListWithCapacity(futures.size());

    // Populate the results list with null initially.
    for (int i = 0; i < futures.size(); ++i) {
      values.add(null);
    }

    this.values = values;
  }

  @Override
  final void collectOneValue(int index, @ParametricNullness V returnValue) {

                && dependenciesEquals(a.getDependencies(), b.getDependencies());
    }

    private static boolean dependenciesEquals(List<Dependency> a, List<Dependency> b) {
        if (a.size() != b.size()) {
            return false;
        }

        Iterator<Dependency> aI = a.iterator();
        Iterator<Dependency> bI = b.iterator();

        while (aI.hasNext()) {
            Dependency aD = aI.next();

        assertNotNull(results);
        assertEquals(1, results.size());
        ProjectBuildingResult result = results.get(0);
        assertNotNull(result);
        assertNotNull(result.getProject());
        assertEquals(1, result.getProblems().size());
        assertEquals(1, result.getProject().getArtifacts().size());
        assertNotNull(result.getDependencyResolutionResult());
    }

    /**

        return true;
      }
      if (object instanceof CharArrayAsList) {
        CharArrayAsList that = (CharArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

    @Override
    protected Set<String> create(String[] elements) {
      ImmutableSet.Builder<String> builder =
          ImmutableSet.builderWithExpectedSize(newHashSet(elements).size());
      for (String e : elements) {
        builder.add(e);
      }
      return builder.build();
    }
  }

  public static class ImmutableSetTooBigBuilderGenerator extends TestStringSetGenerator {

        }
      }

      @Override
      public Iterator<Entry<K, V>> iterator() {
        return delegate().iterator();
      }

      @Override
      public int size() {
        return delegate().size();
      }

      @Override
      public boolean remove(Object o) {
        return delegate().remove(o);
      }

      @Override
      public void clear() {

@app.post("/optional-uploadfile", operation_id="optional_uploadfile")
async def read_optional_uploadfile(p: Annotated[Optional[UploadFile], File()] = None):
    return {"file_size": p.size if p else None}


@pytest.mark.parametrize(
    "path",
    [
        "/optional-bytes",
        "/optional-uploadfile",
    ],
)
def test_optional_schema(path: str):
    openapi = app.openapi()