LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override
    String normalizeWord(String word) {
      return firstCharOnlyToUpper(word);
    }

    @Override
    String normalizeFirstWord(String word) {
      return Ascii.toLowerCase(word);
    }
  },

  /** Java and C++ class naming convention, e.g., "UpperCamel". */
  UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override

  LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override
    String normalizeWord(String word) {
      return firstCharOnlyToUpper(word);
    }

    @Override
    String normalizeFirstWord(String word) {
      return Ascii.toLowerCase(word);
    }
  },

  /** Java and C++ class naming convention, e.g., "UpperCamel". */
  UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override

            <li>{@code missing(path)}: Checks if a file matching the given glob pattern does not exist.</li>
            <li>{@code inrange(version, range)}: Checks if the given version is within the specified version range.</li>
            </ul>

            <h2>Supported properties</h2>

            <p>The following properties are supported in expressions:</p>

            <ul>

    public void test_GetFactoryMethod() {
        // ## Arrange ##
        final String url = "http://example.com";

        // ## Act ##
        final CurlRequest request = Curl.get(url);

        // ## Assert ##
        assertNotNull(request);
        assertEquals(Method.GET, request.method());
    }

    @Test
    public void test_PostFactoryMethod() {
        // ## Arrange ##
        final String url = "http://example.com";

    assertEquals(
        ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 10), 2, Range.closed(12, 16), 3),
        rangeMap.asMapOfRanges());

    sub.putCoalescing(Range.singleton(7), 1);
    assertEquals(
        ImmutableMap.of(Range.closed(5, 7), 1, Range.openClosed(7, 10), 2), sub.asMapOfRanges());
    assertEquals(
        ImmutableMap.of(

    TreeRangeSet<Integer> set = TreeRangeSet.create();
    Range<Integer> range = Range.closedOpen(0, 5);
    set.add(range);
    set.subRangeSet(range).add(range);
  }

  public void testComplement() {
    for (Range<Integer> range1 : QUERY_RANGES) {
      for (Range<Integer> range2 : QUERY_RANGES) {
        TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
        rangeSet.add(range1);

        (
            "/items",
            {"strange_header": "FastAPI test"},
            200,
            {"strange_header": "FastAPI test"},
        ),
        (
            "/items",
            {"strange-header": "Not really underscore"},
            200,
            {"strange_header": None},
        ),
    ],
)
def test(path, headers, expected_status, expected_response, client: TestClient):

     * Gets the artifact coordinates whose version range should be resolved.
     * The coordinates may contain a version range (e.g., "[1.0,2.0)") or a single version.
     *
     * @return the artifact coordinates, never {@code null}
     */
    @Nonnull
    ArtifactCoordinates getArtifactCoordinates();

    /**
     * Gets the nature of repositories to query when resolving the version range.

  TreeMultiset(Reference<AvlNode<E>> rootReference, GeneralRange<E> range, AvlNode<E> endLink) {
    super(range.comparator());
    this.rootReference = rootReference;
    this.range = range;
    this.header = endLink;
  }

  TreeMultiset(Comparator<? super E> comparator) {
    super(comparator);
    this.range = GeneralRange.all(comparator);
    this.header = new AvlNode<>();

    for (Range<C> range : asRanges) {
      assertFalse(range.isEmpty());
    }

    // test that the RangeSet's span is the span of all the ranges
    Iterator<Range<C>> itr = rangeSet.asRanges().iterator();
    Range<C> expectedSpan = null;
    if (itr.hasNext()) {
      expectedSpan = itr.next();
      while (itr.hasNext()) {
        expectedSpan = expectedSpan.span(itr.next());
      }
    }

    try {