for i := 0; i < 2+numReaders; i++ {
		<-cdone
	}
}

// Borrowed from rwmutex_test.go
func TestRWMutex(t *testing.T) {
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
	n := 1000
	if testing.Short() {
		n = 5
	}
	HammerRWMutex(1, 1, n)
	HammerRWMutex(1, 3, n)
	HammerRWMutex(1, 10, n)
	HammerRWMutex(4, 1, n)
	HammerRWMutex(4, 3, n)
	HammerRWMutex(4, 10, n)
	HammerRWMutex(10, 1, n)

                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        DirectoryCacheEntry entry = directoryLeaseManager.getCacheEntry(directoryPath);
        assertNotNull(entry);

        // Set very short expiration time
        entry.setMaxAge(50); // 50ms

        // Update cache
        List<SmbFile> files = Arrays.asList(mockFile1);
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

/**
 * Test class for Smb2TreeDisconnectRequest functionality
 */
@DisplayName("Smb2TreeDisconnectRequest Tests")
@ExtendWith(MockitoExtension.class)
class Smb2TreeDisconnectRequestTest {

    private static final short SMB2_TREE_DISCONNECT = 0x0004;

    @Test
    @DisplayName("Should create request with correct command type")
    void testConstructorSetsCorrectCommand() throws Exception {
        // Given

          sink.putByte((byte) value);
        }
      }
    },
    PUT_SHORT() {
      @Override
      void performAction(Random random, Iterable<? extends PrimitiveSink> sinks) {
        short value = (short) random.nextInt();
        for (PrimitiveSink sink : sinks) {
          sink.putShort(value);
        }
      }
    },
    PUT_CHAR() {
      @Override

          end = ipString.length();
        }
        if (ipString.charAt(start) == IPV6_DELIMITER) {
          // expand zeroes
          for (int i = 0; i < partsSkipped; i++) {
            rawBytes.putShort((short) 0);
          }

        } else {
          rawBytes.putShort(parseHextet(ipString, start, end));
        }
        start = end + 1;
      }
    } catch (NumberFormatException ex) {
      return null;

        SameDoubleInstance that = (SameDoubleInstance) obj;
        return i == that.i;
      }
      return false;
    }
  }

  static class SameShortInstance {
    private final Short i;

    public SameShortInstance(Short i) {
      this.i = checkNotNull(i);
    }

    @Override
    public int hashCode() {
      return i.hashCode();
    }

    @Override

    }

    private static boolean isTypeCompatible(Class<?> type, Object value) {
        if (type.isInstance(value)) {
            return true;
        }
        // likely Boolean -> boolean, Short -> int etc. conversions, it's not the problem case we try to avoid
        return ((type.isPrimitive() || type.getName().startsWith("java.lang."))
                && value.getClass().getName().startsWith("java.lang."));
    }

        assertEquals(2, countField.get(lookupSids));

        Field levelField = lsarpc.LsarLookupSids.class.getDeclaredField("level");
        levelField.setAccessible(true);
        assertEquals((short) 1, levelField.get(lookupSids));
    }

    @Test
    void constructor_shouldCreateCorrectLsarSidArrayX() throws Exception {
        // Arrange
        jcifs.SID mockSid1 = mock(jcifs.SID.class);

    in '0'..'9' -> this - '0'
    in 'a'..'f' -> this - 'a' + 10
    in 'A'..'F' -> this - 'A' + 10
    else -> -1
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

internal infix fun Int.and(mask: Long): Long = toLong() and mask

@Throws(IOException::class)
internal fun BufferedSink.writeMedium(medium: Int) {

	}

	if cap(t.requestsPool) != apiRequestsMaxPerNode {
		// Only replace if needed.
		// Existing requests will use the previous limit,
		// but new requests will use the new limit.
		// There will be a short overlap window,
		// but this shouldn't last long.
		t.requestsPool = make(chan struct{}, apiRequestsMaxPerNode)
	}
	listQuorum := cfg.ListQuorum
	if listQuorum == "" {
		listQuorum = "strict"
	}