def test_datetime_values(value):
    with pytest.raises(TypeError):
        rapidjson.dumps(value)

    dumped = rapidjson.dumps(value, datetime_mode=rapidjson.DATETIME_MODE_ISO8601)
    loaded = rapidjson.loads(dumped, datetime_mode=rapidjson.DATETIME_MODE_ISO8601)
    assert loaded == value

def test_datetime_mode_loads():
    import pytz

    utc = datetime.now(pytz.utc)
    utcstr = utc.isoformat()

    jsond = rapidjson.dumps(utc, datetime_mode=rapidjson.DATETIME_MODE_ISO8601)

    assert jsond == '"%s"' % utcstr
    assert rapidjson.loads(jsond, datetime_mode=rapidjson.DATETIME_MODE_ISO8601) == utc

    local = utc.astimezone(pytz.timezone('Europe/Rome'))
    locstr = local.isoformat()

    jsond = rapidjson.dumps(local, datetime_mode=rapidjson.DATETIME_MODE_ISO8601)

    assert jsond == '"%s"' % locstr
    assert rapidjson.loads(jsond) == locstr
    assert rapidjson.loads(jsond, datetime_mode=rapidjson.DATETIME_MODE_ISO8601) == local

    load_as_utc = rapidjson.loads(jsond, datetime_mode=rapidjson.DATETIME_MODE_ISO8601_UTC)

    assert load_as_utc == utc
    assert not load_as_utc.utcoffset()

    load_as_naive = rapidjson.loads(jsond, datetime_mode=rapidjson.DATETIME_MODE_ISO8601_IGNORE_TZ)

    assert load_as_naive == local.replace(tzinfo=None)

def test_circular_composite():
    dct2 = {}
    dct2['a'] = []
    dct2['a'].append(dct2)

    with pytest.raises(OverflowError):
        rapidjson.dumps(dct2)

def test_allow_nan():
    f = [1.1, float("inf"), 2.2, float("nan"), 3.3, float("-inf"), 4.4]
    expected = '[1.1,Infinity,2.2,NaN,3.3,-Infinity,4.4]'
    assert rapidjson.dumps(f) == expected
    assert rapidjson.dumps(f, allow_nan=True) == expected

    with pytest.raises(ValueError):
        rapidjson.dumps(f, allow_nan=False)

    s = "NaN"
    assert math.isnan(rapidjson.loads(s))
    assert math.isnan(rapidjson.loads(s, allow_nan=True))

    with pytest.raises(ValueError):
        rapidjson.loads(s, allow_nan=False)

    s = "Infinity"
    assert rapidjson.loads(s) == float("inf")
    assert rapidjson.loads(s, allow_nan=True) == float("inf")

    with pytest.raises(ValueError):
        rapidjson.loads(s, allow_nan=False)

    s = "-Infinity"
    assert rapidjson.loads(s) == float("-inf")
    assert rapidjson.loads(s, allow_nan=True) == float("-inf")

    with pytest.raises(ValueError):
        rapidjson.loads(s, allow_nan=False)

def test_sort_keys():
    o = {"a": 1, "z": 2, "b": 3}
    expected1 = '{"a":1,"b":3,"z":2}'
    expected2 = '{\n    "a": 1,\n    "b": 3,\n    "z": 2\n}'

    assert rapidjson.dumps(o, sort_keys=True) == expected1
    assert rapidjson.dumps(o, sort_keys=True, indent=4) == expected2

def test_max_recursion_depth():
    a = {'a': {'b': {'c': 1}}}

    assert rapidjson.dumps(a) == '{"a":{"b":{"c":1}}}'

    with pytest.raises(OverflowError):
        rapidjson.dumps(a, max_recursion_depth=2)

def test_unicode(u):
    s = u.encode('utf-8')
    ju = rapidjson.dumps(u)
    js = rapidjson.dumps(s)
    assert ju == js
    assert ju == json.dumps(u)
    assert rapidjson.dumps(u, ensure_ascii=False) == json.dumps(u, ensure_ascii=False)

def test_unicode_1():
    u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
    s = u.encode('utf-8')
    ju = rapidjson.dumps(u)
    js = rapidjson.dumps(s)
    assert ju == js
    assert ju.lower() == json.dumps(u).lower()
    assert rapidjson.dumps(u, ensure_ascii=False) == json.dumps(u, ensure_ascii=False)

def test_unicode_3():
    u = 'asdf \U0010ffff \U0001ffff qwert \uffff \u10ff \u00ff \u0080 \u7fff \b\n\r'
    s = u.encode('utf-8')
    ju = rapidjson.dumps(u)
    js = rapidjson.dumps(s)
    assert ju == js
    assert ju.lower() == json.dumps(u).lower()
    assert rapidjson.dumps(u, ensure_ascii=False) == json.dumps(u, ensure_ascii=False)

