def test_encodeDictConversion(self):
     input = { "k1": 1, "k2":  2, "k3": 3, "k4": 4 }
     output = ujson.encode(input)
     self.assertEquals(input, json.loads(output))
     self.assertEquals(input, ujson.decode(output))
     self.assertEquals(input, ujson.decode(output))
     pass

 def test_dynamic_by_name(self):
     VISITOR_ID_1 = uuid.uuid4().hex
     EVENT_1 = "Event 1 %s" % uuid.uuid4().hex
     EVENT_2 = "Event 2 %s" % uuid.uuid4().hex
     yield self.post_event(VISITOR_ID_1, EVENT_1)
     yield self.post_event(VISITOR_ID_1, EVENT_2)
     events = yield self.get_event_dict()
     event_id_1 = events[EVENT_1]
     event_id_2 = events[EVENT_2]
     qs = urlencode([("event", EVENT_1), ("event", EVENT_2)])
     result = yield request(
         "GET",
         "%s/funnel?%s" % (self.url, qs),
         username=self.username,
         password=self.password) 
     self.assertEqual(result.code, 200)
     returned_event_ids = ujson.decode(result.body)["event_ids"]
     self.assertTrue(event_id_1 in returned_event_ids)
     self.assertTrue(event_id_2 in returned_event_ids)
     funnel = ujson.decode(result.body)["funnel"]
     unique_funnel = ujson.decode(result.body)["unique_funnel"]
     self.assertEqual(funnel[0][0], event_id_1)
     self.assertEqual(funnel[1][0], event_id_2)
     self.assertEqual(funnel[0][1], 1)
     self.assertEqual(funnel[1][1], 1)
     self.assertEqual(unique_funnel[0][0], event_id_1)
     self.assertEqual(unique_funnel[1][0], event_id_2)
     self.assertEqual(unique_funnel[0][1], 1)
     self.assertEqual(unique_funnel[1][1], 1)

 def is_valid_json(json: str) -> bool:
     try:
         ujson.decode(json)
     except:
         return False
     else:
         return True

 def test_decodeJibberish(self):
     input = "fdsa sda v9sa fdsa"
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

 def test_decodeWithTrailingNonWhitespaces(self):
     try:
         input = "{}\n\t a"
         ujson.decode(input)
     except ValueError:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeNullBroken(self):
     input = "n"
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

 def test_decodeStringUnterminated(self):
     input = "\"TESTING"
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

 def test_decodeStringBadEscape(self):
     input = "\"TESTING\\\""
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

 def test_decodeBrokenObjectStart(self):
     input = "{"
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

 def test_decodeTooBigValue(self):
     try:
         input = "9223372036854775808"
         ujson.decode(input)
     except ValueError as e:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeVeryTooBigValue(self):
     try:
         input = "18446744073709551616"
         ujson.decode(input)
     except ValueError:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeArrayOnlyCommaFail(self):
     input = "[,]"
     try:
         ujson.decode(input)
     except ValueError:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeArrayUnmatchedBracketFail(self):
     input = "[]]"
     try:
         ujson.decode(input)
     except ValueError:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeStringUntermEscapeSequence(self):
     input = '"TESTING\\"'
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except (ValueError):
         return
     assert False, "Wrong exception"

 def test_goodreads(self):
     def autogenerate_goodreads(*args, **kwargs):
         autogenerator = delta.Autogenerator(paths="books", includes="books/id")
         return [x.data for x in autogenerator(*args, **kwargs)]
     from ujson import decode
     old = decode(read("%s/goodreads/old.json" % DATAPATH))
     new = decode(read("%s/goodreads/new.json" % DATAPATH))
     self.assertEqual(autogenerate_goodreads(old, new), [])

 def test_decodeVeryTooSmallValue(self):
     try:
         input = "-90223372036854775809"
         ujson.decode(input)
     except ValueError:
         pass
     else:
         assert False, "expected ValueError"

 def test_decodeObjectDepthTooBig(self):
     input = '{' * (1024 * 1024)
     try:
         ujson.decode(input)
         assert False, "Expected exception!"
     except(ValueError):
         return
     assert False, "Wrong exception"

    def test_decodeDictWithNoValue(self):
        input = "{{{{\"key\":}}}}"
        try:
            ujson.decode(input)
            assert False, "Expected exception!"
        except(ValueError):
            return

        assert False, "Wrong exception"

    def test_decodeDictWithNoColonOrValue(self):
        input = '{{{{"key"}}}}'
        try:
            ujson.decode(input)
            assert False, "Expected exception!"
        except (ValueError):
            return

        assert False, "Wrong exception"

 def test_decodeBigEscape(self):
     for x in range(10):
         if six.PY3:
             base = '\u00e5'.encode('utf-8')
             quote = "\"".encode()
         else:
             base = "\xc3\xa5"
             quote = "\""
         input = quote + (base * 1024 * 1024 * 2) + quote
         ujson.decode(input)