Katalon写一个Groovy脚本，java8利用java-diff-util实现两个文件夹对比，并将比较结果以文件为单位出力成各自的HTML文件。要求：当文件在两个文件夹中都存在时，能识别隔行数据，将两个文件有差异的数据都出力到HTML中，将两个文件的差异数据以逗号隔开，并将有差异的字段高亮显示出来；当文件只在一个文件夹中存在的文件，将这个信息出力到HTML中

以下是一个使用java-diff-utils实现两个文件夹对比的Groovy脚本，将比较结果以文件为单位输出到各自的HTML文件中：

@Grab(group='com.googlecode.java-diff-utils', module='diffutils', version='1.3.0')

import difflib.*
import java.nio.file.*
import java.nio.charset.*
import groovy.xml.MarkupBuilder

// 定义要对比的两个文件夹路径
def oldDirPath = "path/to/old/folder"
def newDirPath = "path/to/new/folder"

// 遍历旧文件夹中的文件
Files.walk(Paths.get(oldDirPath)).filter { Files.isRegularFile(it) }.forEach { oldFilePath ->
    def newFilePath = Paths.get(newDirPath, oldFilePath.getFileName().toString())
    if (Files.exists(newFilePath)) {
        // 两个文件都存在
        def oldLines = Files.readAllLines(oldFilePath, StandardCharsets.UTF_8)
        def newLines = Files.readAllLines(newFilePath, StandardCharsets.UTF_8)
        def patch = DiffUtils.diff(oldLines, newLines)
        if (patch.getDeltas().size() > 0) {
            // 有差异的数据
            def htmlFilePath = "${oldFilePath.toString().replaceAll(oldDirPath, newDirPath)}.html"
            Files.createDirectories(Paths.get(htmlFilePath).getParent())
            def writer = Files.newBufferedWriter(Paths.get(htmlFilePath), StandardCharsets.UTF_8, StandardOpenOption.CREATE)
            new MarkupBuilder(writer).html {
                head {
                    title "Diff of ${oldFilePath.getFileName()} and ${newFilePath.getFileName()}"
                }
                body {
                    h1 "Diff of ${oldFilePath.getFileName()} and ${newFilePath.getFileName()}"
                    table {
                        tr {
                            td {
                                b "Lines only in ${oldFilePath.getFileName()}"
                            }
                            td {
                                b "Lines only in ${newFilePath.getFileName()}"
                            }
                        }
                        def deltaIndex = 0
                        patch.getDeltas().each { delta ->
                            def (oldStart, oldEnd, newStart, newEnd) = delta.getRevised().stream().map { it as List }.collect()
                            def oldLinesRange = (oldStart..oldEnd).collect { it + 1 }
                            def newLinesRange = (newStart..newEnd).collect { it + 1 }
                            def oldLinesDiff = delta.getOriginal().getLines().collect { line ->
                                if (line in oldLinesRange) {
                                    deltaIndex++
                                    " <span style='background-color: lightgreen'><b>$line</b></span>"
                                } else {
                                    " $line"
                                }
                            }.join(",")
                            def newLinesDiff = delta.getRevised().getLines().collect { line ->
                                if (line in newLinesRange) {
                                    deltaIndex++
                                    " <span style='background-color: lightgreen'><b>$line</b></span>"
                                } else {
                                    " $line"
                                }
                            }.join(",")
                            tr {
                                td {
                                    div "${deltaIndex}. $oldLinesDiff"
                                }
                                td {
                                    div "${deltaIndex}. $newLinesDiff"
                                }
                            }
                        }
                    }
                }
            }
            writer.close()
        }
    } else {
        // 只在旧文件夹中存在的文件
        println("File ${oldFilePath.getFileName()} only exists in old folder.")
    }
    // 删除已经比较过的文件
    Files.delete(oldFilePath)
}

// 遍历新文件夹中只存在的文件
Files.walk(Paths.get(newDirPath)).filter { Files.isRegularFile(it) }.forEach { newFilePath ->
    def oldFilePath = Paths.get(oldDirPath, newFilePath.getFileName().toString())
    if (!Files.exists(oldFilePath)) {
        // 只在新文件夹中存在的文件
        println("File ${newFilePath.getFileName()} only exists in new folder.")
    }
}

使用方式：

1. 将以上代码保存到一个Groovy脚本文件中，例如`diff.groovy`

2. 打开命令行终端，进入到脚本所在的目录

3. 执行以下命令：

katalon -runMode=console -projectPath="/path/to/project" -retry=0 -testSuitePath="Test Suites/My Test Suite" -g_diffScriptPath="/path/to/diff.groovy"

其中，`/path/to/project`是你的Katalon项目路径，`Test Suites/My Test Suite`是你的测试套件路径，`/path/to/diff.groovy`是你的Groovy脚本文件路径。

注意，本脚本需要依赖`java-diff-utils`库，因此在脚本中使用了`@Grab`注解来自动下载该库。如果你的网络环境无法访问Maven中央仓库，请手动下载`java-diff-utils-1.3.0.jar`并将其放置到Katalon工程的`Drivers`文件夹中。另外，本脚本使用了Groovy的XML MarkupBuilder来生成HTML文件，因此需要Groovy环境的支持。