Skip to content

Commit 37f0d8d

Browse files
Asmod4nAsmod4n
committed
add fast symbol packing and unpacking
1 parent d855692 commit 37f0d8d

File tree

3 files changed

+206
-72
lines changed

3 files changed

+206
-72
lines changed

‎src/mrb_msgpack.cpp‎

Lines changed: 130 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
// mruby-simplemsgpack C++ packer wrapper (msgpack::packer + msgpack::sbuffer)
21
#define MSGPACK_NO_BOOST
32
#define MSGPACK_DEFAULT_API_VERSION 3
43
#include <msgpack.hpp>
@@ -68,6 +67,37 @@ static inline void mrb_msgpack_pack_string_value(mrb_state *mrb, mrb_value self,
6867
}
6968
}
7069

70+
#ifdef MRB_MSGPACK_SYMBOLS
71+
72+
#ifndef MRB_MSGPACK_SYMBOLS_EXT
73+
#define MRB_MSGPACK_SYMBOLS_EXT 1
74+
#endif
75+
76+
template <typename Packer>
77+
static inline void
78+
mrb_msgpack_pack_symbol_value(mrb_state* mrb, mrb_value self, Packer& pk)
79+
{
80+
mrb_sym sym = mrb_symbol(self);
81+
82+
#ifdef MRB_MSGPACK_SYMBOLS_AS_INT
83+
// Pack the raw mrb_sym value as the ext body
84+
pk.pack_ext(sizeof(sym), static_cast<int8_t>(MRB_MSGPACK_SYMBOLS_EXT));
85+
pk.pack_ext_body(reinterpret_cast<const char*>(&sym), sizeof(sym));
86+
87+
#else
88+
// Pack the symbol’s name as the ext body, using mrb_sym_name_len
89+
mrb_int len;
90+
const char* name = mrb_sym_name_len(mrb, sym, &len);
91+
92+
pk.pack_ext(static_cast<uint32_t>(len),
93+
static_cast<int8_t>(MRB_MSGPACK_SYMBOLS_EXT));
94+
pk.pack_ext_body(name, static_cast<size_t>(len));
95+
96+
#endif
97+
}
98+
99+
#endif // MRB_MSGPACK_SYMBOLS
100+
71101
template <typename Packer>
72102
static void mrb_msgpack_pack_array_value(mrb_state* mrb, mrb_value self, Packer& pk) {
73103
mrb_int n = RARRAY_LEN(self);
@@ -197,6 +227,11 @@ static void mrb_msgpack_pack_value(mrb_state* mrb, mrb_value self, Packer& pk) {
197227
case MRB_TT_STRING:
198228
mrb_msgpack_pack_string_value(mrb, self, pk);
199229
break;
230+
#ifdef MRB_MSGPACK_SYMBOLS
231+
case MRB_TT_SYMBOL:
232+
mrb_msgpack_pack_symbol_value(mrb, self, pk);
233+
break;
234+
#endif
200235
default: {
201236
if (mrb_msgpack_pack_ext_value(mrb, self, pk)) break;
202237

@@ -250,6 +285,27 @@ mrb_msgpack_pack_string(mrb_state* mrb, mrb_value self) {
250285
return mrb_nil_value();
251286
}
252287

288+
#ifdef MRB_MSGPACK_SYMBOLS
289+
290+
static mrb_value
291+
mrb_msgpack_pack_symbol(mrb_state* mrb, mrb_value self) {
292+
try {
293+
msgpack::sbuffer sbuf;
294+
msgpack::packer<msgpack::sbuffer> pk(&sbuf);
295+
mrb_msgpack_pack_symbol_value(mrb, self, pk);
296+
return mrb_str_new(mrb, sbuf.data(), sbuf.size());
297+
} catch (const std::bad_alloc&) {
298+
mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
299+
} catch (const std::exception& e) {
300+
mrb_raisef(mrb, E_MSGPACK_ERROR,
301+
"cannot pack symbol: %S",
302+
mrb_str_new_cstr(mrb, e.what()));
303+
}
304+
return mrb_nil_value();
305+
}
306+
307+
#endif // MRB_MSGPACK_SYMBOLS
308+
253309
static mrb_value
254310
mrb_msgpack_pack_array(mrb_state* mrb, mrb_value self) {
255311
try {
@@ -420,6 +476,13 @@ mrb_msgpack_register_pack_type(mrb_state* mrb, mrb_value self)
420476
mrb_raise(mrb, E_TYPE_ERROR, "not a block");
421477
}
422478

479+
#ifdef MRB_MSGPACK_SYMBOLS
480+
// Prevent registering ext packers for Symbol when built-in symbol packing is enabled
481+
if (mrb_class_ptr(mrb_class) == mrb->symbol_class) {
482+
mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot register ext packer for Symbol when MRB_MSGPACK_SYMBOLS is enabled");
483+
}
484+
#endif
485+
423486
ext_packers = mrb_const_get(mrb, self, MRB_SYM(_ExtPackers));
424487
ext_config = mrb_hash_new_capa(mrb, 2);
425488
mrb_hash_set(mrb, ext_config, mrb_symbol_value(MRB_SYM(type)), mrb_int_value(mrb, type));
@@ -476,7 +539,25 @@ mrb_unpack_msgpack_obj(mrb_state* mrb, const msgpack::object& obj)
476539
return mrb_unpack_msgpack_obj_map(mrb, obj);
477540
case msgpack::type::EXT: {
478541
auto ext_type = obj.via.ext.type();
479-
542+
#ifdef MRB_MSGPACK_SYMBOLS
543+
if (ext_type == MRB_MSGPACK_SYMBOLS_EXT) {
544+
# ifdef MRB_MSGPACK_SYMBOLS_AS_INT
545+
// Body is a raw mrb_sym
546+
if (unlikely(obj.via.ext.size != sizeof(mrb_sym))) {
547+
mrb_raise(mrb, E_MSGPACK_ERROR, "invalid symbol ext body size");
548+
}
549+
mrb_sym sym;
550+
std::memcpy(&sym, obj.via.ext.data(), sizeof(sym));
551+
return mrb_symbol_value(sym);
552+
# else
553+
// Body is the UTF‑8 symbol name
554+
return mrb_symbol_value(
555+
mrb_intern(mrb,
556+
obj.via.ext.data(),
557+
(size_t)obj.via.ext.size));
558+
# endif
559+
}
560+
#endif // MRB_MSGPACK_SYMBOLS
480561
mrb_value unpacker = mrb_hash_get(mrb,
481562
mrb_const_get(mrb, mrb_obj_value(mrb_module_get_id(mrb, MRB_SYM(MessagePack))), MRB_SYM(_ExtUnpackers)),
482563
mrb_int_value(mrb, ext_type));
@@ -733,6 +814,14 @@ mrb_msgpack_register_unpack_type(mrb_state* mrb, mrb_value self)
733814
mrb_raise(mrb, E_TYPE_ERROR, "not a block");
734815
}
735816

817+
#ifdef MRB_MSGPACK_SYMBOLS
818+
/* Prevent registering an unpacker for the reserved symbol ext type */
819+
if (type == MRB_MSGPACK_SYMBOLS_EXT) {
820+
mrb_raise(mrb, E_ARGUMENT_ERROR,
821+
"cannot register unpacker for Symbol ext type when MRB_MSGPACK_SYMBOLS is enabled");
822+
}
823+
#endif
824+
736825
mrb_hash_set(mrb, mrb_const_get(mrb, self, MRB_SYM(_ExtUnpackers)), mrb_int_value(mrb, type), block);
737826

738827
return mrb_nil_value();
@@ -751,40 +840,45 @@ MRB_BEGIN_DECL
751840
void
752841
mrb_mruby_simplemsgpack_gem_init(mrb_state* mrb)
753842
{
754-
struct RClass* msgpack_mod, *mrb_object_handle_class;
843+
struct RClass *msgpack_mod, *mrb_object_handle_class;
755844

756-
mrb_define_method(mrb, mrb->object_class, "to_msgpack", mrb_msgpack_pack_object, MRB_ARGS_NONE());
757-
mrb_define_method(mrb, mrb->string_class, "to_msgpack", mrb_msgpack_pack_string, MRB_ARGS_NONE());
758-
mrb_define_method(mrb, mrb->array_class, "to_msgpack", mrb_msgpack_pack_array, MRB_ARGS_NONE());
759-
mrb_define_method(mrb, mrb->hash_class, "to_msgpack", mrb_msgpack_pack_hash, MRB_ARGS_NONE());
845+
mrb_define_method_id(mrb, mrb->object_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_object, MRB_ARGS_NONE());
846+
mrb_define_method_id(mrb, mrb->string_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_string, MRB_ARGS_NONE());
847+
#ifdef MRB_MSGPACK_SYMBOLS
848+
mrb_define_method_id(mrb, mrb->symbol_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_symbol, MRB_ARGS_NONE());
849+
#endif
850+
mrb_define_method_id(mrb, mrb->array_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_array, MRB_ARGS_NONE());
851+
mrb_define_method_id(mrb, mrb->hash_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_hash, MRB_ARGS_NONE());
760852
#ifndef MRB_WITHOUT_FLOAT
761-
mrb_define_method(mrb, mrb->float_class, "to_msgpack", mrb_msgpack_pack_float, MRB_ARGS_NONE());
853+
mrb_define_method_id(mrb, mrb->float_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_float, MRB_ARGS_NONE());
762854
#endif
763-
mrb_define_method(mrb, mrb->integer_class, "to_msgpack", mrb_msgpack_pack_integer, MRB_ARGS_NONE());
764-
mrb_define_method(mrb, mrb->true_class, "to_msgpack", mrb_msgpack_pack_true, MRB_ARGS_NONE());
765-
mrb_define_method(mrb, mrb->false_class, "to_msgpack", mrb_msgpack_pack_false, MRB_ARGS_NONE());
766-
mrb_define_method(mrb, mrb->nil_class, "to_msgpack", mrb_msgpack_pack_nil, MRB_ARGS_NONE());
767-
msgpack_mod = mrb_define_module(mrb, "MessagePack");
768-
mrb_define_class_under(mrb, msgpack_mod, "Error", E_RUNTIME_ERROR);
769-
mrb_object_handle_class = mrb_define_class_under(mrb, msgpack_mod, "ObjectHandle", mrb->object_class);
770-
MRB_SET_INSTANCE_TT(mrb_object_handle_class, MRB_TT_DATA);
771-
mrb_define_method(mrb, mrb_object_handle_class, "initialize", mrb_msgpack_object_handle_new, MRB_ARGS_REQ(1));
772-
mrb_define_method(mrb, mrb_object_handle_class, "value", mrb_msgpack_object_handle_value, MRB_ARGS_NONE());
773-
mrb_define_method(mrb, mrb_object_handle_class, "at_pointer", mrb_msgpack_object_handle_at_pointer, MRB_ARGS_REQ(1));
774-
775-
776-
mrb_define_const(mrb, msgpack_mod, "LibMsgPackCVersion", mrb_str_new_lit(mrb, MSGPACK_VERSION));
777-
mrb_define_const(mrb, msgpack_mod, "_ExtPackers", mrb_hash_new(mrb));
778-
mrb_define_const(mrb, msgpack_mod, "_ExtUnpackers", mrb_hash_new(mrb));
779-
780-
mrb_define_module_function(mrb, msgpack_mod, "pack", mrb_msgpack_pack_m, MRB_ARGS_REQ(1));
781-
mrb_define_module_function(mrb, msgpack_mod, "register_pack_type", mrb_msgpack_register_pack_type, (MRB_ARGS_REQ(2)|MRB_ARGS_BLOCK()));
782-
mrb_define_module_function(mrb, msgpack_mod, "ext_packer_registered?", mrb_msgpack_ext_packer_registered, MRB_ARGS_REQ(1));
783-
mrb_define_module_function(mrb, msgpack_mod, "unpack", mrb_msgpack_unpack_m, (MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK()));
784-
mrb_define_module_function(mrb, msgpack_mod, "unpack_lazy", mrb_msgpack_unpack_lazy_m, (MRB_ARGS_REQ(1)));
785-
mrb_define_module_function(mrb, msgpack_mod, "register_unpack_type", mrb_msgpack_register_unpack_type, (MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK()));
786-
mrb_define_module_function(mrb, msgpack_mod, "ext_unpacker_registered?", mrb_msgpack_ext_unpacker_registered, MRB_ARGS_REQ(1));
787-
}
788-
789-
void mrb_mruby_simplemsgpack_gem_final(mrb_state* mrb) {}
790-
MRB_END_DECL
855+
mrb_define_method_id(mrb, mrb->integer_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_integer, MRB_ARGS_NONE());
856+
mrb_define_method_id(mrb, mrb->true_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_true, MRB_ARGS_NONE());
857+
mrb_define_method_id(mrb, mrb->false_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_false, MRB_ARGS_NONE());
858+
mrb_define_method_id(mrb, mrb->nil_class, MRB_SYM(to_msgpack), mrb_msgpack_pack_nil, MRB_ARGS_NONE());
859+
860+
msgpack_mod = mrb_define_module_id(mrb, MRB_SYM(MessagePack));
861+
mrb_define_class_under_id(mrb, msgpack_mod, MRB_SYM(Error), E_RUNTIME_ERROR);
862+
863+
mrb_object_handle_class = mrb_define_class_under_id(mrb, msgpack_mod, MRB_SYM(ObjectHandle), mrb->object_class);
864+
MRB_SET_INSTANCE_TT(mrb_object_handle_class, MRB_TT_DATA);
865+
mrb_define_method_id(mrb, mrb_object_handle_class, MRB_SYM(initialize), mrb_msgpack_object_handle_new, MRB_ARGS_REQ(1));
866+
mrb_define_method_id(mrb, mrb_object_handle_class, MRB_SYM(value), mrb_msgpack_object_handle_value, MRB_ARGS_NONE());
867+
mrb_define_method_id(mrb, mrb_object_handle_class, MRB_SYM(at_pointer), mrb_msgpack_object_handle_at_pointer, MRB_ARGS_REQ(1));
868+
869+
mrb_define_const_id(mrb, msgpack_mod, MRB_SYM(LibMsgPackCVersion), mrb_str_new_lit(mrb, MSGPACK_VERSION));
870+
mrb_define_const_id(mrb, msgpack_mod, MRB_SYM(_ExtPackers), mrb_hash_new(mrb));
871+
mrb_define_const_id(mrb, msgpack_mod, MRB_SYM(_ExtUnpackers), mrb_hash_new(mrb));
872+
873+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM(pack), mrb_msgpack_pack_m, MRB_ARGS_REQ(1));
874+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM(register_pack_type), mrb_msgpack_register_pack_type, (MRB_ARGS_REQ(2)|MRB_ARGS_BLOCK()));
875+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM_Q(ext_packer_registered), mrb_msgpack_ext_packer_registered, MRB_ARGS_REQ(1));
876+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM(unpack), mrb_msgpack_unpack_m, (MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK()));
877+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM(unpack_lazy), mrb_msgpack_unpack_lazy_m, MRB_ARGS_REQ(1));
878+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM(register_unpack_type), mrb_msgpack_register_unpack_type, (MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK()));
879+
mrb_define_module_function_id(mrb, msgpack_mod, MRB_SYM_Q(ext_unpacker_registered), mrb_msgpack_ext_unpacker_registered, MRB_ARGS_REQ(1));
880+
}
881+
882+
void
883+
mrb_mruby_simplemsgpack_gem_final(mrb_state* mrb) {}
884+
MRB_END_DECL

