15｜使用LLM生成代码和测试

Apr 10, 2024

15｜使用LLM生成代码和测试-徐昊 · AI时代的软件工程-极客时间



下载APP





关闭

渠道合作

推荐作者

15｜使用LLM生成代码和测试

徐昊 · 徐昊 · AI时代的软件工程

课程介绍



讲述：徐昊

时长03:48大小3.49M



你好，我是徐昊，今天我们来继续学习 AI 时代的软件工程。
通过前面的学习，我们了解了如何使用大语言模型（Large Language Model，LLM）辅助进行业务知识管理。接下来，我们继续学习使用 LLM 辅助软件交付的整体流程，以及其中涉及到的知识管理。
从今天这节课开始，我们将进入如何使用 LLM 辅助软件开发的环节。让我们从一个例子开始。
命令行参数解析我们所使用的例子源自 Robert C. Martin 的 Clean Code 第十四章，也是我的测试驱动专栏《TDD 项目实战 70 讲》讲过的第一个项目，需求描述如下：
我们中的大多数人都不得不时不时地解析一下命令行参数。如果我们没有一个方便的工具，那么我们就简单地处理一下传入 main 函数的字符串数组。有很多开源工具可以完成这个任务，但它们可能并不能完全满足我们的要求。所以我们再写一个吧。
 
传递给程序的参数由标志和值组成。标志应该是一个字符，前面有一个减号。每个标志都应该有零个或多个与之相关的值。例如：
 
-l -p 8080 -d /usr/logs
 
“l”（日志）没有相关的值，它是一个布尔标志，如果存在则为 true，不存在则为 false。“p”（端口）有一个整数值，“d”（目录）有一个字符串值。标志后面如果存在多个值，则该标志表示一个列表：
 
-g this is a list -d 1 2 -3 5
 
“g” 表示一个字符串列表[“this”, “is”, “a”, “list”]，"d"标志表示一个整数列表[1, 2, -3, 5]。
 
如果参数中没有指定某个标志，那么解析器应该指定一个默认值。例如，false 代表布尔值，0 代表数字， "" 代表字符串，[]代表列表。如果给出的参数与模式不匹配，重要的是给出一个好的错误信息，准确地解释什么是错误的。
 
确保你的代码是可扩展的，即如何增加新的数值类型是直接和明显的。
首先，让我们直接将这段需求扔到 LLM 中，看看 LLM 会生成怎样的代码。当然在那之前我们需要将它转化为提示词模板：
需求
====
{requirement}
 
