java 实现正交实验法（伪）

最新推荐文章于 2022-09-22 19:52:36 发布

要日天

最新推荐文章于 2022-09-22 19:52:36 发布

阅读量1k

点赞数

分类专栏：软件测试 java 参数化测试

本文链接：https://blog.csdn.net/w306695293/article/details/107089195

版权

软件测试同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

java

2 篇文章 0 订阅

订阅专栏

参数化测试

1 篇文章 0 订阅

订阅专栏

实现逻辑：
1、接受一个2维数组，按一维数组的长度进行排序
2、一维数组中长度最大的2个数组进行全量匹配，后续的数组根据匹配次数均匀匹配
3、匹配完成后，按之前传入的顺序 重新排序 匹配好的数组

public Object[][] Orthogonal(Object[][] data) {


    List<JSONArray> newData = new LinkedList<>();
    ArrayList<ArrayList<JSONObject>> arrayLists = new ArrayList<>();
    //将二维数组转化为链表 并加入step
    int num=0;
    for (Object[] datum : data) {
        JSONArray jsonArray = new JSONArray();
        for (int j = 0, size1 = datum.length; j < size1; j++) {
            jsonArray.put(j, new JSONObject()
                    .put("value", datum[j])
                    .put("num", num)
                    .put("step", 0));

        }
        num++;
        newData.add(jsonArray);
    }

    if (newData.size() < 2)
        throw new RuntimeException("二维数组长度必须>=2");
    //将linkedList按jsonarray 长度排序
    for (int i = 0, size = newData.size() - 1; i < size; i++) {

        for (int j = i + 1; j <= size; j++) {
            JSONArray jsonArray = newData.get(i);
            JSONArray jsonArray1 = newData.get(j);

            if (jsonArray.length() < jsonArray1.length()) {
                newData.set(i, jsonArray1);
                newData.set(j, jsonArray);
            }
        }
    }
    JSONArray jsonArray = newData.get(0);
    JSONArray jsonArray1 = newData.get(1);

    newData.remove(0);
    newData.remove(0);

    for (int i = 0, size = jsonArray.length(); i < size; i++) {

        for (int k = 0, s = jsonArray1.length(); k < s; k++) {

            ArrayList<JSONObject> arrayList = new ArrayList<>();
            arrayList.add(jsonArray.optJSONObject(i));

            arrayList.add(minValue(jsonArray1));

            if (!newData.isEmpty())
                newData.forEach(array -> arrayList.add(minValue(array)));

            arrayLists.add(arrayList);
        }

    }

    Object[][] objects=new Object[arrayLists.size()][arrayLists.get(0).size()];
    for (int i=0,size=arrayLists.size();i<size;i++){

        JSONArray arr=new JSONArray(arrayLists.get(i));
        //按最开始的数组顺序组合二维数组
        for (int k=0,sizes=arr.length();k<sizes;k++){
            objects[i][k]=new GetJsonValue().getValue(new GetJsonValue()
                    .getJSONObjectOfKV(arr.toString(),"num",k+""),"value");
        }
    }
    return  objects;
}

private JSONObject minValue(JSONArray jsonArray) {
    for (int i = 1, size = jsonArray.length(); i < size; i++) {
        JSONObject jsonObject = jsonArray.optJSONObject(0);
        JSONObject jsonObject1 = jsonArray.getJSONObject(i);


        if (jsonObject.getInt("step") >= jsonObject1.getInt("step")) {
            jsonArray.put(0, jsonObject1);
            jsonArray.put(i, jsonObject);
        }
    }
    return jsonArray.getJSONObject(0);
}