when(handle.isValid()).thenReturn(true);
        when(handle.getTree()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(false);
        when(tree.hasCapability(SmbConstants.CAP_NT_SMBS)).thenReturn(false);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        assertThrows(SmbUnsupportedOperationException.class, sut::watch);
        verify(tree, times(1)).close();
    }

	{dataBlocks: 3, disks: 6, offDisks: 2, badDisks: 0, badStaleDisks: 0, blocksize: int64(blockSizeV2), size: oneMiByte, algorithm: BLAKE2b512, shouldFail: false},               // 1
	{dataBlocks: 4, disks: 8, offDisks: 2, badDisks: 1, badStaleDisks: 0, blocksize: int64(blockSizeV2), size: oneMiByte, algorithm: BLAKE2b512, shouldFail: false},               // 2

        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);
        when(delegate.next()).thenReturn(entry1, entry2);
        when(filter.accept(resource)).thenReturn(false, true);

        TestIterator iterator = new TestIterator(filter);

        // Verify iteration
        assertTrue(iterator.hasNext());

		oTime := oVers.latestModtime()
		if !eTime.Equal(oTime) {
			if eTime.After(oTime) {
				return e, false
			}
			return other, false
		}
		// Tiebreak on version count.
		if len(eVers.versions) > len(oVers.versions) {
			return e, false
		}
		return other, false
	}

	// Check if each version matches...
	for i, eVer := range eVers.versions {
		oVer := oVers.versions[i]

        FILE_NOT_FOUND("File not found", ErrorCategory.FILE_SYSTEM, false), PATH_NOT_FOUND("Path not found", ErrorCategory.FILE_SYSTEM,
                false), FILE_EXISTS("File already exists", ErrorCategory.FILE_SYSTEM, false), DIRECTORY_NOT_EMPTY("Directory not empty",
                        ErrorCategory.FILE_SYSTEM, false), DISK_FULL("Disk full", ErrorCategory.RESOURCE,
                                false), QUOTA_EXCEEDED("Quota exceeded", ErrorCategory.RESOURCE, false),

@GwtCompatible
@NullUnmarked
public abstract class AbstractImmutableSortedMapMapInterfaceTest<K, V>
    extends SortedMapInterfaceTest<K, V> {
  public AbstractImmutableSortedMapMapInterfaceTest() {
    super(false, false, false, false, false);
  }

  @Override
  protected SortedMap<K, V> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  private static final Joiner JOINER = Joiner.on(", ");

  @Override

        // Setup request session
        lenient().when(request.getSession()).thenReturn(session);
        lenient().when(request.getSession(false)).thenReturn(session);
        lenient().when(request.getSession(true)).thenReturn(session);

        // Setup default session attribute behavior
        lenient().when(session.getAttribute(anyString())).thenReturn(null);

                    if (rpc.retval != 0) {
                        throw new SmbException(rpc.retval, false);
                    }
                }

                return new SID(info.sid, jcifs.SID.SID_TYPE_DOMAIN, new UnicodeString(info.name, false).toString(), null, false);
            } catch (final IOException e) {
                throw new CIFSException("Failed to get SID from server", e);

        SmbTreeImpl shared = mock(SmbTreeImpl.class);
        when(shared.acquire(false)).thenReturn(shared);

        setTree(c1, shared);
        setTree(c2, shared);
        assertTrue(c1.isSame(c2));

        SmbTreeImpl other = mock(SmbTreeImpl.class);
        when(other.acquire(false)).thenReturn(other);
        setTree(c2, other);
        assertFalse(c1.isSame(c2));
    }

    @Test

		// Invalid cases
		mkParams("", true, true),
		mkParams("111", true, true),
		mkParams("111", true, false),
		mkParams("111", false, true),
		// Valid cases follow
		mkParams("", true, false),
		mkParams("", false, true),
		mkParams("", false, false),
		mkParams("111", false, false),
	}
	varsArr := []map[string]string{
		// Invalid cases
		{mgmtPrefix: "objprefix"},
		// Valid cases
		{},