实现要求
====
使用 Java 语言实现上面的需求
当然你可以将 Java 语言换成任何你所熟悉的技术栈。我在这里仅仅是用 Java 举例。ChatGPT 给出的结果是这样的：
import java.util.*;
public class CommandLineParser {
    public static void main(String[] args) {
        // 示例用法
        Map<String, Object> parsedArgs = parseArgs(args);
        System.out.println(parsedArgs);
    }
    public static Map<String, Object> parseArgs(String[] args) {
        Map<String, Object> parsedArgs = new HashMap<>();
        String currentFlag = null;
        List<Object> currentValues = new ArrayList<>();
        for (String arg : args) {
          if (arg.startsWith("-")) {
              // 处理之前的标志和值
              if (currentFlag != null) {
                  parsedArgs.put(currentFlag, parseValues(currentValues));
              }
              // 开始处理新的标志
              currentFlag = arg.substring(1);
              currentValues = new ArrayList<>();
            } else {
              // 处理标志对应的值
              currentValues.add(arg);
            }
        }
        // 处理最后一个标志和值
        if (currentFlag != null) {
            parsedArgs.put(currentFlag, parseValues(currentValues));
        }
        return parsedArgs;
    }
    private static Object parseValues(List<Object> values) {
        if (values.isEmpty()) {
            // 如果值为空，默认为布尔值false
            return false;
        } else if (values.size() == 1) {
            // 如果只有一个值，返回该值
            return parseSingleValue(values.get(0));
        } else {
            // 如果有多个值，返回值的列表
            List<Object> parsedList = new ArrayList<>();
            for (Object value : values) {
                parsedList.add(parseSingleValue(value));
            }
            return parsedList;
        }
    }
    private static Object parseSingleValue(Object value) {
        // 解析单个值的类型，可以根据需要扩展
        if (value instanceof String) {
            // 如果是字符串，返回原始字符串
            return value;
        } else {
            try {
                // 尝试解析为整数
                return Integer.parseInt(value.toString());
            } catch (NumberFormatException e) {
                // 如果解析失败，返回原始值
                return value;
            }
         }
    }
}
无论你是否了解 Java，你都可以感受到，这段代码的逻辑是有一定复杂度的。而 ChatGPT 生成这段代码也就只要几秒钟的时间，显然我们无法在几秒钟内判断这段代码是否符合我们的要求。
这就意味着，我们无法知道这段代码是否完成了功能。我们仍然要回归到为这段代码构造测试，并验证它是否正确的道路上。所以哪怕你对于测试驱动开发一无所知，LLM 的特性仍然会将你的注意力引导到测试上。我们可以在现在的代码基础上，让 LLM 帮助我们生成测试。
请根据需求，为这段代码生成相应的测试
ChatGPT 生成的结果是：
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
class CommandLineParserTest {
    @Test
    void testParseArgs() {
        // 测试基本的命令行参数解析
        String[] args1 = {"-l", "-p", "8080", "-d", "/usr/logs"};
        Map<String, Object> result1 = CommandLineParser.parseArgs(args1);
        assertEquals(true, result1.get("l"));
        assertEquals(8080, result1.get("p"));
        assertEquals("/usr/logs", result1.get("d"));
        
        // 测试带有列表的命令行参数解析
        String[] args2 = {"-g", "this", "is", "a", "list", "-d", "1", "2", "-3", "5"};
        Map<String, Object> result2 = CommandLineParser.parseArgs(args2);
        assertEquals(List.of("this", "is", "a", "list"), result2.get("g"));
        assertEquals(List.of(1, 2, -3, 5), result2.get("d"));
        
        // 测试默认值
        String[] args3 = {};
        Map<String, Object> result3 = CommandLineParser.parseArgs(args3);
        assertEquals(false, result3.get("l"));
        assertEquals(0, result3.get("p"));
        assertEquals("", result3.get("d"));
        
        // 测试无效参数
        String[] args4 = {"-p", "abc"};
        assertThrows(NumberFormatException.class, () -> CommandLineParser.parseArgs(args4));
        // 添加更多的测试用例，根据需要进行扩展
    }
}
我们先忽略 ChatGPT 生成测试的风格问题，比如不同的场景应该构造成不同的测试，也可以暂时不考虑这些测试的完备性问题，比如缺少边界条件。先看看 ChatGPT 给出的代码是否能够满足这些测试。
第一次调试然而结果是并不能，按照测试结果显示，当我们传入参数 “-l” 的时候，ChatGPT 生成的代码并没有按照题目要求的逻辑转化为 true。那么我们就要去回看 ChatGPT 生成的代码了，并尝试定位这个问题产生的根源。不难发现问题出在这个地方：
private static Object parseValues(List<Object> values) {
    if (values.isEmpty()) {
        // 如果值为空，默认为布尔值false
        return false;
    } else if (values.size() == 1) {
        // 如果只有一个值，返回该值
        return parseSingleValue(values.get(0));
    } else {
        // 如果有多个值，返回值的列表
        List<Object> parsedList = new ArrayList<>();
        for (Object value : values) {
            parsedList.add(parseSingleValue(value));
        }
        return parsedList;
    }
}
这里 ChatGPT 给出的逻辑是错误的，当我们给出参数 “-l” 的时候，实际的值是[“-l”]，所以 values 是一个空列表，那么返回值应该是 true。我们可以按照这个向 ChatGPT 提出建议。
当然，我们也可以用一种更简单的方式，直接把错误信息提供给 ChatGPT，让它根据错误信息修改代码：
执行测试的错误信息如下，请根据错误信息，修改 CommandLineParser 的代码：
 
