* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.smb1;

import jcifs.smb1.util.Hexdump;
import jcifs.smb1.util.LogStream;

class NetServerEnum2Response extends SmbComTransactionResponse {

    class ServerInfo1 implements FileEntry {
        String name;
        int versionMajor;
        int versionMinor;
        int type;
        String commentOrMasterBrowser;

    /**
     * Minimal concrete implementation for testing.
     * - parse: sets mechanismToken, throws on null
     * - toByteArray: returns mechanismToken or empty array if null
     */
    static class TestSpnegoToken extends SpnegoToken {
        private boolean parsed = false;

        @Override
        public byte[] toByteArray() {
            byte[] tok = getMechanismToken();
            return tok == null ? new byte[0] : tok;

/**
 * Tests for {@code ForwardingSortedMap}.
 *
 * @author Robert KonigsbergSortedMapFeature
 */
@NullUnmarked
public class ForwardingSortedMapTest extends TestCase {
  static class StandardImplForwardingSortedMap<K, V> extends ForwardingSortedMap<K, V> {
    private final SortedMap<K, V> backingSortedMap;

    StandardImplForwardingSortedMap(SortedMap<K, V> backingSortedMap) {

 * footprint.
 */
@GwtCompatible
@NullMarked
final class ObjectCountLinkedHashMap<K extends @Nullable Object> extends ObjectCountHashMap<K> {
  /** Creates an empty {@code ObjectCountLinkedHashMap} instance. */
  static <K extends @Nullable Object> ObjectCountLinkedHashMap<K> create() {
    return new ObjectCountLinkedHashMap<K>();
  }

  /**

 */
@NullUnmarked
public class SynchronizedMapTest extends TestCase {
  public final Object mutex = new Object[0]; // something Serializable

  protected <K, V> Map<K, V> create() {
    TestMap<K, V> inner = new TestMap<>(new HashMap<K, V>(), mutex);
    Map<K, V> outer = Synchronized.map(inner, mutex);
    return outer;
  }

  static class TestMap<K, V> extends ForwardingMap<K, V> implements Serializable {

        }

        @Override
        public <T extends Credentials> T unwrap(Class<T> type) {
            if (type.isInstance(this)) {
                return type.cast(this);
            }
            throw new ClassCastException("Cannot unwrap to " + type.getName());
        }
    }

    static class SelfRenewingCreds extends BaseCreds {
        @Override
        public CredentialsInternal renew() {

    if (t instanceof Error && !(t instanceof StackOverflowError)) {
      throw (Error) t;
    }
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future)
      throws InterruptedException, ExecutionException {
    return future.blockingGet();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)

 * @param <I> the type of the iterator ({@link Iterator} or {@link ListIterator})
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked
abstract class AbstractIteratorTester<E extends @Nullable Object, I extends Iterator<E>> {
  private final Stimulus<E, ? super I>[] stimuli;
  private final Iterator<E> elementsToInsert;
  private final Set<IteratorFeature> features;
  private final List<E> expectedElements;

/**
 * Tests for {@code ForwardingList}.
 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingListTest extends TestCase {
  static final class StandardImplForwardingList<T> extends ForwardingList<T> {
    private final List<T> backingList;

    StandardImplForwardingList(List<T> backingList) {
      this.backingList = backingList;
    }

    @Override

 * @param <I> the type of the iterator ({@link Iterator} or {@link ListIterator})
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked
abstract class AbstractIteratorTester<E extends @Nullable Object, I extends Iterator<E>> {
  private final Stimulus<E, ? super I>[] stimuli;
  private final Iterator<E> elementsToInsert;
  private final Set<IteratorFeature> features;
  private final List<E> expectedElements;