记录java+testng运行selenium（三）---xml、ini、excel、日志等配置

一： ini文件

ini目前只用处存储浏览类型及需要打开的url，ini文件放在configs文件夹下面。

读取ini代码如下：

 package toolskit.documents;

 import java.io.*;
 import java.util.*;

 /**
  * @ ClassName: ReadIni
  * @ Author: DingDong
  * @ Date: 2019/8/23 10:57
  * @ Version: 1.0
  * @ desc: 读取ini后缀名的文件
  */

 public class ReadIni {

     /**
      * 去除ini文件中的注释，以";"或"#"开头，顺便去除UTF-8等文件的BOM头
      * @param source
      * @return
      */
     private static String removeIniComments(String source) {

         String result = source;

         if (result.contains(";")) {
             result = result.substring(0, result.indexOf(";"));
         }

         if (result.contains("#")) {
             result = result.substring(0, result.indexOf("#"));
         }

         return result.trim();
     }

     public static Map<String, Object> readIni(String filename,String filepath) {
         Map<String, List<String>> listResult = new HashMap<>();
         Map<String, Object> result = new HashMap();
         String globalSection = "global";

         if (filepath.equalsIgnoreCase("") || filepath == null){
             filepath = ".\\src\\main\\java\\configs\\";
             filename = filepath + filename;
         }
         File file = new File(filename);
         BufferedReader reader = null;
         try {
             reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
             String str = null;
             String currentSection = globalSection; //处理缺省的section
             List<String> currentProperties = new ArrayList<>();
             boolean lineContinued = false;
             String tempStr = null;

             //一次读入一行（非空），直到读入null为文件结束
             //先全部放到listResult<String, List>中
             while ((str = reader.readLine()) != null) {
                 str = removeIniComments(str).trim(); //去掉尾部的注释、去掉首尾空格

                 if ("".equals(str) || str == null) {
                     continue;
                 }

                 //如果前一行包括了连接符'\'
                 if (lineContinued == true) {
                     str = tempStr + str;
                 }

                 //处理行连接符'\'
                 if (str.endsWith("\\")) {
                     lineContinued = true;
                     tempStr = str.substring(0, str.length() - 1);
                     continue;
                 } else {
                     lineContinued = false;
                 }

                 //是否一个新section开始了
                 if (str.startsWith("[") && str.endsWith("]")) {
                     String newSection = str.substring(1, str.length() - 1).trim();

                     //如果新section不是现在的section，则把当前section存进listResult中
                     if (!currentSection.equals(newSection)) {
                         listResult.put(currentSection, currentProperties);
                         currentSection = newSection;

                         //新section是否重复的section
                         //如果是，则使用原来的list来存放properties
                         //如果不是，则new一个List来存放properties
                         currentProperties = listResult.get(currentSection);
                         if (currentProperties == null) {
                             currentProperties = new ArrayList<>();
                         }
                     }
                 } else {
                     currentProperties.add(str);
                 }
             }
             //把最后一个section存进listResult中
             listResult.put(currentSection, currentProperties);

             reader.close();

         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (reader != null) {
                 try {
                     reader.close();
                 } catch (IOException e1) {
                 }
             }
         }

         //整理拆开name=value对，并存放到MAP中：
         //从listResult<String, List>中，看各个list中的元素是否包含等号“=”，如果包含，则拆开并放到Map中
         //整理后，把结果放进result<String, Object>中
         for (String key : listResult.keySet()) {
             List<String> tempList = listResult.get(key);

             //空section不放到结果里面
             if (tempList == null || tempList.size() == 0) {
                 continue;
             }

             if (tempList.get(0).contains("=")) { //name=value对，存放在MAP里面
                 Map<String, String> properties = new HashMap<>();
                 for (String s : tempList) {
                     int delimiterPos = s.indexOf("=");
                     //处理等号前后的空格
                     properties.put(s.substring(0, delimiterPos).trim(), s.substring(delimiterPos + 1, s.length()).trim());
                 }
                 result.put(key, properties);
             } else { //只有value，则获取原来的list
                 result.put(key, listResult.get(key));
             }
         }
         return result;
     }

 }

二： xml文件读取

xml文件主要存储excel所在路径以及用例类所对应的sheet名

参考：https://www.jianshu.com/p/8e333a0ec42a

代码如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * @ ClassName: toolskit.documents
 * @ Author: DingDong
 * @ Date: 2019/10/21 14:36
 * @ Version: 1.0
 * @ desc:
 */

