跳到正文
春节 −50%团圆仅 99,500 越南盾 首年团圆首年仅 99,500 越南盾, 每年赠 1 份个人解读查看优惠

Blog

用通用测试用例检查你的紫微或农历库

对照器在农历库上运行:正确版本与错误版本

Nhat Nguyet 的测试用例是由网站正在运行的计算核心生成的 17,291 组输入与答案:任何人用任何语言写紫微、八字、生命灵数或农历库,都可以拿它来对照。 Nhat Nguyet 自己的 TypeScript 和 Python 版本必须全部通过。本文说明如何用它检查你的库。

测试用例包含什么?

文件用例数内容
am-lich.json14,936公历转农历(11,039)、农历转公历(3,696)、每年二十四节气时刻(201),含中国、韩国农历
tu-vi.json777命盘、大运、2026 年流年与流曜、格局
bat-tu.json777四柱、十神、大运、小运
than-so-hoc.json600由姓名和生日算出的各数
le-hoi.json2011900 至 2100 年每年各节庆的公历日期

所有文件结构相同:

ca-kiem/am-lich.json 的结构
ca-kiem/am-lich.json 的结构
  • phienBanDongCo:生成答案的计算核心版本,目前为 2.0.1。
  • khoaBo:18 个存放说明文字的键(dienGiai、caveat、cachTinh……),比较前在各层删去,因为措辞会变而计算不变。
  • ca:{"vao", "ra"} 数组;各科的输入写在代码库的 QUY-UOC.md 中。

对照步骤

  1. 从代码库下载 ca-kiem 文件夹。
  2. 写一个 tinh(vao) 函数,调用你的库,返回与 ra 键名相同的结果。
  3. 在两边的各层删去 khoaBo 中的键。
  4. 深度比较:键的顺序不计,数组按顺序比较,浮点数最多相差 1e-9,缺键或多键都算不符。
  5. 打印第一处不符及其键路径,修正后重跑,直到全部通过。

用 Python 写的对照器

import json, math, sys

def bo_khoa(v, bo):
    if isinstance(v, dict):
        return {k: bo_khoa(x, bo) for k, x in v.items() if k not in bo}
    if isinstance(v, list):
        return [bo_khoa(x, bo) for x in v]
    return v

def lech(mong, that, duong="ra"):
    if isinstance(mong, bool) or isinstance(that, bool):
        return None if mong is that else f"{duong}: 期望 {mong},实得 {that}"
    if isinstance(mong, (int, float)) and isinstance(that, (int, float)):
        return None if abs(mong - that) <= 1e-9 else f"{duong}: 期望 {mong},实得 {that}"
    if isinstance(mong, dict) and isinstance(that, dict):
        for k in sorted(set(mong) | set(that)):
            if k not in that or k not in mong:
                return f"{duong}.{k}: 缺少或多出键"
            r = lech(mong[k], that[k], f"{duong}.{k}")
            if r:
                return r
        return None
    if isinstance(mong, list) and isinstance(that, list):
        if len(mong) != len(that):
            return f"{duong}: độ dài 期望 {len(mong)},实得 {len(that)}"
        for i, (a, b) in enumerate(zip(mong, that)):
            r = lech(a, b, f"{duong}[{i}]")
            if r:
                return r
        return None
    return None if mong == that else f"{duong}: 期望 {mong!r},实得 {that!r}"

def kiem(mon, tinh, loc=lambda vao: True):
    tep = json.load(open(f"ca-kiem/{mon}.json", encoding="utf-8"))
    bo = set(tep["khoaBo"])
    dat = tong = 0
    for ca in tep["ca"]:
        if not loc(ca["vao"]):
            continue
        tong += 1
        r = lech(bo_khoa(ca["ra"], bo), bo_khoa(tinh(ca["vao"]), bo))
        if r is None:
            dat += 1
        elif tong - dat <= 3:
            print("  不符:", ca["vao"], r)
    print(f"{mon}: {dat}/{tong} 例通过")

先对照农历库,再试一个故意写错的版本(忘了时区,总按 UTC+8 计算):

from kiem_ca import kiem
from nhatnguyet import am_lich

def am_sang_duong(vao):
    duong, hop_le = am_lich.lunar_to_solar(vao["ngay"], vao["thang"], vao["nam"], vao["nhuan"], vao.get("muiGio", 7))
    return {"duong": duong, "hopLe": hop_le}

kiem("am-lich", am_sang_duong, lambda vao: vao["phep"] == "am-sang-duong")

