Java：测试算法：所有可能的组合

Question

我想详尽地测试一个名为myAlgo（Char [] a，Char [] b）的字符串匹配算法。

详尽的测试包括否。 的不同字符，字母“ l”，以“ n”个长数组表示。 然后，测试会计算所有组合，同时将其与具有相似属性的另一个数组的所有组合（如真值表）进行比较，例如

我也无法计算出会生成大小为n和字母l的数组的每个组合的东西，也无法编写能够将计算合并为迭代测试用例的代码（测试这两个组合的所有组合）比较数组），尽管使用能够生成组合的代码，但制作嵌套的for循环应进行所需的测试。

我的目标是通过使算法计算不应计算的内容来破坏算法。

Test(char[] l, int n)
    l = [a;b] //a case could be
    n = 2     //a case could be
    myAlgo([a;a],[a;a]); //loops over my algorithm in the following way
    myAlgo([a;b],[a;a]);
    myAlgo([b;a],[a;a]);
    myAlgo([b;b],[a;a]);
    myAlgo([a;a],[a;b]);
    myAlgo([a;b],[a;b]);
    myAlgo([b;a],[a;b]);
    myAlgo([b;b],[a;b]);
    myAlgo([a;a],[b;a]);
    myAlgo([a;b],[b;a]);
    ...
    myAlgo([b;b],[b;b]);

我自己的解决方案（仅适用于有限的“ l”集），并且在以后的迭代中也开始打印奇怪的输出。

公开课测试{

//aux function to format chars
public static String concatChar(char [] c){
    String s = "";
    for(char cc : c){
        s += cc;
    }
    return s;
}

public static void main(String[] args) {

    String ss1 = "AA";                          //TestCases, n = 2
    String ss2 = "AA";
    char[] test1 = ss1.toCharArray();
    char[] test2 = ss2.toCharArray();
    Fordi fordi = new Fordi();                  //my algorithm
    TestGenerator tGen = new TestGenerator();   //my testGenerator
    for(int i=0; i<Math.pow(4.0, 2.0);i++){     //to test all different cases

        for(int j=0; j<Math.pow(4.0, 2.0);j++){
            int k = fordi.calculate(test1, test2);  //my algorithm
            String mys1 = concatChar(test1);        //to print result
            String mys2 = concatChar(test2);        //to print result
            System.out.println(mys1 + " - " + mys2);
            System.out.println(k);
            test2 = tGen.countArray(test2);         //"flip" one number
        }
        test2 = ss1.toCharArray();
        test1 = tGen.countArray(test1);             //"flip"
    }
}

}

我的arrayflipper代码：

public char[] countArray(char[] a){
    int i=0;
    while(i<a.length){
        switch (a[i]){
        case 'A':
            a[i]='B';
            clearBottom(a,i);
            return a;
        case 'B':
            a[i]='C';
            clearBottom(a,i);
            return a;
        case 'C':
            a[i]='D';
            clearBottom(a,i);
            return a;
        case 'D':
            i++;
            break;
        default:
            System.out.println("Something went terribly wrong!");

        }
    }
    return a;

}
public char[] clearBottom(char [] a, int i){
    while(i >0){
        i--;
        a[i] = 'A';
    }
    return a;
}

Answer 1

据我了解，您的目标是创建由L个字母组成的所有n个字符长字符串（分别存储为数组中的元素）？

实现此目的的一种方法是对字母进行排序（A = 0，B = 1，C = 2等）。 然后，您可以从AAA ... AAA（长度为n个字符）的起始字符串开始继续加1。本质上，您实现了加法算法。 加1将把A = 0变成B = 1。 例如，n = 3和L = 3：

开始：AAA（0,0,0）。

加1成为AAB（0,0,1）

再次加1成为AAC（0、0、2）

再次加1（因为我们没字母了，现在再加上一点）ABA（0、1、0）。

您可以将过程简化为查找未最大化的最右边的数字，然后将其加1（然后该数字右边的所有数字都将返回零）。 因此，在字符串ABCCC中，B数是最右边的未最大化数字，它上升1并变为C，然后所有右边的最高数字都返回0（A），从而使ACAAA为下一个串。

您的算法只是重复加1，直到字符串中的所有元素都用尽。

Answer 2

我建议不要将要测试的每个字符（A，B，C，D）放入数组中，而不要使用switch语句，然后使用XOR操作以类似的方式根据迭代次数计算每个字符的索引到以下内容：

char[] l = new char[]{'A','B','C','D'};
int n = 2;
char[] test1 = new char[n];
char[] test2 = new char[n];
int max = (int)Math.pow(l.length, n);
for (int i = 0; i < max; i++) {
    for (int k = 0; k < n; k++) {
        test2[k] = l[(i % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
    }
    for (int j = 0; j < max; j++) {
        for (int k = 0; k < n; k++) {
            test1[k] = l[(j % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
        }
        int k = fordi.calculate(test1, test2);
        System.out.println(new String(test1) + "-" + new String(test2));
        System.out.println(k);
    }
}

您可以向l添加更多字符，也可以增加n ，它仍然可以正常工作。 当然，这可以进一步优化，但是您应该明白这一点。 希望这个答案有帮助！