Beispiel #1
0
def test_pack_string():
    b = BytesIO()
    proto.write_val(b, TType.STRING, "hello world!")
    assert "00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21" == \
        hexlify(b.getvalue())

    b = BytesIO()
    proto.write_val(b, TType.STRING, u("你好世界"))
    assert "00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c" == \
        hexlify(b.getvalue())
Beispiel #2
0
def test_pack_string():
    b = BytesIO()
    proto.write_val(b, TType.STRING, "hello world!")
    assert_equal("00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21",
                 hexlify(b.getvalue()))

    b = BytesIO()
    proto.write_val(b, TType.STRING, u("你好世界"))
    assert_equal("00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c",
                 hexlify(b.getvalue()))
Beispiel #3
0
def test_pack_string():
    b, proto = gen_proto()
    proto.write_val(TType.STRING, "hello world!")
    assert "0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21" == \
           hexlify(b.getvalue())

    b1, proto1 = gen_proto()
    proto1.write_val(TType.STRING, "你好世界")
    assert "0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c" == \
           hexlify(b1.getvalue())
Beispiel #4
0
def test_write_string():
    b = TCyMemoryBuffer()
    proto.write_val(b, TType.STRING, "hello world!")
    b.flush()
    assert "00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21" == hexlify(b.getvalue())

    b = TCyMemoryBuffer()
    proto.write_val(b, TType.STRING, u("你好世界"))
    b.flush()
    assert "00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c" == hexlify(b.getvalue())
Beispiel #5
0
def test_write_string():
    b = TCyMemoryBuffer()
    proto.write_val(b, TType.STRING, "hello world!")
    b.flush()
    assert "00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21" == \
        hexlify(b.getvalue())

    b = TCyMemoryBuffer()
    proto.write_val(b, TType.STRING, u("你好世界"))
    b.flush()
    assert "00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c" == \
        hexlify(b.getvalue())
Beispiel #6
0
def test_pack_container_bool():
    b, proto = gen_proto()
    proto.write_val(TType.LIST, [True, False, True], TType.BOOL)
    assert "31 01 02 01" == hexlify(b.getvalue())

    b, proto = gen_proto()
    proto.write_val(TType.MAP, {"a": True}, (TType.STRING, TType.BOOL))
    assert "01 81 01 61 01" == hexlify(b.getvalue())

    b, proto = gen_proto()
    proto.write_val(TType.MAP, {"a": [True, False]},
                    (TType.STRING, (TType.LIST, TType.BOOL)))
    assert "01 89 01 61 21 01 02" == hexlify(b.getvalue())
Beispiel #7
0
def test_pack_string():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.STRING, "hello world!")
    p.write_message_end()
    assert_equal("00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21",
                 hexlify(b.getvalue()))

    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.STRING, u("你好世界"))
    p.write_message_end()
    assert_equal("00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c",
                 hexlify(b.getvalue()))
Beispiel #8
0
def test_pack_string():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.STRING, "hello world!")
    p.write_message_end()
    assert "00 00 00 0c 68 65 6c 6c 6f 20 77 6f 72 6c 64 21" == \
        hexlify(b.getvalue())

    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.STRING, u("你好世界"))
    p.write_message_end()
    assert "00 00 00 0c e4 bd a0 e5 a5 bd e4 b8 96 e7 95 8c" == \
        hexlify(b.getvalue())
Beispiel #9
0
def test_write_message_begin():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_message_begin("test", TType.STRING, 1)
    p.write_message_end()
    assert "80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01" == \
        hexlify(b.getvalue())
Beispiel #10
0
def test_write_empty_struct():
    b = TMemoryBuffer()
    item = TItem()
    p = proto.TCyBinaryProtocol(b)
    p.write_struct(item)
    p.write_message_end()
    assert "00" == hexlify(b.getvalue())
Beispiel #11
0
def test_write_bool():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.BOOL, 1)
    b.flush()

    assert "01" == hexlify(b.getvalue())
