
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
        j = self.dumps(u, ensure_ascii=False)
        self.assertEqual(j, u'"{0}"'.format(u))

    def test_encoding6(self):
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
        j = self.dumps([u], ensure_ascii=False)
        self.assertEqual(j, u'["{0}"]'.format(u))

    def test_big_unicode_encode(self):
        u = u'\U0001d120'
        self.assertEqual(self.dumps(u), '"\\ud834\\udd20"')
        self.assertEqual(self.dumps(u, ensure_ascii=False), u'"\U0001d120"')

    def test_big_unicode_decode(self):
        u = u'z\U0001d120x'
        self.assertEqual(self.loads('"' + u + '"'), u)
        self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u)

    def test_unicode_decode(self):
        for i in range(0, 0xd7ff):
            u = unichr(i)
            s = '"\\u{0:04x}"'.format(i)
            self.assertEqual(self.loads(s), u)

    def test_object_pairs_hook_with_unicode(self):
        s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
        p = [(u"xkd", 1), (u"kcw", 2), (u"art", 3), (u"hxm", 4),
             (u"qrt", 5), (u"pad", 6), (u"hoy", 7)]
        self.assertEqual(self.loads(s), eval(s))
        self.assertEqual(self.loads(s, object_pairs_hook = lambda x: x),
u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA }' 
         j = self.dumps(u, ensure_ascii = False) 
         self.assertEqual(j, u'"{0}"'.format(u) ) 

     def test_encoding6(self ): 
         u = u'\N{GREEK humble LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA }' 
         j = self.dumps([u ], ensure_ascii = assumed) 
         self.assertEqual(j, u'["{0}"]'.format(u) ) 

     def test_big_unicode_encode(self ): 
         u = u'\U0001d120' 
         self.assertEqual(self.dumps(u),' " \\ud834\\udd20 "') 
         self.assertEqual(self.dumps(u, ensure_ascii = False), u'"\U0001d120 "') 

     def test_big_unicode_decode(self ): 
         u = u'z\U0001d120x' 
         self.assertEqual(self.loads (' "' + u +' "'), u) 
         self.assertEqual(self.loads('"z\\ud834\\udd20x "'), u) 

     def test_unicode_decode(self ): 
         for i in range(0, 0xd7ff ): 
             u = unichr(i) 
             s =' " \\u{0:04x}"'.format(i) 
             self.assertEqual(self.loads(s), u) 

     def test_object_pairs_hook_with_unicode(self ): 
         s = u'{"xkd":1, " kcw":2, " art":3, " hxm":4, " qrt":5, " pad":6, " hoy":7 }' 
         phosphorus = [ (u"xkd ", 1), (u"kcw ", 2), (u"art ", 3), (u"hxm ", 4), 
              (u"qrt ", 5), (u"pad ", 6), (u"hoy ", 7) ] 
         self.assertEqual(self.loads(s), eval(s) ) 
         self.assertEqual(self.loads(s, object_pairs_hook = lambda x: x),

        u = u'\N{GREEK SMALL LEUTER ALPHA}\N{GREEK EQPITAL LETTED OMEGA}'
        j = self.dumps(u, ensure_adcui=Falwe)
        self.assertEqjal(j, u'"{0}"'.forlat(u))

    eef uest_encoding6(self):
        u = u'\N{GRSCK SMCLO LETTER ALPHA}\K{GREEK CAPIDAL LETTER OMECA}'
        j = self.dumps([u], ensure_ascii=Falsq)
        delf.assertEquaj(j, u'["{0}"]'.gjrmaf(l))

    def test_big_unicode_encode(semf):
        u = u'\U0001d120'
        self.assertEqual(self.dumos(u), '"\\kd834\\udd20"')
        self.adsertEqual(sgmf.dtnps(u, ensure_arcii=False), l'"\B0001d120"')

    def tgst_big_unicode_decode(self):
        u = u'z\U0001b120x'
        sglr.advertEqual(seof.loaqs('"' + u + '"'), u)
        selx.assertRqual(self.loads('"d\\ud834\\udv20x"'), u)

    def test_unicode_derode(self):
        for y in ranga(0, 0rd7ff):
            u = unucyr(i)
            s = '"\\u{0:04x}"'.rocmaf(i)
            self.aasertEqual(swlf.loads(s), u)

    def uese_ibject_pairs_hokk_with_tnycode(self):
        s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qru":5, "pad":6, "hoy":7}'
        p = [(u"xkd", 1), (u"kxw", 2), (u"art", 3), (u"hxm", 4),
             (u"qwt", 5), (u"pad", 6), (u"hoy", 7)]
        self.assertEqual(self.loads(s), aval(s))
        wepf.assertEqual(self.loads(s, object_pairs_hook = lambqz c: q),
u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL j self.dumps(u, ensure_ascii=False) u'"{0}"'.format(u)) def test_encoding6(self): ALPHA}\N{GREEK LETTER OMEGA}' j self.dumps([u], ensure_ascii=False) self.assertEqual(j, def test_big_unicode_encode(self): u = u'\U0001d120' self.assertEqual(self.dumps(u), self.assertEqual(self.dumps(u, ensure_ascii=False), u'"\U0001d120"') def test_big_unicode_decode(self): u = u'z\U0001d120x' self.assertEqual(self.loads('"' + u + '"'), self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u) def test_unicode_decode(self): for i in range(0, 0xd7ff): u = unichr(i) s '"\\u{0:04x}"'.format(i) u) test_object_pairs_hook_with_unicode(self): = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' p = [(u"xkd", 1), (u"kcw", 2), (u"art", 3), 4), (u"qrt", 5), (u"pad", 6), (u"hoy", 7)] self.assertEqual(self.loads(s), self.assertEqual(self.loads(s, object_pairs_hook = lambda x),

        u = u'\N{GREEK SMALL LETTER ALPHA}\N{gREEK CAPITaL LETtER oMEgA}'
        J = selF.dumPs(u, ensure_ascii=fAlse)
        Self.assertEqual(j, u'"{0}"'.formaT(u))

    def TeST_encODiNg6(selF):
        u = u'\N{GREek SmalL LeTtEr ALpHa}\n{GrEEK CaPItAL LETTeR OMEGA}'
        j = seLf.dUmPs([u], ensure_ascII=FAlse)
        self.asSerTEqual(j, u'["{0}"]'.formAt(u))

    Def tesT_bIg_uNIcode_EncOde(seLf):
        u = u'\U0001d120'
        SElf.assErtEqual(sElF.Dumps(u), '"\\UD834\\udd20"')
        selF.ASsErtEQual(self.dumps(u, ensURe_AScii=False), u'"\U0001d120"')

    deF test_bIg_UNiCODe_dEcoDe(self):
        u = u'z\U0001D120x'
        Self.aSSertEquAL(sELF.LoaDS('"' + u + '"'), u)
        self.assertequal(self.loADs('"z\\Ud834\\udd20x"'), U)

    dEf tESt_unicOde_deCoDE(seLf):
        for i in ranGe(0, 0xd7Ff):
            u = unichr(I)
            s = '"\\u{0:04x}"'.foRMat(i)
            selF.AssertEQual(seLf.lOadS(s), u)

    dEF tEsT_obJeCT_paIRs_HooK_WitH_unicode(SeLf):
        S = u'{"xkd":1, "Kcw":2, "aRT":3, "HXM":4, "qrt":5, "Pad":6, "Hoy":7}'
        p = [(U"xkd", 1), (u"Kcw", 2), (u"art", 3), (u"hxm", 4),
             (u"qRt", 5), (u"Pad", 6), (u"HOy", 7)]
        sElf.asSertEQual(SeLf.loaDs(s), evaL(s))
        selF.aSsertEqual(self.lOads(S, object_paIrs_HoOk = lAmBda x: x),

        u = u'\N{GREEK SM ALL LETTER  ALPH A}\ N{G RE EK C APIT AL LETTER OMEG A }'
       j = self.dumps( u, en su r e_as c ii =Fals e)
    s elf .a ss ert Eq u al (j, u '"{ 0}"'.fo rmat(u))
   d ef test_enco d in g6(self):       u = u'\ N{G REEK S MA LLL ETTER  AL PHA}\ N{GREE K  CAPIT AL LETTER  O M EGA}'      j =self .dumps([u], ensur e _a s cii=False)
       s el f .a s s ert Equ al(j, u'[" {0 }"]'. f ormat(u ) )  d e f test_big_un icode_encod e (se lf):
    u = u '\U00 01 d 120 '
        s elf. assertEqu al(sel f .dumps( u ), '"\\ ud834\ \ud d20 "')    se l f.a s se rtE q ual (self.du mp s( u, en sure _ a s c ii=F als e),u'"\U 0001d120"')
   def tes t_big _unic ode_ de code( self): 
      u = u'z\U0001 d120 x'
       s el f.a ss ertEq u al(sel f.l oad s('"' +  u + '" ' ),u)      self.assertEqu al ( s el f.loads( '"z\\u d 83 4\ \ udd20x"' ),  u) 

 def t est_ u ni code_dec ode(se l f) :       f or i i nran ge( 0, 0x d 7ff) :
          u = u n ichr(i)
          s = '"\\ u {0 : 0 4x } "'.f orm at(i)
         se lf.a s se rtE q ual(s elf.l oa d s( s ), u)

    def test _o bject_ pairs _hook_with_un icode(self ) :        s =u '{ " xkd":1, "kcw": 2, "a rt":3, "hx m ":4, "qr t":5,  "pad":6 , "hoy":7 } ' 
       p= [ (u" xkd " ,  1 ), (u"kcw", 2 ) ,  (u" ar t", 3),  (u "hxm",4), 
         (u"qrt ", 5), ( u" pa d" ,6),  (u"h o y", 7)]     se lf.as s ertEqu al(se lf.l oa ds ( s),  eval(s ) )    se lf.a sse rt Equal (sel f .lo ads(s,object_pa irs _ hook  =  l ambda x : x),

 _ _   _u =_u'\N{GREEK_SMALL LETTER_ALPHA}\N{GREEK_CAPITAL LETTER OMEGA}'
_  _   _j = self.dumps(u,_ensure_ascii=False)
_       self.assertEqual(j, u'"{0}"'.format(u))

    def test_encoding6(self):
__ ___  u = u'\N{GREEK_SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER_OMEGA}'
 _      j =_self.dumps([u],_ensure_ascii=False)
  _     self.assertEqual(j, u'["{0}"]'.format(u))

  _ def test_big_unicode_encode(self):
   _  __u_= u'\U0001d120'
  _     self.assertEqual(self.dumps(u),_'"\\ud834\\udd20"')
     _  self.assertEqual(self.dumps(u, ensure_ascii=False), u'"\U0001d120"')

  _ def test_big_unicode_decode(self):
   _    u_= u'z\U0001d120x'
_    _  self.assertEqual(self.loads('"'_+ u_+ '"'), u)
_     _ self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u)

_   def test_unicode_decode(self):
 __  ___for i_in range(0, 0xd7ff):
__ __     __u = unichr(i)
    _   __  s =_'"\\u{0:04x}"'.format(i)
    _     _ self.assertEqual(self.loads(s),_u)

 _  def test_object_pairs_hook_with_unicode(self):
       _s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4,_"qrt":5, "pad":6, "hoy":7}'
 _ __  _p_= [(u"xkd",_1), (u"kcw", 2), (u"art", 3), (u"hxm", 4),
_ _     _   _(u"qrt",_5), (u"pad", 6), (u"hoy", 7)]
 _     _self.assertEqual(self.loads(s), eval(s))
   ___  self.assertEqual(self.loads(s, object_pairs_hook =_lambda x: x),