def test_unicode_2():
    u = '\U0010ffff'
    s = u.encode('utf-8')
    ju = rapidjson.dumps(u)
    js = rapidjson.dumps(s)
    assert ju == js
    assert ju.lower() == json.dumps(u).lower()
    assert rapidjson.dumps(u, ensure_ascii=False) == json.dumps(u, ensure_ascii=False)

def test_serialize_sets():
    def default_iterable(obj):
        return list(obj)

    rapidjson.dumps([set()], default=default_iterable)

    with pytest.raises(TypeError):
        rapidjson.dumps([set()])

def test_infinity():
    inf = float("inf")
    dumped = rapidjson.dumps(inf)
    loaded = rapidjson.loads(dumped)
    assert loaded == inf

    d = Decimal(inf)
    dumped = rapidjson.dumps(inf, use_decimal=True)
    loaded = rapidjson.loads(dumped, use_decimal=True)
    assert loaded == inf

def test_skipkeys():
    o = {True: False, 1: 1, 1.1: 1.1, (1, 2): "foo", b"asdf": 1, None: None}

    with pytest.raises(TypeError):
        rapidjson.dumps(o)

    with pytest.raises(TypeError):
        rapidjson.dumps(o, skipkeys=False)

    assert rapidjson.dumps(o, skipkeys=True) == '{}'

def test_nan():
    nan = float("nan")
    dumped = rapidjson.dumps(nan)
    loaded = rapidjson.loads(dumped)

    assert math.isnan(nan)
    assert math.isnan(loaded)

    d = Decimal(nan)
    dumped = rapidjson.dumps(nan, use_decimal=True)
    loaded = rapidjson.loads(dumped, use_decimal=True)

    assert math.isnan(d)
    assert math.isnan(loaded)

def _load_schema(name):
    """Load a schema from disk"""
    path = os.path.join(os.path.dirname(__file__), name + '.yaml')
    with open(path) as handle:
        schema = yaml.safe_load(handle)
    fast_schema = rapidjson_schema.loads(rapidjson.dumps(schema))
    return path, (schema, fast_schema)

def test_unicode():
   arabic='بينهم ان يكون مسلما رشيدا عاقلا ًوابنا شرعيا لابوين عمانيين'
   chinese='本站所提供的資料和服務都不收費，因此網站所需要的資金全來自廣告及捐款。若您願意捐款補助'

   for text in [arabic, chinese]:
       dumped = rapidjson.dumps(text)
       loaded = rapidjson.loads(dumped)
       assert text == loaded

def wshandler(request):
    env, error = yield from get_env(request)
    if error:
        return error

    ws = web.WebSocketResponse()
    ws.start(request)

    request.app['sockets'].append((env.username, ws))
    session = request.cookies.get('session')
    while True:
        msg = yield from ws.receive()
        if msg.tp == web.MsgType.text:
            log.debug(msg.data)
            data = json.loads(msg.data)
            payload = data.get('payload')
            if payload:
                payload = json.dumps(payload)
            resp = yield from aiohttp.request(
                'POST' if payload else 'GET',
                env('host_web') + data['url'],
                headers={
                    'X-Requested-With': 'XMLHttpRequest',
                    'Cookie': data['cookie']
                },
                data=payload,
            )
            log.debug('%s %s', resp.status, msg.data)
            if resp.status == 200:
                p = (yield from resp.read()).decode()
                ws.send_str(json.dumps({'uid': data['uid'], 'payload': p}))
                new_session = resp.cookies.get('session')
                if new_session and session != new_session:
                    session = new_session.value
                    msg = {'session': new_session.output(header='').strip()}
                    ws.send_str(json.dumps(msg))
                    log.debug('sent new session')
        elif msg.tp == web.MsgType.close:
            log.debug('ws closed')
            yield from ws.close()
            break
        elif msg.tp == web.MsgType.error:
            log.exception(ws.exception())

    request.app['sockets'].remove((env.username, ws))
    return ws

def test_doubles():
    doubles = []

    for x in range(100000):
        d = sys.maxsize * random.random()
        dumped = rapidjson.dumps(d)
        loaded = rapidjson.loads(dumped)
        assert loaded == d

def test_default():
    def encode_complex(obj):
        if isinstance(obj, complex):
            return [obj.real, obj.imag]

        raise TypeError(repr(obj) + " is not JSON serializable")

    result = rapidjson.dumps(2 + 1j, default=encode_complex)
    assert result == '[2.0,1.0]'

    def write_block(self, block, durability='soft'):
        """Write a block to bigchain.

        Args:
            block (dict): block to write to bigchain.
        """

        block_serialized = rapidjson.dumps(block)
        r.table('bigchain').insert(r.json(block_serialized), durability=durability).run(self.conn)