Beispiel #12
0
def test_write_i32():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I32, 1234567890)
    b.flush()

    assert "49 96 02 d2" == hexlify(b.getvalue())
Beispiel #13
0
def test_write_struct():
    b = BytesIO()
    item = TItem(id=123, phones=["123456", "abcdef"])
    proto.TBinaryProtocol(b).write_struct(item)
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(b.getvalue())
Beispiel #14
0
def test_write_message_begin():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_message_begin('test', TType.STRING, 1)
    p.write_message_end()
    assert_equal("80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01",
                 hexlify(b.getvalue()))
Beispiel #15
0
def test_write_i16():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I16, 12345)
    b.flush()

    assert "30 39" == hexlify(b.getvalue())
Beispiel #16
0
def test_write_empty_struct():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem()
    b.write_struct(item)
    b.write_message_end()
    assert "00" == hexlify(trans.getvalue())
Beispiel #17
0
def test_write_message_begin_no_strict():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans, strict_write=False)
    b.write_message_begin("test", TType.STRING, 1)
    b.write_message_end()
    assert "00 00 00 04 74 65 73 74 0b 00 00 00 01" == \
        hexlify(trans.getvalue())
Beispiel #18
0
def test_write_struct():
    b = BytesIO()
    item = TItem(id=123, phones=['123456', 'abcdef'])
    proto.TCyBinaryProtocol(b).write_struct(item)
    assert_equal("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
                 "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00",
                 hexlify(b.getvalue()))
Beispiel #19
0
def test_write_struct():
    b = BytesIO()
    item = TItem(id=123, phones=["123456", "abcdef"])
    proto.TBinaryProtocol(b).write_struct(item)
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(b.getvalue())
Beispiel #20
0
def test_write_i8():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I08, 123)
    b.flush()

    assert "7b" == hexlify(b.getvalue())
Beispiel #21
0
def test_write_empty_struct():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem()
    b.write_struct(item)
    b.write_message_end()
    assert "00" == hexlify(trans.getvalue())
Beispiel #22
0
def test_write_bool():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.BOOL, 1)
    b.flush()

    assert "01" == hexlify(b.getvalue())
Beispiel #23
0
def test_write_i16():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I16, 12345)
    b.flush()

    assert "30 39" == hexlify(b.getvalue())
Beispiel #24
0
def test_write_i32():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I32, 1234567890)
    b.flush()

    assert "49 96 02 d2" == hexlify(b.getvalue())
Beispiel #25
0
def test_write_message_begin_no_strict():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans, strict_write=False)
    b.write_message_begin("test", TType.STRING, 1)
    b.write_message_end()
    assert "00 00 00 04 74 65 73 74 0b 00 00 00 01" == \
        hexlify(trans.getvalue())
Beispiel #26
0
def test_write_i8():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I08, 123)
    b.flush()

    assert "7b" == hexlify(b.getvalue())
Beispiel #27
0
def test_write_message_begin():
    b = TMemoryBuffer()
    trans = TCyBufferedTransport(b)
    b = proto.TCyBinaryProtocol(trans)
    b.write_message_begin("test", TType.STRING, 1)
    b.write_message_end()
    assert "80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01" == \
        hexlify(trans.getvalue())
Beispiel #28
0
def test_write_message_begin():
    b = TMemoryBuffer()
    trans = TCyBufferedTransport(b)
    b = proto.TCyBinaryProtocol(trans)
    b.write_message_begin("test", TType.STRING, 1)
    b.write_message_end()
    assert "80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01" == \
        hexlify(trans.getvalue())
Beispiel #29
0
def test_write_struct():
    b = BytesIO()
    item = TItem(id=123, phones=['123456', 'abcdef'])
    proto.TCyBinaryProtocol(b).write_struct(item)
    assert_equal(
        "08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
        "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00",
        hexlify(b.getvalue()))