‎test/msgpack.c‎

Lines changed: 48 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
#include <mruby.h>
12
#include <mruby/msgpack.h>
23
#include <limits.h>
34

@@ -12,25 +13,61 @@ mrb_msgpack_test_unpack(mrb_state *mrb, mrb_value self)
1213
{
1314
mrb_value hallo;
1415
mrb_get_args(mrb, "S", &hallo);
15-
1616
return mrb_msgpack_unpack(mrb, hallo);
1717
}
1818

1919
void
2020
mrb_mruby_simplemsgpack_gem_test(mrb_state *mrb)
2121
{
2222
struct RClass *msgpack_test = mrb_define_module(mrb, "MessagePackTest");
23-
mrb_define_module_function(mrb, msgpack_test, "test_pack", mrb_msgpack_test_pack, MRB_ARGS_NONE());
24-
mrb_define_module_function(mrb, msgpack_test, "test_unpack", mrb_msgpack_test_unpack, MRB_ARGS_REQ(1));
25-
mrb_define_const(mrb, msgpack_test, "FIXNUM_MAX", mrb_int_value(mrb, MRB_INT_MAX));
26-
mrb_define_const(mrb, msgpack_test, "FIXNUM_MIN", mrb_int_value(mrb, MRB_INT_MIN));
27-
#ifndef MRB_WITHOUT_FLOAT
28-
#ifdef MRB_USE_FLOAT
29-
mrb_define_const(mrb, msgpack_test, "FLOAT_MAX", mrb_float_value(mrb, FLT_MAX));
30-
mrb_define_const(mrb, msgpack_test, "FLOAT_MIN", mrb_float_value(mrb, FLT_MIN));
23+
24+
mrb_define_module_function(mrb, msgpack_test, "test_pack",
25+
mrb_msgpack_test_pack, MRB_ARGS_NONE());
26+
mrb_define_module_function(mrb, msgpack_test, "test_unpack",
27+
mrb_msgpack_test_unpack, MRB_ARGS_REQ(1));
28+
29+
mrb_define_const(mrb, msgpack_test, "FIXNUM_MAX",
30+
mrb_int_value(mrb, MRB_INT_MAX));
31+
mrb_define_const(mrb, msgpack_test, "FIXNUM_MIN",
32+
mrb_int_value(mrb, MRB_INT_MIN));
33+
34+
#ifdef MRB_MSGPACK_SYMBOLS
35+
#ifndef MRB_MSGPACK_SYMBOLS_EXT
36+
#define MRB_MSGPACK_SYMBOLS_EXT 1
37+
#endif
38+
mrb_define_const(mrb, msgpack_test,
39+
"SYMBOLS_ENABLED",
40+
mrb_true_value());
41+
mrb_define_const(mrb, msgpack_test,
42+
"SYMBOLS_EXT_TYPE",
43+
mrb_int_value(mrb, MRB_MSGPACK_SYMBOLS_EXT));
44+
45+
# ifdef MRB_MSGPACK_SYMBOLS_AS_INT
46+
mrb_define_const(mrb, msgpack_test,
47+
"SYMBOLS_MODE",
48+
mrb_str_new_lit(mrb, "int"));
49+
# else
50+
mrb_define_const(mrb, msgpack_test,
51+
"SYMBOLS_MODE",
52+
mrb_str_new_lit(mrb, "string"));
53+
# endif
3154
#else
32-
mrb_define_const(mrb, msgpack_test, "FLOAT_MAX", mrb_float_value(mrb, DBL_MAX));
33-
mrb_define_const(mrb, msgpack_test, "FLOAT_MIN", mrb_float_value(mrb, DBL_MIN));
55+
mrb_define_const(mrb, msgpack_test,
56+
"SYMBOLS_ENABLED",
57+
mrb_false_value());
3458
#endif
59+
60+
#ifndef MRB_WITHOUT_FLOAT
61+
# ifdef MRB_USE_FLOAT
62+
mrb_define_const(mrb, msgpack_test, "FLOAT_MAX",
63+
mrb_float_value(mrb, FLT_MAX));
64+
mrb_define_const(mrb, msgpack_test, "FLOAT_MIN",
65+
mrb_float_value(mrb, FLT_MIN));
66+
# else
67+
mrb_define_const(mrb, msgpack_test, "FLOAT_MAX",
68+
mrb_float_value(mrb, DBL_MAX));
69+
mrb_define_const(mrb, msgpack_test, "FLOAT_MIN",
70+
mrb_float_value(mrb, DBL_MIN));
71+
# endif
3572
#endif
3673
}

