} finally {
            interpolator.clearAnswers();
        }
    }

    protected List<ValueSource> createValueSources(
            final Model model, final File projectDir, final ProjectBuilderConfiguration config) {
        String timestampFormat = DEFAULT_BUILD_TIMESTAMP_FORMAT;

        Properties modelProperties = model.getProperties();
        if (modelProperties != null) {

    protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;

    // ===================================================================================
    //                                                                           Singleton
    //                                                                           =========

 *
 * @author James Sexton
 * @since 20.0
 */
@Immutable(containerOf = {"N"})
public abstract class EndpointPair<N> implements Iterable<N> {
  private final N nodeU;
  private final N nodeV;

  private EndpointPair(N nodeU, N nodeV) {
    this.nodeU = checkNotNull(nodeU);
    this.nodeV = checkNotNull(nodeV);
  }

  }

  /** A Future that doesn't implement ListenableFuture, useful for testing listenInPoolThread. */
  private static final class NonListenableSettableFuture<V> extends ForwardingFuture<V> {
    static <V> NonListenableSettableFuture<V> create() {
      return new NonListenableSettableFuture<V>();
    }

    final SettableFuture<V> delegate = SettableFuture.create();

    @Override
    protected Future<V> delegate() {

            final String content = new String(is.readAllBytes(), StandardCharsets.UTF_8);

            // Verify encoding doesn't corrupt content
            assertTrue("Content should be valid", content.length() > 0);
            assertTrue("Should not contain encoding errors", !content.contains("\uFFFD"));

            // Verify JSON structure is intact

     */
    public static void register(final RenderData data, final String key, final Object value) {
        if (value == null) {
            return;
        }

        if (value instanceof Entity) {
            data.register(key, BeanUtil.copyBeanToNewMap(value));
        } else {
            if (value instanceof final Collection<?> coll && !coll.isEmpty()) {

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for

/**
 * An ordering that orders elements by applying an order to the result of a function on those
 * elements.
 */
@GwtCompatible
final class ByFunctionOrdering<F extends @Nullable Object, T extends @Nullable Object>
    extends Ordering<F> implements Serializable {
  final Function<F, ? extends T> function;
  final Ordering<T> ordering;

  ByFunctionOrdering(Function<F, ? extends T> function, Ordering<T> ordering) {

 *
 * @author Bob Lee
 * @since 10.0
 */
@GwtCompatible
final class FunctionalEquivalence<F, T> extends Equivalence<F> implements Serializable {

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

  private final Function<? super F, ? extends @Nullable T> function;
  private final Equivalence<T> resultEquivalence;

  FunctionalEquivalence(

        exception.expectMessage(is("index=2"));
        final ArrayIterator<Integer> itr = new ArrayIterator<Integer>(new Integer[] { 1, 2 });
        itr.next();
        itr.next();
        itr.next();
    }

    /**
     *
     */
    @Test
    public void testHasNext() {
        final ArrayIterator<String> itr = new ArrayIterator<String>("A", "B");