def testReadDictWithDoubleSlashComments(self):
     s = """
     {'a':false,
       //  b:true, don't want b
     'c':true
     }
     """
     assert json.read(s) == {'a':False,'c':True}

 def testReadDictWithSlashStarComments(self):
     s = """
     {'a':false,  /*don't want b
         b:true, */
     'c':true
     }
     """
     assert json.read(s) == {'a':False,'c':True}

 def read(self, aString, encoding=None):
     if hasCJson:
         try:
             # the True parameter here tells cjson to make all strings 
             # unicode. This is a good idea here.
             return cjson.decode(aString, True)
         except cjson.DecodeError:
             # fall back to minjson
             pass
     # This is a fall-back position for less-well-constructed JSON
     try:
         return minjson.read(aString, encoding)
     except minjson.ReadException, e:
         raise exceptions.ResponseError(e)

 def testReadDictOfListsWithSpaces(self):
     s = u"{  'a' :    [],  'b'  : []  }    "
     assert json.read(s) == {'a':[],'b':[]}

 def testReadEFloat2(self):
     s = u"1.334E-02"
     assert json.read(s) == 0.01334

 def testReadNegInt(self):
     s = u"-1"
     assert json.read(s) == -1

 def testReadInt(self):
     s = u"1"
     self.assertEqual(json.read(s), 1)

 def testReadString(self):
     s = u"'hello'"
     self.assertEqual(json.read(s) ,'hello')

 def testUnicodeFromNonUnicode(self):
     obj = "'\u20ac'"
     r = json.read(obj)
     self.assertEqual(r, u'\u20ac')

 def readUBadJson(self):
     s = ur"\u0027DOS\u0027*30"
     json.read(s)

 def testReadStringWithEscapedSingleQuote(self):
     s = '"don\'t tread on me."'
     assert json.read(s) == "don't tread on me."

 def testReadStringWithWhiteSpace(self):
     s = ur"'hello \tworld'"
     assert json.read(s) == 'hello \tworld'

 def testReadListOfStringsWithSpaces(self):
     s = u" ['a'    ,'b'  ,\n  'c']  "
     assert json.read(s) == ['a','b','c']

 def testReadListOfDictsWithSpaces(self):
     s = u" [ {    } ,{   \n} ]   "
     assert json.read(s) == [{},{}]

 def testReadListOfDicts(self):
     s = u"[{},{}]"
     assert json.read(s) == [{},{}]

 def readClassExploit(self):
     s = ur'''"__main__".__class__.__subclasses__()'''
     json.read(s)

 def readBadJson(self):
     s = "'DOS'*30"
     json.read(s)

 def testReadStringWithEscapedDoubleQuote(self):
     s = r'"She said, \"Hi.\""'
     assert json.read(s) == 'She said, "Hi."'

 def testReadEncodedUnicode(self):
     obj = "'La Peña'"
     r = json.read(obj, 'utf-8')
     self.assertEqual(r, unicode('La Peña','utf-8'))

 def testReadStringWithNewLine(self):
     s = r'"She said, \"Hi,\"\n to which he did not reply."'
     assert json.read(s) == 'She said, "Hi,"\n to which he did not reply.'