public class XmlUtil {

    public static List getXmlComent(String path){
        //获取xml文件完全路径
        System.out.println("xml·path"+path);

        List contList=new ArrayList();
        //dom4j中读取xml文件的方法
        SAXReader saxR=new SAXReader();
        try {
            Document doc=saxR.read(path);
            //存放顶结点
            Element eleroot=doc.getRootElement();
            //parMap，存放顶结点下一级结点
            Map parMap=null;
            Map sonMap=null;
            for(Iterator i=eleroot.elementIterator();i.hasNext();){
                //parMap中存放的结点的子结点
                parMap=new HashMap();
                sonMap=new HashMap();
                Element elepar=(Element)i.next();
                for(Iterator j=elepar.elementIterator();j.hasNext();){
                    Element eleSon=(Element)j.next();
                    System.out.println("+++++"+eleSon.getName()+"    "+ eleSon.getText());
                    sonMap.put(eleSon.getName(), eleSon.getText());
                }

                parMap.put(elepar.getName(),sonMap);
                System.out.println("*****"+elepar.getName() +"*********" + sonMap);
                contList.add(parMap);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }

        return contList;
    }
}

其中parMap和sonMap要在for里面清空已有的内容，不然contList存储的数据都是重复的

四：excel文件读写

ExcelOperating作为父类，用于区分文件类型及文件是否存在

ReadExcel：用于用户读取excel的内容并存在Map里面然后返回

WriteExcel ：让用户将输入写入excel里面

ExcelOperating代码如下：

 package toolskit.documents;

 import java.io.*;
 import java.text.DecimalFormat;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 import org.apache.commons.io.IOCase;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.usermodel.*;

 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.apache.poi.ss.usermodel.DateUtil;

 public class ExcelOperating {

     private final String XLS_VERSION = "xls";
     private final String XLSX_VERSION = "xlsx";

