Undo（Redo）撤销和重做代码的最后测试文件（相当于文档）

最新推荐文章于 2024-04-22 01:06:58 发布
pandaxcl
最新推荐文章于 2024-04-22 01:06:58 发布
阅读量1.9k
点赞数 1
分类专栏： C++基础软件架构文章标签：测试文档 string email blog qq
本文链接：https://blog.csdn.net/pandaxcl/article/details/1471571
版权
软件架构同时被 2 个专栏收录
26 篇文章 2 订阅
订阅专栏
C++基础
11 篇文章 2 订阅
订阅专栏
本文是之前写过的撤销和重做库的一份比较完整的测试文档，可以当作文档来使用，不过不知道应该如何在这个博客里面链接完整代码，所以需要代码的朋友可以到 CSDN的下载频道去下载(pandaxcl.rar)，或者来邮件索取，如果您使用了我的代码，请麻烦通知一声，我会非常欣慰的:)

#include <iostream>
#include <string>
#include "test.h"
#include "undo/command.h"
#include "undo/center.h"
using namespace pandaxcl;
//namespace Test_N{
//  void run()
//  {
//      XCL_TEST_BEGIN()
//      //在这里添加你的测试代码
//      XCL_TEST_END()
//  }
//}//namespace Test_N{
enum ID{
    PANDAXCL,
    QQ,
    BLOG,
    EMAIL,
    EMAIL1
};
namespace Test1{//基本命令的撤销和重做测试
    void run()
    {
        XCL_TEST_BEGIN()
        //在这里添加你的测试代码
        typedef undo::container<ID,std::string> CT;
        CT c;
        undo::create<CT> createPandaxcl(c,PANDAXCL,std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 在执行其它的命令之前必须保证这个对象已经存在
        createPandaxcl.execute(true);
        // 如果上面的命令不执行的话，后面的对这个对象的修改和移除操作都会失败
        // 调用了上面的create命令后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        // 尝试create命令的撤销
        createPandaxcl.execute(false);// 调用create命令的撤销操作
        // 调用了上面的create命令的撤销命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 尝试create命令的重做操作
        createPandaxcl.execute(true);// 调用create命令的重做操作
        // 调用了上面的create命令的撤销命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));

        // 现在来尝试一下modify命令,特别注意：使用modify和remove命令的时候
        // 必须保证相应的对象已经存在了，否则结果就是未知的:)
        // 下面的这个修改命令将ID为PANDAXCL的对象修改为大写形式
        undo::modify<CT> modifyPandaxcl(c,PANDAXCL,std::string("PANDAXCL"));
        // 调用modify的执行操作（又称重做操作）
        modifyPandaxcl.execute(true);// 参数为true表示执行操作
        // 调用了上面的modify命令的执行命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_NOT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        // 调用modify的撤销操作
        modifyPandaxcl.execute(false);// 参数为false表示撤销操作
        // 调用了上面的modify命令的执行命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_NOT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        // 调用modify的重做操作（又称执行操作）
        modifyPandaxcl.execute(true);// 参数为true表示执行操作
        // 调用了上面的modify命令的重做命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_NOT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        // 再次调用modify的撤销操作
        modifyPandaxcl.execute(false);// 参数为false表示撤销操作
        // 调用了上面的modify命令的执行命令之后可以进行检查了
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_NOT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));

