Question

我正在开发一个脚本来测试另一个程序。基本上我复制了一个具有我正在测试的程序所具有的所有函数的类。为简单起见，假设我只有2个函数：set（value）和add（value）。 set（value）设置累加器值，add（value）为其添加值;我正在测试一个应该做同样事情的程序。

我还有一个check（）函数，用于验证set（value）和add（value）操作的累加器值是否与我正在测试的程序检索的值具有相同的值;所以，在每次操作之后，我想运行这个check（）函数并确保它们匹配。

为了明确这一点，这是一个（未经测试的）示例：

def set(self, value):
    self.acc = value
    sendCommandToMyProgram('set', value)

def add(self, value):
    self.acc += value
    sendCommandToMyProgram('add', value)

def check(self):
    return self.acc == sendCommandToMyProgram('check', value)

我想做“测试场景”，如：

set(1)
check()
add(2)
check()
add(-2)
check()
add(3)

和其他许多人

制作这个“测试场景”脚本的最佳方法是什么？如果它可以使用带有不同参数的函数（在这个例子中，set（）和add（）只接收一个参数 - 值 - 会很好，但情况并非总是如此）。

感谢

Answer 1

假设您不想在正常操作期间检查值 all 的时间，首先想到的是内置unit test module。

如果你需要做更复杂的事情，你不能干净地隔离测试，如下所示，请查看我必须解决的一些my issues。值得注意的是，我最终推出了自己的测试运行器，其行为与单元测试非常相似，但具有更强的控制力。我会在接下来的一个月左右把它推到py-pi。

工作单位测试示例

import unittest

class RealAccumlator(object):
    def __init__(self):
        self.acc = 0

    def add(self, val):
        self.acc += val

    def set(self, val):
        self.acc = val

    def get(self):
        return self.acc


# Using a global variable as I dont know how "sendCommandToMyProgram"
# is used
real_acc = RealAccumlator()


# Test Script

class MyAccumlator(object):
    def __init__(self):
        self.acc = 0

    def add(self, val):
        self.acc += val
        real_acc.add(val)

    def set(self, val):
        self.acc = val
        real_acc.set(val)

    def check(self):
        return self.acc == real_acc.get()

class MockedAccumlatorTests(unittest.TestCase):

    def setUp(self):
        self.acc = MyAccumlator()

    def test_SetFunction(self):
        test_values = range(-10,10)

        # Test the set commands
        for val in test_values:
            self.acc.set(val)
            self.assertTrue(self.acc.check())

    def test_AddFunction(self):
        test_values = range(-10,10)

        # Set the acc to a known value and to a quick test
        self.acc.set(0) 
        self.assertTrue(self.acc.check())

        # Test the add commands
        for val in test_values:
            self.acc.add(val)
            self.assertTrue(self.acc.check())


class RealAccumlatorTests(unittest.TestCase):

    def test_SetFunction(self):
        test_values = range(-10,10)

        # Test the set commands
        for val in test_values:
            real_acc.set(val)
            self.assertEqual(val, real_acc.get())

    def test_AddFunction(self):
        test_values = range(-10,10)

        # Set the acc to a known value and to a quick test
        real_acc.set(0) 
        self.assertEqual(0, real_acc.get())

        # Test the add commands
        expected_value = 0
        for val in test_values:
            expected_value += val
            real_acc.add(val)
            self.assertEqual(expected_value, real_acc.get())

if __name__ == '__main__':
    unittest.main()

根据已接受的答案进行更新

如果这只是一个测试脚本并且你的模拟累加器没有用完，那么这个测试会考虑以下mod。 我仍然相信从长远来看，编写单元测试会更好地为您服务

class MyAccumlator(object):
    def __init__(self):
        self.acc = 0

    def add(self, val):
        self.acc += val
        real_acc.add(val)
        assert(self.check())
        return self.check()

    def set(self, val):
        self.acc = val
        real_acc.set(val)
        assert(self.check())
        return self.check()

    def check(self):
        return self.acc == real_acc.get()

这将允许您迭代所需的任何列表，而无需考虑调用check函数。您可以检查两种方法。

离开assert调用会抛出异常（如果它们不匹配）（仅建议假设这将作为测试脚本存在）。
从您的调用脚本中删除assert并检查返回状态（而不是显式调用check()也可以清理。

Answer 2

我需要在每次操作后运行“check（）”。

我最终创建了“测试场景”，如：

test_scenarios =
    [
        [
            (obj.set, {1}),
            (obj.add, {5}),
            (obj.add, {-2})
        ],
        [
            (obj.set, {-2}),
            (obj.add, {3}),
            (obj.add, {-5})
            (obj.add, {1})
        ]
    ]

然后我迭代测试场景基本上调用test [0]（** test [1]）然后检查（）

也许不是最好的解决方案，但我能想到的最好的解决方案

Answer 3

设置值。使用要添加的值创建列表。然后，遍历该列表，每个循环运行check和add。即：numlist = [1, 2, -2, 3]; for num in numlist: obj.check(); obj.add(num)

在python中运行测试脚本方案

3 个答案: