Beispiel #1
0
 def decode_hash(self, hash, cache, as_map_key):
     if len(hash) != 1:
         h = {}
         for k, v in hash.items():
             # crude/verbose implementation, but this is only version that
             # plays nice w/cache for both msgpack and json thus far.
             # -- e.g., we have to specify encode/decode order for key/val
             # -- explicitly, all implicit ordering has broken in corner
             # -- cases, thus these extraneous seeming assignments
             key = self._decode(k, cache, True)
             val = self._decode(v, cache, False)
             h[key] = val
         return transit_types.frozendict(h)
     else:
         key = list(hash)[0]
         value = hash[key]
         key = self._decode(key, cache, True)
         if isinstance(key, Tag):
             return self.decode_tag(key.tag,
                                    self._decode(value, cache, as_map_key))
     return transit_types.frozendict({key: self._decode(value, cache, False)})
 def decode_hash(self, hash, cache, as_map_key):
     if len(hash) != 1:
         h = {}
         for k, v in hash.items():
             # crude/verbose implementation, but this is only version that
             # plays nice w/cache for both msgpack and json thus far.
             # -- e.g., we have to specify encode/decode order for key/val
             # -- explicitly, all implicit ordering has broken in corner
             # -- cases, thus these extraneous seeming assignments
             key = self._decode(k, cache, True)
             val = self._decode(v, cache, False)
             h[key] = val
         return transit_types.frozendict(h)
     else:
         key = list(hash)[0]
         value = hash[key]
         key = self._decode(key, cache, True)
         if isinstance(key, Tag):
             return self.decode_tag(key.tag,
                                    self._decode(value, cache, as_map_key))
     return transit_types.frozendict(
         {key: self._decode(value, cache, False)})
Beispiel #3
0
    def decode_list(self, node, cache, as_map_key):
        """Special case decodes map-as-array.
        Otherwise lists are treated as Python lists.

        Arguments follow the same convention as the top-level 'decode'
        function.
        """
        if node:
            if node[0] == MAP_AS_ARR:
                # key must be decoded before value for caching to work.
                returned_dict = {}
                for k, v in pairs(node[1:]):
                    key = self._decode(k, cache, True)
                    val = self._decode(v, cache, as_map_key)
                    returned_dict[key] = val
                return transit_types.frozendict(returned_dict)

            decoded = self._decode(node[0], cache, as_map_key)
            if isinstance(decoded, Tag):
                return self.decode_tag(decoded.tag,
                                       self._decode(node[1], cache, as_map_key))
        return tuple(self._decode(x, cache, as_map_key) for x in node)
    def decode_list(self, node, cache, as_map_key):
        """Special case decodes map-as-array.
        Otherwise lists are treated as Python lists.

        Arguments follow the same convention as the top-level 'decode'
        function.
        """
        if node:
            if node[0] == MAP_AS_ARR:
                # key must be decoded before value for caching to work.
                returned_dict = {}
                for k, v in pairs(node[1:]):
                    key = self._decode(k, cache, True)
                    val = self._decode(v, cache, as_map_key)
                    returned_dict[key] = val
                return transit_types.frozendict(returned_dict)

            decoded = self._decode(node[0], cache, as_map_key)
            if isinstance(decoded, Tag):
                return self.decode_tag(
                    decoded.tag, self._decode(node[1], cache, as_map_key))
        return tuple(self._decode(x, cache, as_map_key) for x in node)
Beispiel #5
0
def hash_of_size(n):
    return frozendict(izip(array_of_symbools(n), range(0, n+1)))
Beispiel #6
0
        def test_roundtrip(self):
            in_data = value
            io = StringIO()
            w = Writer(io, "json")
            w.write(in_data)
            r = Reader("json")
            out_data = r.read(StringIO(io.getvalue()))
            self.assertEqual(in_data, out_data)

    globals()["test_" + name + "_json"] = RegressionTest

regression("cache_consistency", ({"Problem?":true},
                                  Symbol("Here"),
                                  Symbol("Here")))
regression("one_pair_frozendict", frozendict({"a":1}))
regression("json_int_max", (2**53+100, 2**63+100))
regression("newline_in_string", "a\nb")
regression("big_decimal", Decimal("190234710272.2394720347203642836434"))

def json_int_boundary(value, expected_type):
    class JsonIntBoundaryTest(unittest.TestCase):

        def test_max_is_number(self):
            for protocol in ("json", "json_verbose"):
                io = StringIO()
                w = Writer(io, protocol)
                w.write([value])
                actual_type = type(json.loads(io.getvalue())[0])
                self.assertEqual(expected_type, actual_type)
Beispiel #7
0
        def test_roundtrip(self):
            in_data = value
            io = StringIO()
            w = Writer(io, "json")
            w.write(in_data)
            r = Reader("json")
            out_data = r.read(StringIO(io.getvalue()))
            self.assertEqual(in_data, out_data)

    globals()["test_" + name + "_json"] = RegressionTest

