return new String[length];
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // suite
  @AndroidIncompatible // test-suite builders
  public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTest(
        BiMapTestSuiteBuilder.using(new EnumHashBiMapGenerator())
            .named("EnumHashBiMap")
            .withFeatures(
                CollectionSize.ANY,

    String upperString = testString.toUpperCase();
    CharSequence testSeq = new StringBuilder(testString);
    CharSequence upperSeq = new StringBuilder(upperString);
    CharSequence[] lhs = new CharSequence[] {testString, testSeq, testString, testSeq};
    CharSequence[] rhs = new CharSequence[] {upperString, upperString, upperSeq, upperSeq};

    boolean dummy = false;

  private static List<String> newDelegatingList(List<String> delegate) {
    return Reflection.newProxy(List.class, new DelegatingInvocationHandler(delegate));
  }

  @SuppressWarnings("unchecked") // proxy of List<String>
  private static List<String> newDelegatingListWithEquals(List<String> delegate) {
    return Reflection.newProxy(List.class, new DelegatingInvocationHandlerWithEquals(delegate));
  }

     */
    public static ZipFile create(final String file) {
        assertArgumentNotEmpty("file", file);

        try {
            return new ZipFile(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Creates and returns a <code>ZipFile</code> for reading the specified file.
     *
     * @param file

    private static final Logger log = LoggerFactory.getLogger(DisniMemoryRegion.class);
    private static final AtomicInteger keyGenerator = new AtomicInteger(2000);
    private static final AtomicLong addressCounter = new AtomicLong(0x10000000L);
    private static final Map<ByteBuffer, Long> bufferAddresses = new ConcurrentHashMap<>();

    // DiSNI objects - would be actual DiSNI types in real implementation

            crawlingInfo = new CrawlingInfo(sessionId);
            try {
                getCrawlingInfoService().store(crawlingInfo);
            } catch (final Exception e) {
                throw new FessSystemException("No crawling session.", e);
            }
        }

        if (infoMap != null) {
            final List<CrawlingInfoParam> crawlingInfoParamList = new ArrayList<>();

        KeyMatchCQ cq = new KeyMatchCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            KeyMatchCA ca = new KeyMatchCA();
            aggsLambda.callback(ca);

        new TreeBasedTable<>(
            requireNonNull(table.rowKeySet().comparator()), table.columnComparator());
    result.putAll(table);
    return result;
  }

  TreeBasedTable(Comparator<? super R> rowComparator, Comparator<? super C> columnComparator) {
    super(new TreeMap<R, Map<C, V>>(rowComparator), new Factory<C, V>(columnComparator));

  public static <E extends @Nullable Object> HashSet<E> newHashSet(Iterator<? extends E> elements) {
    HashSet<E> set = new HashSet<>();
    Iterators.addAll(set, elements);
    return set;
  }

  /**
   * Returns a new hash set using the smallest initial table size that can hold {@code expectedSize}

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    private volatile boolean shutdown = false;

    /**
     * Create a new persistent handle manager
     * @param context the CIFS context
     */
    public PersistentHandleManager(CIFSContext context) {
        this.context = context;
        this.handles = new ConcurrentHashMap<>();
        this.guidToHandle = new ConcurrentHashMap<>();