def testPackUTF32():
    test_data = [
        "", "abcd", ("defgh",), "Русский текст",
        ]
    for td in test_data:
        print(packs(td, encoding='utf-32'))
        re = unpacks(packs(td, encoding='utf-32'), encoding='utf-32')
        assert_equal(re, td)

def testPackUnicode():
    test_data = [
        u"", u"abcd", (u"defgh",), u"Русский текст",
        ]
    for td in test_data:
        re = unpacks(packs(td, encoding='utf-8'), encoding='utf-8')
        assert_equal(re, td)

def _check(obj):
    # NOTE:
    # msgpack.packs(obj) nad msgpack_pure.packs(obj) are not necessarily
    # match because there are some possible variations which type to use
    # for integer values (i.e. uint8/int16 for 0xFF).
    obj = _list_to_tuple(obj)
    
    assert msgpack_pure.unpacks(msgpack.packs(obj)) == obj
    assert msgpack.unpacks(msgpack_pure.packs(obj)) == obj
    assert msgpack_pure.unpacks(msgpack_pure.packs(obj)) == obj

def testPackUnicode():
    test_data = [
        "", "abcd", ("defgh",), "Русский текст",
        ]
    for td in test_data:
        re = unpacks(packs(td, encoding='utf-8'), encoding='utf-8')
        assert_equal(re, td)
        packer = Packer(encoding='utf-8')
        data = packer.pack(td)
        re = Unpacker(BytesIO(data), encoding='utf-8').unpack()
        assert_equal(re, td)

    def handle(self):
        unpacker = Unpacker()

        while 1:
            data = self.request.recv(4096)
            if len(data) == 0:
                break
            unpacker.feed(data)
            for msg in unpacker:
                print msg
                assert len(msg) == 4
                assert msg[0] == 0
                assert msg[2] == "echo"
                sdata = packs((1, msg[1], None, msg[-1]))
                self.request.sendall(sdata)

    def run(self):
        while True:
            # grab the next message
            message = self.queue.get(block=True)

            # we have a message to send, the heart beat
            # can take a break
            self.lastSentData = time.time()

            # msgpack it
            message = packs(message)

            # send the message
            success = self.transport.send(message)

            # tell the queue we are done
            self.queue.task_done()

            if (success):
                self.log("Message sent")
                self.dump(unpacks(message, use_list=True))
            else:
                self.error("Sending metrics to Graphdat failed")

def testStrictUnicodeUnpack():
    unpacks(packs('abc\xeddef'), encoding='utf-8')

def check(length, obj):
    v = packs(obj)
    assert_equal(len(v), length, "%r length should be %r but get %r" % (obj, length, len(v)))
    assert_equal(unpacks(v), obj)

def test_bad_hook():
    packed = packs([3, 1 + 2j], default=lambda o: o)
    unpacked = unpacks(packed)

def test_encode_hook():
    packed = packs([3, 1 + 2j], default=_encode_complex)
    unpacked = unpacks(packed)
    eq_(unpacked[1], {"__complex__": True, "real": 1, "imag": 2})

def test_decode_hook():
    packed = packs([3, {b'__complex__': True, b'real': 1, b'imag': 2}])
    unpacked = unpacks(packed, object_hook=_decode_complex)
    eq_(unpacked[1], 1+2j)

def testNoEncoding():
    packs(u"abc", encoding=None)

 def _send_response(self, msgid, error, result):
     print "Sending response: %r", ((msgid, error, result))
     msg = packs((1, msgid, error, result))
     self.request.sendall(msg)

def test_array_hook():
	packed = packs([1,2,3])
	cup = ArrayStrUnpacker()
	cup.feed(packed)
	unpacked = cup.unpack()
	eq_(unpacked, b'123')

def test_decode_hook():
	cup = ComplexUnpacker()
	packed = packs([3, {b'__complex__': True, b'real': 1, b'imag': 2}])
	cup.feed(packed)
	unpacked = cup.unpack()
	eq_(unpacked[1], 1+2j)

 def _send(self, msg, name, level=10):
     msg = {'msg': msg, 'name': name, 'id': 1, 'path': self.path,
         'time': time.time(), 'level': level}
     txtmsg = msgpack.packs(msg)
     self.logd.sendto(txtmsg, (self.host, self.port))

def testStrictUnicodePack():
    packs(u"abc\xeddef", encoding='ascii', unicode_errors='strict')

def testIgnoreErrorsPack():
    re = unpacks(
            packs(u"abcФФФdef", encoding='ascii', unicode_errors='ignore'),
            encoding='utf-8')
    assert_equal(re, u"abcdef")

def sendmsg(sock, to):
    id = uuid4().hex
    msg = {"id": id, "msg": "sending %s" % id}
    msgb = msgpack.packs(msg)
    return sock.sendto(msgb, to)

def testDecodeBinary():
    re = unpacks(packs(u"abc"), encoding=None)
    assert_equal(re, "abc")