final int index = offset + SIGNATURE_OFFSET;
            for (int i = 0; i < SIGNATURE_LENGTH; i++) {
                data[index + i] = 0;
            }

            // set signed flag
            final int oldFlags = SMBUtil.readInt4(data, offset + 16);
            final int flags = oldFlags | ServerMessageBlock2.SMB2_FLAGS_SIGNED;
            SMBUtil.writeInt4(flags, data, offset + 16);

                Arguments.of("复杂名.txt", "unicode name is preserved"), Arguments.of(null, "null name is passed through"));
    }

    @ParameterizedTest(name = "getName returns as-set: [{0}] - {1}")
    @MethodSource("nameProvider")
    void name_edgeCases(String name, String caseDesc) {
        // Arrange
        FileEntry e = new TestFileEntry(name, 0, 0, 0L, 0L, 0L, 0L, 0);
        // Act

    private void setPrivateField(Object target, String fieldName, Object value) throws Exception {
        Field field = findField(target.getClass(), fieldName);
        field.setAccessible(true);
        field.set(target, value);
    }

    private Field findField(Class<?> clazz, String fieldName) {
        while (clazz != null) {
            try {
                return clazz.getDeclaredField(fieldName);

        ServerMessageBlock response = new SmbComOpenAndXResponse();

        // Execute send
        tree.send(request, response);

        // Verify session.send was called and tid was set
        verify(session).send(request, response);
        assertEquals(123, request.tid);
    }

    @Test
    void testSendWithDfs() throws SmbException {

                }
            }
        }

        /*
         * MNG-4312: We neither have reserved all of the above magic expressions nor is their set fixed/well-known (it
         * gets occasionally extended by newer Maven versions). This imposes the risk for existing plugins to

   * <i>should</i> hold {@code expectedSize} elements without rebuilding internal data structures.
   *
   * @param expectedSize the number of elements you expect to add to the returned set
   * @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */

          Function<? super T, ? extends V> valueFunction) {
    return CollectCollectors.toImmutableBiMap(keyFunction, valueFunction);
  }

  // Casting to any type is safe because the set will never hold any elements.
  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableBiMap<K, V> of() {
    return (ImmutableBiMap<K, V>) RegularImmutableBiMap.EMPTY;
  }

import static com.google.common.collect.Platform.reduceIterationsIfGwt;
import static com.google.common.collect.ReflectionFreeAssertThrows.assertThrows;
import static com.google.common.collect.Sets.newHashSet;
import static com.google.common.truth.Truth.assertThat;
import static java.util.Arrays.asList;
import static java.util.Collections.shuffle;

import com.google.common.annotations.GwtCompatible;

   * calls the comparator to compare the two keys. If that change is made,
   * AbstractMultiset.equals() can simply check whether two multisets have equal entry sets.
   */

  /**
   * @serialData the comparator, the number of distinct elements, the first element, its count, the
   *     second element, its count, and so on
   */
  @GwtIncompatible

	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	// Write success response.
	writeSuccessResponseJSON(w, configData)
}

// SetRemoteTargetHandler - sets a remote target for bucket
func (a adminAPIHandlers) SetRemoteTargetHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	vars := mux.Vars(r)
	bucket := pathClean(vars["bucket"])