     /**
      * 判断Excel的版本,获取Workbook
      * @param fileName 文件名
      * @return sheet对象
      */
     public Workbook distinguishWorkbook(String fileName) {
         Workbook workbook = null;
         InputStream is = null;
         try {
             File file = new File(fileName);
             is = new FileInputStream(file);

             if (IOCase.SENSITIVE.checkEndsWith(fileName, XLS_VERSION)) {

                 workbook = new HSSFWorkbook(is);

             } else if (IOCase.SENSITIVE.checkEndsWith(fileName, XLSX_VERSION)) {

                 workbook = new XSSFWorkbook(is);

             } else {
                 System.out.println("该文件不是excle表格:" + fileName);

             }
         } catch (FileNotFoundException e) {
             System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
             e.printStackTrace();
         } catch (IOException e) {
             System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
             e.printStackTrace();
         }finally {
             if (is != null) {
                 try {
                     is.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return workbook;
     }

     public   String getIntTypeValue(Cell cell) {
         String cellValue = "";
         double value = cell.getNumericCellValue();
         if (cell.getCellStyle().getDataFormat() == 176) {

             // 处理自定义日期格式:M月D日(通过判断单元格的格式id解决,ID的值是58)
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             Date date = DateUtil.getJavaDate(value);
             cellValue = sdf.format(date);

         } else {
             CellStyle style = cell.getCellStyle();
             DecimalFormat format = new DecimalFormat();
             String temp = style.getDataFormatString();

             // 把数字当成String来读，避免出现1读成1.0的情况.这个方式没这么灵活
             //        if (cell.getCellType() == CellType.NUMERIC) {
             //            cell.setCellType(CellType.STRING);
             //        }

             // 单元格设置成常规
             if (temp.equals("General")) {
                 format.applyPattern("#");
             }
             cellValue = format.format(value);
         }
         return cellValue;
     }

     /**
      * 判断获取当前内容的格式，然后进行返回内容
      * 把单元格的内容转为字符串
      * 高版本的import org.apache.poi.ss.usermodel.CellType变为了import org.apache.poi.ss.usermodel.Cell;
      * 同时cellRowName.setCellType(CellType.STRING);变为了cellRowName.setCellType(Cell.CELL_TYPE_STRING);
      * 并且xssfCell.getCellTypeEnum()变成xssfCell.getCellType()
      * CellType                    类型            值
      * NUMERIC                    数值型            0
      * STRING                    字符串型        1
      * FORMULA                    公式型            2
      * BLANK                    空值            3
      * BOOLEAN                    布尔型            4
      * ERROR                    错误            5
      * @param cell 单元格
      * @return 字符串
      */
     @SuppressWarnings("deprecation")
     public  String getCellValue(Cell cell) {
         String cellValue = "";
         if (cell == null) {
             return cellValue;
         }

         //判断数据的类型，低版本中switch里面的case写法不一样。
         CellType cellType = cell.getCellType();

         switch (cellType) {
             case NUMERIC: //数字
                 cellValue = getIntTypeValue(cell);
                 break;
             case STRING: //字符串
                 cellValue = String.valueOf(cell.getStringCellValue());
                 break;
             case BOOLEAN: //Boolean
                 cellValue = String.valueOf(cell.getBooleanCellValue());

                 break;
             case FORMULA: //公式
                 cellValue = String.valueOf(cell.getCellFormula());
                 break;
             case BLANK: //空值
                 cellValue = "";
                 break;
             case ERROR: //故障
                 cellValue = "非法字符";
                 break;
             case _NONE: //故障
                 cellValue = "非法字符";
                 break;
             default:
                 cellValue = "未知类型";
                 break;
         }
         return cellValue;
     }

 }

ReadExcel代码如下：

 package toolskit.documents;

 import java.io.*;
 import java.util.*;

 import org.apache.poi.ss.usermodel.*;

 public class ReadExcel extends ExcelOperating {
 //    public static void main(String[] args) {
 //        ReadExcel re = new ReadExcel();
 //        String load = "C:\\Users\\LGYY-USER\\Desktop\\红包发放.xlsx";

 //         方式一: 指定sheet来读取
 //        List<Map<String, String>> excelList = re.readExcel(load, "登录");
 //        System.out.println("从excel读取数据并开始使用:");
 //        for (Map<String, String> list : excelList) {
 //            System.out.println(list);
 //            for (Map.Entry<String, String> entry : list.entrySet()) {
 //                System.out.println(entry.getValue());
 //            }
 //            System.out.println();
 //        }

 //         方式二: 读取单个文件,单行数据
 //            Map<String, String> stringStringMap = re.singleReadXlsx(load, "登录", 2);
 //        System.out.println(stringStringMap);
 //            for(Map.Entry<String, String> entry : stringStringMap.entrySet()){
 //                System.out.print("Key = "+entry.getKey()+",value="+entry.getValue() + "\n");
 //            }

 //         方式三: 读取全部sheet的数据
 //        List<Map<Integer, Object>> lists = re.wholeReadXlsx(load);
 //        for (Map<Integer, Object> i : lists) {
 //            System.out.print(i);
 //        }

 //    }

     /**
      * 通过Workbook来读取excle表格上的数据
      *
      * @param load 文件所在路径
      * @return 获取到的数据
      */
     public List<Map<Integer, Object>> wholeReadXlsx(String load) {
         // excel中第几列 ： 对应的表头
         Map<Integer, String> colAndNameMap = new HashMap<Integer, String>();
         List<Map<Integer, Object>> resultList = new ArrayList<Map<Integer, Object>>();
         Workbook wb = null;
         try {
             wb = distinguishWorkbook(load);
             for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++) {
                 //获取sheet数据
                 Sheet st = wb.getSheetAt(sheetIndex);
                 //遍历一个sheet中每一行
                 for (int rowIndex = 0; rowIndex <= st.getLastRowNum(); rowIndex++) {
                     // 表头：值
                     Map<Integer, Object> nameAndValMap = new HashMap<Integer, Object>();
                     // 获取到一行数据
                     Row row = st.getRow(rowIndex);
                     for (int cellIndex = 0; cellIndex < row.getPhysicalNumberOfCells(); cellIndex++) {

                         if (rowIndex == 0) {
                             colAndNameMap.put(cellIndex, row.getCell(cellIndex).getStringCellValue());
                         } else if (!colAndNameMap.isEmpty()) {
                             nameAndValMap.put(cellIndex, getCellValue(row.getCell(cellIndex)));
                         }
                     }
                     if (!nameAndValMap.isEmpty()) {
                         resultList.add(nameAndValMap);
                     }
                 }
             }
             return resultList;
         } catch (Exception e) {
             System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
             e.printStackTrace();
         } finally {
             try {
                 wb.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return null;
     }

     /**
      * 读取指定工作薄里的指定行的内容
      * load文档所在地
      * numSheet当前文档中所读写的工作薄
      * rowNum当前工作薄中的第几个数据
      * @param load 文件所在路径
      * @param sheetName sheet表格名字
      * @param rowNum 指定行数
      * @return 找到的全部数据
      */
     public Map<String, String> singleReadXlsx(String load, String sheetName, int rowNum) {
         Workbook xssfWorkbook = distinguishWorkbook(load);
         Map<String, String> aMap = new HashMap<String, String>();
         Sheet xssfSheet;
         if (sheetName.equals("")) {
             // 默认取第一个子表
             xssfSheet = xssfWorkbook.getSheetAt(0);
         } else {
             xssfSheet = xssfWorkbook.getSheet(sheetName);
         }

         if (xssfSheet != null) {
             // 获取指定行
             Row xssfRow = xssfSheet.getRow(rowNum);//获取该行的全部数据
             if (xssfRow != null) {

                 int firstCellNum = (int) xssfRow.getFirstCellNum();// 首列
                 int lastCellNum = (int) xssfRow.getLastCellNum();// 最后一列

                 for (int col = firstCellNum; col < lastCellNum; col++) {
                     String sEnum = col + "";
                     aMap.put(sEnum, getCellValue(xssfRow.getCell(col)));
                 }
             } else {
                 System.out.println("xssfRow为空");
             }
         }

         return aMap;
     }

     /**
      *  指定表格中行的数据长度
      * @param load 文件名
      * @param nameSheet 表格名字
      * @return 表格行的总数
      */
     public int singleXlsx(String load, String nameSheet) {
         int row = 0;
         // 获取每一个工作薄
         Sheet sheetAt = distinguishWorkbook(load).getSheet(nameSheet);
         if (sheetAt != null) {
             row = sheetAt.getLastRowNum();
         }
         return row;

     }

     /**
      * 读取Excel文件中指定sheet的内容
      *
      * @param load      excel文件的所在路径
      * @param sheetName sheet名字
      * @return 以List返回excel中内容
      */
     public List<Map<String, String>> readExcel(String load, String sheetName) {

         Workbook xssfWorkbook = distinguishWorkbook(load);

         //定义工作表
         Sheet xssfSheet;

         if (sheetName.equals("")) {
             // 默认取第一个子表
             xssfSheet = xssfWorkbook.getSheetAt(0);
         } else {
             xssfSheet = xssfWorkbook.getSheet(sheetName);
         }

         List<Map<String, String>> list = new ArrayList<Map<String, String>>();

         // 默认第一行为标题行，index = 0
         Row titleRow = xssfSheet.getRow(0);

         // 根据第一行返回该行中单元格的数量
         int cellNumber = titleRow.getPhysicalNumberOfCells();

         // 返回sheet标中行的总数
         int rownumber = xssfSheet.getPhysicalNumberOfRows();

         // 循环取每行的数据
         for (int rowIndex = 1; rowIndex < rownumber; rowIndex++) {
             Row xssfRow = xssfSheet.getRow(rowIndex);
             if (xssfRow == null) {
                 continue;
             }

             Map<String, String> map = new LinkedHashMap<String, String>();

             //循环取每个单元格(cell)的数据
             for (int cellIndex = 0; cellIndex < cellNumber; cellIndex++) {
                 Cell titleCell = titleRow.getCell(cellIndex);
                 Cell xssfCell = xssfRow.getCell(cellIndex);
                 map.put(getCellValue(titleCell), getCellValue(xssfCell));
             }
             list.add(map);
         }
         return list;
     }

     /**
      * 把一个Map中的所有键和值分别放到一个list中，
      * 再把这两个list整个放到一个大的list里面，即 [ [key1,key2,key3...] , [value1,value2,value3...] ]
      *
      * @param map 需要转换的map
      * @return 已转换后的list
      */
     public static List<List> convertMapToList(Map map) {
         List<List> list = new ArrayList<List>();
         List<String> key_list = new LinkedList<String>();
         List<String> value_list = new LinkedList<String>();

         Set set = map.entrySet();
         Iterator<Map.Entry<String, String>> iter1 = set.iterator();
         while (iter1.hasNext()) {
             key_list.add(iter1.next().getKey());
         }
         list.add(key_list);

         Collection<String> value = map.values();
         Iterator<String> iter2 = value.iterator();
         while (iter2.hasNext()) {
             value_list.add(iter2.next());
         }
         list.add(value_list);
         return list;
     }
 }

WriteExcel写法如下：很少使用这个类

package toolskit.documents;

import java.io.*;
import java.util.List;

import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class WriteExcel extends ExcelOperating{

    // 当前文件已经存在
    private String excelPath = "E:/MyFirstExcel.xlsx";

    // 从第几行插入进去
    private int insertStartPointer;

    // 根据工作薄名进行插入
    private String sheetName;

    // 根据工作薄所在位置进行插入
    private int sheetInsert = 0;

    public WriteExcel(String excelPath, int insertStartPointer, String sheetName, int sheetInsert) {
        this.excelPath = excelPath;
        this.insertStartPointer = insertStartPointer;
        this.sheetName = sheetName;
        this.sheetInsert = sheetInsert;
    }

    public WriteExcel() {
    }

    /**
     * 总的入口方法
     */
    public static void main(String[] args){
        WriteExcel crt = new WriteExcel();
        int i = new ReadExcel().singleXlsx(crt.excelPath, "sheet");
        crt.insertStartPointer = i + 1;
        crt.insertRows();
    }

    /**
     * 在已有的Excel文件中插入一行新的数据的入口方法
     */
    public void insertRows() {
        Workbook wb = returnWorkBookGivenFileHandle();
        // XSSFSheet sheet1 = wb.getSheet(sheetName);
        sheetName = wb.getSheetName(sheetInsert);
        Sheet sheet = wb.getSheet(sheetName);
        Row row = createRow(sheet, insertStartPointer);
        createCell(row);
        saveExcel(wb);

    }

    /**
     * 保存工作薄
     *
     * @param wb
     */
    private void saveExcel(Workbook wb) {
        FileOutputStream fileOut;
        try {
            fileOut = new FileOutputStream(excelPath);
            wb.write(fileOut);
            fileOut.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 创建要出入的行中单元格
     *
     * @param row
     * @return
     */
    private Cell createCell(Row row) {
        Cell cell = row.createCell((short) 0);
        cell.setCellValue(999999);
        row.createCell(1).setCellValue(1.2);
        row.createCell(2).setCellValue("This is a string cell");
        return cell;
    }

    /**
     * 得到一个已有的工作薄的POI对象
     *
     * @return
     */
    private Workbook returnWorkBookGivenFileHandle() {
        Workbook wb = null;
        File f = new File(excelPath);
        try {
            if (f != null) {
                wb = distinguishWorkbook(excelPath);
            }
        } catch (Exception e) {
            return null;
        }
        return wb;
    }

    /**
     * 找到需要插入的行数，并新建一个POI的row对象
     *
     * @param sheet
     * @param rowIndex
     * @return
     */
    private Row createRow(Sheet sheet, Integer rowIndex) {
        Row row = null;
        if (sheet.getRow(rowIndex) != null) {
            int lastRowNo = sheet.getLastRowNum();
            sheet.shiftRows(rowIndex, lastRowNo, 1);
        }
        row = sheet.createRow(rowIndex);
        return row;
    }

    /**
     * 把内容写入Excel
     *
     * @param list         传入要写的内容，此处以一个List内容为例，先把要写的内容放到一个list中
     * @param outputStream 把输出流怼到要写入的Excel上，准备往里面写数据
     */
    public void writeExcel(List<List> list, OutputStream outputStream) {
        //创建工作簿
        XSSFWorkbook xssfWorkbook;
        xssfWorkbook = new XSSFWorkbook();

        //创建工作表
        XSSFSheet xssfSheet;
        xssfSheet = xssfWorkbook.createSheet();

        //创建行
        XSSFRow xssfRow;

        //创建列，即单元格Cell
        XSSFCell xssfCell;

        //把List里面的数据写到excel中
        for (int i = 0; i < list.size(); i++) {
            //从第一行开始写入
            xssfRow = xssfSheet.createRow(i);
            //创建每个单元格Cell，即列的数据
            List sub_list = list.get(i);
            for (int j = 0; j < sub_list.size(); j++) {
                xssfCell = xssfRow.createCell(j); //创建单元格
                xssfCell.setCellValue((String) sub_list.get(j)); //设置单元格内容
            }
        }

        //用输出流写到excel
        try {
            xssfWorkbook.write(outputStream);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

五：日志输出

日志输出一般有两个方式:

1. 定义全局的System.out.println统一进行输出

2. 由log日志进行输出

由System.out.println输出的模板：

package toolskit;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @ ClassName: SystemOut
 * @ Author: DingDong
 * @ Date: 2019/8/13 11:33
 * @ Version: 1.0
 * @ desc:
 */

public class SystemOut {

    public static void textStringOut(String data, String text) {
        System.out.println(data + ":" + text);
    }

    public static void textStringOut(String status, String data, String text) {
        System.out.println(status + ":" + data + ":" + text);
    }

    public static void textStringOut(String text) {
        System.out.println(text);
    }

    /**
     * 用例成功,并且编辑成功
     *
     * @param massage   用例编号
     * @param parameter 用例输入的内容
     */
    public static void caseSuccess(String massage, String parameter) {
        System.out.println(massage + "用例执行成功，编辑内容为：" + parameter);
    }

    /**
     * 编辑判断成功
     *
     * @param massage 执行编号
     */
    public static void caseEditSuccess(String massage) {
        System.out.println(massage + "用例中的元素对象不需要编辑,程序判断成功。。");
    }

    /**
     * 用例执行成功
     *
     * @param massage
     */
    public static void caseSuccess(String massage) {
        System.out.println(massage + "用例执行成功");
    }

    /**
     * 用例执行失败，并且打印出输入信息
     *
     * @param massage
     */
    public static void caseFail(String massage) {
        System.out.println(massage + "用例执行失败。。。。");
    }

    /**
     * 不需要进行编辑时发生失败
     *
     * @param massage 用例编号
     */
    public static void caseEditFail(String massage) {
        System.out.println(massage + "用例中的元素对象不需要编辑，程序判断失败。");
    }

    public static void caseFail(String massage, String parameter) {
        System.out.println(massage + "用例执行失败，编辑内容为：" + parameter);
    }

    /**
     * @param li
     */
    public static void getStringOut(List<List> li) throws InterruptedException {
        textStringOut("打印list开始" + li.size());
        for (int i = 0; i < li.size(); i++) {
            textStringOut(li.get(i).toString());
        }
    }

    public static void getStringOut(Map<String, String> aMap) throws InterruptedException {
        textStringOut("打印list开始" + aMap.size());
        Iterator<Map.Entry<String, String>> iterator = aMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            System.out.println("Key = " + next.getKey() + ", Value = " + next.getValue());
        }
    }
}

log日志输出：

1. 在resources文件夹下面创建以下两个文件：common-logging.properties 和 log4j.properties

2. 配置两个dependency，分别是commons-logging 和 log4j

common-logging.properties 里面内容为：

org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger

log4j.properties 里面内容为：

#设置logger级别DEBUG、INFO、WRNING、ERROR和输出格式A、B、C或D
log4j.rootLogger=debug , stdout , D , E
### 输出INFO级别以上的日志到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.Threshold=DEBUG
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### 输出到日志文件 ###
log4j.appender.D=org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File=E:/logs/log.log
log4j.appender.D.Append=true
## 输出DEBUG级别以上的日志
log4j.appender.D.Threshold=DEBUG
log4j.appender.D.layout=org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %c{1}:%L %m%n
### 保存异常信息到单独文件 ###
log4j.appender.E=org.apache.log4j.DailyRollingFileAppender
## 异常日志文件名
log4j.appender.E.File=E:/logs/error.log
log4j.appender.E.Append=true
## 只输出ERROR级别以上的日志!!!
log4j.appender.E.Threshold=ERROR
log4j.appender.E.layout=org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n

pom文件配置：dependency

 <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <!--日志文件-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

log代码：

package toolskit;

import org.apache.log4j.Logger;

/**
 * @ ClassName: InformationLog
 * @ Author: DingDong
 * @ Date: 2019/8/9 17:39
 * @ Version: 1.0
 * @ desc:
 */
public class InformationLog {
    protected static final Logger logger = Logger.getLogger(InformationLog.class);

    public static void inputLogInfo(String infoData) {
        logger.info(infoData);
    }

    public static void inputLogDebug(String infoData) {
        logger.debug(infoData);
    }

    public static void inputLogWarn(String infoData) {
        logger.warn(infoData);
    }

    public static void inputLogError(String infoData) {
        logger.error(infoData);
    }

    public static void inputLogFatal(String infoData) {
        logger.fatal(infoData);
    }

}

说明：

定义文件地址的时候，都是写死；文件地址这边写死（动态又高级的写法不懂如何编写）