‎test/msgpack.rb‎

Lines changed: 28 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -35,9 +35,26 @@
3535
assert_equal("😎", MessagePack.unpack("😎".to_msgpack))
3636
end
3737

38-
assert("Symbol#to_msgpack") do
39-
assert_equal('symbol', MessagePack.unpack(:symbol.to_msgpack))
40-
assert_equal('symbol', MessagePack.unpack(MessagePack.pack(:symbol)))
38+
if MessagePackTest::SYMBOLS_ENABLED
39+
assert("Symbol#to_msgpack MRB_MSGPACK_SYMBOLS") do
40+
assert_equal(:symbol, MessagePack.unpack(:symbol.to_msgpack))
41+
assert_equal(:symbol, MessagePack.unpack(MessagePack.pack(:symbol)))
42+
end
43+
else
44+
assert("Symbol#to_msgpack") do
45+
assert_equal('symbol', MessagePack.unpack(:symbol.to_msgpack))
46+
assert_equal('symbol', MessagePack.unpack(MessagePack.pack(:symbol)))
47+
end
48+
49+
assert("Symbol#to_msgpack with registered ext type") do
50+
MessagePack.register_pack_type(0, Symbol) { |symbol| symbol.to_s }
51+
MessagePack.register_unpack_type(0) { |data| data.to_sym }
52+
assert_equal(:symbol, MessagePack.unpack(:symbol.to_msgpack))
53+
54+
hash = { key: 123, nested: [:array] }
55+
assert_equal(hash, MessagePack.unpack(hash.to_msgpack))
56+
assert_equal(hash, MessagePack.unpack(MessagePack.pack(hash)))
57+
end
4158
end
4259

