import junit.framework.TestCase;

/** @author David Beaumont */
@GwtCompatible
public class ArrayBasedEscaperMapTest extends TestCase {
  public void testNullMap() {
    assertThrows(NullPointerException.class, () -> ArrayBasedEscaperMap.create(null));
  }

  public void testEmptyMap() {
    Map<Character, String> map = ImmutableMap.of();
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);

    private boolean insideGet;

    @Deprecated
    protected void getTransfer(Resource resource, File destination, InputStream input, boolean closeInput, int maxSize)
            throws TransferFailedException {
        addTransfer("getTransfer " + resource.getName());
        super.getTransfer(resource, destination, input, closeInput, maxSize);
    }

    public void get(String resourceName, File destination)

        return buffer;
    }

    static void writeULong(byte[] dest, int offset, int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);
        dest[offset + 2] = (byte) (ulong >> 16 & 0xff);
        dest[offset + 3] = (byte) (ulong >> 24 & 0xff);
    }

    static void writeUShort(byte[] dest, int offset, int ushort) {

    protected long crawlerWaitMillis = 10000;

    protected List<IntervalRule> ruleList = new ArrayList<>();

    public void checkCrawlerStatus() {
        while (!crawlerRunning) {
            ThreadUtil.sleepQuietly(crawlerWaitMillis);
        }
    }

    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

            setNext(null);
            n.clearFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        }
        return n;
    }


    /**
     * 
     * @param next
     */
    public void setNext ( ServerMessageBlock2Request<?> next ) {
        super.setNext(next);
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#getCreditCost()
     */

    public int previousIndex() {
      return nextIndex - 1;
    }

    @Override
    public void set(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void add(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    void setValue(@ParametricNullness V value) {
      checkState(current != null);
      current.value = value;
    }

          || !(uncontended = a.cas(v = a.value, v + x))) retryUpdate(x, hc, uncontended);
    }
  }

  /** Equivalent to {@code add(1)}. */
  @Override
  public void increment() {
    add(1L);
  }

  /** Equivalent to {@code add(-1)}. */
  public void decrement() {
    add(-1L);
  }

  /**
   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in

    }

    public Transformer getTransformer() {
        return transformer;
    }

    public void setTransformer(final Transformer transformer) {
        this.transformer = transformer;
    }

    public int[] getSuccessfulHttpCodes() {
        return successfulHttpCodes;
    }

    public void setSuccessfulHttpCodes(final int[] successfulHttpCodes) {
        this.successfulHttpCodes = successfulHttpCodes;

    }


    void setUid ( int uid ) {
        this.uid = uid;
    }


    void setSessionSetup ( Smb2SessionSetupResponse response ) {
        this.extendedSecurity = true;
        this.connectionState.set(2);
        this.sessionId = response.getSessionId();
    }


    void setSessionSetup ( SmbComSessionSetupAndXResponse response ) {

import static org.junit.jupiter.api.Assertions.assertThrows;

class FileSizeFormatTest {

    @Test
    void testNegativeSize() {
        FileSizeFormat format = new FileSizeFormat();

        long negativeSize = -100L;
        assertThrows(IllegalArgumentException.class, () -> format.format(negativeSize));
    }

    @Test
    void testSize() {
        FileSizeFormat format = new FileSizeFormat();

        long _0_bytes = 0L;