        // 下面来尝试一下remove操作，同modify操作一样，执行remove操作的时候必须
        // 保证指定ID的对象已经存在了!
        // 下面的这个remove删除ID为PANDAXCL的对象
        undo::remove<CT> removePandaxcl(c,PANDAXCL);
        // 调用remove命令的执行操作
        removePandaxcl.execute(true);
        // 调用remove命令的执行操作之后来核实一下我们想要的结果
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 调用remove命令的撤销操作
        removePandaxcl.execute(false);
        // 调用remove命令的撤销操作之后来核实一下我们想要的结果
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_NOT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        // 同样你也可以对一个命令执行很多次，但是需要特别注意上面的几个顺序问题
        // 1. create命令可以在对象不存在的时候创建，但是不能创建相同ID的对象两
        //      次及其以上
        // 2. modify命令必须在指定ID存在的时候进行操作，否则程序运行意义未知
        // 3. remove命令必须在指定ID存在的时候进行操作，否则程序运行意义未知
        // 为了对上面的三种情况进行保证，才出现了undo里面的其它的几个模版类
        XCL_TEST_END()
    }
}//namespace Test1{
namespace Test2{
    void run()
    {
        XCL_TEST_BEGIN()
        //在这里添加你的测试代码
        typedef undo::container<ID,std::string> CT;
        CT c;
        // 这里进行macro命令的测试
        undo::macro queue;// 特别注意macro并不是模版类
        // 首先让这个macro类记录多个（4个）命令，可以是三个基本的命令，也可以是macro命令
        // 特别注意这里的命令都必须是通过new操作符得到的对象，否则结果未知
        queue.record(new undo::create<CT>(c,PANDAXCL,std::string("熊春雷")));
        queue.record(new undo::create<CT>(c,QQ,std::string("56637059")));
        queue.record(new undo::create<CT>(c,BLOG,std::string("http://blog.csdn.net/pandaxcl")));
        queue.record(new undo::create<CT>(c,EMAIL,std::string("pandaxcl@163.com")));
        // 先检查初始状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 执行这个macro命令的执行操作，具体意义视其记录的命令而定
        queue.execute(true);// true表示执行操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        // 执行这个macro命令的撤销操作，具体意义视其记录的命令而定
        queue.execute(false);// false表示撤销操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 执行这个macro命令的重做操作，具体意义视其记录的命令而定
        queue.execute(true);// true表示重做操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 其实macro命令里面可以使用create，modify，remove和macro一共4种子命令
        // 为了测试，先把queue这个macro命令里面记录的所有子命令删除
        queue.free();
        // 重新记录新的命令
        queue.record(new undo::modify<CT>(c,PANDAXCL,std::string("PANDAXCL")));
        queue.record(new undo::remove<CT>(c,QQ));
        // 为了在macro里面记录子macro命令，需要额外声明一个变量
        // 假想第一次创建了一个错误的电子邮箱地址然后再进行修改的过程
        undo::macro * childqueue = new undo::macro();
        childqueue->record(new undo::create<CT>(c,EMAIL1,std::string("pandaxcl@163.com")));
        childqueue->record(new undo::modify<CT>(c,EMAIL1,std::string("pandaxcl2000@163.com")));
        // 最后在父macro命令里面记录这个子macro命令，注意：这个子macro命令也是new出来的
        queue.record(childqueue);
        // 执行这个重新记录的macro命令的执行操作，具体意义视其记录的命令而定
        queue.execute(true);// true表示执行操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        //XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL1),std::string("pandaxcl2000@163.com"));
        // 执行这个macro命令的撤销操作，具体意义视其记录的命令而定
        queue.execute(false);// false表示撤销操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        // 执行这个macro命令的重做操作，具体意义视其记录的命令而定
        queue.execute(true);// true表示重做操作
        // 检查状态
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("PANDAXCL"));
        //XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL1),std::string("pandaxcl2000@163.com"));

        XCL_TEST_END()
    }
}//namespace Test2{
namespace Test3{
    void run()
    {
        XCL_TEST_BEGIN()
        //在这里添加你的测试代码
        typedef undo::container<ID,std::string> CT;
        CT c;// 注意这里的容器类仍然是和撤销和重做概念是分离的，实际应用的过程可能是整合
             // 在一起的，命令中心对象和容器对象是同一个对象，通过多重派生得到
        // 在上面的代码中没有涉及到和一般的应用程序相关的类似概念，那么center模版类的出现这是
        // 给出了这个非常近似的概念
        undo::center cc;// 和容器类的名称都及其类似，当然可以整合了，这里不这样做
        // 下面用center命令中心的观点来重新实现上面的功能
        // 注意center对象的record已经不可以直接使用了，为的就是下面的这个概念：
        // 每一个操作都是立即执行的，这和一般的应用程序里面的操作概念非常类似
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);

