C++单元测试框架-gtest-4-深入解析gtest

最新推荐文章于 2024-08-05 20:02:00 发布
最新推荐文章于 2024-08-05 20:02:00 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： c++语言 文章标签： TEST TEST_F TEST_P RUN_ALL_TEST GTEST_TEST_
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shenwanjiang111/article/details/87991233
版权

0 目录

1 TEST宏

我们查看一段测试代码：

TEST(FactorialTest, Zero) 
{
    EXPECT_EQ(1, Factorial(0));
}

将其进行宏展开后

// 声明的测试类
class FactorialTest_Zero_Test : public ::testing::Test 
{ 
public: 
    FactorialTest_Zero_Test() {} 
private: 
    virtual void TestBody(); 
    static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); 
    FactorialTest_Zero_Test(FactorialTest_Zero_Test const &) ; 
    void operator=(FactorialTest_Zero_Test const &) ;
};
// 记录测试信息
::testing::TestInfo* const FactorialTest_Zero_Test::test_info_ = 
        ::testing::internal::MakeAndRegisterTestInfo( 
            "FactorialTest", 
            "Zero", 
            __null, 
            __null, 
            ::testing::internal::CodeLocation("gtest/gtest_Average.cpp", 21), 
            (::testing::internal::GetTestTypeId()), 
            ::testing::Test::SetUpTestCase, 
            ::testing::Test::TearDownTestCase, 
            new ::testing::internal::TestFactoryImpl< FactorialTest_Zero_Test>);
void FactorialTest_Zero_Test::TestBody() 
{
    switch (0) 
        case 0: 
        default: 
        if (/* 断言是否成功 */) /* 如果成功，则什么都不做*/; 
        else 
            // 断言失败，则打印失败信息，使用::testing::Message()
}

展开后，我们观察到：

  1. TEST宏展开后，是一个继承自testing::Test的类。
  2. 我们在TEST宏里面写的测试代码，其实是被放到了类的TestBody方法中。
  3. 通过静态变量test_info_，调用MakeAndRegisterTestInfo对测试案例进行注册。

对于函数 MakeAndRegisterTestInfo，查看源代码：

// 创建一个 TestInfo 对象并注册到 Google Test;
// 返回创建的TestInfo对象
//
// 参数:
//
//   test_case_name:          测试案例的名称
//   name:                    测试的名称
//   test_case_comment:       测试案例的注释信息
//   comment:                 测试的注释信息
//   fixture_class_id:        test fixture类的ID
//   set_up_tc:               事件函数SetUpTestCases的函数地址
//   tear_down_tc:            事件函数TearDownTestCases的函数地址
//   factory:                 工厂对象，用于创建测试对象(Test)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name, const char* name,
    const char* test_case_comment, const char* comment,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) 
{
    TestInfo* const test_info = new TestInfo(
                    test_case_name, 
                    name, 
                    test_case_comment, 
                    comment,
                    fixture_class_id, 
                    factory);
    GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
    return test_info;
}

我们看到，上面创建了一个 TestInfo 对象，然后通过 AddTestInfo 注册了这个对象。TestInfo对象到底是一个什么样的东西呢？ TestInfo对象主要用于包含如下信息：

  1. 测试案例名称（testcase name）
  2. 测试名称（test name）
  3. 该案例是否需要执行
  4. 执行案例时，用于创建Test对象的函数指针
  5. 测试结果

我们还看到，TestInfo的构造函数中，非常重要的一个参数就是工厂对象，它主要负责在运行测试案例时创建出Test对象。 我们看到我们上面的例子的factory为：

::testing::internal::TestFactoryImpl< FactorialTest_Zero_Test>

FactorialTest_Zero_Test 就是TEST宏展开后的那个类的对象，再看看TestFactoryImpl的实现：

template <class TestClass>
class TestFactoryImpl : public TestFactoryBase 
{
public:
    virtual Test* CreateTest() { return new TestClass; }
};

