push(stack, collector.combiner().apply(left, right));
        }
        return pop(stack);
      }

      <E extends @Nullable Object> void push(List<E> stack, E value) {
        stack.add(value);
      }

      <E extends @Nullable Object> E pop(List<E> stack) {
        return stack.remove(stack.size() - 1);
      }
    };

/*
 * Copyright (C) 2016 Square, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

                return result;
            }
        }
        return null;
    }

    private boolean isProjectContext(String context) {
        return context != null && context.startsWith("project");
    }

    private static boolean isAny(String str) {
        return "*".equals(str);
    }

        }

        return lifecycleMappings;
    }

    private Map<PhaseId, List<MojoExecution>> getPhaseBindings(
            Map<String, Map<PhaseId, List<MojoExecution>>> mappings, String phase) {
        if (phase != null) {
            PhaseId id = PhaseId.of(phase);
            return mappings.get(id.executionPoint().prefix() + id.phase());
        }
        return null;
    }

        return new DefaultModelUrlNormalizer().setUrlNormalizer(newUrlNormalizer());
    }

    protected InheritanceAssembler newInheritanceAssembler() {
        return new DefaultInheritanceAssembler();
    }

    protected ProfileInjector newProfileInjector() {
        return new DefaultProfileInjector();
    }

    protected SuperPomProvider newSuperPomProvider() {

Si vous ouvrez une URL comme :

```
http://127.0.0.1:8000/items/foo-item
```

...sans ajouter le paramètre requis `needy`, vous aurez une erreur :

```JSON
{
    "detail": [
        {
            "loc": [
                "query",
                "needy"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

      if (name.equals(Finalizer.class.getName())) {
        Class<?> clazz = findClass(name);
        if (resolve) {
          resolveClass(clazz);
        }
        return clazz;
      }

      return super.loadClass(name, resolve);
    }
  }

  @Test
  public void testGetFinalizerUrl() {
    assertThat(getClass().getResource("internal/Finalizer.class")).isNotNull();
  }

      return Objects.hash(duration, unit);
    }

    @Override
    public boolean equals(@Nullable Object o) {
      if (o instanceof DurationSpec) {
        DurationSpec that = (DurationSpec) o;
        return unit.toNanos(duration) == that.unit.toNanos(that.duration);
      }
      return false;
    }

    @Override
    public String toString() {
      return MoreObjects.toStringHelper(this)

/*
 * Copyright (C) 2008 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

        return escapeSlow(s, i);
      }
    }
    return s;
  }

  /**
   * Escapes a single character using the replacement array and safe range values. If the given
   * character does not have an explicit replacement and lies outside the safe range then {@link
   * #escapeUnsafe} is called.
   *