* insert a key-value pair with a key that isn't already in the multimap, {@code
 * AbstractMapBasedMultimap} calls {@link #createCollection()} to create the collection of values
 * for that key. The subclass should not call {@link #createCollection()} directly, and a new
 * instance should be created every time the method is called.
 *

        }

        @Override
        public String getServletPath() {
            return "";
        }

        @Override
        public jakarta.servlet.http.HttpSession getSession(boolean create) {
            return null;
        }

        @Override
        public jakarta.servlet.http.HttpSession getSession() {
            return null;
        }

        @Override

    void testConstructorWithDifferentInfoClasses(byte infoClass, String description) {
        response = new Smb2QueryDirectoryResponse(mockConfig, infoClass);

        assertNotNull(response, "Should create response for " + description);
        assertNull(response.getResults());
    }

    @Test
    @DisplayName("Test readBytesWireFormat handles entry with nextEntryOffset loop correctly")

	if newCred.ParentUser != globalActiveCred.AccessKey {
		replLogIf(ctx, globalSiteReplicationSys.IAMChangeHook(ctx, madmin.SRIAMItem{
			Type: madmin.SRIAMItemSvcAcc,
			SvcAccChange: &madmin.SRSvcAccChange{
				Create: &madmin.SRSvcAccCreate{
					Parent:        newCred.ParentUser,
					AccessKey:     newCred.AccessKey,
					SecretKey:     newCred.SecretKey,
					Groups:        newCred.Groups,
					Name:          newCred.Name,

 *
 * Start a {@code ClosingFuture} pipeline {@linkplain #submit(ClosingCallable, Executor) from a
 * callable block} that may capture objects for later closing. To start a pipeline from a {@link
 * ListenableFuture} that doesn't create resources that should be closed later, you can use {@link
 * #from(ListenableFuture)} instead.
 *
 * <h3>Derived steps</h3>
 *

	}
	return paths
}

// string concat alternative to s1 + s2 with low overhead.
func concat(ss ...string) string {
	length := len(ss)
	if length == 0 {
		return ""
	}
	// create & allocate the memory in advance.
	n := 0
	for i := range length {
		n += len(ss[i])
	}
	b := make([]byte, 0, n)
	for i := range length {
		b = append(b, ss[i]...)
	}

 * <p>Implementations that choose to support the {@link #add(Range)} operation are required to
 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * {@snippet :
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();
 * rangeSet.add(Range.closed(1, 10)); // {[1, 10]}
 * rangeSet.add(Range.closedOpen(11, 15)); // disconnected range; {[1, 10], [11, 15)}
 * rangeSet.add(Range.closedOpen(15, 20)); // connected range; {[1, 10], [11, 20)}

            .createTestSuite());

    suite.addTest(
        SetTestSuiteBuilder.using(
                new TestStringSetGenerator() {
                  @Override
                  protected Set<String> create(String[] elements) {
                    ImmutableSet.Builder<String> builder = ImmutableSet.builder();
                    builder.forceJdk();
                    builder.add(elements);

import jcifs.Configuration;
import jcifs.internal.CommonServerMessageBlockRequest;
import jcifs.internal.smb1.com.SmbComBlankResponse;
import jcifs.internal.smb1.com.SmbComClose;
import jcifs.internal.smb2.create.Smb2CloseRequest;

@ExtendWith(MockitoExtension.class)
class SmbFileHandleImplTest {

    @Mock
    Configuration cfg;

    @Mock
    SmbTreeHandleImpl tree;

        Name mockRecordName = new Name(mockConfig);
        recordNameField.set(nameQueryResponse, mockRecordName);

        NbtAddress[] addresses = new NbtAddress[2];
        // Create dummy NbtAddress objects for testing toString
        addresses[0] = new NbtAddress(mockRecordName, 0xC0A80101, false, 0); // 192.168.1.1
        addresses[1] = new NbtAddress(mockRecordName, 0x0A000005, true, 1); // 10.0.0.5