4360
assert("Array#to_msgpack") do
@@ -98,20 +115,22 @@
98115
assert_equal(unpacked, [value1, value2, value3])
99116
end
100117

118+
class TestClassFoo; end
119+
101120
assert("MessagePack.register_pack_type") do
102121
assert_raise(RangeError, "ext type out of range") do
103-
MessagePack.register_pack_type(-1, Symbol)
122+
MessagePack.register_pack_type(-1, TestClassFoo)
104123
end
105124

106125
assert_raise(RangeError, "ext type out of range") do
107-
MessagePack.register_pack_type(128, Symbol)
126+
MessagePack.register_pack_type(128, TestClassFoo)
108127
end
109128

110129
assert_raise(ArgumentError, "no block given") do
111-
MessagePack.register_pack_type(1, Symbol)
130+
MessagePack.register_pack_type(127, TestClassFoo)
112131
end
113132

114-
assert_nil(MessagePack.register_pack_type(1, Symbol) {})
133+
assert_nil(MessagePack.register_pack_type(127, TestClassFoo) {})
115134
end
116135

117136
assert("MessagePack.register_unpack_type") do
@@ -124,20 +143,10 @@
124143
end
125144

126145
assert_raise(ArgumentError, "no block given") do
127-
MessagePack.register_unpack_type(1)
146+
MessagePack.register_unpack_type(127)
128147
end
129148

