root/lang/c/msgpack/trunk/cpp/test.cpp @ 18843

Revision 18843, 4.1 kB (checked in by frsyuki, 6 years ago)

lang/c/msgpack: C++ binding: changed calback function of packer from Stream& append(const char*, size_t) to SomeType? write(SomePointerType?, SomeSizeType?)

Line 
1#include <iostream>
2#include <string>
3//#include <msgpack/unpack.hpp>
4//#include <msgpack/pack.hpp>
5#include <msgpack.hpp>
6#include <sstream>
7#include <boost/scoped_ptr.hpp>
8
9class checker {
10public:
11        void check(const char* d, size_t len, msgpack::object should) {
12                using msgpack::object;
13                try {
14                        std::cout << "----" << std::endl;
15
16                        object o;
17                        try {
18                                o = msgpack::unpack(d, len, m_zone);
19                        } catch (std::runtime_error& e) {
20                                std::cout << should << std::endl;
21                                std::cout << "**" << e.what() << "**" << std::endl;
22                                return;
23                        }
24
25                        std::cout << o << std::endl;
26                        if(o != should) {
27                                std::cout << "** TEST FAILED **" << std::endl;
28                        }
29
30                        try {
31                                std::stringstream s;
32                                msgpack::pack(s, o);
33                                std::string str(s.str());
34                                object ro = msgpack::unpack(str.data(), str.size(), m_zone);
35                                if(ro != o) { throw std::runtime_error("NOT MATCH"); }
36                        } catch (std::runtime_error& e) {
37                                std::cout << "** REUNPACK FAILED **" << std::endl;
38                                std::cout << e.what() << std::endl;
39                        } catch (...) {
40                                std::cout << "** REUNPACK FAILED **" << std::endl;
41                                std::cout << "unknown error" << std::endl;
42                        }
43
44                } catch (...) { m_zone.clear(); throw; }
45                m_zone.clear();
46        }
47private:
48        msgpack::zone m_zone;
49};
50
51int main(void)
52{
53        checker c;
54
55        {  // SimpleValue
56                msgpack::zone z;
57                const char d[] = {
58                        0x93, 0xc0, 0xc2, 0xc3,
59                };
60                c.check(d, sizeof(d),
61                        z.narray(
62                                z.nnil(), z.nfalse(), z.ntrue()
63                        )
64                );
65        }
66
67        {  // Fixnum
68                msgpack::zone z;
69                const char d[] = {
70                        0x92,
71                                0x93, 0x00, 0x40, 0x7f,
72                                0x93, 0xe0, 0xf0, 0xff,
73                };
74                c.check(d, sizeof(d),
75                        z.narray(
76                                z.narray(
77                                        z.nu8(0),
78                                        z.nu8(64),
79                                        z.nu8(127)
80                                ),
81                                z.narray(
82                                        z.ni8(-32),
83                                        z.ni8(-16),
84                                        z.ni8(-1)
85                                )
86                        )
87                );
88        }
89
90        {  // FixArray
91                msgpack::zone z;
92                const char d[] = {
93                        0x92,
94                                0x90,
95                                0x91,
96                                        0x91, 0xc0,
97                };
98                c.check(d, sizeof(d),
99                        z.narray(
100                                z.narray(),
101                                z.narray(
102                                        z.narray(
103                                                z.nnil()
104                                        )
105                                )
106                        )
107                );
108        }
109
110        {  // FixRaw
111                msgpack::zone z;
112                const char d[] = {
113                        0x94,
114                                0xa0,
115                                0xa1, 'a',
116                                0xa2, 'b', 'c',
117                                0xa3, 'd', 'e', 'f',
118                };
119                c.check(d, sizeof(d),
120                        z.narray(
121                                z.nraw_ref("", 0),
122                                z.nraw_ref("a", 1),
123                                z.nraw_ref("bc", 2),
124                                z.nraw_ref("def", 3)
125                        )
126                );
127        }
128
129        static const uint16_t TASK_ARRAY = 100;
130        static char tarray[3];
131        static char traw[64];
132
133        {
134                memset(traw, 'a', sizeof(traw));
135                traw[0] = 0xda;
136                uint16_t n = htons(sizeof(traw)-3);
137                traw[1] = ((char*)&n)[0];
138                traw[2] = ((char*)&n)[1];
139
140                msgpack::zone z;
141                std::cout << msgpack::unpack(traw, sizeof(traw), z) << std::endl;;
142        }
143
144        {
145                tarray[0] = 0xdc;
146                uint16_t n = htons(TASK_ARRAY);
147                tarray[1] = ((char*)&n)[0];
148                tarray[2] = ((char*)&n)[1];
149        }
150
151        {
152                // write message
153                ssize_t total_bytes = 0;
154                std::stringstream stream;
155                for(unsigned q=0; q < 10; ++q) {
156                        stream.write(tarray, sizeof(tarray));
157                        total_bytes += sizeof(tarray);
158                        for(uint16_t i=0; i < TASK_ARRAY; ++i) {
159                                stream.write(traw, sizeof(traw));
160                                total_bytes += sizeof(traw);
161                        }
162                }
163
164                stream.seekg(0);
165
166                // reserive message
167                unsigned num_msg = 0;
168
169                static const size_t RESERVE_SIZE = 32;//*1024;
170
171                msgpack::unpacker upk;
172                while(stream.good() && total_bytes > 0) {
173
174                        // 1. reserve buffer
175                        upk.reserve_buffer(RESERVE_SIZE);
176
177                        // 2. read data to buffer() up to buffer_capacity() bytes
178                        size_t sz = stream.readsome(
179                                        (char*)upk.buffer(),
180                                        upk.buffer_capacity());
181
182                        total_bytes -= sz;
183                        std::cout << "read " << sz << " bytes to capacity "
184                                        << upk.buffer_capacity() << " bytes"
185                                        << std::endl;
186
187                        // 3. specify the number of  bytes actually copied
188                        upk.buffer_consumed(sz);
189
190                        // 4. repeat execute() until it returns false
191                        while( upk.execute() ) {
192                                std::cout << "message parsed" << std::endl;
193
194                                // 5.1. take out the parsed object
195                                msgpack::object o = upk.data();
196
197                                // 5.2. the parsed object is valid until the zone is deleted
198                                boost::scoped_ptr<msgpack::zone> pz(upk.release_zone());
199
200                                std::cout << o << std::endl;
201                                ++num_msg;
202
203                                // 5.3 re-initialize unpacker
204                                upk.reset();
205                        }
206
207                }
208
209                std::cout << "stream finished" << std::endl;
210                std::cout << num_msg << " messages reached" << std::endl;
211        }
212
213        return 0;
214}
215
Note: See TracBrowser for help on using the browser.