}
            })
        .named("singletonList")
        .withFeatures(
            CollectionFeature.SERIALIZABLE,
            CollectionFeature.ALLOWS_NULL_VALUES,
            CollectionSize.ONE)
        .suppressing(suppressForSingletonList())
        .createTestSuite();
  }

  public Test testsForArraysAsList() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {

import java.util.Iterator;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * A sorted multiset which forwards all its method calls to another sorted multiset. Subclasses
 * should override one or more methods to modify the behavior of the backing multiset as desired per
 * the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

      classes.add(descendant);
      descendant = descendant.getSuperclass();
    }

    return classes;
  }

  /**
   * Not really a signature -- just the parts that affect whether one method is a fauxveride of a
   * method from an ancestor class.
   *
   * <p>See JLS 8.4.2 for the definition of the related "override-equivalent."
   */

                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    NavigableMap<Integer, String> map1 = ImmutableSortedMap.of(1, "one");
    NavigableMap<Integer, String> map2 = ImmutableSortedMap.of(2, "two");
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();

    // share access specified in SmbFile

    // create disposition

    /*
     * Creates a new file or supersedes the existing one
     */

    static final int FILE_SUPERSEDE = 0x0;

    /*
     * Open the file or fail if it does not exist
     * aka OPEN_EXISTING
     */

    static final int FILE_OPEN = 0x1;

    /*

                SmbConstants.TYPE_NAMED_PIPE, SmbConstants.TYPE_PRINTER, SmbConstants.TYPE_COMM };

        for (int type : types) {
            // Check if it's a power of 2 (has exactly one bit set)
            assertTrue(type > 0 && (type & (type - 1)) == 0, "Resource type " + type + " should be a power of 2");
        }
    }

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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
 *

          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,

      assertEquals(2 * N + 2 * i - 1, (int) bimap.get(2 * i));
    }
  }

  public void testBiMapEntrySetIteratorRemove() {
    BiMap<Integer, String> map = HashBiMap.create();
    map.put(1, "one");
    Set<Entry<Integer, String>> entries = map.entrySet();
    Iterator<Entry<Integer, String>> iterator = entries.iterator();
    Entry<Integer, String> entry = iterator.next();

          sinks.add(new Sink(chunkSize, bufferSize));
          // For convenience, testing only with big endianness, to match DataOutputStream.
          // I regard highly unlikely that both the little endianness tests above and this one
          // passes, and there is still a little endianness bug lurking around.
        }
      }

      Control control = new Control();
      Hasher controlSink = control.newHasher(1024);