Expected :true
Actual   :false

 
org.opentest4j.AssertionFailedError: expected:but was:
at org.junit.jupiter.api.AssertionFailureBuilder.build(AssertionFailureBuilder.java:151)
at org.junit.jupiter.api.AssertionFailureBuilder.buildAndThrow(AssertionFailureBuilder.java:132)
at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)
at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:182)
at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:177)
at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:1141)
at CommandLineParserTest.testParseArgs(CommandLineParserTest.java:15)
at java.base/java.lang.reflect.Method.invoke(Method.java:580)
at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CommandLineParser {
    public static void main(String[] args) {
        // 示例用法
        Map<String, Object> parsedArgs = parseArgs(args);
        System.out.println(parsedArgs);
    }
    public static Map<String, Object> parseArgs(String[] args) {
        Map<String, Object> parsedArgs = new HashMap<>();
        String currentFlag = null;
        List<Object> currentValues = new ArrayList<>();
        for (String arg : args) {
            if (arg.startsWith("-")) {
                // 处理之前的标志和值
                if (currentFlag != null) {
                    parsedArgs.put(currentFlag, parseValues(currentValues));
                }
                // 开始处理新的标志
                currentFlag = arg.substring(1);
                currentValues = new ArrayList<>();
            } else {
                // 处理标志对应的值
                currentValues.add(arg);
            }
        }
        // 处理最后一个标志和值
        if (currentFlag != null) {
            parsedArgs.put(currentFlag, parseValues(currentValues));
        }
        return parsedArgs;
    }
    private static Object parseValues(List<Object> values) {
        if (values.isEmpty()) {
            // 如果值为空，默认为布尔值true
            return true;
        } else if (values.size() == 1) {
            // 如果只有一个值，返回该值
            return parseSingleValue(values.get(0));
        } else {
            // 如果有多个值，返回值的列表
            List<Object> parsedList = new ArrayList<>();
            for (Object value : values) {
                parsedList.add(parseSingleValue(value));
            }
            return parsedList;
        }
    }
    private static Object parseSingleValue(Object value) {
        // 解析单个值的类型，可以根据需要扩展
        if (value instanceof String) {
            // 如果是字符串，返回原始字符串
            return value;
        } else {
            try {
                // 尝试解析为整数
                return Integer.parseInt(value.toString());
            } catch (NumberFormatException e) {
                // 如果解析失败，返回原始值
                return value;
            }
        }
    }
}
再次执行测试，依然存在错误。
第二次调试这次的问题要更严重一些，从错误结果上看，我们期待传入 “-p 8080” 时，得到参数的类型是整型，而 ChatGPT 生成的代码给出的结果是字符串。同样我们不难定位到错误在什么地方：
    } else if (values.size() == 1) {
        // 如果只有一个值，返回该值
        return parseSingleValue(values.get(0));
    } else {
在这段代码中，ChatGPT 将任何的单值参数都当作了字符串类型。这背后反映的是 ChatGPT 给出的代码在设计上的缺陷。也就是说是，不同的参数 “-l”, “-p” 和 “-d” 对应了不同的类型（bool，int 和 string）。而 ChatGPT 给出的代码忽略了类型的差异，尝试从结果上去推断类型，这自然是不能成功的。那么如果我们仍然按照前面的做法，让 ChatGPT 自行解决，它会发现这个问题吗？
执行测试的错误信息如下，请根据错误信息，修改 CommandLineParser 的代码：
 
Expected :8080
Actual   :8080

 
org.opentest4j.AssertionFailedError: expected: java.lang.Integer@1c5920df<8080> but was: java.lang.String@17f9d882<8080>
at org.junit.jupiter.api.AssertionFailureBuilder.build(AssertionFailureBuilder.java:151)
at org.junit.jupiter.api.AssertionFailureBuilder.buildAndThrow(AssertionFailureBuilder.java:132)
at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)
at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:182)
at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:177)
at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:1141)
at CommandLineParserTest.testParseArgs(CommandLineParserTest.java:16)
at java.base/java.lang.reflect.Method.invoke(Method.java:580)
at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
很显然，它没发现这是个设计问题，但是它给出了一个能通过测试的最简单的办法。这种做法也蛮符合测试驱动开发对于节奏的要求。那么这时候，应该由我们给出设计上的建议和改进了。
需求中给出的参数具有不同类型，比如：
-l 是 bool
-p 是 int
-d 是 string
-g 是 list
我们需要指定不同参数的不同类型。然后根据类型去解析参数。请按照这个思路重新编写 CommandLineParser
提供建议以后，GPT 返回的修改结果如下。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CommandLineParser {
    // 定义参数类型的枚举
    public enum ArgType {
        BOOLEAN, INTEGER, STRING, LIST
    }
    public static void main(String[] args) {
        // 示例用法
        Map<String, Object> parsedArgs = parseArgs(args);
        System.out.println(parsedArgs);
    }
    public static Map<String, Object> parseArgs(String[] args) {
        Map<String, Object> parsedArgs = new HashMap<>();
        String currentFlag = null;
        List<Object> currentValues = new ArrayList<>();
        ArgType currentType = null;
        for (String arg : args) {
            if (arg.startsWith("-")) {
                // 处理之前的标志和值
                if (currentFlag != null) {
                    parsedArgs.put(currentFlag, parseValues(currentValues, currentType));
                }
                // 开始处理新的标志
                currentFlag = arg.substring(1);
                currentValues = new ArrayList<>();
                currentType = determineArgType(currentFlag);
            } else {
                // 处理标志对应的值
                currentValues.add(arg);
            }
        }
        // 处理最后一个标志和值
        if (currentFlag != null) {
            parsedArgs.put(currentFlag, parseValues(currentValues, currentType));
        }
        return parsedArgs;
    }
    private static ArgType determineArgType(String flag) {
        // 根据标志确定参数类型
        switch (flag) {
            case "l":
                return ArgType.BOOLEAN;
            case "p":
                return ArgType.INTEGER;
            case "d":
                return ArgType.STRING;
            case "g":
                return ArgType.LIST;
            // 添加更多的类型，根据需要进行扩展
            default:
                throw new IllegalArgumentException("Unknown flag: " + flag);
        }
    }
    private static Object parseValues(List<Object> values, ArgType type) {
        if (values.isEmpty()) {
            // 如果值为空，默认为布尔值true
            return true;
        } else if (values.size() == 1) {
            // 如果只有一个值，返回该值
            return parseSingleValue(values.get(0), type);
        } else {
            // 如果有多个值，返回值的列表
            List<Object> parsedList = new ArrayList<>();
            for (Object value : values) {
                parsedList.add(parseSingleValue(value, type));
            }
            return parsedList;
        }
    }
    private static Object parseSingleValue(Object value, ArgType type) {
        // 解析单个值的类型，可以根据需要扩展
        switch (type) {
            case BOOLEAN:
                return true;  // 目前布尔值都设为true，可以根据实际需求调整
            case INTEGER:
                try {
                    return Integer.parseInt(value.toString());
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Invalid integer value: " + value);
                }
            case STRING:
                return value.toString();
            case LIST:
                return parseListValue(value);
            // 添加更多的类型，根据需要进行扩展
            default:
                throw new IllegalArgumentException("Unsupported type: " + type);
        }
    }
    private static List<Object> parseListValue(Object value) {
        // 解析列表类型的值
        if (value instanceof String) {
            // 如果是字符串，按空格分割
            String[] parts = ((String) value).split(" ");
            List<Object> listValues = new ArrayList<>();
            for (String part : parts) {
                listValues.add(part);
            }
            return listValues;
        } else {
            throw new IllegalArgumentException("Invalid list value: " + value);
        }
    }
}
第三次调试按照 ChatGPT 给出的修改，我们仍然没能通过全部的测试。新的错误继续出现：
现在测试失败的地方在于，ChatGPT 生成的代码将 -3 看作了参数名，而不是参数值。现在我们可以直接告诉 ChatGPT 现在的问题在哪，问题出在下面这个方法中将参数类型硬编码了（hard-coded）：
private static ArgType determineArgType(String flag) {
        // 根据标志确定参数类型
        switch (flag) {
            case "l":
                return ArgType.BOOLEAN;
            case "p":
                return ArgType.INTEGER;
            case "d":
                return ArgType.STRING;
            case "g":
                return ArgType.LIST;
            // 添加更多的类型，根据需要进行扩展
            default:
                throw new IllegalArgumentException("Unknown flag: " + flag);
        }
    }
