final Lock lock;

    LockingThread(Lock lock) {
      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

		if err != nil {
			return err
		}
		pk.add(key.Kid, pkey)
	}

	return nil
}

func (pk *publicKeys) add(keyID string, key any) {
	pk.Lock()
	defer pk.Unlock()

	pk.pkMap[keyID] = key
}

func (pk *publicKeys) get(kid string) any {
	pk.RLock()
	defer pk.RUnlock()
	return pk.pkMap[kid]
}

// PopulatePublicKey - populates a new publickey from the JWKS URL.

            lock.readLock().unlock();
        }
    }

    /**
     * Get handle information by path
     * @param path the file path
     * @return the handle info or null if not found
     */
    public HandleInfo getHandleByPath(String path) {
        lock.readLock().lock();
        try {
            return handles.get(path);
        } finally {
            lock.readLock().unlock();
        }
    }

  enum Impl {
    EAGER {
      @Override
      Striped<Lock> get(int stripes) {
        return Striped.lock(stripes);
      }
    },
    LAZY_SMALL {
      @Override
      Striped<Lock> get(int stripes) {
        return new Striped.SmallLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    },
    LAZY_LARGE {
      @Override
      Striped<Lock> get(int stripes) {

            lock = new Smb2Lock(offset, length, flags);

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with zero offset and length")
        void testConstructorWithZeroValues() {
            lock = new Smb2Lock(0L, 0L, 0);

            assertNotNull(lock);
        }

        @Test

 */
package jcifs.internal.smb2.lock;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lock data structure.
 *
 * This class represents a single lock element used in
 * SMB2 Lock requests for byte-range locking.
 *
 * @author mbechler
 */
public class Smb2Lock implements Encodable {

    /**
     * Flag indicating a shared lock that allows concurrent read access.
     */

    void testClockTimezone() {
        MonotonicClock clock = MonotonicClock.get();

        assertEquals(ZoneOffset.UTC, clock.getZone(), "Clock should use UTC timezone");

        // Verify that attempting to change timezone returns the same instance
        Clock newClock = clock.withZone(ZoneId.systemDefault());
        assertSame(clock, newClock, "withZone() should return the same clock instance");
    }

    @Test

        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

     */
    int allocate() {
        try {
            lock.lock();
            return getAvailablePort();
        } finally {
            lock.unlock();
        }
    }

    /**
     * Deallocate the given port
     *
     * @param port The port to deallocate
     */
    public void deallocate(int port) {
        try {
            lock.lock();
            allocated.remove(Integer.valueOf(port));