这个工厂对象简单吧，我信仰极简主义。当我们需要创建一个测试对象(Test)时，调用工厂类的 *CreateTest()*方法就可以了。 创建了 TestInfo对象后， 再通过下面的方法对 TestInfo对象进行注册：

GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);

GetUnitTestImpl()是获取UnitTestImpl对象：

inline UnitTestImpl* GetUnitTestImpl() {
    return UnitTest::GetInstance()->impl();
}

其中，UnitTest是一个 Singleton 对象，整个进程空间只有一个实例，通过 UnitTest::GetInstance() 获取单例对象。上面的代码看到，UnitTestImpl 对象是最终是从 UnitTest对象中获取的。那么 UnitTestImpl到底是一个什么样的东西呢？可以这样理解：

我们先来看一下 UnitTest 实现的内容：

class GTEST_API_ UnitTest 
{
public:
    static UnitTest* GetInstance();       // 获得单例模式的 UnitTest 对象

    // 运行在这个UnitTest对象内的所有测试，并且打印结果。如果成功返回0；否则，返回1。
    // 这个方法只能从main线程中被调用。内部实现-不要用在用户程序中。
    int Run() GTEST_MUST_USE_RESULT_;

    ...
    // 实现对象的访问接口
    internal::UnitTestImpl* impl() { return impl_; }
    const internal::UnitTestImpl* impl() const { return impl_; }
    
    ...//此处省略
    internal::UnitTestImpl* impl_;
    ...//此处省略
};

UnitTestImpl是一个在 UnitTest 内部使用的，为执行单元测试案例而提供了一系列实现的那么一个类。（自己归纳的，可能不准确）

我们上面的 AddTestInfo 就是其中的一个实现，负责注册 TestInfo 实例：