# 试一个错误版本:忘了时区,总按 UTC+8 计算
def ban_sai(vao):
    duong, hop_le = am_lich.lunar_to_solar(vao["ngay"], vao["thang"], vao["nam"], vao["nhuan"], 8)
    return {"duong": duong, "hopLe": hop_le}

kiem("am-lich", ban_sai, lambda vao: vao["phep"] == "am-sang-duong")
am-lich: 3696/3696 例通过
  不符: {'nam': 1914, 'ngay': 1, 'nhuan': False, 'phep': 'am-sang-duong', 'thang': 10} ra.duong.day: 期望 17,实得 18
  不符: {'nam': 1914, 'ngay': 15, 'nhuan': False, 'phep': 'am-sang-duong', 'thang': 10} ra.duong.day: 期望 1,实得 2
  不符: {'nam': 1914, 'ngay': 29, 'nhuan': False, 'phep': 'am-sang-duong', 'thang': 10} ra.duong.day: 期望 15,实得 16
am-lich: 3593/3696 例通过
Python 对照器:正确版本全部通过,错误版本有 103 例不符
Python 对照器:正确版本全部通过,错误版本有 103 例不符

正确版本通过 3,696/3,696。错误版本通过 3,593,103 例不符,不符的那一行直指问题:ra.duong.day: 期望 17,实得 18,即按越南时间 1914 年十月初一早一天。

用 TypeScript 做同样的事

import { readFileSync } from "node:fs";
import { lapLaSoTuVi, daiVan, tinhHanNam, tinhSaoLuu, nhanDienCachCuc } from "@nhatnguyet/tu-vi";

const tep = JSON.parse(readFileSync("ca-kiem/tu-vi.json", "utf8"));
const bo = new Set(tep.khoaBo);
const sach = (x) => Array.isArray(x) ? x.map(sach)
  : x && typeof x === "object" ? Object.fromEntries(Object.entries(x).filter(([k]) => !bo.has(k)).map(([k, v]) => [k, sach(v)]))
  : x;
function lech(a, b, duong = "ra") {
  if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) <= 1e-9 ? null : `${duong}: 期望 ${a},实得 ${b}`;
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) return `${duong}: độ dài 期望 ${a.length},实得 ${b.length}`;
    for (let i = 0; i < a.length; i++) { const r = lech(a[i], b[i], `${duong}.${i}`); if (r) return r; }
    return null;
  }
  if (a && b && typeof a === "object" && typeof b === "object") {
    for (const k of new Set([...Object.keys(a), ...Object.keys(b)])) {
      if (!(k in a) || !(k in b)) return `${duong}.${k}: 缺少或多出键`;
      const r = lech(a[k], b[k], `${duong}.${k}`); if (r) return r;
    }
    return null;
  }
  return a === b ? null : `${duong}: 期望 ${JSON.stringify(a)},实得 ${JSON.stringify(b)}`;
}

let dat = 0;
for (const { vao, ra } of tep.ca) {
  const laSo = lapLaSoTuVi("", vao.gioiTinh, vao.dd, vao.mm, vao.yyyy, vao.gio);
  const kq = { laSo, daiVan: daiVan(laSo), hanNam: tinhHanNam(laSo, vao.namXem),
    saoLuu: tinhSaoLuu(laSo, vao.namXem), cachCuc: nhanDienCachCuc(laSo) };
  const r = lech(sach(ra), sach(JSON.parse(JSON.stringify(kq))));
  if (r) console.log("不符", vao, r); else dat++;
}
console.log(`tu-vi: ${dat}/${tep.ca.length} 例通过`);
tu-vi: 777/777 例通过
TypeScript 对照器通过 777 个紫微用例中的 777 个
TypeScript 对照器通过 777 个紫微用例中的 777 个

用例不符时怎么办?

  • 先看键路径:ngaySinhAm 不符是历法问题,cung 不符是安星问题。
  • 派别分歧是约定,不是错误:子时从 23 点起、庚干四化、闰月。你的库若另有选择,请写进文档并单独过滤这些用例。
  • 怀疑答案有误时不要改用例:把你的输入和结果发到 [email protected],我们会重新核对计算核心。

全部通过表示你的库与 Nhat Nguyet 的计算核心一样准确地套用了该派规则;它不表示紫微或八字的规则对人生成立,这一点未经检验。

许可

测试用例采用 CC BY 4.0,代码采用 MIT。请在 README 中注明:“测试用例:Nhat Nguyet (nhatnguyet.org)”。代码库和测试用例见开源页面。

开放数据农历、干支、节庆数据集,CC BY 4.0 许可。立即试用

博客中的更多文章

全部博客文章