Beispiel #30
0
def test_write_struct():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem(id=123, phones=["123456", "abcdef"])
    b.write_struct(item)
    b.write_message_end()
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(trans.getvalue())
Beispiel #31
0
def test_write_struct():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem(id=123, phones=["123456", "abcdef"])
    b.write_struct(item)
    b.write_message_end()
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(trans.getvalue())
Beispiel #32
0
def test_write_struct_recur():
    b, proto = gen_proto()
    item1 = TItem(id=123, phones=["123456", "abcdef"])
    item2 = TItem(id=456, phones=["123456", "abcdef"])
    pkg = TPkg(id=123, items=[item1, item2])
    proto.write_val(TType.STRUCT, pkg)
    assert ("15 f6 01 19 2c 15 f6 01 19 28 06 31 32 33 34 35 36 06 61 62 63 "
            "64 65 66 00 15 90 07 19 28 06 31 32 33 34 35 36 06 61 62 63 64 "
            "65 66 00 00" == hexlify(b.getvalue()))
Beispiel #33
0
def test_write_struct():
    b = TMemoryBuffer()
    item = TItem(id=123, phones=['123456', 'abcdef'])
    p = proto.TCyBinaryProtocol(b)
    p.write_struct(item)
    p.write_message_end()
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(b.getvalue())
Beispiel #34
0
def test_write_struct():
    b = TMemoryBuffer()
    item = TItem(id=123, phones=['123456', 'abcdef'])
    p = proto.TCyBinaryProtocol(b)
    p.write_struct(item)
    p.write_message_end()
    assert_equal(
        "08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
        "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00",
        hexlify(b.getvalue()))
Beispiel #35
0
def test_write_wrong_arg_type():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem(id="wrong type", phones=["123456", "abcdef"])
    try:
        b.write_struct(item)
    except Exception:
        pass
    b.write_message_end()

    item2 = TItem(id=123, phones=["123456", "abcdef"])
    b.write_struct(item2)
    b.write_message_end()
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(trans.getvalue())
Beispiel #36
0
def test_write_wrong_arg_type():
    trans = TCyMemoryBuffer()
    b = proto.TCyBinaryProtocol(trans)
    item = TItem(id="wrong type", phones=["123456", "abcdef"])
    try:
        b.write_struct(item)
    except Exception:
        pass
    b.write_message_end()

    item2 = TItem(id=123, phones=["123456", "abcdef"])
    b.write_struct(item2)
    b.write_message_end()
    assert ("08 00 01 00 00 00 7b 0f 00 02 0b 00 00 00 02 00 00 00 "
            "06 31 32 33 34 35 36 00 00 00 06 61 62 63 64 65 66 00") == \
        hexlify(trans.getvalue())
Beispiel #37
0
def test_write_i64():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.I64, 1234567890123456789)
    b.flush()
    assert "11 22 10 f4 7d e9 81 15" == hexlify(b.getvalue())
Beispiel #38
0
def test_pack_i32():
    b = BytesIO()
    proto.write_val(b, TType.I32, 1234567890)
    assert "49 96 02 d2" == hexlify(b.getvalue())
Beispiel #39
0
def test_pack_i64():
    b = BytesIO()
    proto.write_val(b, TType.I64, 1234567890123456789)
    assert "11 22 10 f4 7d e9 81 15" == hexlify(b.getvalue())
Beispiel #40
0
def test_pack_double():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.DOUBLE, 1234567890.1234567890)
    p.write_message_end()
    assert_equal("41 d2 65 80 b4 87 e6 b7", hexlify(b.getvalue()))
Beispiel #41
0
def test_pack_i8():
    b = BytesIO()
    proto.write_val(b, TType.I08, 123)
    assert "7b" == hexlify(b.getvalue())
Beispiel #42
0
def test_pack_i64():
    b = BytesIO()
    proto.write_val(b, TType.I64, 1234567890123456789)
    assert_equal("11 22 10 f4 7d e9 81 15", hexlify(b.getvalue()))
Beispiel #43
0
def test_pack_i16():
    b = BytesIO()
    proto.write_val(b, TType.I16, 12345)
    assert_equal("30 39", hexlify(b.getvalue()))
