Java 如何在这个程序中为二进制搜索实现JUnit测试？

如何将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;
}


}

---

试着把它看作是对行为的验证。 您期望BinarySearch类的行为是，对于给定的数组a和元素E，如果E是a的元素，它将返回a中元素E的索引；如果不是，则返回-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和assertj依赖项添加到程序中。如果您使用的是像gradle这样的生成工具，则需要将以下条目添加到build.gradle中的依赖项块中：

测试实现'org.junit.jupiter:junit-jupiter:5.4.2'

测试实现“org.assertj:assertj核心：3.12.2”