NumPy 源码解析（九十四）

.\numpy\tools\swig\test\testFarray.py

#!/usr/bin/env python3
# System imports
# 导入系统模块
from distutils.util import get_platform
import os
import sys
import unittest

# Import NumPy
# 导入 NumPy 库
import numpy as np
# 解析 NumPy 版本号
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
# 根据 NumPy 的主版本号判断错误类型
if major == 0: BadListError = TypeError
else:          BadListError = ValueError

# Add the distutils-generated build directory to the python search path and then
# import the extension module
# 将 distutils 生成的构建目录添加到 Python 搜索路径中，并导入扩展模块
libDir = "lib.{}-{}.{}".format(get_platform(), *sys.version_info[:2])
sys.path.insert(0, os.path.join("build", libDir))
import Farray

######################################################################

class FarrayTestCase(unittest.TestCase):

    def setUp(self):
        # 设置测试用例的初始条件
        self.nrows = 5
        self.ncols = 4
        # 创建 Farray 对象
        self.array = Farray.Farray(self.nrows, self.ncols)

    def testConstructor1(self):
        "Test Farray size constructor"
        # 测试 Farray 的大小构造函数
        self.assertTrue(isinstance(self.array, Farray.Farray))

    def testConstructor2(self):
        "Test Farray copy constructor"
        # 测试 Farray 的复制构造函数
        for i in range(self.nrows):
            for j in range(self.ncols):
                self.array[i, j] = i + j
        # 创建 Farray 对象的副本
        arrayCopy = Farray.Farray(self.array)
        # 断言副本与原始对象相等
        self.assertTrue(arrayCopy == self.array)

    def testConstructorBad1(self):
        "Test Farray size constructor, negative nrows"
        # 测试 Farray 的大小构造函数，负数行数
        self.assertRaises(ValueError, Farray.Farray, -4, 4)

    def testConstructorBad2(self):
        "Test Farray size constructor, negative ncols"
        # 测试 Farray 的大小构造函数，负数列数
        self.assertRaises(ValueError, Farray.Farray, 4, -4)

    def testNrows(self):
        "Test Farray nrows method"
        # 测试 Farray 的 nrows 方法
        self.assertTrue(self.array.nrows() == self.nrows)

    def testNcols(self):
        "Test Farray ncols method"
        # 测试 Farray 的 ncols 方法
        self.assertTrue(self.array.ncols() == self.ncols)

    def testLen(self):
        "Test Farray __len__ method"
        # 测试 Farray 的 __len__ 方法
        self.assertTrue(len(self.array) == self.nrows*self.ncols)

    def testSetGet(self):
        "Test Farray __setitem__, __getitem__ methods"
        # 测试 Farray 的 __setitem__ 和 __getitem__ 方法
        m = self.nrows
        n = self.ncols
        for i in range(m):
            for j in range(n):
                self.array[i, j] = i*j
        for i in range(m):
            for j in range(n):
                self.assertTrue(self.array[i, j] == i*j)

    def testSetBad1(self):
        "Test Farray __setitem__ method, negative row"
        # 测试 Farray 的 __setitem__ 方法，负数行号
        self.assertRaises(IndexError, self.array.__setitem__, (-1, 3), 0)

    def testSetBad2(self):
        "Test Farray __setitem__ method, negative col"
        # 测试 Farray 的 __setitem__ 方法，负数列号
        self.assertRaises(IndexError, self.array.__setitem__, (1, -3), 0)

    def testSetBad3(self):
        "Test Farray __setitem__ method, out-of-range row"
        # 测试 Farray 的 __setitem__ 方法，超出范围的行号
        self.assertRaises(IndexError, self.array.__setitem__, (self.nrows+1, 0), 0)

    def testSetBad4(self):
        "Test Farray __setitem__ method, out-of-range col"
        # 测试 Farray 的 __setitem__ 方法，超出范围的列号
        self.assertRaises(IndexError, self.array.__setitem__, (0, self.ncols+1), 0)
    # 测试 Farray 的 __getitem__ 方法，检查负索引行为是否引发 IndexError 异常
    def testGetBad1(self):
        "Test Farray __getitem__ method, negative row"
        self.assertRaises(IndexError, self.array.__getitem__, (-1, 3))

    # 测试 Farray 的 __getitem__ 方法，检查负索引列是否引发 IndexError 异常
    def testGetBad2(self):
        "Test Farray __getitem__ method, negative col"
        self.assertRaises(IndexError, self.array.__getitem__, (1, -3))

    # 测试 Farray 的 __getitem__ 方法，检查超出范围的行索引是否引发 IndexError 异常
    def testGetBad3(self):
        "Test Farray __getitem__ method, out-of-range row"
        self.assertRaises(IndexError, self.array.__getitem__, (self.nrows+1, 0))

    # 测试 Farray 的 __getitem__ 方法，检查超出范围的列索引是否引发 IndexError 异常
    def testGetBad4(self):
        "Test Farray __getitem__ method, out-of-range col"
        self.assertRaises(IndexError, self.array.__getitem__, (0, self.ncols+1))

    # 测试 Farray 的 asString 方法
    def testAsString(self):
        "Test Farray asString method"
        result = """\
"""
[ [ 0, 1, 2, 3 ],
  [ 1, 2, 3, 4 ],
  [ 2, 3, 4, 5 ],
  [ 3, 4, 5, 6 ],
  [ 4, 5, 6, 7 ] ]
"""

# 遍历每个元素的行和列索引，为二维数组填充递增的整数值
for i in range(self.nrows):
    for j in range(self.ncols):
        self.array[i, j] = i+j
self.assertTrue(self.array.asString() == result)

def testStr(self):
    "Test Farray __str__ method"
    result = """\
[ [ 0, -1, -2, -3 ],
  [ 1, 0, -1, -2 ],
  [ 2, 1, 0, -1 ],
  [ 3, 2, 1, 0 ],
  [ 4, 3, 2, 1 ] ]
