Trans2FindFirst2Response resp = inv.getArgument(1);
            // First response content
            FE[] res = java.util.Arrays.stream(batches.get(0)).map(FE::new).toArray(FE[]::new);
            setField(resp, jcifs.internal.smb1.trans.SmbComTransactionResponse.class, "results", res);
            setField(resp, Trans2FindFirst2Response.class, "sid", 42);

            }
        }

        final String[] hosts = split(ResourceUtil.getFesenHttpUrl(), ",")
                .get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        nodeManager = new NodeManager(hosts, node -> request(new CurlRequest(Method.GET, node.getUrl("/"))));
        nodeManager.setHeartbeatInterval(fessConfig.getFesenHeartbeatInterval());
    }

            _conditionAggregation.getAggregationBuilderList().forEach(builder::addAggregation);
        }

        if (_specification != null) {
            builder.setFetchSource(_specification.columnList.toArray(new String[_specification.columnList.size()]), null);
        }

        return builder;
    }

    // ===================================================================================

      chars.add(randomAlpha());
    }
    for (int i = 0; i < nonAlpha; i++) {
      chars.add(randomNonAlpha());
    }
    Collections.shuffle(chars, random);
    char[] array = Chars.toArray(chars);
    this.testString = new String(array);
  }

  private char randomAlpha() {
    return ALPHA.charAt(random.nextInt(ALPHA.length()));
  }

  private char randomNonAlpha() {

  }

  @SuppressWarnings("unchecked") // Generic array creation
  CompoundOrdering(Iterable<? extends Comparator<? super T>> comparators) {
    this.comparators =
        Iterables.toArray(comparators, (Comparator<? super T>[]) new Comparator<?>[0]);
  }

  @Override
  public int compare(@ParametricNullness T left, @ParametricNullness T right) {
    for (int i = 0; i < comparators.length; i++) {

                searchLog.setUserSessionId(userCode);
                searchLog.setUserInfo(getUserInfo(userCode));
            }
        }

        searchLog.setRoles(roleQueryHelper.build(params.getType()).stream().toArray(n -> new String[n]));
        searchLog.setQueryId(queryId);
        searchLog.setHitCount(queryResponseList.getAllRecordCount());
        searchLog.setHitCountRelation(queryResponseList.getAllRecordCountRelation());

  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArrayEmpty() {
    Iterator<String> iterator = Collections.<String>emptyList().iterator();
    String[] array = Iterators.toArray(iterator, String.class);
    assertTrue(Arrays.equals(new String[0], array));
  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArraySingleton() {

    doTestToArrayImpl1(Lists.newArrayList(1));
    doTestToArrayImpl1(Lists.<@Nullable Integer>newArrayList(1, null, 3));
  }

  private void doTestToArrayImpl1(List<Integer> list) {
    Object[] reference = list.toArray();
    Object[] target = ObjectArrays.toArrayImpl(list);
    assertEquals(reference.getClass(), target.getClass());
    assertTrue(Arrays.equals(reference, target));
  }

  public void testToArrayImpl2() {

                ciphers.add(EncryptionNegotiateContext.CIPHER_AES128_CCM);

                int[] cipherArray = ciphers.stream().mapToInt(Integer::intValue).toArray();
                negoContexts.add(new EncryptionNegotiateContext(config, cipherArray));
            }

            // Add compression context for SMB3 compression support

   *
   * <p><b>{@code Stream} equivalent:</b> if an object array is acceptable, use {@code
   * stream.toArray()}; if {@code type} is a class literal such as {@code MyType.class}, use {@code
   * stream.toArray(MyType[]::new)}. Otherwise use {@code stream.toArray( len -> (E[])
   * Array.newInstance(type, len))}.
   *
   * @param type the type of the elements