130-
assert_nil(MessagePack.register_unpack_type(1) {})
131-
end
132-
133-
assert("Symbol#to_msgpack with registered ext type") do
134-
MessagePack.register_pack_type(0, Symbol) { |symbol| symbol.to_s }
135-
MessagePack.register_unpack_type(0) { |data| data.to_sym }
136-
assert_equal(:symbol, MessagePack.unpack(:symbol.to_msgpack))
137-
138-
hash = { key: 123, nested: [:array] }
139-
assert_equal(hash, MessagePack.unpack(hash.to_msgpack))
140-
assert_equal(hash, MessagePack.unpack(MessagePack.pack(hash)))
149+
assert_nil(MessagePack.register_unpack_type(127) {})
141150
end
142151

143152
assert("Class#to_msgpack with registered ext type") do
@@ -152,12 +161,6 @@
152161
assert_equal(['item'], MessagePack.unpack(['item'].to_msgpack))
153162
end
154163

155-
assert("Unknown Ext Type raises a Exception when tried to unpack") do
156-
assert_raise(MessagePack::Error) do
157-
MessagePack.register_pack_type(50, Symbol) { |symbol| symbol.to_s }
158-
MessagePack.unpack(:hallo.to_msgpack)
159-
end
160-
end
161164

162165
assert("Extension types are inherited") do
163166
class Test

0 commit comments

Comments
 (0)