那么我们现在可以告诉 ChatGPT 这个问题，并让它重新生成代码：
目前 determineArgType 中限定了可以使用的参数，将它改编为可配置的情况。也就是当用户初始化 CommandLineParser 时，可以指定支持的参数及其类型。
GPT 的回复如下。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CommandLineParser {
    // 定义参数类型的枚举
    public enum ArgType {
        BOOLEAN, INTEGER, STRING, LIST
    }
    // 可配置的参数类型映射
    private final Map<String, ArgType> argTypeMap;
    public CommandLineParser(Map<String, ArgType> argTypeMap) {
        // 初始化参数类型映射
        this.argTypeMap = new HashMap<>(argTypeMap);
    }
    public static void main(String[] args) {
        // 示例用法
        // 初始化参数类型映射，可以根据需要配置
        Map<String, ArgType> customArgTypeMap = new HashMap<>();
        customArgTypeMap.put("l", ArgType.BOOLEAN);
        customArgTypeMap.put("p", ArgType.INTEGER);
        customArgTypeMap.put("d", ArgType.STRING);
        customArgTypeMap.put("g", ArgType.LIST);
        // 创建 CommandLineParser 实例时传入自定义的参数类型映射
        CommandLineParser parser = new CommandLineParser(customArgTypeMap);
        Map<String, Object> parsedArgs = parser.parseArgs(args);
        System.out.println(parsedArgs);
    }
    public Map<String, Object> parseArgs(String[] args) {
        Map<String, Object> parsedArgs = new HashMap<>();
        String currentFlag = null;
        List<Object> currentValues = new ArrayList<>();
        ArgType currentType = null;
        for (String arg : args) {
            if (arg.startsWith("-")) {
                // 处理之前的标志和值
                if (currentFlag != null) {
                    parsedArgs.put(currentFlag, parseValues(currentValues, currentType));
                }
                // 开始处理新的标志
                currentFlag = arg.substring(1);
                currentValues = new ArrayList<>();
                currentType = determineArgType(currentFlag);
            } else {
                // 处理标志对应的值
                currentValues.add(arg);
            }
        }
        // 处理最后一个标志和值
        if (currentFlag != null) {
            parsedArgs.put(currentFlag, parseValues(currentValues, currentType));
        }
        return parsedArgs;
    }
    private ArgType determineArgType(String flag) {
        // 根据标志确定参数类型，如果未配置，默认为STRING类型
        return argTypeMap.getOrDefault(flag, ArgType.STRING);
    }
    private Object parseValues(List<Object> values, ArgType type) {
        if (values.isEmpty()) {
            // 如果值为空，默认为布尔值true
            return true;
        } else if (values.size() == 1) {
            // 如果只有一个值，返回该值
            return parseSingleValue(values.get(0), type);
        } else {
            // 如果有多个值，返回值的列表
            List<Object> parsedList = new ArrayList<>();
            for (Object value : values) {
                parsedList.add(parseSingleValue(value, type));
            }
            return parsedList;
        }
    }
    private Object parseSingleValue(Object value, ArgType type) {
        // 解析单个值的类型，可以根据需要扩展
        switch (type) {
            case BOOLEAN:
                return true;  // 目前布尔值都设为true，可以根据实际需求调整
            case INTEGER:
                try {
                    return Integer.parseInt(value.toString());
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Invalid integer value: " + value);
                }
            case STRING:
                return value.toString();
            case LIST:
                return parseListValue(value);
            // 添加更多的类型，根据需要进行扩展
            default:
                throw new IllegalArgumentException("Unsupported type: " + type);
        }
    }
    private List<Object> parseListValue(Object value) {
        // 解析列表类型的值
        if (value instanceof String) {
            // 如果是字符串，按空格分割
            String[] parts = ((String) value).split(" ");
            List<Object> listValues = new ArrayList<>();
            for (String part : parts) {
                listValues.add(part);
            }
            return listValues;
        } else {
            throw new IllegalArgumentException("Invalid list value: " + value);
        }
    }
}
我们看到这里 ChatGPT 在 main 方法中给出了配置 CommandLineParser 的方式，我们需要将它改到我们的测试中。当然也可以用 ChatGPT 修改我们的测试，但其实没有这个必要。
小结按照 ChatGPT 给出的修改，我们仍然没能通过全部的测试。新的错误继续出现：
这次是列表的结构错误。当然，这里我们可以继续告诉 ChatGPT，错误发生在哪，然后让 ChatGPT 再重写代码。过程与前面的类似，我们就不再重复了。
在这里我并不是想说 ChatGPT 生成的代码有多么的不靠谱。恰恰相反，哪怕漏洞百出，这仍然展示了巨大的效率提升。你可以试试自己从头开始编写这么一段功能，再比较一下这节课展示的方法，就会明白我的意思。
这里我想提醒你的是，LLM 快则快矣，质量堪忧。当我们使用 LLM 辅助软件开发的时候，更多的精力要放到质量的控制上。而不是一味地关注效率。
那么下节课，我们就来讲讲怎么在提高效率的同时保持质量。
思考题请跟 LLM 一起完成课程中的这个题目。
欢迎你在留言区分享自己的思考或疑惑，我们会把精彩内容置顶供大家学习讨论。