// 添加TestInfo对象到整个单元测试中
//
// 参数:
//
//   set_up_tc:         事件函数SetUpTestCases的函数地址
//   tear_down_tc:      事件函数TearDownTestCases的函数地址
//   test_info:         TestInfo对象
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
               Test::TearDownTestCaseFunc tear_down_tc,
               TestInfo * test_info) 
{
    // 处理死亡测试的代码，先不关注它
    if (original_working_dir_.IsEmpty()) {
        original_working_dir_.Set(FilePath::GetCurrentDir());
        if (original_working_dir_.IsEmpty()) {
            printf("%s\n", "Failed to get the current working directory.");
            abort();
        }
    }
    // 获取或创建了一个TestCase对象，并将testinfo添加到TestCase对象中。
    GetTestCase(test_info->test_case_name(),
                test_info->test_case_comment(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
}

我们看到，TestCase对象出来了，并通过AddTestInfo添加了一个TestInfo对象。这时，似乎豁然开朗了：

  1. TEST宏中的两个参数，第一个参数testcase_name，就是TestCase对象的名称，第二个参数test_name就是Test对象的名称。而TestInfo包含了一个测试案例的一系列信息。
  2. 一个TestCase对象对应一个或多个TestInfo对象。

我们来看看TestCase的创建过程(UnitTestImpl::GetTestCase)：

// 查找并返回一个指定名称的TestCase对象。如果对象不存在，则创建一个并返回
//
// 参数:
//
//   test_case_name:    测试案例名称
//   set_up_tc:            事件函数SetUpTestCases的函数地址
//   tear_down_tc:       事件函数TearDownTestCases的函数地址
TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
                                    const char* comment,
                                    Test::SetUpTestCaseFunc set_up_tc,
                                    Test::TearDownTestCaseFunc tear_down_tc) {
  // 从test_cases里查找指定名称的TestCase
    internal::ListNode<TestCase*>* node = test_cases_.FindIf(
        TestCaseNameIs(test_case_name));

    if (node == NULL) {
        // 没找到，我们来创建一个
        TestCase* const test_case =
            new TestCase(test_case_name, comment, set_up_tc, tear_down_tc);

        // 判断是否为死亡测试案例
        if (internal::UnitTestOptions::MatchesFilter(String(test_case_name),
                                                 kDeathTestCaseFilter)) {
            // 是的话，将该案例插入到最后一个死亡测试案例后
            node = test_cases_.InsertAfter(last_death_test_case_, test_case);
            last_death_test_case_ = node;
        } else {
            // 否则，添加到test_cases最后。
            test_cases_.PushBack(test_case);
            node = test_cases_.Last();
        }
    }

    // 返回TestCase对象
    return node->element();
}

2 其它的TEST宏定义

回过头看看TEST宏的定义：

#define TEST(test_case_name, test_name)\
    GTEST_TEST_(test_case_name, test_name, \
              ::testing::Test, ::testing::internal::GetTestTypeId())

与TEST_F宏对比，

#define TEST_F(test_fixture, test_name)\
    GTEST_TEST_(test_fixture, test_name, test_fixture, \
              ::testing::internal::GetTypeId<test_fixture>())

都是使用了GTEST_TEST_宏，在看看这个宏如何定义的：

#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
public:\
    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
private:\
    virtual void TestBody();\
    static ::testing::TestInfo* const test_info_;\
    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
        GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
};\
\
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
    ::test_info_ =\
        ::testing::internal::MakeAndRegisterTestInfo(\
            #test_case_name, #test_name, "", "", \
            (parent_id), \
            parent_class::SetUpTestCase, \
            parent_class::TearDownTestCase, \
            new ::testing::internal::TestFactoryImpl<\
                GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()

不需要多解释了，和我们上面展开看到的差不多，不过这里比较明确的看到了，我们在TEST宏里写的就是TestBody里的东西。这里再补充说明一下里面的GTEST_DISALLOW_COPY_AND_ASSIGN_宏，我们上面的例子看出，这个宏展开后：

FactorialTest_Zero_Test(FactorialTest_Zero_Test const &) ; 
void operator=(FactorialTest_Zero_Test const &) ;

正如这个宏的名字一样，它是用于防止对对象进行拷贝和赋值操作的。

3 RUN_ALL_TESTS宏

RUN_ALL_TEST的定义非常简单：

#define RUN_ALL_TESTS()\
    (::testing::UnitTest::GetInstance()->Run())

我们又看到了熟悉的 ::testing::UnitTest::GetInstance()，看来案例的执行时从 UnitTest的 Run方法开始的， 我提取了一些 Run中的关键代码，如下：

int UnitTest::Run() {
    __try 
    {
        return impl_->RunAllTests();    // 执行所有测试
    }
    __except(异常判断) 
    {
        // 异常处理代码
        return 1;
    }
    return impl_->RunAllTests();
}

我们又看到了熟悉的 impl（UnitTestImpl），具体案例该怎么执行，还是得靠 UnitTestImpl。

int UnitTestImpl::RunAllTests() {
    // ... (此处省略)
    printer->OnUnitTestStart(parent_);
    
    // 计时
    const TimeInMillis start = GetTimeInMillis();
    printer->OnGlobalSetUpStart(parent_);
    
    // 执行全局的SetUp事件
    environments_.ForEach(SetUpEnvironment);
    printer->OnGlobalSetUpEnd(parent_);
    
    // 全局的SetUp事件执行成功的话
    if (!Test::HasFatalFailure()) {
        // 执行每个测试案例
        test_cases_.ForEach(TestCase::RunTestCase);
    }
    
    // 执行全局的TearDown事件
    printer->OnGlobalTearDownStart(parent_);
    environments_in_reverse_order_.ForEach(TearDownEnvironment);
    printer->OnGlobalTearDownEnd(parent_);

    elapsed_time_ = GetTimeInMillis() - start;

    // 执行完成
    printer->OnUnitTestEnd(parent_);

    // 得到结果并清除
    if (!Passed()) {
      failed = true;
    }
    ClearResult();

    // 返回测试结果
    return failed ? 1 : 0;
}

上面，我们很开心的看到了我们前面讲到的全局事件的调用。environments_是一个Environment的链表结构（List），它的内容是我们在main中通过：

testing::AddGlobalTestEnvironment(new FooEnvironment);

添加进去的。test_cases_我们之前也了解过了，是一个TestCase的链表结构（List）。gtest实现了一个链表，并且提供了一个Foreach方法，迭代调用某个函数，并将里面的元素作为函数的参数：

template <typename F>  // F是函数或函子类型
void ForEach(F functor) const {
    for ( const ListNode<E> * node = Head();
          node != NULL;
          node = node->next() ) {
      functor(node->element());
    }
}

因此，我们关注一下：environments_.ForEach(SetUpEnvironment)，其实是迭代调用了 SetUpEnvironment函数：

static void SetUpEnvironment(Environment* env) { env->SetUp(); }

最终调用了我们定义的 SetUp() 函数。

再看看 test_cases_.ForEach(TestCase::RunTestCase) 的 TestCase::RunTestCase实现：

static void RunTestCase(TestCase * test_case) { test_case->Run(); }

再看 TestCase的 Run实现：

void TestCase::Run() 
{
    if (!should_run_) return;

    internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
    impl->set_current_test_case(this);

    UnitTestEventListenerInterface * const result_printer = impl->result_printer();

    result_printer->OnTestCaseStart(this);
    impl->os_stack_trace_getter()->UponLeavingGTest();
    // 哈！ SetUpTestCases 事件在这里调用
    set_up_tc_();

    const internal::TimeInMillis start = internal::GetTimeInMillis();
    // 嗯，前面分析的一个TestCase对应多个TestInfo，因此，在这里迭代对TestInfo调用RunTest方法
    test_info_list_->ForEach(internal::TestInfoImpl::RunTest);
    elapsed_time_ = internal::GetTimeInMillis() - start;

    impl->os_stack_trace_getter()->UponLeavingGTest();
    
    // TearDownTestCases 事件在这里调用
    tear_down_tc_();
    result_printer->OnTestCaseEnd(this);
    impl->set_current_test_case(NULL);
}

第二种事件机制又浮出我们眼前，非常兴奋。可以看出，SetUpTestCases和 TearDownTestCases是在一个TestCase之前和之后调用的。 接着看 test_info_list_->ForEach(internal::TestInfoImpl::RunTest)：

static void RunTest(TestInfo * test_info) {
    test_info->impl()->Run();
}

哦？TestInfo也有一个 impl？看来我们之前漏掉了点东西，和 UnitTest很类似，TestInfo内部也有一个主管各种实现的类，那就是 TestInfoImpl，它在 TestInfo的构造函数中创建了出来（还记得前面讲的 TestInfo的创建过程吗？）：

TestInfo::TestInfo(const char* test_case_name,
                   const char* name,
                   const char* test_case_comment,
                   const char* comment,
                   internal::TypeId fixture_class_id,
                   internal::TestFactoryBase* factory) {
    impl_ = new internal::TestInfoImpl(this, test_case_name, name,
                                     test_case_comment, comment,
                                     fixture_class_id, factory);
}

因此，案例的执行还得看TestInfoImpl的Run()方法，同样，我简化一下，只列出关键部分的代码：

void TestInfoImpl::Run() {
    // ...

    UnitTestEventListenerInterface* const result_printer = impl->result_printer();
    result_printer->OnTestStart(parent_);
    // 开始计时
    const TimeInMillis start = GetTimeInMillis();

    Test* test = NULL;

    __try { 
        test = factory_->CreateTest(); // 我们的对象工厂，使用CreateTest()生成Test对象
    } __except(/*捕捉异常*/) {
        // 抛出异常
        return;
    }

    // 如果Test对象创建成功
    if (!Test::HasFatalFailure()) 
    {     
        test->Run(); // 调用Test对象的Run()方法，执行测试案例 
    }

    // 执行完毕，删除Test对象
    impl->os_stack_trace_getter()->UponLeavingGTest();
    delete test;
    test = NULL;

    // 停止计时
    result_.set_elapsed_time(GetTimeInMillis() - start);
    result_printer->OnTestEnd(parent_);
}

上面看到了我们前面讲到的对象工厂fatory，通过fatory的CreateTest()方法，创建Test对象，然后执行案例又是通过Test对象的Run()方法：

void Test::Run() {
    if (!HasSameFixtureClass()) return;

    internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
    impl->os_stack_trace_getter()->UponLeavingGTest();
    __try 
    {
        SetUp();    // Yeah！每个案例的SetUp事件在这里调用
    } __except(/*捕捉异常 */)
    {
        // 抛出异常
    }

    // We will run the test only if SetUp() had no fatal failure.
    if (!HasFatalFailure()) {
        impl->os_stack_trace_getter()->UponLeavingGTest();
        __try {
            // 哈哈！！千辛万苦，我们定义在TEST宏里的东西终于被调用了！
            TestBody();
        } __except(/*捕捉异常 */) {
            // 抛出异常
        }
    }

    impl->os_stack_trace_getter()->UponLeavingGTest();
    __try {
        // 每个案例的TearDown事件在这里调用
        TearDown();
    } __except(/*捕捉异常 */) {
        // 抛出异常
    }
}

上面的代码里非常极其以及特别的兴奋的看到了执行测试案例的前后事件，测试案例执行TestBody()的代码。仿佛整个gtest的流程在眼前一目了然了。

3 总结

总结一下gtest里的几个关键的对象：

  1. UnitTest 单例，总管整个测试，包括测试环境信息，当前执行状态等等。
  2. UnitTestImpl UnitTest内部具体功能的实现者。
  3. Test 我们自己编写的，或通过TEST，TEST_F等宏展开后的Test对象，管理着测试案例的前后事件，具体的执行代码TestBody。
  4. TestCase 测试案例对象，管理着基于TestCase的前后事件，管理内部多个TestInfo。
  5. TestInfo 管理着测试案例的基本信息，包括Test对象的创建方法。
  6. TestInfoImpl TestInfo内部具体功能的实现者 。

其它请参考：

  1. <C++单元测试框架-gtest-1-断言>
  2. <C++单元测试框架-gtest-2-事件机制>
  3. <C++单元测试框架-gtest-3-参数化>
tupelo-shen
关注
专栏目录
跨平台C++单元测试框架——GTest
king_weng的博客
03-02 2012
1、简介 GTest是google公司发布的一个跨平台的(Liunx、Mac OS X、Windows、Cygwin、Windows CE and Symbian)C++单元测试框架。它提供了丰富的断言、致命和非致命判断、参数化、死亡测试等等。 使用gtest时，就是编写断言（assertions），断言语句会检测条件是否为真。一个断言可存在三种结果：success（成功），nonfatal failure（非致命失败）,或 fatal failure（致命失败）。当出现致命...
C++轻量级单元测试框架
个人独立博客http://www.acb0y.cn/
04-25 755
单元测试是构建稳定、高质量的程序、服务或系统的必不可少的一环。通过单元测试，我们可以在开发过程中及时发现和修复代码中的问题，提高代码的质量和可维护性。同时，单元测试也可以帮助我们更好地理解代码的功能和实现细节，从而更好地进行代码重构和优化。
轻松编写 C++ 单元测试(gtest)
11-10
单元测试概述 测试并不只是测试工程师的责任,对于开发工程师,为了保证发布给测试环节的代码具有足够好 的质量( Quality ),为所编写的功能代码编写适量的单元测试是十分必要的
c++单元测试框架之gtest
c_shell_python的博客
10-30 1034
搞了3个礼拜的单元测试了，把最近所学所用的东西记录一下，顺便为公司接下来要做的单元测试培训做下背书。 首先什么是单元测试。 在面向对象编程中，通常一个类会承担一个单一的职责，所以我们可以用类来划分单元。单元测试，就是针对项目中的各个类进行测试。它侧重于发现单元内部的逻辑错误，属于白盒测试的范畴。 单元测试强调以下几点： 语句覆盖：选择足够的测试数据，使得代码的每个语句都至少被执行一次。 ...
c-＞c++(四):gtest
最新发布
tyro_wzp的博客
08-05 243
gtest安装，TEST/TEST_F，断言宏，事件机制，程序退出/崩溃
C++单元测试框架
xunmeng2002的专栏
11-13 525
新写了一个简单的单元测试框架，测试用例抽象为TestCase对象，包含两个接口：bool exec_case();与void report_result(); 调用exec_case时，执行测试用例的单元测试函数（由具体的测试用例给出），将测试结果和相关信息记录下来； 调用report_result时，将测试结果与相关信息输出。 test_case.h #ifndef __h_te...
玩转Google开源C++单元测试框架Google Test系列.pdf
10-23
gtest除了基本的测试用例编写外，还支持断言、事件机制、参数化测试、死亡测试、运行参数以及如何深入解析gtest和打造自己的单元测试框架。这些高级特性扩展了gtest的功能，使得开发者可以更加方便地编写测试用例，...
玩转Google开源C++单元测试框架
weixin_42488011的博客
04-29 490
玩转Google开源C++单元测试框架Google Test系列(gtest)(总) 前段时间学习和了解了下Google的开源C++单元测试框架Google Test，简称gtest，非常的不错。 我们原来使用的是自己实现的一套单元测试框架，在使用过程中，发现越来越多使用不便之处，而这样不便之处，gtest恰恰很好的解决了。 其实gtest本身的实现并不复杂，我们完全可以模仿gtest，不断的完善我们的测试框架， 但最后我们还是决定使用gtest取代掉原来的自己的测试框架，原因是： 1.不断完善我们的测试框
玩转Google开源C++单元测试框架Google Test系列1
08-08
《玩转Google开源C++单元测试框架Google Test系列1》 单元测试是软件开发过程中的重要环节，它能确保代码的正确性和稳定性。Google Test（gtest）是一个强大的、开源的C++测试框架，旨在简化和优化C++代码的单元...
Google开源C++单元测试框架gTest 7：深入探索gTest
xi_gua_gua的博客
02-25 533
一、前言 “深入解析”对我来说的确有些难度，所以我尽量将我学习到和观察到的gtest内部实现介绍给大家。本文算是抛砖引玉吧，只能是对gtest的整体结构的一些介绍，想要了解更多细节最好的办法还是看gtest源码，如果你看过gtest源码，你会发现里面的注释非常的详细！好了，下面就开始了解gtest吧。 二、从TEST宏开始 前面的文章已经介绍过TEST宏的用法了，通过TEST
CppUTest-基于C++的自动化单元测试框架
12-28
CPPUTest 虽然名称上看起来是 C++ 的单元测试框架, 其实它也是支持测试 C 代码的.(由于CSDN必须2分，实在抱歉)，安装方法：解压后，进入到目录中：./configure make make install即可
gtest测试框架
08-14
研究学习gtest的框架
GTest测试框架，c/c++
01-27
GTest测试框架是一个短小精湛的c/c++测试框架
GTest测试框架入门教程
05-14
Google公司写的开源测试框架，基于C++语言，很实用的入门教程！
C++单元测试gtest入门
我的博客
12-18 347
C++单元测试gtest入门
c++ 测试框架gtest的入门
m0_37847176的博客
09-20 1988
第一次接触和使用c++的测试框架，在这里记录一下 参考资料 http://www.cnblogs.com/coderzh/archive/2009/04/06/1426755.html 打算试试google test,简称gtest,首先需要下载这个源码，是开源的 https://github.com/google/googletest/tree/release-1.7.0 我下这个版本的 需要...
Google C++单元测试框架---Gtest框架简介（译文）
huatian5的博客
08-13 579
地址：https://www.cnblogs.com/jycboy/p/6057677.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值