我怎样才能在这个程序中实现JUnit测试以进行二进制搜索

Question

我如何在该程序中实现 JUnit 测试以进行二进制搜索，我对这项任务感到非常不知所措，因为我真的不熟悉 JUnit，而且我有所有这些包和路径，你在我需要使用的代码中看到

。

我已经尝试为我制作的普通 Java 类实现测试，但这也没有用，如果有人也可以向我解释我的代码的一些测试的语法，那就太好了。

package de.hska.iwi.ads.solution.search;
import java.security.acl.LastOwnerException;
import de.hska.iwi.ads.search.Search;
public class BinarySearch<E extends Comparable<E>> implements Search<E> {

@Override
public int search(E[] a, E key, int lower, int upper) {
    // TODO Auto-generated method stub
    this.lower = lower;
    this.upper = upper;
    if(upper > a.length) {
        throw new ArrayIndexOutOfBoundsException();
    }
    int ret = binarySearch(a, key, lower, upper);
    return returnValue;
}
int lower;
int upper;
int returnValue;

/**
 * 
 * @param a Array, der durchsucht werden soll.
 * @param key Element, nach dem gesucht wird.
 * @param lower untere Grenze des zu durchsuchenden Bereiches.
 * @param upper obere Grenze des zu durchsuchenden Bereiches.
 * @return index der Stelle wo daa Elemnt ist.
 */
private int binarySearch(E[] a, E key, int lower, int upper) {
    if (lower < upper) {
        int middle = (lower / 2) + (upper / 2);
        int tempInt = a[middle].compareTo(key);
        if (tempInt > 0) {
            return binarySearch(a, key, lower, middle - 1);
        }
        if (tempInt < 0) {
            return binarySearch(a, key, middle + 1, upper);
        }
        this.returnValue = middle;
        if (key.equals(a[middle]) && !key.equals(a[middle-1])) {
            return middle;
        } else {
            return binarySearch(a, key, lower, middle-1);
        }
    }
    if (key.equals(a[lower])) {
        this.returnValue = lower;
        int temp = checkForDuplicates(a, key, 0, upper-1);
        return returnValue;
    }
    int temp = key.compareTo(a[this.upper]);
    if(temp > 0) {
        this.returnValue = (this.upper + 1);
        return (this.upper + 1);
    }
    temp = key.compareTo(a[this.lower]);
    if(temp < 0) {
        this.returnValue = this.lower - 1;
        return (this.lower - 1);
    } else {
        this.returnValue = upper + 1;
    }

    return returnValue;
}
int lastIndex;
private int checkForDuplicates(E[] a, E key, int lower, int upper) {
    if (lower < upper) {
        int middle = (lower / 2) + (upper / 2);
        lastIndex = middle;
        int tempInt = a[middle].compareTo(key);
        if (tempInt < 0) {
            return checkForDuplicates(a, key, middle + 1, upper);
        }
        this.returnValue = middle;
        if (key.equals(a[lower])) {
            this.returnValue = lower;
            checkForDuplicates(a, key, 0, middle-1);
            return returnValue;
        }
        return -1;
    }
    if (key.equals(a[lower])) {
        this.returnValue = lower;
        return returnValue;
    } 
    return -1;
}

}

Answer 1

试着把它想象成"验证行为"。您期望从 BinarySearch 类获得的行为是，对于给定的数组 A 和元素 E，如果 E 是 A 的元素，它将返回 A 中元素 E 的索引，如果不是 A 的元素，则返回 -1。一个非常简单的第一次测试尝试可能如下所示：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayNameGeneration;
import org.junit.jupiter.api.DisplayNameGenerator;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
class BinarySearchTest {
    private BinarySearch<Integer> integerBinarySearch;
    @BeforeEach
    void setUp() {
        integerBinarySearch = new BinarySearch<>();
    }
    @Test
    void returns_index_of_searched_element_when_searched_element_is_in_the_beginning_of_array() {
        // given
        Integer[] numbers = new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int numberToSearch = 1;
        // when
        int indexOfSearchedNumber = integerBinarySearch.search(numbers, numberToSearch, 0, numbers.length - 1);
        // then
        assertThat(indexOfSearchedNumber).isEqualTo(0);
    }
    @Test
    void returns_index_of_searched_element_when_searched_element_is_in_the_end_of_array() {
        // given
        Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int numberToSearch = 10;
        // when
        int indexOfSearchedNumber = integerBinarySearch.search(numbers, numberToSearch, 0, numbers.length - 1);
        // then
        assertThat(indexOfSearchedNumber).isEqualTo(9);
    }
    @Test
    void returns_index_of_searched_element_when_searched_element_is_in_the_middle_of_array() {
        // given
        Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
        int numberToSearch = 6;
        // when
        int indexOfSearchedNumber = integerBinarySearch.search(numbers, numberToSearch, 0, numbers.length - 1);
        // then
        assertThat(indexOfSearchedNumber).isEqualTo(5);
    }
    @Test
    void returns_minus_one_when_element_is_not_in_array() {
        // given
        Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int numberToSearch = 42;
        // when
        int indexOfSearchedNumber = integerBinarySearch.search(numbers, numberToSearch, 0, numbers.length - 1);
        // then
        assertThat(indexOfSearchedNumber).isEqualTo(-1);
    }
}

例如，这将告诉您，当元素不在数组中时，您的搜索实现的行为不正确。要编译此程序，您需要将 junit5 和断言依赖项添加到您的程序中。如果您使用的是像 gradle 这样的构建工具，则需要将以下条目添加到 build.gradle 中的依赖项块中：

testImplementation 'org.junit.jupiter：junit-jupiter：5.4.2'

testImplementation 'org.assertj：

assertj-core：3.12.2'