cicv_data_closed_loop/test/io_test.go

package test

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"regexp"
	"strings"
	"testing"
)

func TestIO(t *testing.T) {
	//file, err := os.OpenFile("b.txt", os.O_RDONLY, 0)
	file, err := os.OpenFile("b.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	contentBytes, err := io.ReadAll(file)
	fmt.Println(string(contentBytes))
}

func TestPrint1(t *testing.T) {

	// 打开文件[1,3](@ref)
	file, err := os.Open("C:\\Users\\mlxengingin\\GolandProjects\\cicv_data_closed_loop0326\\aarch64\\pjibot_clean\\master\\package\\config\\清洁机器人话题列表.txt")
	if err != nil {
		fmt.Printf("Error opening file: %v\n", err)
		return
	}
	defer file.Close()

	// 创建扫描器逐行读取[1,3,8](@ref)
	scanner := bufio.NewScanner(file)
	lineNumber := 1

	// 处理每一行内容
	for scanner.Scan() {
		line := scanner.Text()
		// 格式化输出为 TopicN = "行内容"[1,8](@ref)
		fmt.Printf("\tTopic%-3d = \"%s\"\n", lineNumber, line)
		lineNumber++
	}

	// 检查扫描错误[1,3](@ref)
	if err := scanner.Err(); err != nil {
		fmt.Printf("Error reading file: %v\n", err)
	}
}
func TestPrint2(t *testing.T) {
	// 使用固定宽度左对齐格式控制规则编号排版[6,7](@ref)
	const (
		ruleWidth   = 10  // 规则编号部分占10字符宽度
		totalRules  = 284 // 总生成规则数
		ruleNameFmt = "Rule%d"
	)

	// 通过for循环生成指定数量的规则行[3,4](@ref)
	for i := 1; i <= totalRules; i++ {
		// 使用Sprintf构建规则前缀[6](@ref)
		rulePrefix := fmt.Sprintf(ruleNameFmt, i)
		// 采用%-*s实现动态宽度对齐，确保后续内容垂直对齐[7](@ref)
		fmt.Printf("%-*s []func(data *sensor_msgs.Imu) string\n", ruleWidth, rulePrefix)
	}
}
func TestPrint3(t *testing.T) {
	// 文件路径配置（根据实际位置修改）
	const filePath = "C:\\Users\\mlxengingin\\GolandProjects\\cicv_data_closed_loop0326\\aarch64\\pjibot_clean\\master\\package\\config\\机器人话题和数据类型对应关系.txt"

	// 使用高效方式读取文件（网页1、网页3推荐方法）
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Printf("文件打开失败: %v\n", err)
		return
	}
	defer file.Close()

	// 初始化规则生成器
	var rules []string
	ruleCounter := 1

	// 逐行处理文件内容（网页2、网页4推荐方法）
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue // 跳过空行
		}

		// 分割字段（网页7推荐方法）
		fields := strings.Fields(line)
		if len(fields) < 2 {
			continue // 跳过格式错误行
		}

		// 转换消息类型格式（网页8字符串处理）
		msgType := strings.Replace(fields[1], "/", ".", -1)

		// 生成规则定义（网页6格式化最佳实践）
		rule := fmt.Sprintf("Rule%-2d  []func(data *%s) string", ruleCounter, msgType)
		rules = append(rules, rule)
		ruleCounter++
	}

	// 错误检查（网页3建议）
	if err := scanner.Err(); err != nil {
		fmt.Printf("文件读取错误: %v\n", err)
		return
	}

	// 格式化输出结果（网页5、网页8的字符串构建建议）
	fmt.Println("生成规则结构体：")
	fmt.Println("type Rules struct {")
	for _, rule := range rules {
		fmt.Printf("\t%s\n", rule)
	}
	fmt.Println("}")
}

func TestPrint4(t *testing.T) {
	rules := parseRules("C:\\Users\\mlxengingin\\GolandProjects\\cicv_data_closed_loop0326\\aarch64\\pjibot_clean\\master\\package\\config\\rules.txt")
	generateCode(rules)
}

// 定义规则解析结构体
type RuleMeta struct {
	RuleName    string
	MessageType string
}

func parseRules(filename string) []RuleMeta {
	file, _ := os.Open(filename)
	defer file.Close()

	scanner := bufio.NewScanner(file)
	var rules []RuleMeta
	pattern := regexp.MustCompile(`(\w+)\s+$$$$func$data\s+\*([\w\.]+)$`)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if matches := pattern.FindStringSubmatch(line); len(matches) == 3 {
			rules = append(rules, RuleMeta{
				RuleName:    matches[1],
				MessageType: matches[2],
			})
		}
	}
	return rules
}
func generateCode(rules []RuleMeta) {
	var builder strings.Builder
	builder.WriteString("switch topic2 {\n")

	for i, rule := range rules {
		// 生成条件分支
		builder.WriteString(fmt.Sprintf("\tcase Topic%d: // %d\n", i+1, i+1))
		builder.WriteString(fmt.Sprintf("\t\tif f, ok1 := rule.(func(*%s) string); ok1 {\n", rule.MessageType))
		builder.WriteString(fmt.Sprintf("\t\t\t%s = append(%s, f)\n", rule.RuleName, rule.RuleName))
		builder.WriteString("\t\t\tgoto JudgeDone\n")
		builder.WriteString("\t\t}\n")
		builder.WriteString("\t\tlog(triggerLocalPath)\n")
		builder.WriteString("\t\tcontinue\n\n")
	}

	builder.WriteString("\tdefault:\n\t\t// 默认处理逻辑\n")
	builder.WriteString("}")

	fmt.Println(builder.String())
}