if ( context.getServer() == null ) {
                pos = 1;
            }

            // first remaining path element would be share
            if ( nameParts.length > pos ) {
                this.share = nameParts[ pos++ ];
            }

            // all other remaining path elements are actual path
            if ( nameParts.length > pos ) {
                String[] remainParts = new String[nameParts.length - pos];

        OneSizeTestContainerGenerator<SetMultimap<K, V>, Entry<K, V>> multimapGenerator) {
      super(multimapGenerator);
    }

    @Override
    public Set<Entry<K, V>> create(Object... elements) {
      return (Set<Entry<K, V>>) super.create(elements);
    }
  }

  static class MultimapGetGenerator<K, V>
      extends MultimapTestSuiteBuilder.MultimapGetGenerator<K, V, SetMultimap<K, V>>
      implements TestSetGenerator<V> {

    implements ListMultimap<K, V> {
  /**
   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableListMultimap}
   * whose keys and values are the result of applying the provided mapping functions to the input
   * elements.
   *
   * <p>For streams with defined encounter order (as defined in the Ordering section of the {@link

        final EnumerationIterator<String> itr = new EnumerationIterator<String>(vector.elements());
        itr.remove();
    }

    /**
     * @throws Exception
     */
    @Test
    public void testNext() throws Exception {
        final EnumerationIterator<String> itr = new EnumerationIterator<String>(new Vector<String>().elements());
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**

  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testEquals_containingNull() {
    ArrayList<E> elements = new ArrayList<>(getSampleElements());
    elements.set(elements.size() / 2, null);
    collection = getSubjectGenerator().create(elements.toArray());
    List<E> other = new ArrayList<>(getSampleElements());
    assertFalse(

      Entry<E> entry = entriesArray[i];
      int count = entry.getCount();
      size += count;
      E element = checkNotNull(entry.getElement());
      delegateMap.put(element, count);
      if (!(entry instanceof Multisets.ImmutableEntry)) {
        entriesArray[i] = Multisets.immutableEntry(element, count);
      }
    }
    return new JdkBackedImmutableMultiset<>(

    return rowKeyToIndex.containsKey(rowKey);
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    for (@Nullable V[] row : array) {
      for (V element : row) {
        if (Objects.equal(value, element)) {
          return true;
        }
      }
    }
    return false;
  }

  @Override
  @CheckForNull

    }
}(typeof window !== 'undefined' ? window : this, function(moment, $) {
    var DateRangePicker = function(element, options, cb) {

        //default settings for options
        this.parentEl = 'body';
        this.element = $(element);
        this.startDate = moment().startOf('day');
        this.endDate = moment().endOf('day');
        this.minDate = false;
        this.maxDate = false;

    return new Enums();
  }

  @Override
  public Multiset<AnEnum> create(Object... elements) {
    AnEnum[] array = new AnEnum[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (AnEnum) e;
    }
    return create(array);
  }

  protected abstract Multiset<AnEnum> create(AnEnum[] elements);

  @Override
  public AnEnum[] createArray(int length) {
    return new AnEnum[length];

      return gen.samples();
    }

    @Override
    public Set<E> create(Object... elements) {
      Object[] duplicated = new Object[elements.length * 2];
      for (int i = 0; i < elements.length; i++) {
        duplicated[i] = elements[i];
        duplicated[i + elements.length] = elements[i];
      }
      return ((Multiset<E>) gen.create(duplicated)).elementSet();
    }

    @Override