Beispiel #44
0
def test_write_message_begin():
    b = BytesIO()
    proto.TBinaryProtocol(b).write_message_begin("test", TType.STRING, 1)
    assert "80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01" == \
        hexlify(b.getvalue())
Beispiel #45
0
def test_write_empty_struct():
    b = BytesIO()
    item = TItem()
    proto.TBinaryProtocol(b).write_struct(item)
    assert "00" == hexlify(b.getvalue())
Beispiel #46
0
def test_pack_i16():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.I16, 12345)
    p.write_message_end()
    assert_equal("30 39", hexlify(b.getvalue()))
Beispiel #47
0
def test_write_i64():
    b = TCyMemoryBuffer()
    proto.write_val(b, TType.I64, 1234567890123456789)
    b.flush()
    assert "11 22 10 f4 7d e9 81 15" == hexlify(b.getvalue())
Beispiel #48
0
def test_pack_i32():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.I32, 1234567890)
    p.write_message_end()
    assert_equal("49 96 02 d2", hexlify(b.getvalue()))
Beispiel #49
0
def test_pack_i64():
    b = TMemoryBuffer()
    p = proto.TCyBinaryProtocol(b)
    p.write_val(TType.I64, 1234567890123456789)
    p.write_message_end()
    assert_equal("11 22 10 f4 7d e9 81 15", hexlify(b.getvalue()))
Beispiel #50
0
def test_pack_i16():
    b = BytesIO()
    proto.write_val(b, TType.I16, 12345)
    assert "30 39" == hexlify(b.getvalue())
Beispiel #51
0
def test_write_double():
    b = TMemoryBuffer()
    b = TCyBufferedTransport(b)
    proto.write_val(b, TType.DOUBLE, 1234567890.1234567890)
    b.flush()
    assert "41 d2 65 80 b4 87 e6 b7" == hexlify(b.getvalue())
Beispiel #52
0
def test_pack_i8():
    b = BytesIO()
    proto.write_val(b, TType.I08, 123)
    assert_equal("7b", hexlify(b.getvalue()))
Beispiel #53
0
def test_write_message_begin_not_strict():
    b = BytesIO()
    proto.TBinaryProtocol(b, strict_write=False) \
        .write_message_begin("test", TType.STRING, 1)
    assert "00 00 00 04 74 65 73 74 0b 00 00 00 01" == \
        hexlify(b.getvalue())
Beispiel #54
0
def test_pack_i32():
    b = BytesIO()
    proto.write_val(b, TType.I32, 1234567890)
    assert_equal("49 96 02 d2", hexlify(b.getvalue()))
Beispiel #55
0
def test_write_message_begin():
    b = BytesIO()
    proto.TBinaryProtocol(b).write_message_begin("test", TType.STRING, 1)
    assert "80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01" == \
        hexlify(b.getvalue())
Beispiel #56
0
def test_pack_double():
    b = BytesIO()
    proto.write_val(b, TType.DOUBLE, 1234567890.1234567890)
    assert_equal("41 d2 65 80 b4 87 e6 b7", hexlify(b.getvalue()))
Beispiel #57
0
def test_pack_double():
    b = BytesIO()
    proto.write_val(b, TType.DOUBLE, 1234567890.1234567890)
    assert "41 d2 65 80 b4 87 e6 b7" == hexlify(b.getvalue())
Beispiel #58
0
def test_write_message_begin():
    b = BytesIO()
    proto.TCyBinaryProtocol(b).write_message_begin('test', TType.STRING, 1)
    assert_equal("80 01 00 0b 00 00 00 04 74 65 73 74 00 00 00 01",
                 hexlify(b.getvalue()))
Beispiel #59
0
def test_write_double():
    b = TCyMemoryBuffer()
    proto.write_val(b, TType.DOUBLE, 1234567890.1234567890)
    b.flush()
    assert "41 d2 65 80 b4 87 e6 b7" == hexlify(b.getvalue())