1. 使用大语言模型（LLM）辅助进行业务知识管理，学习使用LLM辅助软件交付的整体流程，以及其中涉及到的知识管理。 2. 强调了即使使用LLM生成了代码，仍需要进行测试来验证代码的正确性，以及使用LLM生成测试的过程。 3. 发现使用LLM生成的代码存在问题，需要进行调试和修改，以及提出错误信息来指导LLM修改代码的过程。 4. 展示了调试过程中对生成的代码进行修改，以及再次执行测试仍存在错误的情况。 5. 强调了测试的重要性，以及在调试过程中不断修正代码和测试的过程。 6. 展示了对生成的代码进行修改后再次执行测试，依然存在错误的情况。

分享给需要的人，Ta购买本课程，你将得29元

生成海报并分享

2024-04-10

赞 3

提建议

直播专场（二）｜如何进行业务知识管理？

16｜任务划分与测试驱动AI开发

 写留言

全部留言(5)

最新
精选

穿靴子的加菲猫
2024-04-10 来自上海
“l”（日志）没有相关的值，它是一个布尔标志，如果存在则为 true，不存在则为 false。“p”（端口）有一个整数值，“d”（目录）有一个字符串值。标志后面如果存在多个值，则该标志表示一个列表： -g this is a list -d 1 2 -3 5 “g” 表示一个字符串列表[“this”, “is”, “a”, “list”]，"d"标志表示一个整数列表[1, 2, -3, 5]。这里第二个d是不是换个字母好点，后文第二次调试时d代表字符串，会增加理解成本
作者回复: 原本需求就这样
术子米德
2024-04-10 来自日本
🤔☕️🤔☕️🤔 【Q】前面的课程，拉来认知模型，拉出LLM辅助建模和用户故事，做了这么多准备，怎么就跳跃到CleanCode的parseCmdLineArgs，这是出现幻觉了嘛？项目里，难道不是基于用户故事和建出来的模型，开始拆解到任务列表，让LLM浸泡在这个KnowledgeContext里持续辅助，然后用TDD的方法边验证、边实现、边详细设计、边螺旋迭代嘛？忽然间切换KnowledgeContext，这个人也适用不了，更何况LLM怎么适应，这个跳跃真不懂。 — by 术子米德@2024年4月10日
展开
编辑回复: 因为在你说这的这些之前，需要把技术知识处理掉。比如你说拆任务这个那需要把架构和测试策略放到llm里才行。后续课程里这个例子还会再做一遍，到时可以仔细对比一下两种方式的不同。
术子米德
2024-04-10 来自日本
//BEGIN UT CODE GENERATED BY GITHUB COPILOT, EXCEPT FIRST LINE COMMENT //use gtest to test the function CC_parseCmdLineArgs defined in CC_parseCmdLineArgs.h #include "CC_parseCmdLineArgs.h" #include <gtest/gtest.h> TEST(CC_parseCmdLineArgs, NullCmdLineArgs) { CC_CmdLineArgs_T CmdLineArgs; EXPECT_EQ(CC_FAIL, CC_parseCmdLineArgs(0, NULL, &CmdLineArgs)); } TEST(CC_parseCmdLineArgs, NullCmdLineArgsPtr) { EXPECT_EQ(CC_FAIL, CC_parseCmdLineArgs(0, NULL, NULL)); } TEST(CC_parseCmdLineArgs, NoArgs) { CC_CmdLineArgs_T CmdLineArgs; char *argv[] = { (char *)"test" }; EXPECT_EQ(CC_SUCCESS, CC_parseCmdLineArgs(1, argv, &CmdLineArgs)); EXPECT_FALSE(CmdLineArgs.IsLoggingEnabled); EXPECT_EQ(0, CmdLineArgs.RecvPort); EXPECT_EQ(NULL, CmdLineArgs.pLogSavingDir); } ... TEST(CC_parseCmdLineArgs, RecvPort) { CC_CmdLineArgs_T CmdLineArgs; char *argv[] = { (char *)"test", (char *)"-p", (char *)"1234" }; EXPECT_EQ(CC_SUCCESS, CC_parseCmdLineArgs(3, argv, &CmdLineArgs)); EXPECT_FALSE(CmdLineArgs.IsLoggingEnabled); EXPECT_EQ(1234, CmdLineArgs.RecvPort); EXPECT_EQ(NULL, CmdLineArgs.pLogSavingDir); } TEST(CC_parseCmdLineArgs, LogSavingDir) { CC_CmdLineArgs_T CmdLineArgs; char *argv[] = { (char *)"test", (char *)"-d", (char *)"/tmp" }; EXPECT_EQ(CC_SUCCESS, CC_parseCmdLineArgs(3, argv, &CmdLineArgs)); EXPECT_FALSE(CmdLineArgs.IsLoggingEnabled); EXPECT_EQ(0, CmdLineArgs.RecvPort); EXPECT_STREQ("/tmp", CmdLineArgs.pLogSavingDir); } TEST(CC_parseCmdLineArgs, AllArgs) { CC_CmdLineArgs_T CmdLineArgs; char *argv[] = { (char *)"test", (char *)"-l", (char *)"-p", (char *)"1234", (char *)"-d", (char *)"/tmp" }; EXPECT_EQ(CC_SUCCESS, CC_parseCmdLineArgs(7, argv, &CmdLineArgs)); EXPECT_TRUE(CmdLineArgs.IsLoggingEnabled); EXPECT_EQ(1234, CmdLineArgs.RecvPort); EXPECT_STREQ("/tmp", CmdLineArgs.pLogSavingDir); } int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }
展开
术子米德
2024-04-10 来自日本
//BEGIN CODE&COMMENT BY ME typedef enum { CC_SUCCESS = 0, CC_FAIL = 1, } CC_Result_T; typedef struct { bool IsLoggingEnabled; //-l int RecvPort; //-p <port> char *pLogSavingDir; //-d <dir> } CC_CmdLineArgs_T; /** * @brief: Use CC_parseCmdLineArgs to parse command line arguments and save them in CC_CmdLingArgs_T. * * @param argc same as main * @param argv same as main * @param pCmdLineArgs pointer to CC_CmdLineArgs_T * @return CC_SUCCESS if successful, CC_FAIL otherwise in CC_Result_T */ CC_Result_T CC_parseCmdLineArgs(int argc, char *argv[], CC_CmdLineArgs_T *pCmdLineArgs);
展开
aoe
2024-04-10 来自浙江
使用 AI 生成的测试通过 9 个，失败 7 个。在已有代码上修补，比自己从 0 到 1 实现快了非常多，这个只用了十几分钟！主要步骤： 1. 15 课的例子扔给 coze 的 GPT4，得到的代码简单粗暴 2. 使用 Optimize 功能优化一下 prompt 3. 在优化的 prompt 上添加自己的想法 4. 因返回 token 限制，需要多次对话完成结果 4.1 请给出 CommandLineParser 的完整代码 4.2 请给出完整测试代码 4.3 补全测试代码：测试用例可以继续增加，包括各种边界情况和无效输入 5. 最终得到的代码虽然测试没跑通，但功能强大
展开
共 1 条评论

