Junit тестирование. Как создавать адекватные модули?

package Main;
import java.util.LinkedHashMap;
import java.util.Map;
 
 
 
public class LRUAlgoritm<K, V> implements Cache<K, V>{
     private LRUStorage storage; 
 
 
        public LRUAlgoritm(int capacity) {
            this.storage = new LRUStorage(capacity);
        }
 
    @Override
    public V get(K key) {
 
        return storage.get(key);
    }
    @Override
    public V put(K key, V value) {
 
        return storage.put(key,value);
    }
 
 
    private class LRUStorage extends LinkedHashMap<K, V>{
        private final int capacity;
 
        private LRUStorage (int capacity){
            this.capacity = capacity;
        }
        @Override
            protected boolean removeEl******try(Map.Entry<K, V> eldest){
                return size()>capacity ; 
            }
        }
 
    @Override
    public String toString() {
        return  "storage= " + storage ;
    }
 
 
}

package Main;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
 
public class LFUCache<K, V> implements Cache<K, V> {
 
    private final LinkedHashMap<K, Node> storage; //the declaration of the variable "storage" for storing data with key type "K" and value type "Node".
    private final int capacity;
 
    public LFUCache(int capacity) {
        if (capacity <= 0) {//validation of the capacity on the negative and the zero value
            throw new IllegalArgumentException("Capacity should be more than 0");
        }
        this.capacity = capacity;
        this.storage = new LinkedHashMap<>(capacity, 1); //initialization of variable "storage" - data storage. 
                                                            //Inside the parentheses: the specified initial capacity and load factor = 1 
    }
//overriding methods "get" and "put" to be implemented from the interface "Cache"
    @Override
    public V get(K key) {
        Node node = storage.get(key);//the get method of LinkedHashMap class according to the
                                        //"http://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashMap.html" 
                                        //returns "null" if the requested key is missing or 
                                        //has the value - a Hash mapping key if the key exists in the cache storage "storage"
        if (node == null) {//check the value of the variable "node" to NULL
            return null;
        }
        return node.incrementFrequency().getValue();//if the value of the variable "node" is not NULL, 
                                                    //then the called method to increase the frequency on the unit and 
                                                    //obtain take associated with the key "key" variable value "value"
    }
 
    @Override
    public V put(K key, V value) {
       //   if (storage.get(key)!=null&& Objects.equals(value, storage.get(key).getValue()))
        //{return storage.get(key).incrementFrequency().getValue();}//verification of the presence of the led element in the cache storage "storage" 
                                                                //if the element is present then return the value from the cache store
 
        doEvictionIfNeeded(key);//verification of occupancy of the cache storage, and the presence of the inserted key in the cache storage "storage"
 
        Node oldNode = storage.put(key, new Node(value));//the put method, inherited from Map interface, returns the previous value associated with key, 
                                                            //or null if there was no mapping for key
        if (oldNode == null) {
            return null;
        }
        return oldNode.getValue();
    }
 
 
// method to displace the old value with the least frequency when the storage of the cached data is completely filled
    private void doEvictionIfNeeded(K putKey) {
        if (storage.size() < capacity) {//verification of occupancy of the cache storage
            return;
        }
        long minFrequency = Long.MAX_VALUE;//the maximum assignable value for a variable of type Long
        K keyToRemove = null;
        for (Map.Entry<K, Node> entry : storage.entrySet()) {//search cash store the minimum value of frequency the "frequency" of all those elements
            if (Objects.equals(entry.getKey(), putKey)) {
                //no eviction required cause element already exists, we just need to replace it
                return;
            }
            if (minFrequency >= entry.getValue().getFrequency()) {
                minFrequency = entry.getValue().getFrequency();
                keyToRemove = entry.getKey();
            }
        }
        storage.remove(keyToRemove);//removal item's key with the minimum number of calls
    }
//an inner class "Node" in the object which is stored the value "value". 
    //And is created for this value a variable to hold the frequency "frequency" to the value "value'
    private class Node { 
        private final V value;
        private long frequency;
 
        //create a constructor with a parameter (a value of type V) to write the value in the node object.
        //And setting the initial value of the frequency of reference to "value" - "frequency" = 1
        public Node(V value) {
            this.value = value;
            this.frequency = 1;
        }
 
        public V getValue() {
            return value;
        }
 
        public long getFrequency() {
            return frequency;
        }
 
        public Node incrementFrequency() {// method to increase frequency by one(+1)
            ++frequency;
            return this;
        }
 
        @Override
        public String toString() {
            return "Node [value=" + value + ", frequency=" + frequency + "]";
        }
 
    }
    @Override
    public String toString() {
        return "storage = "+ storage + ", capacity=" + capacity ;
    }
}

package Test;
 
import static org.junit.Assert.*;
 
import org.junit.Test;
 
public class TestLRUAlgoritm {
 
    @Test
    public final void testRemoveEl******tryEntryOfKV() {
        fail("Not yet implemented");
    }
 
}