Java 使用Mockito隔离JUnit测试

我对如何应用Mockito框架有基本的了解。 但是当涉及到一些实时场景时，我没有单独编写测试（通过模拟依赖类）

您可以通过模拟PriorityQueue实现（BinaryMaxHeap.java）来帮助我编写PriorityQueuePrinter类的单元测试吗

我使用BinaryMaxHeap对象编写了testPriorityQueue（），在这种情况下，我的测试成功了，但我希望实现与模拟BinaryMaxHeap相同的结果，以便隔离测试。我认为我必须在我的测试方法中设置方法行为

简而言之，Priority Queue是BinaryHeapTree的实现，Printer类使用Priority Queue

下面是代码类

public interface PriorityQueue<T extends Comparable<T>> {
    int size();
    void insert(T element);
    T popMax();
}




public class BinaryMaxHeap<T extends Comparable<T>> implements PriorityQueue<T> {

    private ArrayList<T> items;

    public BinaryMaxHeap() {
        items = new ArrayList<T>();
    }   

    public int size() {
        return items.size();
    }

    public void insert(T element) {
        items.add(element);
        shiftUp();
    }

    public T popMax() {
        if (items.size() == 1) {
            return items.remove(0);
        }
        T hold = items.get(0);
        items.set(0, items.remove(items.size()-1));
        shiftDown();
        return hold;
    }

    /*
     * place newly added element in correct position in binary tree
     */
    private void shiftUp() {
        int k = items.size() - 1;
        while (k > 0) {
            int p = (k-1) / 2;  // get parent element index
            T child = items.get(k);
            T parent = items.get(p);
            if (child.compareTo(parent) > 0) {
                // parent and child are not in correct position, need to swap
                items.set(k, parent);
                items.set(p, child);
                k = p;
            } else {
                break;
            }
        }
    }

    private void shiftDown() {
        int k = 0;
        int l = 2*k+1;  // left leaf node
        while (l < items.size()) {
            int max = l;    // assume left node as max element
            int r = l+1;    // right leaf node
            if (r < items.size()) { 
                if (items.get(r).compareTo(items.get(l)) > 0) { 
                    max++;  // identify max element in leaf nodes
                }
            }
            T parent = items.get(k);
            T child = items.get(max);
            if (parent.compareTo(child) < 0) {
                // parent element is less than leaf node, need to swap it
                    T temp = items.get(k);
                    items.set(k, items.get(max));
                    items.set(max, temp);
                    k = max;
                    l = 2*k+1;
            } else {
                break;
            }
        }
    }
 }

public interface Printer {
    public <T extends Comparable<T>> String asSortedString(T... values);
}

public class PriorityQueuePrinter implements Printer {

    private PriorityQueue priorityQueue = null;

    public <T extends Comparable<T>> PriorityQueuePrinter(PriorityQueue<T> priorityQueue) {
        this.priorityQueue = priorityQueue;
    }

    public <T extends Comparable<T>> String asSortedString(T... values) {

        //PriorityQueue<T> priorityQueue = 
        addElements(values);
        //return getSortedElements();
        return null;
    }

    private <T extends Comparable<T>> void addElements(T... values) {
        //PriorityQueue<T> priorityQueue = new BinaryMaxHeap<T>();
        for (T element : values) {
            priorityQueue.insert(element);
        }
        //return priorityQueue;
    }

    public int size() {
        return priorityQueue.size();
    }

    private String getSortedElements() {
        StringBuilder sortedElements =  new StringBuilder();
        boolean isFirstElement = true;
        while(priorityQueue.size() > 0) {
            if (!isFirstElement) {
                sortedElements.append(",");
            }
            isFirstElement = false;
            sortedElements.append(priorityQueue.popMax());
        }
        return sortedElements.toString();
    }

    public static void main(String a[]) {
        PriorityQueuePrinter p = new PriorityQueuePrinter(new BinaryMaxHeap<Integer>());
        String sortedElements = p.asSortedString(1,4,6,3,2);
        System.out.println(sortedElements);
    }
}