"""

# 遍历每个元素的行和列索引，为二维数组填充递减的整数值
for i in range(self.nrows):
    for j in range(self.ncols):
        self.array[i, j] = i-j
self.assertTrue(str(self.array) == result)

def testView(self):
    "Test Farray view method"
    
# 遍历每个元素的行和列索引，为二维数组填充递增的整数值
for i in range(self.nrows):
    for j in range(self.ncols):
        self.array[i, j] = i+j

# 调用数组的视图方法，并进行断言检查其返回的对象是否是 np.ndarray 类型
a = self.array.view()
self.assertTrue(isinstance(a, np.ndarray))

# 断言检查数组是否是列优先（Fortran）存储
self.assertTrue(a.flags.f_contiguous)

# 遍历每个元素的行和列索引，检查视图数组中的元素值是否正确
for i in range(self.nrows):
    for j in range(self.ncols):
        self.assertTrue(a[i, j] == i+j)

######################################################################

if __name__ == "__main__":

    # 构建测试套件
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(FarrayTestCase))

    # 执行测试套件
    print("Testing Classes of Module Farray")
    print("NumPy version", np.__version__)
    print()
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\testFlat.py

# 定义一个单元测试类 FlatTestCase，继承自 unittest.TestCase
class FlatTestCase(unittest.TestCase):

    # 初始化方法，设置默认测试方法为 runTest
    def __init__(self, methodName="runTest"):
        # 调用父类 unittest.TestCase 的初始化方法
        unittest.TestCase.__init__(self, methodName)
        # 设置类型字符串为 "double"
        self.typeStr  = "double"
        # 设置类型代码为 "d"
        self.typeCode = "d"

    # 测试方法，测试处理一维数组的函数 (type* INPLACE_ARRAY_FLAT, int DIM_FLAT)
    def testProcess1D(self):
        "Test Process function 1D array"
        # 打印类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Flat 模块中的处理函数，根据类型字符串动态调用
        process = Flat.__dict__[self.typeStr + "Process"]
        # 初始化一个空的字节串 pack_output
        pack_output = b''
        # 将 0 到 9 的数据按照类型代码打包到 pack_output 中
        for i in range(10):
            pack_output += struct.pack(self.typeCode, i)
        # 从 pack_output 中创建 NumPy 数组 x，数据类型由 self.typeCode 指定
        x = np.frombuffer(pack_output, dtype=self.typeCode)
        # 创建 y 数组作为 x 的副本
        y = x.copy()
        # 调用处理函数处理 y 数组
        process(y)
        # 断言 (x+1) 是否等于 y 的所有元素，返回 True
        self.assertEqual(np.all((x + 1) == y), True)

    # 测试方法，测试处理三维数组的函数 (type* INPLACE_ARRAY_FLAT, int DIM_FLAT)
    def testProcess3D(self):
        "Test Process function 3D array"
        # 打印类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Flat 模块中的处理函数，根据类型字符串动态调用
        process = Flat.__dict__[self.typeStr + "Process"]
        # 初始化一个空的字节串 pack_output
        pack_output = b''
        # 将 0 到 23 的数据按照类型代码打包到 pack_output 中
        for i in range(24):
            pack_output += struct.pack(self.typeCode, i)
        # 从 pack_output 中创建 NumPy 数组 x，数据类型由 self.typeCode 指定
        x = np.frombuffer(pack_output, dtype=self.typeCode)
        # 将 x 数组的形状设置为 (2, 3, 4)
        x.shape = (2, 3, 4)
        # 创建 y 数组作为 x 的副本
        y = x.copy()
        # 调用处理函数处理 y 数组
        process(y)
        # 断言 (x+1) 是否等于 y 的所有元素，返回 True
        self.assertEqual(np.all((x + 1) == y), True)

    # 测试方法，测试处理三维数组的函数，使用 FORTRAN 顺序 (type* INPLACE_ARRAY_FLAT, int DIM_FLAT)
    def testProcess3DTranspose(self):
        "Test Process function 3D array, FORTRAN order"
        # 打印类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Flat 模块中的处理函数，根据类型字符串动态调用
        process = Flat.__dict__[self.typeStr + "Process"]
        # 初始化一个空的字节串 pack_output
        pack_output = b''
        # 将 0 到 23 的数据按照类型代码打包到 pack_output 中
        for i in range(24):
            pack_output += struct.pack(self.typeCode, i)
        # 从 pack_output 中创建 NumPy 数组 x，数据类型由 self.typeCode 指定
        x = np.frombuffer(pack_output, dtype=self.typeCode)
        # 将 x 数组的形状设置为 (2, 3, 4)
        x.shape = (2, 3, 4)
        # 创建 y 数组作为 x 的副本
        y = x.copy()
        # 调用处理函数处理 y 数组的转置
        process(y.T)
        # 断言 (x.T+1) 是否等于 y 的转置的所有元素，返回 True
        self.assertEqual(np.all((x.T + 1) == y.T), True)

    # 测试方法，测试处理非连续数组的函数，预期引发 TypeError 异常
    def testProcessNoncontiguous(self):
        "Test Process function with non-contiguous array, which should raise an error"
        # 打印类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Flat 模块中的处理函数，根据类型字符串动态调用
        process = Flat.__dict__[self.typeStr + "Process"]
        # 初始化一个空的字节串 pack_output
        pack_output = b''
        # 将 0 到 23 的数据按照类型代码打包到 pack_output 中
        for i in range(24):
            pack_output += struct.pack(self.typeCode, i)
        # 从 pack_output 中创建 NumPy 数组 x，数据类型由 self.typeCode 指定
        x = np.frombuffer(pack_output, dtype=self.typeCode)
        # 将 x 数组的形状设置为 (2, 3, 4)
        x.shape = (2, 3, 4)
        # 调用处理函数处理 x[:,:,0] 子数组，预期引发 TypeError 异常
        self.assertRaises(TypeError, process, x[:,:,0])


# 定义 scharTestCase 类，继承自 FlatTestCase 类
class scharTestCase(FlatTestCase):

    # 初始化方法，设置默认测试方法为 runTest
    def __init__(self, methodName="runTest"):
        # 调用父类 FlatTestCase 的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "schar"
        self.typeStr  = "schar"
        # 设置类型代码为 "b"
        self.typeCode = "b"


# 主程序的入口点，开始执行单元测试
    # 定义初始化方法，初始化一个测试对象
    def __init__(self, methodName="runTest"):
        # 调用父类 FlatTestCase 的初始化方法，传入 methodName 参数
        FlatTestCase.__init__(self, methodName)
        # 设置实例变量 typeStr，表示数据类型为无符号字符（unsigned char）
        self.typeStr  = "uchar"
        # 设置实例变量 typeCode，表示数据类型编码为 'B'
        self.typeCode = "B"
######################################################################

# 定义一个测试类 shortTestCase，继承自 FlatTestCase
class shortTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "short"
        self.typeStr  = "short"
        # 设置类型代码为 "h"
        self.typeCode = "h"

######################################################################

# 定义一个测试类 ushortTestCase，继承自 FlatTestCase
class ushortTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "ushort"
        self.typeStr  = "ushort"
        # 设置类型代码为 "H"
        self.typeCode = "H"

######################################################################

# 定义一个测试类 intTestCase，继承自 FlatTestCase
class intTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "int"
        self.typeStr  = "int"
        # 设置类型代码为 "i"
        self.typeCode = "i"

######################################################################

# 定义一个测试类 uintTestCase，继承自 FlatTestCase
class uintTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "uint"
        self.typeStr  = "uint"
        # 设置类型代码为 "I"
        self.typeCode = "I"

######################################################################

# 定义一个测试类 longTestCase，继承自 FlatTestCase
class longTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "long"
        self.typeStr  = "long"
        # 设置类型代码为 "l"
        self.typeCode = "l"

######################################################################

# 定义一个测试类 ulongTestCase，继承自 FlatTestCase
class ulongTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "ulong"
        self.typeStr  = "ulong"
        # 设置类型代码为 "L"
        self.typeCode = "L"

######################################################################

# 定义一个测试类 longLongTestCase，继承自 FlatTestCase
class longLongTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "longLong"
        self.typeStr  = "longLong"
        # 设置类型代码为 "q"
        self.typeCode = "q"

######################################################################

# 定义一个测试类 ulongLongTestCase，继承自 FlatTestCase
class ulongLongTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "ulongLong"
        self.typeStr  = "ulongLong"
        # 设置类型代码为 "Q"
        self.typeCode = "Q"

######################################################################

# 定义一个测试类 floatTestCase，继承自 FlatTestCase
class floatTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "float"
        self.typeStr  = "float"
        # 设置类型代码为 "f"
        self.typeCode = "f"

######################################################################

# 定义一个测试类 doubleTestCase，继承自 FlatTestCase
class doubleTestCase(FlatTestCase):
    # 初始化方法，接受一个可选参数 methodName，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FlatTestCase.__init__(self, methodName)
        # 设置类型字符串为 "double"
        self.typeStr  = "double"
        # 设置类型代码为 "d"
        self.typeCode = "d"

######################################################################

# 如果作为独立模块执行
if __name__ == "__main__":

    # 创建一个测试套件对象
    suite = unittest.TestSuite()
    # 向测试套件中添加 scharTestCase 类的测试用例
    suite.addTest(unittest.makeSuite(scharTestCase))
    # 向测试套件中添加 ucharTestCase 类的测试用例
    suite.addTest(unittest.makeSuite(ucharTestCase))
    # 向测试套件中添加 shortTestCase 类的测试用例
    suite.addTest(unittest.makeSuite(shortTestCase))
    # 将 ushortTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(ushortTestCase))
    # 将 intTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(intTestCase))
    # 将 uintTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(uintTestCase))
    # 将 longTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(longTestCase))
    # 将 ulongTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(ulongTestCase))
    # 将 longLongTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(longLongTestCase))
    # 将 ulongLongTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    # 将 floatTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(floatTestCase))
    # 将 doubleTestCase 的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(doubleTestCase))
    
    # 执行测试套件
    print("Testing 1D Functions of Module Flat")
    # 打印 NumPy 的版本号
    print("NumPy version", np.__version__)
    print()
    
    # 运行测试套件，并输出详细的测试结果（verbosity=2）
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    
    # 根据测试结果（有错误或失败的测试用例），返回适当的退出状态码给操作系统
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\testFortran.py

#!/usr/bin/env python3
# System imports
import sys  # 导入系统模块 sys
import unittest  # 导入单元测试模块 unittest

# Import NumPy
import numpy as np  # 导入 NumPy 库，并命名为 np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]  # 解析 NumPy 版本信息
if major == 0:  # 如果主版本号为 0
    BadListError = TypeError  # 则定义 BadListError 为 TypeError
else:  # 否则
    BadListError = ValueError  # 定义 BadListError 为 ValueError

import Fortran  # 导入 Fortran 模块

######################################################################

class FortranTestCase(unittest.TestCase):
    # 初始化方法
    def __init__(self, methodName="runTests"):
        unittest.TestCase.__init__(self, methodName)
        self.typeStr  = "double"  # 设置测试用例中的数据类型字符串为 "double"
        self.typeCode = "d"       # 设置测试用例中的数据类型代码为 "d"

    # Test (type* IN_FARRAY2, int DIM1, int DIM2) typemap
    def testSecondElementFortran(self):
        "Test Fortran matrix initialized from reshaped NumPy fortranarray"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)  # 打印当前数据类型字符串到标准错误输出
        second = Fortran.__dict__[self.typeStr + "SecondElement"]  # 获取 Fortran 模块中对应数据类型的第二个元素函数
        matrix = np.asfortranarray(np.arange(9).reshape(3, 3),
                                   self.typeCode)  # 生成一个 Fortran 风格的 NumPy 数组
        self.assertEqual(second(matrix), 3)  # 断言第二个元素函数对该数组的调用结果为 3

    def testSecondElementObject(self):
        "Test Fortran matrix initialized from nested list fortranarray"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)  # 打印当前数据类型字符串到标准错误输出
        second = Fortran.__dict__[self.typeStr + "SecondElement"]  # 获取 Fortran 模块中对应数据类型的第二个元素函数
        matrix = np.asfortranarray([[0, 1, 2], [3, 4, 5], [6, 7, 8]], self.typeCode)  # 生成一个 Fortran 风格的 NumPy 数组
        self.assertEqual(second(matrix), 3)  # 断言第二个元素函数对该数组的调用结果为 3

######################################################################

class scharTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "schar"  # 设置测试用例中的数据类型字符串为 "schar"
        self.typeCode = "b"      # 设置测试用例中的数据类型代码为 "b"

######################################################################

class ucharTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "uchar"  # 设置测试用例中的数据类型字符串为 "uchar"
        self.typeCode = "B"      # 设置测试用例中的数据类型代码为 "B"

######################################################################

class shortTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "short"  # 设置测试用例中的数据类型字符串为 "short"
        self.typeCode = "h"      # 设置测试用例中的数据类型代码为 "h"

######################################################################

class ushortTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "ushort"  # 设置测试用例中的数据类型字符串为 "ushort"
        self.typeCode = "H"       # 设置测试用例中的数据类型代码为 "H"

######################################################################

class intTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "int"  # 设置测试用例中的数据类型字符串为 "int"
        self.typeCode = "i"    # 设置测试用例中的数据类型代码为 "i"

######################################################################

class uintTestCase(FortranTestCase):
    # 初始化方法
    def __init__(self, methodName="runTest"):
        FortranTestCase.__init__(self, methodName)
        self.typeStr  = "uint"  # 设置测试用例中的数据类型字符串为 "uint"
        self.typeCode = "I"     # 设置测试用例中的数据类型代码为 "I"
######################################################################

class longTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "long"
        self.typeStr  = "long"
        # 设置测试类型码为 "l"
        self.typeCode = "l"

######################################################################

class ulongTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "ulong"
        self.typeStr  = "ulong"
        # 设置测试类型码为 "L"
        self.typeCode = "L"

######################################################################

class longLongTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "longLong"
        self.typeStr  = "longLong"
        # 设置测试类型码为 "q"
        self.typeCode = "q"

######################################################################

class ulongLongTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "ulongLong"
        self.typeStr  = "ulongLong"
        # 设置测试类型码为 "Q"
        self.typeCode = "Q"

######################################################################

class floatTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "float"
        self.typeStr  = "float"
        # 设置测试类型码为 "f"
        self.typeCode = "f"

######################################################################

class doubleTestCase(FortranTestCase):
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        FortranTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "double"
        self.typeStr  = "double"
        # 设置测试类型码为 "d"
        self.typeCode = "d"

######################################################################

if __name__ == "__main__":

    # 创建测试套件对象
    suite = unittest.TestSuite()
    # 将各个测试类添加到测试套件中
    suite.addTest(unittest.makeSuite(    scharTestCase))
    suite.addTest(unittest.makeSuite(    ucharTestCase))
    suite.addTest(unittest.makeSuite(    shortTestCase))
    suite.addTest(unittest.makeSuite(   ushortTestCase))
    suite.addTest(unittest.makeSuite(      intTestCase))
    suite.addTest(unittest.makeSuite(     uintTestCase))
    suite.addTest(unittest.makeSuite(     longTestCase))
    suite.addTest(unittest.makeSuite(    ulongTestCase))
    suite.addTest(unittest.makeSuite( longLongTestCase))
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    suite.addTest(unittest.makeSuite(    floatTestCase))
    suite.addTest(unittest.makeSuite(   doubleTestCase))

    # 执行测试套件中的测试
    print("Testing 2D Functions of Module Matrix")
    print("NumPy version", np.__version__)
    print()
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    # 根据测试结果返回相应的退出状态码
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\testMatrix.py

# 指定 Python 解释器路径，使脚本可以在环境中独立运行
#!/usr/bin/env python3

# 导入系统相关模块
import sys
import unittest

# 导入 NumPy 库，并获取其主版本号和次版本号
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError
else:          BadListError = ValueError

# 导入 Matrix 模块
import Matrix

######################################################################

# 定义测试类 MatrixTestCase，继承自 unittest.TestCase
class MatrixTestCase(unittest.TestCase):

    # 构造方法，初始化测试实例
    def __init__(self, methodName="runTests"):
        # 调用父类构造方法初始化
        unittest.TestCase.__init__(self, methodName)
        # 设置测试用例类型字符串和类型代码
        self.typeStr  = "double"
        self.typeCode = "d"

    # 测试用例，测试 det 函数的正常情况
    # Test (type IN_ARRAY2[ANY][ANY]) typemap
    def testDet(self):
        "Test det function"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 det 函数
        det = Matrix.__dict__[self.typeStr + "Det"]
        # 定义测试矩阵
        matrix = [[8, 7], [6, 9]]
        # 断言调用 det 函数后的返回值为预期值 30
        self.assertEqual(det(matrix), 30)

    # 测试用例，测试 det 函数处理不良列表的情况
    # Test (type IN_ARRAY2[ANY][ANY]) typemap
    def testDetBadList(self):
        "Test det function with bad list"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 det 函数
        det = Matrix.__dict__[self.typeStr + "Det"]
        # 定义包含非法类型的测试矩阵
        matrix = [[8, 7], ["e", "pi"]]
        # 断言调用 det 函数时会引发 BadListError 异常
        self.assertRaises(BadListError, det, matrix)

    # 测试用例，测试 det 函数处理维度错误的情况
    # Test (type IN_ARRAY2[ANY][ANY]) typemap
    def testDetWrongDim(self):
        "Test det function with wrong dimensions"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 det 函数
        det = Matrix.__dict__[self.typeStr + "Det"]
        # 定义维度不符合要求的测试矩阵
        matrix = [8, 7]
        # 断言调用 det 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, det, matrix)

    # 测试用例，测试 det 函数处理尺寸错误的情况
    # Test (type IN_ARRAY2[ANY][ANY]) typemap
    def testDetWrongSize(self):
        "Test det function with wrong size"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 det 函数
        det = Matrix.__dict__[self.typeStr + "Det"]
        # 定义尺寸不符合要求的测试矩阵
        matrix = [[8, 7, 6], [5, 4, 3], [2, 1, 0]]
        # 断言调用 det 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, det, matrix)

    # 测试用例，测试 det 函数处理非容器的情况
    # Test (type IN_ARRAY2[ANY][ANY]) typemap
    def testDetNonContainer(self):
        "Test det function with non-container"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 det 函数
        det = Matrix.__dict__[self.typeStr + "Det"]
        # 断言调用 det 函数时会引发 TypeError 异常，因为传入了非容器对象
        self.assertRaises(TypeError, det, None)

    # 测试用例，测试 max 函数的正常情况
    # Test (type* IN_ARRAY2, int DIM1, int DIM2) typemap
    def testMax(self):
        "Test max function"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 max 函数
        max = Matrix.__dict__[self.typeStr + "Max"]
        # 定义测试矩阵
        matrix = [[6, 5, 4], [3, 2, 1]]
        # 断言调用 max 函数后的返回值为预期值 6
        self.assertEqual(max(matrix), 6)

    # 测试用例，测试 max 函数处理不良列表的情况
    # Test (type* IN_ARRAY2, int DIM1, int DIM2) typemap
    def testMaxBadList(self):
        "Test max function with bad list"
        # 输出类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 模块中特定类型的 max 函数
        max = Matrix.__dict__[self.typeStr + "Max"]
        # 定义包含非法类型的测试矩阵
        matrix = [[6, "five", 4], ["three", 2, "one"]]
        # 断言调用 max 函数时会引发 BadListError 异常
        self.assertRaises(BadListError, max, matrix)

    # 其他测试用例待补充
    # 定义一个测试函数，用于测试在非容器对象上使用 max 函数
    def testMaxNonContainer(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最大值函数
        max = Matrix.__dict__[self.typeStr + "Max"]
        # 断言调用该最大值函数时传入 None 会引发 TypeError 异常
        self.assertRaises(TypeError, max, None)

    # 测试函数签名为 (type* IN_ARRAY2, int DIM1, int DIM2)，验证 max 函数对错误维度输入的处理
    def testMaxWrongDim(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最大值函数
        max = Matrix.__dict__[self.typeStr + "Max"]
        # 断言调用该最大值函数时传入维度错误的列表会引发 TypeError 异常
        self.assertRaises(TypeError, max, [0, 1, 2, 3])

    # 测试函数签名为 (int DIM1, int DIM2, type* IN_ARRAY2)，验证 min 函数的正常工作
    def testMin(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最小值函数
        min = Matrix.__dict__[self.typeStr + "Min"]
        # 创建一个二维列表作为矩阵输入，并验证其最小值为 4
        matrix = [[9, 8], [7, 6], [5, 4]]
        self.assertEqual(min(matrix), 4)

    # 测试函数签名为 (int DIM1, int DIM2, type* IN_ARRAY2)，验证 min 函数对包含非数值元素的列表的处理
    def testMinBadList(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最小值函数
        min = Matrix.__dict__[self.typeStr + "Min"]
        # 创建一个包含非数值元素的二维列表，并验证调用最小值函数时会引发 BadListError 异常
        matrix = [["nine", "eight"], ["seven", "six"]]
        self.assertRaises(BadListError, min, matrix)

    # 测试函数签名为 (int DIM1, int DIM2, type* IN_ARRAY2)，验证 min 函数对错误维度输入的处理
    def testMinWrongDim(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最小值函数
        min = Matrix.__dict__[self.typeStr + "Min"]
        # 断言调用该最小值函数时传入维度错误的列表会引发 TypeError 异常
        self.assertRaises(TypeError, min, [1, 3, 5, 7, 9])

    # 测试函数签名为 (int DIM1, int DIM2, type* IN_ARRAY2)，验证 min 函数在非容器对象上的处理
    def testMinNonContainer(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的最小值函数
        min = Matrix.__dict__[self.typeStr + "Min"]
        # 断言调用该最小值函数时传入 False 会引发 TypeError 异常
        self.assertRaises(TypeError, min, False)

    # 测试函数签名为 (type INPLACE_ARRAY2[ANY][ANY])，验证 scale 函数的正常工作
    def testScale(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的缩放函数
        scale = Matrix.__dict__[self.typeStr + "Scale"]
        # 创建一个 NumPy 数组作为矩阵输入，并验证缩放后的结果是否符合预期
        matrix = np.array([[1, 2, 3], [2, 1, 2], [3, 2, 1]], self.typeCode)
        scale(matrix, 4)
        # 断言缩放后矩阵的元素是否全部符合预期值
        self.assertEqual((matrix == [[4, 8, 12], [8, 4, 8], [12, 8, 4]]).all(), True)

    # 测试函数签名为 (type INPLACE_ARRAY2[ANY][ANY])，验证 scale 函数对错误维度输入的处理
    def testScaleWrongDim(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的缩放函数
        scale = Matrix.__dict__[self.typeStr + "Scale"]
        # 创建一个维度错误的 NumPy 数组，并断言调用缩放函数时会引发 TypeError 异常
        matrix = np.array([1, 2, 2, 1], self.typeCode)
        self.assertRaises(TypeError, scale, matrix)

    # 测试函数签名为 (type INPLACE_ARRAY2[ANY][ANY])，验证 scale 函数对错误大小输入的处理
    def testScaleWrongSize(self):
        # 打印当前测试类型字符串，指示正在进行的测试，输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Matrix 类中与当前类型字符串相关的缩放函数
        scale = Matrix.__dict__[self.typeStr + "Scale"]
        # 创建一个大小错误的 NumPy 数组，并断言调用缩放函数时会引发 TypeError 异常
        matrix = np.array([[1, 2], [2, 1]], self.typeCode)
        self.assertRaises(TypeError, scale, matrix)
    # Test (type INPLACE_ARRAY2[ANY][ANY]) typemap
    def testScaleWrongType(self):
        "Test scale function with wrong type"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的缩放函数
        scale = Matrix.__dict__[self.typeStr + "Scale"]
        # 创建一个 NumPy 数组作为测试矩阵，使用 'c' 类型码
        matrix = np.array([[1, 2, 3], [2, 1, 2], [3, 2, 1]], 'c')
        # 断言调用缩放函数时会引发 TypeError 异常
        self.assertRaises(TypeError, scale, matrix)
    
    # Test (type INPLACE_ARRAY2[ANY][ANY]) typemap
    def testScaleNonArray(self):
        "Test scale function with non-array"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的缩放函数
        scale = Matrix.__dict__[self.typeStr + "Scale"]
        # 创建一个普通的 Python 列表作为测试矩阵
        matrix = [[1, 2, 3], [2, 1, 2], [3, 2, 1]]
        # 断言调用缩放函数时会引发 TypeError 异常
        self.assertRaises(TypeError, scale, matrix)
    
    # Test (type* INPLACE_ARRAY2, int DIM1, int DIM2) typemap
    def testFloor(self):
        "Test floor function"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取底函数
        floor = Matrix.__dict__[self.typeStr + "Floor"]
        # 创建一个 NumPy 数组作为测试矩阵，使用 self.typeCode 类型码
        matrix = np.array([[6, 7], [8, 9]], self.typeCode)
        # 调用取底函数，并验证矩阵的预期变化
        floor(matrix, 7)
        np.testing.assert_array_equal(matrix, np.array([[7, 7], [8, 9]]))
    
    # Test (type* INPLACE_ARRAY2, int DIM1, int DIM2) typemap
    def testFloorWrongDim(self):
        "Test floor function with wrong dimensions"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取底函数
        floor = Matrix.__dict__[self.typeStr + "Floor"]
        # 创建一个一维 NumPy 数组作为测试矩阵，使用 self.typeCode 类型码
        matrix = np.array([6, 7, 8, 9], self.typeCode)
        # 断言调用取底函数时会引发 TypeError 异常
        self.assertRaises(TypeError, floor, matrix)
    
    # Test (type* INPLACE_ARRAY2, int DIM1, int DIM2) typemap
    def testFloorWrongType(self):
        "Test floor function with wrong type"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取底函数
        floor = Matrix.__dict__[self.typeStr + "Floor"]
        # 创建一个 NumPy 数组作为测试矩阵，使用 'c' 类型码
        matrix = np.array([[6, 7], [8, 9]], 'c')
        # 断言调用取底函数时会引发 TypeError 异常
        self.assertRaises(TypeError, floor, matrix)
    
    # Test (type* INPLACE_ARRAY2, int DIM1, int DIM2) typemap
    def testFloorNonArray(self):
        "Test floor function with non-array"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取底函数
        floor = Matrix.__dict__[self.typeStr + "Floor"]
        # 创建一个普通的 Python 列表作为测试矩阵
        matrix = [[6, 7], [8, 9]]
        # 断言调用取底函数时会引发 TypeError 异常
        self.assertRaises(TypeError, floor, matrix)
    
    # Test (int DIM1, int DIM2, type* INPLACE_ARRAY2) typemap
    def testCeil(self):
        "Test ceil function"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取上函数
        ceil = Matrix.__dict__[self.typeStr + "Ceil"]
        # 创建一个 NumPy 数组作为测试矩阵，使用 self.typeCode 类型码
        matrix = np.array([[1, 2], [3, 4]], self.typeCode)
        # 调用取上函数，并验证矩阵的预期变化
        ceil(matrix, 3)
        np.testing.assert_array_equal(matrix, np.array([[1, 2], [3, 3]]))
    
    # Test (int DIM1, int DIM2, type* INPLACE_ARRAY2) typemap
    def testCeilWrongDim(self):
        "Test ceil function with wrong dimensions"
        # 打印当前类型信息到标准错误输出流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取与当前类型相关的取上函数
        ceil = Matrix.__dict__[self.typeStr + "Ceil"]
        # 创建一个一维 NumPy 数组作为测试矩阵，使用 self.typeCode 类型码
        matrix = np.array([1, 2, 3, 4], self.typeCode)
        # 断言调用取上函数时会引发 TypeError 异常
        self.assertRaises(TypeError, ceil, matrix)
    # Test (int DIM1, int DIM2, type* INPLACE_ARRAY2) typemap
    def testCeilWrongType(self):
        # 测试 ceil 函数对于维度错误的矩阵
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Matrix.__dict__[self.typeStr + "Ceil"]
        # 创建一个以字符串 'c' 表示的数组矩阵
        matrix = np.array([[1, 2], [3, 4]], 'c')
        # 断言会抛出 TypeError 异常
        self.assertRaises(TypeError, ceil, matrix)
    
    # Test (int DIM1, int DIM2, type* INPLACE_ARRAY2) typemap
    def testCeilNonArray(self):
        # 测试 ceil 函数对于非数组输入的情况
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Matrix.__dict__[self.typeStr + "Ceil"]
        # 创建一个普通的嵌套列表表示的矩阵
        matrix = [[1, 2], [3, 4]]
        # 断言会抛出 TypeError 异常
        self.assertRaises(TypeError, ceil, matrix)
    
    # Test (type ARGOUT_ARRAY2[ANY][ANY]) typemap
    def testLUSplit(self):
        # 测试 luSplit 函数
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 luSplit 函数
        luSplit = Matrix.__dict__[self.typeStr + "LUSplit"]
        # 对一个特定的 3x3 矩阵进行 LU 分解
        lower, upper = luSplit([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
        # 断言下三角矩阵是否符合预期
        self.assertEqual((lower == [[1, 0, 0], [4, 5, 0], [7, 8, 9]]).all(), True)
        # 断言上三角矩阵是否符合预期
        self.assertEqual((upper == [[0, 2, 3], [0, 0, 6], [0, 0, 0]]).all(), True)
######################################################################

# 创建一个名为 scharTestCase 的类，继承自 MatrixTestCase
class scharTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "schar"
        self.typeStr  = "schar"
        # 设置实例属性 typeCode 为字符 "b"
        self.typeCode = "b"

######################################################################

# 创建一个名为 ucharTestCase 的类，继承自 MatrixTestCase
class ucharTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "uchar"
        self.typeStr  = "uchar"
        # 设置实例属性 typeCode 为字符 "B"
        self.typeCode = "B"

######################################################################

# 创建一个名为 shortTestCase 的类，继承自 MatrixTestCase
class shortTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "short"
        self.typeStr  = "short"
        # 设置实例属性 typeCode 为字符 "h"
        self.typeCode = "h"

######################################################################

# 创建一个名为 ushortTestCase 的类，继承自 MatrixTestCase
class ushortTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "ushort"
        self.typeStr  = "ushort"
        # 设置实例属性 typeCode 为字符 "H"
        self.typeCode = "H"

######################################################################

# 创建一个名为 intTestCase 的类，继承自 MatrixTestCase
class intTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "int"
        self.typeStr  = "int"
        # 设置实例属性 typeCode 为字符 "i"
        self.typeCode = "i"

######################################################################

# 创建一个名为 uintTestCase 的类，继承自 MatrixTestCase
class uintTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "uint"
        self.typeStr  = "uint"
        # 设置实例属性 typeCode 为字符 "I"
        self.typeCode = "I"

######################################################################

# 创建一个名为 longTestCase 的类，继承自 MatrixTestCase
class longTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "long"
        self.typeStr  = "long"
        # 设置实例属性 typeCode 为字符 "l"
        self.typeCode = "l"

######################################################################

# 创建一个名为 ulongTestCase 的类，继承自 MatrixTestCase
class ulongTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "ulong"
        self.typeStr  = "ulong"
        # 设置实例属性 typeCode 为字符 "L"
        self.typeCode = "L"

######################################################################

# 创建一个名为 longLongTestCase 的类，继承自 MatrixTestCase
class longLongTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "longLong"
        self.typeStr  = "longLong"
        # 设置实例属性 typeCode 为字符 "q"
        self.typeCode = "q"

######################################################################

# 创建一个名为 ulongLongTestCase 的类，继承自 MatrixTestCase
class ulongLongTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "ulongLong"
        self.typeStr  = "ulongLong"
        # 设置实例属性 typeCode 为字符 "Q"
        self.typeCode = "Q"

######################################################################

# 创建一个名为 floatTestCase 的类，继承自 MatrixTestCase
class floatTestCase(MatrixTestCase):
    # 初始化方法，接受一个 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法
        MatrixTestCase.__init__(self, methodName)
        # 设置实例属性 typeStr 为字符串 "float"
        self.typeStr  = "float"
        # 设置实例属性 typeCode 为字符 "f"
        self.typeCode = "f"

######################################################################
######################################################################

class doubleTestCase(MatrixTestCase):
    # 定义一个名为 doubleTestCase 的测试用例类，继承自 MatrixTestCase
    def __init__(self, methodName="runTest"):
        # 调用父类的初始化方法，设置测试方法的名称
        MatrixTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "double"
        self.typeStr  = "double"
        # 设置测试类型代码为 "d"
        self.typeCode = "d"

######################################################################

if __name__ == "__main__":

    # 构建测试套件
    suite = unittest.TestSuite()
    # 将各个测试用例类添加到测试套件中
    suite.addTest(unittest.makeSuite(    scharTestCase))
    suite.addTest(unittest.makeSuite(    ucharTestCase))
    suite.addTest(unittest.makeSuite(    shortTestCase))
    suite.addTest(unittest.makeSuite(   ushortTestCase))
    suite.addTest(unittest.makeSuite(      intTestCase))
    suite.addTest(unittest.makeSuite(     uintTestCase))
    suite.addTest(unittest.makeSuite(     longTestCase))
    suite.addTest(unittest.makeSuite(    ulongTestCase))
    suite.addTest(unittest.makeSuite( longLongTestCase))
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    suite.addTest(unittest.makeSuite(    floatTestCase))
    suite.addTest(unittest.makeSuite(   doubleTestCase))

    # 执行测试套件
    print("Testing 2D Functions of Module Matrix")
    print("NumPy version", np.__version__)
    print()
    # 运行测试套件并获取测试结果
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    # 根据测试结果，如果有错误或者失败的测试，以非零退出码退出程序
    sys.exit(bool(result.errors + result.failures))


这段代码是一个用于测试的主程序，它构建了一个包含各种数据类型测试用例的测试套件，并执行这些测试用例。

.\numpy\tools\swig\test\testSuperTensor.py

#!/usr/bin/env python3
# System imports
import sys  # 导入系统模块sys，用于处理系统相关的功能
import unittest  # 导入unittest模块，用于编写和运行单元测试

# Import NumPy
import numpy as np  # 导入NumPy库，用于数值计算

major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError  # 如果NumPy的主版本号为0，则定义BadListError为TypeError
else:          BadListError = ValueError  # 否则定义BadListError为ValueError

import SuperTensor  # 导入SuperTensor模块，假设这是一个自定义的张量处理模块

######################################################################

class SuperTensorTestCase(unittest.TestCase):

    def __init__(self, methodName="runTests"):
        unittest.TestCase.__init__(self, methodName)
        self.typeStr  = "double"  # 定义测试用例中的类型字符串为"double"
        self.typeCode = "d"       # 定义测试用例中的类型代码为"d"

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    def testNorm(self):
        "Test norm function"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        norm = SuperTensor.__dict__[self.typeStr + "Norm"]  # 获取SuperTensor模块中的对应类型的Norm函数
        supertensor = np.arange(2*2*2*2, dtype=self.typeCode).reshape((2, 2, 2, 2))  # 创建一个4维数组作为输入张量
        #Note: cludge to get an answer of the same type as supertensor.
        #Answer is simply sqrt(sum(supertensor*supertensor)/16)
        answer = np.array([np.sqrt(np.sum(supertensor.astype('d')*supertensor)/16.)], dtype=self.typeCode)[0]
        self.assertAlmostEqual(norm(supertensor), answer, 6)  # 断言计算的norm函数值接近预期值，精确到小数点后6位

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    def testNormBadList(self):
        "Test norm function with bad list"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        norm = SuperTensor.__dict__[self.typeStr + "Norm"]  # 获取SuperTensor模块中的对应类型的Norm函数
        supertensor = [[[[0, "one"], [2, 3]], [[3, "two"], [1, 0]]], [[[0, "one"], [2, 3]], [[3, "two"], [1, 0]]]]
        # 创建一个包含不合法元素的多维列表作为输入张量
        self.assertRaises(BadListError, norm, supertensor)  # 断言调用norm函数时抛出BadListError异常

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    def testNormWrongDim(self):
        "Test norm function with wrong dimensions"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        norm = SuperTensor.__dict__[self.typeStr + "Norm"]  # 获取SuperTensor模块中的对应类型的Norm函数
        supertensor = np.arange(2*2*2, dtype=self.typeCode).reshape((2, 2, 2))  # 创建一个3维数组作为输入张量
        self.assertRaises(TypeError, norm, supertensor)  # 断言调用norm函数时抛出TypeError异常

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    def testNormWrongSize(self):
        "Test norm function with wrong size"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        norm = SuperTensor.__dict__[self.typeStr + "Norm"]  # 获取SuperTensor模块中的对应类型的Norm函数
        supertensor = np.arange(3*2*2, dtype=self.typeCode).reshape((3, 2, 2))  # 创建一个不符合尺寸要求的输入张量
        self.assertRaises(TypeError, norm, supertensor)  # 断言调用norm函数时抛出TypeError异常

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    def testNormNonContainer(self):
        "Test norm function with non-container"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        norm = SuperTensor.__dict__[self.typeStr + "Norm"]  # 获取SuperTensor模块中的对应类型的Norm函数
        self.assertRaises(TypeError, norm, None)  # 断言调用norm函数时抛出TypeError异常

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMax(self):
        "Test max function"
        print(self.typeStr, "... ", file=sys.stderr)  # 打印当前类型字符串到标准错误流
        max = SuperTensor.__dict__[self.typeStr + "Max"]  # 获取SuperTensor模块中的对应类型的Max函数
        supertensor = [[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]]
        # 创建一个多维列表作为输入张量
        self.assertEqual(max(supertensor), 8)  # 断言调用max函数计算的最大值为预期的8
    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxBadList(self):
        "Test max function with bad list"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        # 创建一个包含非法元素的超级张量
        supertensor = [[[[1, "two"], [3, 4]], [[5, "six"], [7, 8]]], [[[1, "two"], [3, 4]], [[5, "six"], [7, 8]]]]
        # 断言调用最大值函数时会抛出 BadListError 异常
        self.assertRaises(BadListError, max, supertensor)
    
    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxNonContainer(self):
        "Test max function with non-container"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        # 断言调用最大值函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, max, None)
    
    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxWrongDim(self):
        "Test max function with wrong dimensions"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        # 断言调用最大值函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, max, [0, -1, 2, -3])
    
    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMin(self):
        "Test min function"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        # 创建一个正常的超级张量
        supertensor = [[[[9, 8], [7, 6]], [[5, 4], [3, 2]]], [[[9, 8], [7, 6]], [[5, 4], [3, 2]]]]
        # 断言调用最小值函数返回值为预期的最小值
        self.assertEqual(min(supertensor), 2)
    
    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinBadList(self):
        "Test min function with bad list"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        # 创建一个包含非法元素的超级张量
        supertensor = [[[["nine", 8], [7, 6]], [["five", 4], [3, 2]]], [[["nine", 8], [7, 6]], [["five", 4], [3, 2]]]]
        # 断言调用最小值函数时会抛出 BadListError 异常
        self.assertRaises(BadListError, min, supertensor)
    
    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinNonContainer(self):
        "Test min function with non-container"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        # 断言调用最小值函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, min, True)
    
    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinWrongDim(self):
        "Test min function with wrong dimensions"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        # 断言调用最小值函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, min, [[1, 3], [5, 7]])
    
    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    def testScale(self):
        "Test scale function"
        # 输出正在进行的测试类型到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取当前类型对应的缩放函数
        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
        # 创建一个 NumPy 超级张量，用于测试
        supertensor = np.arange(3*3*3*3, dtype=self.typeCode).reshape((3, 3, 3, 3))
        # 创建预期的结果，通过复制当前张量并缩放
        answer = supertensor.copy()*4
        # 调用缩放函数
        scale(supertensor, 4)
        # 断言张量缩放后的结果符合预期
        self.assertEqual((supertensor == answer).all(), True)
    # 定义一个测试方法，用于测试在错误类型情况下调用 scale 函数
    def testScaleWrongType(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 scale 函数
        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
        # 创建一个三维的 numpy 数组作为测试输入
        supertensor = np.array([[[1, 0, 1], [0, 1, 0], [1, 0, 1]],
                          [[0, 1, 0], [1, 0, 1], [0, 1, 0]],
                          [[1, 0, 1], [0, 1, 0], [1, 0, 1]]], 'c')
        # 断言调用 scale 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, scale, supertensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个测试方法，用于测试在错误维度情况下调用 scale 函数
    def testScaleWrongDim(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 scale 函数
        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
        # 创建一个错误维度的 numpy 数组作为测试输入
        supertensor = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1],
                          [0, 1, 0], [1, 0, 1], [0, 1, 0]], self.typeCode)
        # 断言调用 scale 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, scale, supertensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个测试方法，用于测试在错误尺寸情况下调用 scale 函数
    def testScaleWrongSize(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 scale 函数
        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
        # 创建一个错误尺寸的 numpy 数组作为测试输入
        supertensor = np.array([[[1, 0], [0, 1], [1, 0]],
                          [[0, 1], [1, 0], [0, 1]],
                          [[1, 0], [0, 1], [1, 0]]], self.typeCode)
        # 断言调用 scale 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, scale, supertensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个测试方法，用于测试在非数组类型情况下调用 scale 函数
    def testScaleNonArray(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 scale 函数
        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
        # 断言调用 scale 函数时会抛出 TypeError 异常，传入的参数为 True
        self.assertRaises(TypeError, scale, True)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 定义一个测试方法，用于测试 floor 函数的正常操作
    def testFloor(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 使用 typeCode 创建一个特定类型的 numpy 数组
        supertensor = np.arange(2*2*2*2, dtype=self.typeCode).reshape((2, 2, 2, 2))
        # 复制 supertensor 以备后续比较
        answer = supertensor.copy()
        # 将 answer 数组中小于 4 的元素设置为 4
        answer[answer < 4] = 4

        # 获取对应类型的 floor 函数
        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
        # 调用 floor 函数，将 supertensor 中小于 4 的元素设置为 4
        floor(supertensor, 4)
        # 使用 numpy.testing.assert_array_equal 检查 supertensor 是否等于 answer
        np.testing.assert_array_equal(supertensor, answer)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 定义一个测试方法，用于测试在错误类型情况下调用 floor 函数
    def testFloorWrongType(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 floor 函数
        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
        # 创建一个错误类型的 numpy 数组作为测试输入
        supertensor = np.ones(2*2*2*2, dtype='c').reshape((2, 2, 2, 2))
        # 断言调用 floor 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, floor, supertensor)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 定义一个测试方法，用于测试在错误维度情况下调用 floor 函数
    def testFloorWrongDim(self):
        # 打印当前对象的 typeStr 属性到标准错误输出流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 floor 函数
        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
        # 创建一个错误维度的 numpy 数组作为测试输入
        supertensor = np.arange(2*2*2, dtype=self.typeCode).reshape((2, 2, 2))
        # 断言调用 floor 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, floor, supertensor)
    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testFloorNonArray(self):
        "Test floor function with non-array"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 floor 函数并调用，预期会抛出 TypeError 异常
        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
        self.assertRaises(TypeError, floor, object)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    def testCeil(self):
        "Test ceil function"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 创建一个指定类型和形状的超级张量，并复制一个相同的答案张量
        supertensor = np.arange(2*2*2*2, dtype=self.typeCode).reshape((2, 2, 2, 2))
        answer = supertensor.copy()
        # 将答案张量中大于5的元素设置为5
        answer[answer > 5] = 5
        # 获取对应类型的 ceil 函数并调用，修改 supertensor
        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
        ceil(supertensor, 5)
        # 使用 NumPy 测试断言确保 supertensor 和答案张量相等
        np.testing.assert_array_equal(supertensor, answer)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    def testCeilWrongType(self):
        "Test ceil function with wrong type"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 ceil 函数并调用，传入一个不合适类型的超级张量
        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
        supertensor = np.ones(2*2*2*2, 'c').reshape((2, 2, 2, 2))
        # 预期会抛出 TypeError 异常
        self.assertRaises(TypeError, ceil, supertensor)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    def testCeilWrongDim(self):
        "Test ceil function with wrong dimensions"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 ceil 函数并调用，传入一个维度不匹配的超级张量
        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
        supertensor = np.arange(2*2*2, dtype=self.typeCode).reshape((2, 2, 2))
        # 预期会抛出 TypeError 异常
        self.assertRaises(TypeError, ceil, supertensor)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    def testCeilNonArray(self):
        "Test ceil function with non-array"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 ceil 函数并调用，传入一个转换为列表的超级张量
        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
        supertensor = np.arange(2*2*2*2, dtype=self.typeCode).reshape((2, 2, 2, 2)).tolist()
        # 预期会抛出 TypeError 异常
        self.assertRaises(TypeError, ceil, supertensor)

    # Test (type ARGOUT_ARRAY3[ANY][ANY][ANY]) typemap
    def testLUSplit(self):
        "Test luSplit function"
        # 打印当前类型字符串到标准错误流
        print(self.typeStr, "... ", file=sys.stderr)
        # 获取对应类型的 luSplit 函数并调用，传入一个全为1的超级张量
        luSplit = SuperTensor.__dict__[self.typeStr + "LUSplit"]
        supertensor = np.ones(2*2*2*2, dtype=self.typeCode).reshape((2, 2, 2, 2))
        # 预期 lower 和 upper 分解的结果与设定的答案相等
        answer_upper = [[[[0, 0], [0, 1]], [[0, 1], [1, 1]]], [[[0, 1], [1, 1]], [[1, 1], [1, 1]]]]
        answer_lower = [[[[1, 1], [1, 0]], [[1, 0], [0, 0]]], [[[1, 0], [0, 0]], [[0, 0], [0, 0]]]]
        lower, upper = luSplit(supertensor)
        # 使用断言确保 lower 和 answer_lower 相等
        self.assertEqual((lower == answer_lower).all(), True)
        # 使用断言确保 upper 和 answer_upper 相等
        self.assertEqual((upper == answer_upper).all(), True)
######################################################################

class scharTestCase(SuperTensorTestCase):
    # scharTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "schar"
        # 设置实例变量 typeStr 为字符串 "schar"
        
        self.typeCode = "b"
        # 设置实例变量 typeCode 为字符 "b"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class ucharTestCase(SuperTensorTestCase):
    # ucharTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "uchar"
        # 设置实例变量 typeStr 为字符串 "uchar"
        
        self.typeCode = "B"
        # 设置实例变量 typeCode 为字符 "B"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class shortTestCase(SuperTensorTestCase):
    # shortTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "short"
        # 设置实例变量 typeStr 为字符串 "short"
        
        self.typeCode = "h"
        # 设置实例变量 typeCode 为字符 "h"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class ushortTestCase(SuperTensorTestCase):
    # ushortTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "ushort"
        # 设置实例变量 typeStr 为字符串 "ushort"
        
        self.typeCode = "H"
        # 设置实例变量 typeCode 为字符 "H"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class intTestCase(SuperTensorTestCase):
    # intTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "int"
        # 设置实例变量 typeStr 为字符串 "int"
        
        self.typeCode = "i"
        # 设置实例变量 typeCode 为字符 "i"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class uintTestCase(SuperTensorTestCase):
    # uintTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "uint"
        # 设置实例变量 typeStr 为字符串 "uint"
        
        self.typeCode = "I"
        # 设置实例变量 typeCode 为字符 "I"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class longTestCase(SuperTensorTestCase):
    # longTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "long"
        # 设置实例变量 typeStr 为字符串 "long"
        
        self.typeCode = "l"
        # 设置实例变量 typeCode 为字符 "l"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class ulongTestCase(SuperTensorTestCase):
    # ulongTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "ulong"
        # 设置实例变量 typeStr 为字符串 "ulong"
        
        self.typeCode = "L"
        # 设置实例变量 typeCode 为字符 "L"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class longLongTestCase(SuperTensorTestCase):
    # longLongTestCase 类，继承自 SuperTensorTestCase 类

    def __init__(self, methodName="runTest"):
        # 初始化方法，接受一个 methodName 参数，默认为 "runTest"

        SuperTensorTestCase.__init__(self, methodName)
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数

        self.typeStr  = "longLong"
        # 设置实例变量 typeStr 为字符串 "longLong"
        
        self.typeCode = "q"
        # 设置实例变量 typeCode 为字符 "q"

        #self.result   = int(self.result)
        # 注释掉的代码，可能是待解开的功能性代码或注释

######################################################################

class ulongLongTestCase(SuperTensorTestCase):
    # ulongLongTestCase 类，继承自 SuperTensorTestCase 类

    # 此处省略了类的具体实现，可能是意图留待后续添加
    # 定义类的初始化方法，接受一个可选参数 methodName，默认为"runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类 SuperTensorTestCase 的初始化方法，并传入 methodName 参数
        SuperTensorTestCase.__init__(self, methodName)
        # 设置实例变量 typeStr 为字符串 "ulongLong"
        self.typeStr  = "ulongLong"
        # 设置实例变量 typeCode 为字符串 "Q"
        self.typeCode = "Q"
        # 注释掉的代码行，原来是设置实例变量 result 为整数化后的 self.result，已经被注释掉
        #self.result   = int(self.result)
######################################################################

class floatTestCase(SuperTensorTestCase):
    # floatTestCase 类，继承自 SuperTensorTestCase
    def __init__(self, methodName="runTest"):
        # 调用父类构造函数初始化对象
        SuperTensorTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "float"
        self.typeStr  = "float"
        # 设置测试类型代码为 "f"
        self.typeCode = "f"

######################################################################

class doubleTestCase(SuperTensorTestCase):
    # doubleTestCase 类，继承自 SuperTensorTestCase
    def __init__(self, methodName="runTest"):
        # 调用父类构造函数初始化对象
        SuperTensorTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "double"
        self.typeStr  = "double"
        # 设置测试类型代码为 "d"
        self.typeCode = "d"

######################################################################

if __name__ == "__main__":

    # 构建测试套件
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(    scharTestCase))
    suite.addTest(unittest.makeSuite(    ucharTestCase))
    suite.addTest(unittest.makeSuite(    shortTestCase))
    suite.addTest(unittest.makeSuite(   ushortTestCase))
    suite.addTest(unittest.makeSuite(      intTestCase))
    suite.addTest(unittest.makeSuite(     uintTestCase))
    suite.addTest(unittest.makeSuite(     longTestCase))
    suite.addTest(unittest.makeSuite(    ulongTestCase))
    suite.addTest(unittest.makeSuite( longLongTestCase))
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    suite.addTest(unittest.makeSuite(    floatTestCase))
    suite.addTest(unittest.makeSuite(   doubleTestCase))

    # 执行测试套件
    print("Testing 4D Functions of Module SuperTensor")
    print("NumPy version", np.__version__)
    print()
    # 运行测试套件并获取结果
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    # 根据测试结果判断是否有错误或失败，并退出程序
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\testTensor.py

#!/usr/bin/env python3
# System imports
# 导入数学库中的平方根函数
from   math           import sqrt
# 导入系统库
import sys
# 导入单元测试框架
import unittest

# Import NumPy
# 导入 NumPy 库，并获取其主要和次要版本号
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
# 根据 NumPy 版本号设置异常类型
if major == 0: BadListError = TypeError
else:          BadListError = ValueError

# 导入自定义的 Tensor 模块
import Tensor

######################################################################

# 定义 TensorTestCase 类，继承自 unittest.TestCase
class TensorTestCase(unittest.TestCase):

    # 构造函数，初始化测试用例
    def __init__(self, methodName="runTests"):
        # 调用父类的构造函数
        unittest.TestCase.__init__(self, methodName)
        # 初始化类型字符串
        self.typeStr  = "double"
        # 初始化类型代码
        self.typeCode = "d"
        # 初始化预期结果，为计算平方根后的值
        self.result   = sqrt(28.0/8)

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    # 测试 norm 函数
    def testNorm(self):
        "Test norm function"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 norm 函数
        norm = Tensor.__dict__[self.typeStr + "Norm"]
        # 定义测试用的三维张量
        tensor = [[[0, 1], [2, 3]],
                  [[3, 2], [1, 0]]]
        # 根据结果类型进行断言检查
        if isinstance(self.result, int):
            self.assertEqual(norm(tensor), self.result)
        else:
            self.assertAlmostEqual(norm(tensor), self.result, 6)

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    # 测试包含不良数据的 norm 函数
    def testNormBadList(self):
        "Test norm function with bad list"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 norm 函数
        norm = Tensor.__dict__[self.typeStr + "Norm"]
        # 定义包含不良数据的测试三维张量
        tensor = [[[0, "one"], [2, 3]],
                  [[3, "two"], [1, 0]]]
        # 检查是否引发预期的异常
        self.assertRaises(BadListError, norm, tensor)

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    # 测试维度错误的 norm 函数
    def testNormWrongDim(self):
        "Test norm function with wrong dimensions"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 norm 函数
        norm = Tensor.__dict__[self.typeStr + "Norm"]
        # 定义维度错误的测试二维张量
        tensor = [[0, 1, 2, 3],
                  [3, 2, 1, 0]]
        # 检查是否引发预期的异常
        self.assertRaises(TypeError, norm, tensor)

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    # 测试大小错误的 norm 函数
    def testNormWrongSize(self):
        "Test norm function with wrong size"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 norm 函数
        norm = Tensor.__dict__[self.typeStr + "Norm"]
        # 定义大小错误的测试三维张量
        tensor = [[[0, 1, 0], [2, 3, 2]],
                  [[3, 2, 3], [1, 0, 1]]]
        # 检查是否引发预期的异常
        self.assertRaises(TypeError, norm, tensor)

    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
    # 测试非容器类型的 norm 函数
    def testNormNonContainer(self):
        "Test norm function with non-container"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 norm 函数
        norm = Tensor.__dict__[self.typeStr + "Norm"]
        # 检查是否引发预期的异常
        self.assertRaises(TypeError, norm, None)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 测试 max 函数
    def testMax(self):
        "Test max function"
        # 输出类型字符串到标准错误
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Tensor 模块中对应类型的 max 函数
        max = Tensor.__dict__[self.typeStr + "Max"]
        # 定义测试用的三维张量
        tensor = [[[1, 2], [3, 4]],
                  [[5, 6], [7, 8]]]
        # 检查最大值计算是否正确
        self.assertEqual(max(tensor), 8)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 定义一个测试方法，用于测试在存在不良列表情况下的最大函数
    def testMaxBadList(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = Tensor.__dict__[self.typeStr + "Max"]
        # 创建一个三维列表，其中包含混合类型的元素
        tensor = [[[1, "two"], [3, 4]],
                  [[5, "six"], [7, 8]]]
        # 断言调用最大值函数时抛出不良列表错误
        self.assertRaises(BadListError, max, tensor)

    # 测试具有非容器类型参数的最大函数
    def testMaxNonContainer(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = Tensor.__dict__[self.typeStr + "Max"]
        # 断言调用最大值函数时抛出类型错误，传入参数为 None
        self.assertRaises(TypeError, max, None)

    # 测试具有错误维度的最大函数
    def testMaxWrongDim(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最大值函数
        max = Tensor.__dict__[self.typeStr + "Max"]
        # 断言调用最大值函数时抛出类型错误，传入参数为一维列表
        self.assertRaises(TypeError, max, [0, -1, 2, -3])

    # 测试最小函数
    def testMin(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = Tensor.__dict__[self.typeStr + "Min"]
        # 创建一个三维列表，包含整数元素
        tensor = [[[9, 8], [7, 6]],
                  [[5, 4], [3, 2]]]
        # 断言调用最小值函数返回的结果为 2
        self.assertEqual(min(tensor), 2)

    # 测试具有不良列表的最小函数
    def testMinBadList(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = Tensor.__dict__[self.typeStr + "Min"]
        # 创建一个三维列表，其中包含混合类型的元素
        tensor = [[["nine", 8], [7, 6]],
                  [["five", 4], [3, 2]]]
        # 断言调用最小值函数时抛出不良列表错误
        self.assertRaises(BadListError, min, tensor)

    # 测试具有非容器类型参数的最小函数
    def testMinNonContainer(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = Tensor.__dict__[self.typeStr + "Min"]
        # 断言调用最小值函数时抛出类型错误，传入参数为布尔值 True
        self.assertRaises(TypeError, min, True)

    # 测试具有错误维度的最小函数
    def testMinWrongDim(self):
        # 打印当前类型字符串，作为测试标识输出到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的最小值函数
        min = Tensor.__dict__[self.typeStr + "Min"]
        # 断言调用最小值函数时抛出类型错误，传入参数为二维列表
        self.assertRaises(TypeError, min, [[1, 3], [5, 7]])

    # 测试 (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个名为 testScale 的测试方法，用于测试 scale 函数
    def testScale(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 scale 函数
        scale = Tensor.__dict__[self.typeStr + "Scale"]
        # 创建一个三维 NumPy 数组作为测试用例，使用给定的类型码
        tensor = np.array([[[1, 0, 1], [0, 1, 0], [1, 0, 1]],
                          [[0, 1, 0], [1, 0, 1], [0, 1, 0]],
                          [[1, 0, 1], [0, 1, 0], [1, 0, 1]]], self.typeCode)
        # 调用 scale 函数对 tensor 进行缩放操作
        scale(tensor, 4)
        # 使用断言检查 tensor 是否等于预期的值
        self.assertEqual((tensor == [[[4, 0, 4], [0, 4, 0], [4, 0, 4]],
                                      [[0, 4, 0], [4, 0, 4], [0, 4, 0]],
                                      [[4, 0, 4], [0, 4, 0], [4, 0, 4]]]).all(), True)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个名为 testScaleWrongType 的测试方法，测试 scale 函数对于错误类型的处理
    def testScaleWrongType(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 scale 函数
        scale = Tensor.__dict__[self.typeStr + "Scale"]
        # 创建一个三维 NumPy 数组作为测试用例，使用错误的类型码 'c'
        tensor = np.array([[[1, 0, 1], [0, 1, 0], [1, 0, 1]],
                          [[0, 1, 0], [1, 0, 1], [0, 1, 0]],
                          [[1, 0, 1], [0, 1, 0], [1, 0, 1]]], 'c')
        # 使用断言检查 scale 函数是否能正确抛出 TypeError 异常
        self.assertRaises(TypeError, scale, tensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个名为 testScaleWrongDim 的测试方法，测试 scale 函数对于错误维度的处理
    def testScaleWrongDim(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 scale 函数
        scale = Tensor.__dict__[self.typeStr + "Scale"]
        # 创建一个二维 NumPy 数组作为测试用例，使用给定的类型码
        tensor = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1],
                          [0, 1, 0], [1, 0, 1], [0, 1, 0]], self.typeCode)
        # 使用断言检查 scale 函数是否能正确抛出 TypeError 异常
        self.assertRaises(TypeError, scale, tensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个名为 testScaleWrongSize 的测试方法，测试 scale 函数对于错误大小的处理
    def testScaleWrongSize(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 scale 函数
        scale = Tensor.__dict__[self.typeStr + "Scale"]
        # 创建一个二维 NumPy 数组作为测试用例，使用给定的类型码
        tensor = np.array([[[1, 0], [0, 1], [1, 0]],
                          [[0, 1], [1, 0], [0, 1]],
                          [[1, 0], [0, 1], [1, 0]]], self.typeCode)
        # 使用断言检查 scale 函数是否能正确抛出 TypeError 异常
        self.assertRaises(TypeError, scale, tensor)

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    # 定义一个名为 testScaleNonArray 的测试方法，测试 scale 函数对于非数组输入的处理
    def testScaleNonArray(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 scale 函数
        scale = Tensor.__dict__[self.typeStr + "Scale"]
        # 使用断言检查 scale 函数是否能正确抛出 TypeError 异常，传入 True 作为参数
        self.assertRaises(TypeError, scale, True)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 定义一个名为 testFloor 的测试方法，测试 floor 函数
    def testFloor(self):
        # 打印测试类型的字符串，输出到标准错误流中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 根据类型字符串获取对应的 floor 函数
        floor = Tensor.__dict__[self.typeStr + "Floor"]
        # 创建一个三维 NumPy 数组作为测试用例，使用给定的类型码
        tensor = np.array([[[1, 2], [3, 4]],
                          [[5, 6], [7, 8]]], self.typeCode)
        # 调用 floor 函数对 tensor 进行 floor 操作，将大于等于 4 的元素替换为 4
        floor(tensor, 4)
        # 使用 NumPy 的断言函数检查 tensor 是否与预期值相等
        np.testing.assert_array_equal(tensor, np.array([[[4, 4], [4, 4]],
                                                      [[5, 6], [7, 8]]]))

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 测试 floor 函数对于错误类型的输入
    def testFloorWrongType(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 floor 函数
        floor = Tensor.__dict__[self.typeStr + "Floor"]
        # 创建一个三维 NumPy 数组，使用 'c' 表示以 C 风格存储
        tensor = np.array([[[1, 2], [3, 4]],
                          [[5, 6], [7, 8]]], 'c')
        # 断言调用 floor 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, floor, tensor)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 测试 floor 函数对于维度错误的输入
    def testFloorWrongDim(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 floor 函数
        floor = Tensor.__dict__[self.typeStr + "Floor"]
        # 创建一个二维 NumPy 数组，使用 self.typeCode 表示数据类型
        tensor = np.array([[1, 2], [3, 4], [5, 6], [7, 8]], self.typeCode)
        # 断言调用 floor 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, floor, tensor)

    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    # 测试 floor 函数对于非数组输入
    def testFloorNonArray(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 floor 函数
        floor = Tensor.__dict__[self.typeStr + "Floor"]
        # 断言调用 floor 函数时会引发 TypeError 异常，输入为 object 类型
        self.assertRaises(TypeError, floor, object)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    # 测试 ceil 函数的正常使用
    def testCeil(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Tensor.__dict__[self.typeStr + "Ceil"]
        # 创建一个三维 NumPy 数组，使用 self.typeCode 表示数据类型
        tensor = np.array([[[9, 8], [7, 6]],
                          [[5, 4], [3, 2]]], self.typeCode)
        # 调用 ceil 函数对 tensor 进行操作
        ceil(tensor, 5)
        # 使用 NumPy 的断言方法验证数组是否符合预期
        np.testing.assert_array_equal(tensor, np.array([[[5, 5], [5, 5]],
                                                      [[5, 4], [3, 2]]]))

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    # 测试 ceil 函数对于错误类型的输入
    def testCeilWrongType(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Tensor.__dict__[self.typeStr + "Ceil"]
        # 创建一个三维 NumPy 数组，使用 'c' 表示以 C 风格存储
        tensor = np.array([[[9, 8], [7, 6]],
                          [[5, 4], [3, 2]]], 'c')
        # 断言调用 ceil 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, ceil, tensor)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    # 测试 ceil 函数对于维度错误的输入
    def testCeilWrongDim(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Tensor.__dict__[self.typeStr + "Ceil"]
        # 创建一个二维 NumPy 数组，使用 self.typeCode 表示数据类型
        tensor = np.array([[9, 8], [7, 6], [5, 4], [3, 2]], self.typeCode)
        # 断言调用 ceil 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, ceil, tensor)

    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
    # 测试 ceil 函数对于非数组输入
    def testCeilNonArray(self):
        # 打印类型字符串，指示测试正在进行中
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取当前类型对应的 ceil 函数
        ceil = Tensor.__dict__[self.typeStr + "Ceil"]
        # 创建一个嵌套列表表示的三维数组
        tensor = [[[9, 8], [7, 6]],
                  [[5, 4], [3, 2]]]
        # 断言调用 ceil 函数时会引发 TypeError 异常
        self.assertRaises(TypeError, ceil, tensor)

    # Test (type ARGOUT_ARRAY3[ANY][ANY][ANY]) typemap
    # 这个测试用例的注释未提供，可能需要补充
    def testLUSplit(self):
        "Test luSplit function"
        # 打印测试类型字符串到标准错误流，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        
        # 获取当前类型的 luSplit 函数
        luSplit = Tensor.__dict__[self.typeStr + "LUSplit"]
        
        # 对输入张量进行 LU 分解，分别得到下三角矩阵 lower 和上三角矩阵 upper
        lower, upper = luSplit([[[1, 1], [1, 1]],
                                [[1, 1], [1, 1]]])
        
        # 断言下三角矩阵 lower 是否与预期相等
        self.assertEqual((lower == [[[1, 1], [1, 0]],
                                     [[1, 0], [0, 0]]]).all(), True)
        
        # 断言上三角矩阵 upper 是否与预期相等
        self.assertEqual((upper == [[[0, 0], [0, 1]],
                                     [[0, 1], [1, 1]]]).all(), True)
######################################################################

class scharTestCase(TensorTestCase):
    # scharTestCase 类，继承自 TensorTestCase 类，用于测试有符号字符类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "schar"
        self.typeCode = "b"
        self.result   = int(self.result)

######################################################################

class ucharTestCase(TensorTestCase):
    # ucharTestCase 类，继承自 TensorTestCase 类，用于测试无符号字符类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "uchar"
        self.typeCode = "B"
        self.result   = int(self.result)

######################################################################

class shortTestCase(TensorTestCase):
    # shortTestCase 类，继承自 TensorTestCase 类，用于测试短整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "short"
        self.typeCode = "h"
        self.result   = int(self.result)

######################################################################

class ushortTestCase(TensorTestCase):
    # ushortTestCase 类，继承自 TensorTestCase 类，用于测试无符号短整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "ushort"
        self.typeCode = "H"
        self.result   = int(self.result)

######################################################################

class intTestCase(TensorTestCase):
    # intTestCase 类，继承自 TensorTestCase 类，用于测试整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "int"
        self.typeCode = "i"
        self.result   = int(self.result)

######################################################################

class uintTestCase(TensorTestCase):
    # uintTestCase 类，继承自 TensorTestCase 类，用于测试无符号整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "uint"
        self.typeCode = "I"
        self.result   = int(self.result)

######################################################################

class longTestCase(TensorTestCase):
    # longTestCase 类，继承自 TensorTestCase 类，用于测试长整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "long"
        self.typeCode = "l"
        self.result   = int(self.result)

######################################################################

class ulongTestCase(TensorTestCase):
    # ulongTestCase 类，继承自 TensorTestCase 类，用于测试无符号长整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "ulong"
        self.typeCode = "L"
        self.result   = int(self.result)

######################################################################

class longLongTestCase(TensorTestCase):
    # longLongTestCase 类，继承自 TensorTestCase 类，用于测试长长整型类型的测试用例
    def __init__(self, methodName="runTest"):
        # 初始化方法，调用父类的初始化方法，并设置类型字符串、类型代码和结果值
        TensorTestCase.__init__(self, methodName)
        self.typeStr  = "longLong"
        self.typeCode = "q"
        self.result   = int(self.result)

######################################################################

class ulongLongTestCase(TensorTestCase):
    # ulongLongTestCase 类，继承自 TensorTestCase 类，用于测试无符号长长整型类型的测试用例
    # 初始化方法，用于创建对象实例
    def __init__(self, methodName="runTest"):
        # 调用父类 TensorTestCase 的初始化方法，传入当前对象实例和方法名
        TensorTestCase.__init__(self, methodName)
        # 设置对象实例的 typeStr 属性为字符串 "ulongLong"
        self.typeStr  = "ulongLong"
        # 设置对象实例的 typeCode 属性为字符串 "Q"
        self.typeCode = "Q"
        # 将对象实例的 result 属性转换为整数类型
        self.result   = int(self.result)
######################################################################

# 定义一个继承自 TensorTestCase 的浮点数测试用例类
class floatTestCase(TensorTestCase):
    # 初始化方法，接受一个可选的 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类 TensorTestCase 的初始化方法
        TensorTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "float"
        self.typeStr  = "float"
        # 设置测试类型代码为 "f"
        self.typeCode = "f"

######################################################################

# 定义一个继承自 TensorTestCase 的双精度浮点数测试用例类
class doubleTestCase(TensorTestCase):
    # 初始化方法，接受一个可选的 methodName 参数，默认为 "runTest"
    def __init__(self, methodName="runTest"):
        # 调用父类 TensorTestCase 的初始化方法
        TensorTestCase.__init__(self, methodName)
        # 设置测试类型字符串为 "double"
        self.typeStr  = "double"
        # 设置测试类型代码为 "d"

######################################################################

# 确保当前文件是主程序时执行以下代码块
if __name__ == "__main__":

    # 构建测试套件
    suite = unittest.TestSuite()
    # 将各个测试用例类添加到测试套件中
    suite.addTest(unittest.makeSuite(    scharTestCase))
    suite.addTest(unittest.makeSuite(    ucharTestCase))
    suite.addTest(unittest.makeSuite(    shortTestCase))
    suite.addTest(unittest.makeSuite(   ushortTestCase))
    suite.addTest(unittest.makeSuite(      intTestCase))
    suite.addTest(unittest.makeSuite(     uintTestCase))
    suite.addTest(unittest.makeSuite(     longTestCase))
    suite.addTest(unittest.makeSuite(    ulongTestCase))
    suite.addTest(unittest.makeSuite( longLongTestCase))
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    suite.addTest(unittest.makeSuite(    floatTestCase))
    suite.addTest(unittest.makeSuite(   doubleTestCase))

    # 执行测试套件
    print("Testing 3D Functions of Module Tensor")
    # 打印 NumPy 版本信息
    print("NumPy version", np.__version__)
    print()
    # 运行测试套件，并获取测试结果
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    # 根据测试结果，退出程序并返回是否有错误或失败的布尔值
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\testVector.py

#!/usr/bin/env python3
# System imports
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError
else:          BadListError = ValueError

# Import Vector module
import Vector

######################################################################

class VectorTestCase(unittest.TestCase):

    def __init__(self, methodName="runTest"):
        unittest.TestCase.__init__(self, methodName)
        self.typeStr  = "double"
        self.typeCode = "d"

    # Test the (type IN_ARRAY1[ANY]) typemap
    def testLength(self):
        "Test length function"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的长度函数并测试
        length = Vector.__dict__[self.typeStr + "Length"]
        self.assertEqual(length([5, 12, 0]), 13)

    # Test the (type IN_ARRAY1[ANY]) typemap
    def testLengthBadList(self):
        "Test length function with bad list"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的长度函数并测试，预期抛出 BadListError 异常
        length = Vector.__dict__[self.typeStr + "Length"]
        self.assertRaises(BadListError, length, [5, "twelve", 0])

    # Test the (type IN_ARRAY1[ANY]) typemap
    def testLengthWrongSize(self):
        "Test length function with wrong size"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的长度函数并测试，预期抛出 TypeError 异常
        length = Vector.__dict__[self.typeStr + "Length"]
        self.assertRaises(TypeError, length, [5, 12])

    # Test the (type IN_ARRAY1[ANY]) typemap
    def testLengthWrongDim(self):
        "Test length function with wrong dimensions"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的长度函数并测试，预期抛出 TypeError 异常
        length = Vector.__dict__[self.typeStr + "Length"]
        self.assertRaises(TypeError, length, [[1, 2], [3, 4]])

    # Test the (type IN_ARRAY1[ANY]) typemap
    def testLengthNonContainer(self):
        "Test length function with non-container"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的长度函数并测试，预期抛出 TypeError 异常
        length = Vector.__dict__[self.typeStr + "Length"]
        self.assertRaises(TypeError, length, None)

    # Test the (type* IN_ARRAY1, int DIM1) typemap
    def testProd(self):
        "Test prod function"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的乘积函数并测试
        prod = Vector.__dict__[self.typeStr + "Prod"]
        self.assertEqual(prod([1, 2, 3, 4]), 24)

    # Test the (type* IN_ARRAY1, int DIM1) typemap
    def testProdBadList(self):
        "Test prod function with bad list"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的乘积函数并测试，预期抛出 BadListError 异常
        prod = Vector.__dict__[self.typeStr + "Prod"]
        self.assertRaises(BadListError, prod, [[1, "two"], ["e", "pi"]])

    # Test the (type* IN_ARRAY1, int DIM1) typemap
    def testProdWrongDim(self):
        "Test prod function with wrong dimensions"
        # 输出测试类型和测试开始信息到标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的乘积函数并测试，预期抛出 TypeError 异常
        prod = Vector.__dict__[self.typeStr + "Prod"]
        self.assertRaises(TypeError, prod, [[1, 2], [8, 9]])

    # Test the (type* IN_ARRAY1, int DIM1) typemap
    # 测试非容器对象的 prod 函数
    def testProdNonContainer(self):
        "Test prod function with non-container"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 prod 函数
        prod = Vector.__dict__[self.typeStr + "Prod"]
        # 断言调用 prod 函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, prod, None)

    # 测试 sum 函数，参数为 (int DIM1, type* IN_ARRAY1) typemap
    def testSum(self):
        "Test sum function"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 sum 函数
        sum = Vector.__dict__[self.typeStr + "Sum"]
        # 断言 sum 函数对 [5, 6, 7, 8] 的计算结果为 26
        self.assertEqual(sum([5, 6, 7, 8]), 26)

    # 测试 sum 函数，参数为 (int DIM1, type* IN_ARRAY1) typemap，使用错误的列表
    def testSumBadList(self):
        "Test sum function with bad list"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 sum 函数
        sum = Vector.__dict__[self.typeStr + "Sum"]
        # 断言调用 sum 函数时会抛出 BadListError 异常，因为列表包含非数值类型元素
        self.assertRaises(BadListError, sum, [3, 4, 5, "pi"])

    # 测试 sum 函数，参数为 (int DIM1, type* IN_ARRAY1) typemap，使用错误的维度
    def testSumWrongDim(self):
        "Test sum function with wrong dimensions"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 sum 函数
        sum = Vector.__dict__[self.typeStr + "Sum"]
        # 断言调用 sum 函数时会抛出 TypeError 异常，因为输入的是二维列表而不是一维列表
        self.assertRaises(TypeError, sum, [[3, 4], [5, 6]])

    # 测试 sum 函数，参数为 (int DIM1, type* IN_ARRAY1) typemap，使用非容器对象
    def testSumNonContainer(self):
        "Test sum function with non-container"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 sum 函数
        sum = Vector.__dict__[self.typeStr + "Sum"]
        # 断言调用 sum 函数时会抛出 TypeError 异常，因为输入参数是 True，而不是可迭代对象
        self.assertRaises(TypeError, sum, True)

    # 测试 reverse 函数，参数为 (type INPLACE_ARRAY1[ANY]) typemap
    def testReverse(self):
        "Test reverse function"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 reverse 函数
        reverse = Vector.__dict__[self.typeStr + "Reverse"]
        # 创建一个包含 [1, 2, 4] 的 NumPy 数组，并进行反转操作
        vector = np.array([1, 2, 4], self.typeCode)
        reverse(vector)
        # 断言 vector 是否等于 [4, 2, 1] 的所有元素，即反转是否成功
        self.assertEqual((vector == [4, 2, 1]).all(), True)

    # 测试 reverse 函数，参数为 (type INPLACE_ARRAY1[ANY]) typemap，使用错误的维度
    def testReverseWrongDim(self):
        "Test reverse function with wrong dimensions"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 reverse 函数
        reverse = Vector.__dict__[self.typeStr + "Reverse"]
        # 创建一个二维 NumPy 数组作为参数，断言调用 reverse 函数时会抛出 TypeError 异常
        vector = np.array([[1, 2], [3, 4]], self.typeCode)
        self.assertRaises(TypeError, reverse, vector)

    # 测试 reverse 函数，参数为 (type INPLACE_ARRAY1[ANY]) typemap，使用错误的大小
    def testReverseWrongSize(self):
        "Test reverse function with wrong size"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 reverse 函数
        reverse = Vector.__dict__[self.typeStr + "Reverse"]
        # 创建一个包含 [9, 8, 7, 6, 5, 4] 的 NumPy 数组作为参数，断言调用 reverse 函数时会抛出 TypeError 异常
        vector = np.array([9, 8, 7, 6, 5, 4], self.typeCode)
        self.assertRaises(TypeError, reverse, vector)

    # 测试 reverse 函数，参数为 (type INPLACE_ARRAY1[ANY]) typemap，使用错误的类型
    def testReverseWrongType(self):
        "Test reverse function with wrong type"
        # 打印测试类型字符串到标准错误，不换行
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取对应类型的 reverse 函数
        reverse = Vector.__dict__[self.typeStr + "Reverse"]
        # 创建一个包含 [1, 2, 4] 的 NumPy 数组，但指定错误的类型 'c'，断言调用 reverse 函数时会抛出 TypeError 异常
        vector = np.array([1, 2, 4], 'c')
        self.assertRaises(TypeError, reverse, vector)
    def testReverseNonArray(self):
        "Test reverse function with non-array"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的反转函数
        reverse = Vector.__dict__[self.typeStr + "Reverse"]
        # 断言调用反转函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, reverse, [2, 4, 6])

    # Test the (type* INPLACE_ARRAY1, int DIM1) typemap
    def testOnes(self):
        "Test ones function"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的ones函数
        ones = Vector.__dict__[self.typeStr + "Ones"]
        # 创建一个全零的向量数组
        vector = np.zeros(5, self.typeCode)
        # 调用ones函数将向量数组填充为全1
        ones(vector)
        # 使用 NumPy 测试工具断言向量数组与期望的全1数组相等
        np.testing.assert_array_equal(vector, np.array([1, 1, 1, 1, 1]))

    # Test the (type* INPLACE_ARRAY1, int DIM1) typemap
    def testOnesWrongDim(self):
        "Test ones function with wrong dimensions"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的ones函数
        ones = Vector.__dict__[self.typeStr + "Ones"]
        # 创建一个维度为(5, 5)的全零向量数组
        vector = np.zeros((5, 5), self.typeCode)
        # 断言调用ones函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, ones, vector)

    # Test the (type* INPLACE_ARRAY1, int DIM1) typemap
    def testOnesWrongType(self):
        "Test ones function with wrong type"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的ones函数
        ones = Vector.__dict__[self.typeStr + "Ones"]
        # 创建一个类型为'c'的向量数组
        vector = np.zeros((5, 5), 'c')
        # 断言调用ones函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, ones, vector)

    # Test the (type* INPLACE_ARRAY1, int DIM1) typemap
    def testOnesNonArray(self):
        "Test ones function with non-array"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的ones函数
        ones = Vector.__dict__[self.typeStr + "Ones"]
        # 断言调用ones函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, ones, [2, 4, 6, 8])

    # Test the (int DIM1, type* INPLACE_ARRAY1) typemap
    def testZeros(self):
        "Test zeros function"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的zeros函数
        zeros = Vector.__dict__[self.typeStr + "Zeros"]
        # 创建一个全1的向量数组
        vector = np.ones(5, self.typeCode)
        # 调用zeros函数将向量数组填充为全0
        zeros(vector)
        # 使用 NumPy 测试工具断言向量数组与期望的全0数组相等
        np.testing.assert_array_equal(vector, np.array([0, 0, 0, 0, 0]))

    # Test the (int DIM1, type* INPLACE_ARRAY1) typemap
    def testZerosWrongDim(self):
        "Test zeros function with wrong dimensions"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的zeros函数
        zeros = Vector.__dict__[self.typeStr + "Zeros"]
        # 创建一个维度为(5, 5)的全1向量数组
        vector = np.ones((5, 5), self.typeCode)
        # 断言调用zeros函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, zeros, vector)

    # Test the (int DIM1, type* INPLACE_ARRAY1) typemap
    def testZerosWrongType(self):
        "Test zeros function with wrong type"
        # 输出测试类型字符串到标准错误流
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取指定类型的zeros函数
        zeros = Vector.__dict__[self.typeStr + "Zeros"]
        # 创建一个类型为'c'的全1向量数组
        vector = np.ones(6, 'c')
        # 断言调用zeros函数时会抛出 TypeError 异常
        self.assertRaises(TypeError, zeros, vector)
    # 定义一个测试方法，测试当参数不是数组时的情况
    def testZerosNonArray(self):
        "Test zeros function with non-array"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "Zeros" 的方法，并引发 TypeError 异常，期望传入参数为列表
        zeros = Vector.__dict__[self.typeStr + "Zeros"]
        self.assertRaises(TypeError, zeros, [1, 3, 5, 7, 9])

    # 测试 (type ARGOUT_ARRAY1[ANY]) 类型映射的 typemap
    def testEOSplit(self):
        "Test eoSplit function"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "EOSplit" 的方法，并测试其返回的 even 和 odd 是否符合预期
        eoSplit = Vector.__dict__[self.typeStr + "EOSplit"]
        even, odd = eoSplit([1, 2, 3])
        self.assertEqual((even == [1, 0, 3]).all(), True)
        self.assertEqual((odd  == [0, 2, 0]).all(), True)

    # 测试 (type* ARGOUT_ARRAY1, int DIM1) 类型映射的 typemap
    def testTwos(self):
        "Test twos function"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "Twos" 的方法，并测试其返回的向量是否为全是 2 的数组
        twos = Vector.__dict__[self.typeStr + "Twos"]
        vector = twos(5)
        self.assertEqual((vector == [2, 2, 2, 2, 2]).all(), True)

    # 测试 (type* ARGOUT_ARRAY1, int DIM1) 类型映射的 typemap，验证传入非整数维度时的行为
    def testTwosNonInt(self):
        "Test twos function with non-integer dimension"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "Twos" 的方法，并引发 TypeError 异常，期望传入参数为整数
        twos = Vector.__dict__[self.typeStr + "Twos"]
        self.assertRaises(TypeError, twos, 5.0)

    # 测试 (int DIM1, type* ARGOUT_ARRAY1) 类型映射的 typemap
    def testThrees(self):
        "Test threes function"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "Threes" 的方法，并测试其返回的向量是否为全是 3 的数组
        threes = Vector.__dict__[self.typeStr + "Threes"]
        vector = threes(6)
        self.assertEqual((vector == [3, 3, 3, 3, 3, 3]).all(), True)

    # 测试 (type* ARGOUT_ARRAY1, int DIM1) 类型映射的 typemap，验证传入非整数维度时的行为
    def testThreesNonInt(self):
        "Test threes function with non-integer dimension"
        # 打印当前类型字符串，指示测试开始，使用标准错误输出
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        # 获取 Vector 类的对应类型加上 "Threes" 的方法，并引发 TypeError 异常，期望传入参数为整数
        threes = Vector.__dict__[self.typeStr + "Threes"]
        self.assertRaises(TypeError, threes, "threes")
######################################################################

class scharTestCase(VectorTestCase):
    # scharTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'schar'
        self.typeStr  = "schar"
        # 设置类型代码为 'b'
        self.typeCode = "b"

######################################################################

class ucharTestCase(VectorTestCase):
    # ucharTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'uchar'
        self.typeStr  = "uchar"
        # 设置类型代码为 'B'
        self.typeCode = "B"

######################################################################

class shortTestCase(VectorTestCase):
    # shortTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'short'
        self.typeStr  = "short"
        # 设置类型代码为 'h'
        self.typeCode = "h"

######################################################################

class ushortTestCase(VectorTestCase):
    # ushortTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'ushort'
        self.typeStr  = "ushort"
        # 设置类型代码为 'H'
        self.typeCode = "H"

######################################################################

class intTestCase(VectorTestCase):
    # intTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'int'
        self.typeStr  = "int"
        # 设置类型代码为 'i'
        self.typeCode = "i"

######################################################################

class uintTestCase(VectorTestCase):
    # uintTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'uint'
        self.typeStr  = "uint"
        # 设置类型代码为 'I'
        self.typeCode = "I"

######################################################################

class longTestCase(VectorTestCase):
    # longTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'long'
        self.typeStr  = "long"
        # 设置类型代码为 'l'
        self.typeCode = "l"

######################################################################

class ulongTestCase(VectorTestCase):
    # ulongTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'ulong'
        self.typeStr  = "ulong"
        # 设置类型代码为 'L'
        self.typeCode = "L"

######################################################################

class longLongTestCase(VectorTestCase):
    # longLongTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'longLong'
        self.typeStr  = "longLong"
        # 设置类型代码为 'q'
        self.typeCode = "q"

######################################################################

class ulongLongTestCase(VectorTestCase):
    # ulongLongTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'ulongLong'
        self.typeStr  = "ulongLong"
        # 设置类型代码为 'Q'
        self.typeCode = "Q"

######################################################################

class floatTestCase(VectorTestCase):
    # floatTestCase 类继承自 VectorTestCase 类
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的初始化方法
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 'float'
        self.typeStr  = "float"
        # 设置类型代码为 'f'
        self.typeCode = "f"

######################################################################
######################################################################

class doubleTestCase(VectorTestCase):
    # 定义 doubleTestCase 类，继承自 VectorTestCase
    def __init__(self, methodName="runTest"):
        # 调用父类 VectorTestCase 的构造函数初始化
        VectorTestCase.__init__(self, methodName)
        # 设置类型字符串为 "double"
        self.typeStr  = "double"
        # 设置类型代码为 "d"
        self.typeCode = "d"

######################################################################

if __name__ == "__main__":
    # 如果作为主程序运行

    # 创建一个测试套件
    suite = unittest.TestSuite()
    # 将各个类型的测试用例添加到测试套件中
    suite.addTest(unittest.makeSuite(    scharTestCase))
    suite.addTest(unittest.makeSuite(    ucharTestCase))
    suite.addTest(unittest.makeSuite(    shortTestCase))
    suite.addTest(unittest.makeSuite(   ushortTestCase))
    suite.addTest(unittest.makeSuite(      intTestCase))
    suite.addTest(unittest.makeSuite(     uintTestCase))
    suite.addTest(unittest.makeSuite(     longTestCase))
    suite.addTest(unittest.makeSuite(    ulongTestCase))
    suite.addTest(unittest.makeSuite( longLongTestCase))
    suite.addTest(unittest.makeSuite(ulongLongTestCase))
    suite.addTest(unittest.makeSuite(    floatTestCase))
    suite.addTest(unittest.makeSuite(   doubleTestCase))

    # 执行测试套件中的测试用例
    print("Testing 1D Functions of Module Vector")
    # 打印 NumPy 的版本号
    print("NumPy version", np.__version__)
    print()
    # 运行测试并获取测试结果
    result = unittest.TextTestRunner(verbosity=2).run(suite)
    # 根据测试结果，如果有错误或失败，以非零状态退出，否则以零状态退出
    sys.exit(bool(result.errors + result.failures))

.\numpy\tools\swig\test\Vector.cxx

// 包含标准库头文件：stdlib.h（包含通用函数）、math.h（包含数学函数）、iostream（输入输出流）
#include <stdlib.h>
#include <math.h>
#include <iostream>
// 引入自定义头文件 "Vector.h"
#include "Vector.h"

// 定义宏 TEST_FUNCS，生成一系列函数，用于处理给定类型的一维数组
#define TEST_FUNCS(TYPE, SNAME) \
\
// 计算向量长度，接受长度为3的向量数组作为参数
TYPE SNAME ## Length(TYPE vector[3]) {                   \
  double result = 0;                                     \
  // 计算向量的模长
  for (int i=0; i<3; ++i) result += vector[i]*vector[i]; \
  return (TYPE)sqrt(result);                        \
}                                                        \
\
// 计算数组元素的乘积，接受指向数组的指针和数组大小作为参数
TYPE SNAME ## Prod(TYPE * series, int size) {     \
  TYPE result = 1;                                \
  // 计算数组元素的乘积
  for (int i=0; i<size; ++i) result *= series[i]; \
  return result;                                  \
}                                                 \
\
// 计算数组元素的总和，接受数组大小和指向数组的指针作为参数
TYPE SNAME ## Sum(int size, TYPE * series) {      \
  TYPE result = 0;                                \
  // 计算数组元素的总和
  for (int i=0; i<size; ++i) result += series[i]; \
  return result;                                  \
}                                                 \
\
// 将数组中的元素反转，接受长度为3的数组作为参数
void SNAME ## Reverse(TYPE array[3]) { \
  TYPE temp = array[0];               \
  array[0] = array[2];                 \
  array[2] = temp;                     \
}                                      \
\
// 将数组中的所有元素设置为1，接受指向数组的指针和数组大小作为参数
void SNAME ## Ones(TYPE * array, int size) { \
  // 将数组中所有元素设置为1
  for (int i=0; i<size; ++i) array[i] = 1;   \
}                                            \
\
// 将数组中的所有元素设置为0，接受数组大小和指向数组的指针作为参数
void SNAME ## Zeros(int size, TYPE * array) { \
  // 将数组中所有元素设置为0
  for (int i=0; i<size; ++i) array[i] = 0;    \
}                                             \
\
// 将一个长度为3的向量数组拆分为奇数位和偶数位数组，接受源向量、偶数位数组和奇数位数组作为参数
void SNAME ## EOSplit(TYPE vector[3], TYPE even[3], TYPE odd[3]) { \
  for (int i=0; i<3; ++i) {                       \
    // 将偶数位元素复制到偶数位数组
    if (i % 2 == 0) {                           \
      even[i] = vector[i];                       \
      // 将奇数位元素设置为0
      odd[ i] = 0;                           \
    } else {                               \
      even[i] = 0;                           \  # 如果当前索引处的元素为偶数，则将 even 数组对应位置置为 0
      odd[ i] = vector[i];                       \  # 如果当前索引处的元素为奇数，则将 odd 数组对应位置设置为 vector 数组当前位置的值
    }                                   \  # 结束 if-else 分支
  }                                   \  # 结束 for 循环
# 定义一个以给定类型和名称为前缀的函数，将给定数组中的所有元素设置为2
void SNAME ## Twos(TYPE* twoVec, int size) {
  # 循环遍历数组，将每个元素设置为2
  for (int i=0; i<size; ++i) twoVec[i] = 2;
}

# 定义一个以给定名称为前缀的函数，将给定数组中的所有元素设置为3
void SNAME ## Threes(int size, TYPE* threeVec) {
  # 循环遍历数组，将每个元素设置为3
  for (int i=0; i<size; ++i) threeVec[i] = 3;
}

# 以下是为不同数据类型定义测试函数的宏展开
TEST_FUNCS(signed char       , schar    )
TEST_FUNCS(unsigned char     , uchar    )
TEST_FUNCS(short             , short    )
TEST_FUNCS(unsigned short    , ushort   )
TEST_FUNCS(int               , int      )
TEST_FUNCS(unsigned int      , uint     )
TEST_FUNCS(long              , long     )
TEST_FUNCS(unsigned long     , ulong    )
TEST_FUNCS(long long         , longLong )
TEST_FUNCS(unsigned long long, ulongLong)
TEST_FUNCS(float             , float    )
TEST_FUNCS(double            , double   )


每个函数和宏的作用已经通过注释清楚地描述了出来，不改变代码的结构和缩进。

.\numpy\tools\swig\test\Vector.h

#ifndef VECTOR_H
#define VECTOR_H

// 定义了一系列与一维数组操作相关的函数原型的宏
//
//     TYPE SNAMELength( TYPE vector[3]);
//     TYPE SNAMEProd(   TYPE * series, int size);
//     TYPE SNAMESum(    int size, TYPE * series);
//     void SNAMEReverse(TYPE array[3]);
//     void SNAMEOnes(   TYPE * array,  int size);
//     void SNAMEZeros(  int size, TYPE * array);
//     void SNAMEEOSplit(TYPE vector[3], TYPE even[3], TYPE odd[3]);
//     void SNAMETwos(   TYPE * twoVec, int size);
//     void SNAMEThrees( int size, TYPE * threeVec);
//
// 对于指定的类型 TYPE（例如：short、unsigned int、long long 等），使用简称 SNAME
// （例如：short、uint、longLong 等）定义这些函数原型。宏会根据给定的 TYPE/SNAME 组合
// 进行扩展。生成的函数用于测试 numpy 接口，分别为：
//
//  * 针对固定长度的一维输入数组
//  * 针对一维输入数组
//  * 针对一维输入数组，数据在最后
//  * 针对固定长度的一维原地操作数组
//  * 针对一维原地操作数组
//  * 针对一维原地操作数组，数据在最后
//  * 针对固定长度的一维输出数组
//  * 针对一维输出数组
//  * 针对一维输出数组，数据在最后
//
#define TEST_FUNC_PROTOS(TYPE, SNAME) \
\
TYPE SNAME ## Length( TYPE vector[3]); \
TYPE SNAME ## Prod(   TYPE * series, int size); \
TYPE SNAME ## Sum(    int size, TYPE * series); \
void SNAME ## Reverse(TYPE array[3]); \
void SNAME ## Ones(   TYPE * array,  int size); \
void SNAME ## Zeros(  int size, TYPE * array); \
void SNAME ## EOSplit(TYPE vector[3], TYPE even[3], TYPE odd[3]); \
void SNAME ## Twos(   TYPE * twoVec, int size); \
void SNAME ## Threes( int size, TYPE * threeVec); \

// 使用宏扩展，生成不同类型的函数原型
TEST_FUNC_PROTOS(signed char       , schar    )
TEST_FUNC_PROTOS(unsigned char     , uchar    )
TEST_FUNC_PROTOS(short             , short    )
TEST_FUNC_PROTOS(unsigned short    , ushort   )
TEST_FUNC_PROTOS(int               , int      )
TEST_FUNC_PROTOS(unsigned int      , uint     )
TEST_FUNC_PROTOS(long              , long     )
TEST_FUNC_PROTOS(unsigned long     , ulong    )
TEST_FUNC_PROTOS(long long         , longLong )
TEST_FUNC_PROTOS(unsigned long long, ulongLong)
TEST_FUNC_PROTOS(float             , float    )
TEST_FUNC_PROTOS(double            , double   )

#endif

.\numpy\tools\wheels\check_license.py

#!/usr/bin/env python
"""
check_license.py [MODULE]

