小编Joe*_*y O的帖子

我有一个函数 func1() 正在生产中且无法修改。它调用另一个模块中的函数 function_to_be_mocked()。这需要输入参数。

我有另一个函数 func2() 调用 func1()。

我正在编写单元测试来测试 func2() ，并尝试模拟 function_to_be_mocked （因为它取决于我本地系统上没有（也不应该有）的一些键）。我唯一可以修改的是test_func2()。

我有如下设置（最小示例）：

from othermodule import function_to_be_mocked
import pytest
import mock

def func1():
    function_to_be_mocked(None)

def func2():
    ret = func1()
    print (ret)

@mock.patch('othermodule.function_to_be_mocked', return_value = 3)
def test_func2(mocker):
    func2()

othermodule.py 是：

def function_to_be_mocked(arg1):
    if not arg1 == 'foo':
        raise ValueError

我的输出：

直接调用func2：

Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/Users/blah/temp.py", line 9, in func2
    ret = func1()
  File "/Users/blah/temp.py", line 6, in func1
    function_to_be_mocked(None)
  File …

我今天一直在思考一个问题，在google上很难找到答案。

在处理指向在堆上和堆栈上分配的对象的指针时，我试图了解 STL 容器的行为。

所以，从对象开始，没有指针......想象我有......

std::vector<int> myVec;
while(true)
{
    int myInt = 5;
    myVec.push_back(myInt);
    myVec.pop_back();
}

我的理解是 pop_back() 方法将确保删除向量中包含的整数，而不仅仅是从容器中删除。因此，如果它运行并进行了 10 亿次迭代，我不应该期望内存泄漏。我插入的所有内容都将被删除。内存检查显示了这种行为。

现在考虑我使用一个指针向量（指向堆上的对象）......

std::vector<int*> myVec;
while(true)
{
    int * myIntP = new int(5);
    myVec.push_back(myIntP);
    myVec.pop_back();
}

在这种情况下，每次调用 pop_back() 时只应删除指针本身，并且底层对象保持未删除状态，从而导致内存泄漏。因此，经过十亿次迭代后，我使用了相当多的内存，即使我的向量中没有条目。

现在，如果我有一个指针向量（指向堆栈上的对象）怎么办...

std::vector<int*> myVec;
while(true)
{
    int myInt = 5;
    int * myIntP = &myInt;
    myVec.push_back(myIntP);
    myVec.pop_back();
}

这里的指针指向堆栈对象。他们的内存是否在调用 pop_back() 时被释放？内存检查表明这种行为没有内存泄漏。使用的少量内存表明这就像堆栈上的对象一样。然而，这对我来说不是预期的，因为如果指针是从另一个函数传递给我的，则是一个堆栈变量，即

void myFunc(int * myIntP)
{
    std::vector<int*> myVec;
    myVec.push_back(myIntP);
    myVec.pop_back();
}
int main()
{
    int myInt = 5;                                                                                                                      
    int * myIntP = &myInt; …