// 待测函数
    int foobar(int x) {
        return x;
    }

    // 测试时，像下面这样就可以mock
    EMOCK(foobar)
        .stubs()
        .with(any()) // 约束匹配任意输入
        .will(returnValue(1)); // 调用时返回1

    // 调用会返回1
    ASSERT_EQ(foobar(0), 1);

    // 待测成员函数
    class Foo
    {
    public:
        void bar1(int);
        virtual void bar2(double);
        static int bar3();
    };

    ////////////////////////////////////

    // 指定调用的mock函数
    void EMOCK_API mock_bar1(Foo* obj, int) {
        // ...
    }
    void EMOCK_API mock_bar2(Foo* obj, double) {
        // ...
    }

    // 测试时，像下面这样就可以mock
    EMOCK(&Foo::bar1)
        .stubs()
        .will(invoke(mock_bar1)); // 指定调用自定义的函数而不是指定返回值
    EMOCK(&Foo::bar2) // 虚成员函数并不特别
        .stubs()
        .will(invoke(mock_bar2));
    EMOCK(Foo::bar3) // 静态函数类似全局函数，不需要&
        .stubs()
        .will(returnValue(1));

    // 待测重载函数
    int foobar(int x) {
        return x;
    }
    double foobar(double x) {
        return x;
    }

    // 重载函数，像下面这样就可以mock
    EMOCK((int (*)(int))foobar)
        .stubs()
        .will(returnValue(1));
    EMOCK(static_cast<double (*)(double)>(foobar))
        .stubs()
        .will(returnValue(1.0));

    // 待测重载成员函数
    class Foo
    {
    public:
        void bar(int);
        void bar(double);
    };

    // 重载的成员函数，像下面这样就可以mock
    EMOCK((void (Foo::*)(int))&Foo::bar)
        .expects(once()); // 只会调用一次
    EMOCK(static_cast<void (Foo::*)(double)>(&Foo::bar))
        .expects(never()); // 不会被调用