使用信号量为班级创建测试

Question

我上课的任务如下： -只允许x个用户进入系统， -仅处理给定用户的y个请求， -只处理所有用户的z个请求 -每个请求都可以等待给定的时间来处理

import lombok.Getter;
import lombok.Setter;

import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

@Setter
@Getter
public class RequestsLimiter {

    private int maxNumberOfRequestsFromSingleUser;
    private long waitTimeInMillis;
    private Semaphore usersLimiter;
    private Semaphore requestsLimiter;
    private ConcurrentHashMap<String, Semaphore> requestsPerUserLimiter = new ConcurrentHashMap<>();


    public RequestsLimiter(int maxNumberOfUsers, int maxNumberOFRequestsPerUser, int maxNumberOfRequests, long waitTimeInMillis) {
        usersLimiter = new Semaphore(maxNumberOfUsers);
        this.maxNumberOfRequestsFromSingleUser = maxNumberOFRequestsPerUser;
        requestsLimiter = new Semaphore(maxNumberOfRequests);
        this.waitTimeInMillis = waitTimeInMillis;
    }


    public boolean work(String user) throws InterruptedException {
        long startTime = new Date().getTime();
        if (tryLogin(user) && tryPassRequestFromUser(user, startTime) && trySendRequest(user, startTime)) {
            TimeUnit.MILLISECONDS.sleep((int) (Math.random() * 2000));
            return true;
        } else {
            return false;
        }
    }

    private boolean trySendRequest(String user, long startTime) throws InterruptedException {
        try {
            return checkIfRequestCanBeSend(startTime);
        } finally {
            requestsLimiter.release();
        }
    }

    private boolean tryPassRequestFromUser(String user, long startTime) throws InterruptedException {
        try {
            return checkIfUserCanGenerateRequest(user, startTime);
        } finally {
            releaseSlotForGivenUser(user);
        }
    }

    private boolean tryLogin(String user) throws InterruptedException {
        if (requestsPerUserLimiter.containsKey(user)) {
            return true;
        } else {
            return usersLimiter.tryAcquire(waitTimeInMillis, TimeUnit.MILLISECONDS);
        }
    }

    private boolean checkIfUserCanGenerateRequest(String user, long startTime) throws InterruptedException {
        if (!requestsPerUserLimiter.containsKey(user))
            requestsPerUserLimiter.put(user, new Semaphore(maxNumberOfRequestsFromSingleUser));
        return requestsPerUserLimiter.get(user).tryAcquire(waitTimeInMillis - (new Date().getTime() - startTime), TimeUnit.MILLISECONDS);
    }

    private boolean checkIfRequestCanBeSend(long startTime) throws InterruptedException {
        return requestsLimiter.tryAcquire(waitTimeInMillis - (new Date().getTime() - startTime), TimeUnit.MILLISECONDS);
    }


    private void releaseSlotForGivenUser(String user) {
        requestsPerUserLimiter.get(user).release();
        if (requestsPerUserLimiter.get(user).availablePermits() == maxNumberOfRequestsFromSingleUser) {
            requestsPerUserLimiter.remove(user);
            usersLimiter.release();
        }
    }

}

我可以问您一些如何正确测试的提示吗？我真的很难尝试找出答案