公共接口优先队列{
int size（）；
空心插件（T元件）；
T popMax（）；
}
公共类BinaryMaxHeap实现PriorityQueue{
私有ArrayList项；
公共二进制maxheap（）{
items=newarraylist（）；
}   
公共整数大小（）{
返回items.size（）；
}
公共空白插入（T元素）{
添加（元素）；
shiftUp（）；
}
公共T popMax（）{
如果（items.size（）==1）{
返回项目。删除（0）；
}
T hold=items.get（0）；
items.set（0，items.remove（items.size（）-1））；
shiftDown（）；
返回保持；
}
/*
*将新添加的元素放置在二叉树中的正确位置
*/
私有void shiftUp（）{
int k=items.size（）-1；
而（k>0）{
int p=（k-1）/2；//获取父元素索引
T child=items.get（k）；
T parent=items.get（p）；
如果（子项比较到（父项）>0）{
//父项和子项位置不正确，需要交换
项目集（k，父项）；
项目集（p，子项）；
k=p；
}否则{
打破
}
}
}
私有void shiftDown（）{
int k=0；
int l=2*k+1；//左叶节点
而（l0{
max++；//标识叶节点中的max元素
}
}
T parent=items.get（k）；
T child=items.get（最大值）；
if（父级比较到（子级）<0）{
//父元素小于叶节点，需要交换它
T temp=项目获取（k）；
items.set（k，items.get（max））；
项目设置（最大值、温度）；
k=最大值；
l=2*k+1；
}否则{
打破
}
}
}
}
公共接口打印机{
公共字符串分类字符串（T…值）；
}
公共类PriorityQueuePrinter实现打印机{
private PriorityQueue PriorityQueue=null；
公共优先级队列打印机（优先级队列优先级队列）{
this.priorityQueue=priorityQueue；
}
公共字符串分类字符串（T…值）{
//优先级队列优先级队列=
加法（值）；
//返回getSortedElements（）；
返回null；
}
私有无效加法器（T…值）{
//PriorityQueue PriorityQueue=new BinaryMaxHeap（）；
对于（T元素：值）{
priorityQueue.insert（元素）；
}
//返回优先队列；
}
公共整数大小（）{
return priorityQueue.size（）；
}
私有字符串getSortedElements（）{
StringBuilder sortedElements=新StringBuilder（）；
布尔值isFirstElement=true；
while（priorityQueue.size（）>0）{
如果（！isFirstElement）{
sortedElements.追加（“，”）；
}
isFirstElement=false；
append（priorityQueue.popMax（））；
}
返回sortedElements.toString（）；
}
公共静态void main（字符串a[]{
PriorityQueuePrinter p=new PriorityQueuePrinter（new BinaryMaxHeap（））；
字符串分类数据=p.分类字符串（1,4,6,3,2）；
系统输出打印LN（分类删除）；
}
}

下面是已尝试但无法完成的示例测试代码

public class PrinterTest {
    @Mock
PriorityQueue<Integer> mockPriorityQueue;   // mock object
PriorityQueue<Integer> priorityQueue;

@Test
public void testPriorityQueueWithMock() {

    PriorityQueuePrinter printer = new PriorityQueuePrinter(mockPriorityQueue);
    String s = printer.asSortedString(5,3,6);
    assertEquals("6,5,3", s);
}

@Ignore
public void testPriorityQueue() {
    priorityQueue = new BinaryMaxHeap<Integer>();
    PriorityQueuePrinter printer = new PriorityQueuePrinter(priorityQueue);

    String s = printer.asSortedString(5,3,6);

    assertEquals("6,5,3", s);
}

@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
}

@After
public void tearDown() throws Exception {
    System.out.println("==tearDown==");
}
    }

    @Before
    public void setUp() throws Exception {
        //mockPriorityQueue = new BinaryMaxHeap<Integer>();
        MockitoAnnotations.initMocks(this);
    }
}

公共类PrinterTest{
@嘲弄
PriorityQueue mockPriorityQueue；//模拟对象
优先队列优先队列；
@试验
public void testPriorityQueueWithMock（）{
PriorityQueuePrinter打印机=新的PriorityQueuePrinter（mockPriorityQueue）；
字符串s=打印机。组合字符串（5,3,6）；
资产质量（“6,5,3”，s）；
}
@忽略
public void testPriorityQueue（）{
priorityQueue=new BinaryMaxHeap（）；
PriorityQueuePrinter打印机=新的PriorityQueuePrinter（priorityQueue）；
字符串s=打印机。组合字符串（5,3,6）；
资产质量（“6,5,3”，s）；
}
@以前
public void setUp（）引发异常{
initMocks（this）；
}
@之后
public void tearDown（）引发异常{
System.out.println（“==拆卸==”）；
}
}
@以前
public void setUp（）引发异常{
//mockPriorityQueue=new BinaryMaxHeap（）；
initMocks（this）；
}
}

您的问题是什么？如果您得到了异常，请发布itI。我没有任何线索可以通过模拟PriorityQueue为PriorityQueuePrinter类单独编写测试。若我创建了普通的PriorityQueuePrinter对象，那个么我就能够为分类字符串（…）方法编写测试用例。我必须用Mock object实现相同的行为。删除setUp（）方法，删除@Mock，并将mockPriorityQueue初始化为Mockito。Mock（PriorityQueue.class）@Nadir，如果我执行上述设置，我将获得什么好处。无论如何，这两种方法都是创建Mock对象的相同方法。我认为您使用的是注释，也使用mockito运行程序，不必手动调用MockitoAnnotations。