Check the presence of a LICENSE.txt in the installed module directory,
and that it appears to contain text prevalent for a NumPy binary
distribution.

"""
import sys  # 导入 sys 模块，用于访问系统相关的功能
import re  # 导入 re 模块，用于正则表达式操作
import argparse  # 导入 argparse 模块，用于解析命令行参数
import pathlib  # 导入 pathlib 模块，用于处理文件路径

def check_text(text):
    # 检查文本是否包含 "Copyright (c)" 并且符合预期的二进制分发文本模式
    ok = "Copyright (c)" in text and re.search(
        r"This binary distribution of \w+ also bundles the following software",
        text,
    )
    return ok

def main():
    p = argparse.ArgumentParser(usage=__doc__.rstrip())
    p.add_argument("module", nargs="?", default="numpy")
    args = p.parse_args()

    # 从 sys.path 中移除空字符串项
    sys.path.pop(0)

    # 寻找指定模块的路径
    __import__(args.module)
    mod = sys.modules[args.module]

    # LICENSE.txt 通常安装在 .dist-info 目录中，因此在此查找它
    sitepkgs = pathlib.Path(mod.__file__).parent.parent
    distinfo_path = [s for s in sitepkgs.glob("numpy-*.dist-info")][0]

    # 检查许可证文本
    license_txt = distinfo_path / "LICENSE.txt"
    with open(license_txt, encoding="utf-8") as f:
        text = f.read()

    # 调用 check_text 函数检查许可证文本是否符合预期
    ok = check_text(text)
    if not ok:
        print(
            "ERROR: License text {} does not contain expected "
            "text fragments\n".format(license_txt)
        )
        print(text)
        sys.exit(1)

    sys.exit(0)

if __name__ == "__main__":
    main()