        cc.execute(new undo::create<CT>(c,PANDAXCL,std::string("熊春雷")));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));

        cc.execute(new undo::create<CT>(c,QQ,std::string("56637059")));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),2);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));

        cc.execute(new undo::create<CT>(c,BLOG,std::string("http://blog.csdn.net/pandaxcl")));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),3);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));

        cc.execute(new undo::create<CT>(c,EMAIL,std::string("pandaxcl@163.com")));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 撤销一步操作
        cc.undo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),3);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        // 重做一步操作
        cc.redo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 撤销多步操作
        cc.undo(3);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        // 重做多步操作
        cc.redo(3);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        //撤销多步操作（如果撤销的步骤数量比实际的可撤销数量多，多余的部分没有任何效果）
        cc.undo(100);// 注意这里的实际可撤销步骤只有4步
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 重做多步操作
        cc.redo(200);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 撤销多步操作
        cc.undo(3);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        // 重做操作的步骤数量和先前撤销操作的数量不等
        cc.redo(1);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),2);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        // 再次全部撤销
        cc.undo(100);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 再次全部重做
        cc.redo(100);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 当出现连续进行撤销操作的时候
        cc.undo(1);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),3);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        cc.undo(1);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),2);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        cc.undo(1);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),1);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        cc.redo(3);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));

        // 当出现进行撤销操作的时候又开始了新命令的时候，就会把先前已经存在的已
        // 经撤销过的可重做操作清除也就是说这里存在一个不可撤销过程，实际上相当
        // 于我们做事的时候，刚开始做错了，恢复原始状态之后马上进行重新选择的过
        // 程，当然不需要记录之前我们做错过的事情:(
        cc.undo(2);
        XCL_ASSERT_EQUAL_DETAIL(c.size(),2);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        // 这个时候又开始了一个新的命令
        cc.execute(new undo::create<CT>(c,EMAIL1,std::string("pandaxcl2000@163.com")));
        XCL_ASSERT_EQUAL_DETAIL(c.size(),3);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL1),std::string("pandaxcl2000@163.com"));
        // 在这种情况下考虑重做的过程
        cc.redo(100);// 实际上什么也没有做，因为之前缓存的可重做队列被清空了:(
        XCL_ASSERT_EQUAL_DETAIL(c.size(),3);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL1),std::string("pandaxcl2000@163.com"));

        XCL_TEST_END()
    }
}//namespace Test3{
namespace Test4{
    void run()
    {
        XCL_TEST_BEGIN()
        //在这里添加你的测试代码
        typedef undo::container<ID,std::string> CT;
        CT c;// 容器对象，每个对象必须放在一个同类型的容器中
        undo::center cc;// 命令中心

        // 现在来考虑一下之前考虑过的macro命令在center中是如何表示的
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        cc.record();
        cc.execute(new undo::create<CT>(c,PANDAXCL,std::string("熊春雷")));
        cc.execute(new undo::create<CT>(c,EMAIL,std::string("pandaxcl@163.com")));
        cc.execute(new undo::create<CT>(c,QQ,std::string("56637059")));
        cc.execute(new undo::create<CT>(c,BLOG,std::string("http://blog.csdn.net/pandaxcl")));
        cc.stop();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        // 撤销一步，实际上就是把上面的三个子命令组成的一个macro命令撤销了
        cc.undo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 重做一步，实际上就是把上面的三个子命令组成的一个macro命令重做了
        cc.redo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));

        // 上面的记录过程其实还可以嵌套子记录过程，相当于前面的例子中的子macro命令一样
        cc.record();
        cc.stop();
        XCL_TEST_END()
    }
}//namespace Test4{
namespace Test5{
    void run()
    {
        XCL_TEST_BEGIN()
        //在这里添加你的测试代码
        typedef undo::container<ID,std::string> CT;
        CT c;// 容器对象，每个对象必须放在一个同类型的容器中
        undo::center cc;// 命令中心

        // 现在来考虑一下之前考虑过的macro命令在center中是如何表示的
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        cc.record();
        {
            cc.execute(new undo::create<CT>(c,PANDAXCL,std::string("熊春雷")));
            // 上面的记录过程其实还可以嵌套子记录过程，相当于前面的例子中的子macro命令一样
            cc.record();
            {
                cc.execute(new undo::create<CT>(c,EMAIL,std::string("pandaxcl@163.com")));
                cc.record();
                {
                    cc.execute(new undo::create<CT>(c,QQ,std::string("56637059")));
                    cc.execute(new undo::create<CT>(c,BLOG,std::string("http://blog.csdn.net/pandaxcl")));
                }
                cc.stop();
            }
            cc.stop();
        }
        cc.stop();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));
        // 撤销一步，实际上就是把上面的三个子命令组成的一个macro命令撤销了
        cc.undo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),0);
        // 重做一步，实际上就是把上面的三个子命令组成的一个macro命令重做了
        cc.redo();
        XCL_ASSERT_EQUAL_DETAIL(c.size(),4);
        XCL_ASSERT_EQUAL_DETAIL(c.ref(PANDAXCL),std::string("熊春雷"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(EMAIL),std::string("pandaxcl@163.com"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(QQ),std::string("56637059"));
        XCL_ASSERT_EQUAL_DETAIL(c.ref(BLOG),std::string("http://blog.csdn.net/pandaxcl"));

        // 由上述测试可以看出，只要center的record函数和stop函数是配对的那么就可以无限制的
        // 进行嵌套！当然，如果一个macro命令只有一个子命令的话就没有必要啦:)
        // 注意加深嵌套层级就意味着性能损失，虽然它数量少的时候微不足道，但是一旦数量庞大
        // 之后就很明显啦:)
        XCL_TEST_END()
    }
}//namespace Test5{
int main()
{
    Test1::run();
    Test2::run();
    Test3::run();
    Test4::run();
    Test5::run();
    XCL_TEST_REPORT();
    return 0;
}

// 运行结果
[1]......................
[2]...........................
[3].........................................................................
[4]............
[5]............
Test ITEM    total:[5]
Test SUBITEM total:[146]
Test Success      :[146]
Test failed       :[0]
Test pass rate    :[100%]
pandaxcl
关注
1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Undo（Redo）撤销和重做代码的最后测试文件（相当于文档）

本文是之前写过的撤销和重做库的一份比较完整的测试文档，可以当作文档来使用，不过不知道应该如何在这个博客里面链接完整代码，所以需要代码的朋友可以到 CSDN的下载频道去下载(pandaxcl.rar)，或者来邮件索取，如果您使用了我的代码，请麻烦通知一声，我会非常欣慰的:) #include #include #include "test.h"#include "undo/command.h
复制链接

扫一扫
专栏目录