regression("cache_consistency", ({"Problem?":true},
                                  Symbol("Here"),
                                  Symbol("Here")))
regression("one_pair_frozendict", frozendict({"a":1}))
regression("json_int_max", (2**53+100, 2**63+100))
regression("newline_in_string", "a\nb")
regression("big_decimal", Decimal("190234710272.2394720347203642836434"))

def json_int_boundary(value, expected_type):
    class JsonIntBoundaryTest(unittest.TestCase):

        def test_max_is_number(self):
            for protocol in ("json", "json_verbose"):
                io = StringIO()
                w = Writer(io, protocol)
                w.write([value])
                actual_type = type(json.loads(io.getvalue())[0])
                self.assertEqual(expected_type, actual_type)
         UUID('d1dc64fa-da79-444b-9fa4-d4412f427289'),
         UUID('501a978e-3a3e-4060-b3be-1cf2bd4b1a38'),
         UUID('b3ba141a-a776-48e4-9fae-a28ea8571f58'))

URIS = (URI(u'http://example.com'), URI(u'ftp://example.com'),
        URI(u'file:///path/to/file.txt'), URI(u'http://www.詹姆斯.com/'))

DATES = tuple(
    map(lambda x: datetime.fromtimestamp(x / 1000.0, tz=dateutil.tz.tzutc()),
        [-6106017600000, 0, 946728000000, 1396909037000]))

SET_SIMPLE = frozenset(ARRAY_SIMPLE)
SET_MIXED = frozenset(ARRAY_MIXED)
SET_NESTED = frozenset([SET_SIMPLE, SET_MIXED])

MAP_SIMPLE = frozendict({Keyword("a"): 1, Keyword("b"): 2, Keyword("c"): 3})

MAP_MIXED = frozendict({
    Keyword("a"): 1,
    Keyword("b"): u"a string",
    Keyword("c"): true
})

MAP_NESTED = frozendict({
    Keyword("simple"): MAP_SIMPLE,
    Keyword("mixed"): MAP_MIXED
})

exemplar("nil", None)
exemplar("true", true)
exemplar("false", false)
 def from_rep(cmap):
     return transit_types.frozendict(pairs(cmap))
Beispiel #10
0
def hash_of_size(n):
    return frozendict(izip(array_of_symbools(n), range(0, n + 1)))
Beispiel #11
0
        def test_roundtrip(self):
            in_data = value
            io = StringIO()
            w = Writer(io, "json")
            w.write(in_data)
            r = Reader("json")
            out_data = r.read(StringIO(io.getvalue()))
            self.assertEqual(in_data, out_data)

    globals()["test_" + name + "_json"] = RegressionTest


regression("cache_consistency", ({
    "Problem?": true
}, Symbol("Here"), Symbol("Here")))
regression("one_pair_frozendict", frozendict({"a": 1}))
regression("json_int_max", (2**53 + 100, 2**63 + 100))
regression("newline_in_string", "a\nb")
regression("big_decimal", Decimal("190234710272.2394720347203642836434"))
regression("dict_in_set", frozenset(frozendict({"test": "case"})))


def json_verbose_cache_bug():
    class JsonVerboseCacheBug(RegressionBaseTest):
        """Can't rely on roundtrip behavior to test this bug, have to
           actually verify that both keys are written for json_verbose
           behavior to be correct."""
        def test_key_not_cached(self):
            io = StringIO()
            w = Writer(io, "json_verbose")
            w.write([{'myKey1': 42}, {'myKey1': 42}])
URIS = (
  URI(u'http://example.com'),
  URI(u'ftp://example.com'),
  URI(u'file:///path/to/file.txt'),
  URI(u'http://www.詹姆斯.com/'))

DATES = tuple(map(lambda x: datetime.fromtimestamp(x/1000.0, tz=dateutil.tz.tzutc()),
                  [-6106017600000, 0, 946728000000, 1396909037000]))

SET_SIMPLE = frozenset(ARRAY_SIMPLE)
SET_MIXED = frozenset(ARRAY_MIXED)
SET_NESTED = frozenset([SET_SIMPLE, SET_MIXED])

MAP_SIMPLE = frozendict({Keyword("a"): 1,
                         Keyword("b"): 2,
                         Keyword("c"): 3})

MAP_MIXED = frozendict({Keyword("a"): 1,
                        Keyword("b"): u"a string",
                        Keyword("c"): true})

MAP_NESTED = frozendict({Keyword("simple"): MAP_SIMPLE,
                         Keyword("mixed"): MAP_MIXED})

exemplar("nil", None)
exemplar("true", true)
exemplar("false", false)
exemplar("zero", 0)
exemplar("one", 1)
exemplar("one_string", "hello")