// hasNext/next sequence over two elements
        assertTrue(it.hasNext(), "Expected first element available");
        SmbResource r1 = it.next();
        assertNotNull(r1);
        assertEquals("foo/", r1.getName(), "First child name should match with trailing slash");

        assertTrue(it.hasNext(), "Expected second element available");
        SmbResource r2 = it.next();
        assertNotNull(r2);

    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

    @Override
    public Collection<E> create(Object... elements) {
      return SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override

  <!--
   | With toolchains you can refer to installations on your system. This
   | way you don't have to hardcode paths in your pom.xml.
   |
   | Every toolchain consist of 3 elements:
   | * type: the type of tool. An often used value is 'jdk'. Toolchains-aware
   |   plugins should document which type you must use.
   |
   | * provides: A list of key/value-pairs.

  private static TestStringMultisetGenerator hashMultisetGenerator() {
    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return HashMultiset.create(asList(elements));
      }
    };
  }

  public void testCreate() {
    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");

  public void testBuilderAddArrayHandlesNulls() {
    @Nullable String[] elements = new @Nullable String[] {"a", null, "b"};
    ImmutableList.Builder<String> builder = ImmutableList.builder();
    assertThrows(NullPointerException.class, () -> builder.add((String[]) elements));
    ImmutableList<String> result = builder.build();

    /*
     * Maybe it rejects all elements, or maybe it adds "a" before failing.
     * Either way is fine with us.

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.Immutable;
import com.google.errorprone.annotations.InlineMe;

/**
 * A {@link ValueGraph} whose elements and structural relationships will never change. Instances of
 * this class may be obtained with {@link #copyOf(ValueGraph)}.
 *
 * <p>See the Guava User's Guide's <a

        QueueTestSuiteBuilder.using(
                new TestStringQueueGenerator() {

                  @Override
                  protected Queue<String> create(String[] elements) {
                    return new StandardImplForwardingQueue<>(new LinkedList<>(asList(elements)));
                  }
                })
            .named("ForwardingQueue[LinkedList] with standard implementations")
            .withFeatures(

  }

  @Override
  protected <E extends Comparable<? super E>> SortedSet<E> copyOf(E[] elements) {
    return ImmutableSortedSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> SortedSet<E> copyOf(
      Collection<? extends E> elements) {
    return ImmutableSortedSet.copyOf(elements);
  }

  @Override

#                 ; [group-name] = map:{
#                     ; groupComment=[comment]
#                     ; elementList=list:{[the list of classification element's name]}
#                 }
#             }
#         }
#         # classification elements for implicit classification
#         ; map:{
#             ; code=[code]; name=[name]; alias=[alias]; comment=[comment]

                  @Override
                  @SuppressWarnings({"unchecked", "rawtypes"})
                  public Map<Class, Impl> create(Object... elements) {
                    MutableClassToInstanceMap<Impl> map = MutableClassToInstanceMap.create();
                    for (Object object : elements) {
                      Entry<Class, Impl> entry = (Entry<Class, Impl>) object;
                      map.putInstance(entry.getKey(), entry.getValue());