Python py2.range3函数代码示例

def deep_runner(container):
    depth = random.randint(1, 10)
    i = 0
    connections = [None] * depth
    for i in range3(depth):
        connections[i] = container.acquire_connection()
    for i in range3(depth - 1, -1, -1):
        container.release_connection(connections[i])

 def test_ucd_classes(self):
     class_cc = unicode5.CharClass.ucd_category('Cc')
     class_c = unicode5.CharClass.ucd_category('C')
     for code in range3(0x20):
         self.assertTrue(class_cc.test(character(code)))
         self.assertTrue(class_c.test(character(code)))
     for code in range3(0x7F, 0xA0):
         self.assertTrue(class_cc.test(character(code)))
         self.assertTrue(class_c.test(character(code)))
     self.assertFalse(class_cc.test(character(0xAD)))
     self.assertTrue(class_c.test(character(0xAD)))
     self.assertTrue(
         unicode5.CharClass.ucd_category('Cf').test(character(0xAD)))

 def test_multiget(self):
     threads = []
     for i in range3(10):
         threads.append(threading.Thread(target=self.domain3_thread_oneshot))
     for i in range3(10):
         threads.append(threading.Thread(target=self.domain4_thread_oneshot))
     for t in threads:
         t.start()
     while threads:
         t = threads.pop()
         t.join()
     # success criteria?  that we survived
     self.client.idle_cleanup(3)
     self.client.idle_cleanup(0)

 def test_letnum(self):
     """Basic syntax definitions::
         <let-num> ::= <upper> | <lower> | <number>
         <let-num-hyp> ::= <upper> | <lower> | <number> | "-"
     """
     for i in range3(0x00, 0x2D):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertFalse(urn.is_letnum(character(i)))
         self.assertFalse(urn.is_letnumhyp(character(i)))
     self.assertFalse(urn.is_upper(character(0x2D)))
     self.assertFalse(urn.is_lower(character(0x2D)))
     self.assertFalse(urn.is_number(character(0x2D)))
     self.assertFalse(urn.is_letnum(character(0x2D)))
     self.assertTrue(urn.is_letnumhyp(character(0x2D)))
     for i in range3(0x2E, 0x30):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertFalse(urn.is_letnum(character(i)))
         self.assertFalse(urn.is_letnumhyp(character(i)))
     for i in range3(0x30, 0x3A):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertTrue(urn.is_number(character(i)))
         self.assertTrue(urn.is_letnum(character(i)))
         self.assertTrue(urn.is_letnumhyp(character(i)))
     for i in range3(0x3A, 0x41):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertFalse(urn.is_letnum(character(i)))
         self.assertFalse(urn.is_letnumhyp(character(i)))
     for i in range3(0x41, 0x5B):
         self.assertTrue(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertTrue(urn.is_letnum(character(i)))
         self.assertTrue(urn.is_letnumhyp(character(i)))
     for i in range3(0x5B, 0x61):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertFalse(urn.is_letnum(character(i)))
         self.assertFalse(urn.is_letnumhyp(character(i)))
     for i in range3(0x61, 0x7B):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertTrue(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertTrue(urn.is_letnum(character(i)))
         self.assertTrue(urn.is_letnumhyp(character(i)))
     for i in range3(0x7B, 0xFF):
         self.assertFalse(urn.is_upper(character(i)))
         self.assertFalse(urn.is_lower(character(i)))
         self.assertFalse(urn.is_number(character(i)))
         self.assertFalse(urn.is_letnum(character(i)))
         self.assertFalse(urn.is_letnumhyp(character(i)))

 def multidata_app(self, environ, start_response):
     # the point of this app is to generate data of unknown
     # length forcing chunked encoding where possible
     start_response("200 OK", [])
     for i in range3(random.randint(2, 10)):
         yield b"Hello"
     yield b"xyz"

 def test_goodsize(self):
     data = b"How long is a piece of string?"
     src = io.BytesIO(data)
     # default buffer is larger than src
     b = BufferedStreamWrapper(src)
     self.assertTrue(isinstance(b, io.RawIOBase))
     self.assertTrue(b.readable())
     self.assertFalse(b.writable())
     self.assertTrue(b.seekable())
     self.assertTrue(b.length == len(data))
     pos = b.tell()
     self.assertTrue(pos == 0, "buffer starts at beginning of stream")
     for i in range3(100):
         # check seek and read
         newpos = random.randint(0, len(data) + 1)
         rlen = random.randint(0, len(data) + 1)
         whence = random.choice((io.SEEK_SET, io.SEEK_CUR, io.SEEK_END))
         if whence == io.SEEK_CUR:
             adj = newpos - pos
         elif whence == io.SEEK_END:
             adj = newpos - len(data)
         elif whence == io.SEEK_SET:
             adj = newpos
         b.seek(adj, whence)
         self.assertTrue(b.tell() == newpos,
                         "Expected %i found %i" % (newpos, b.tell()))
         pos = newpos
         xlen = max(0, min(len(data) - pos, rlen))
         rdata = b.read(rlen)
         self.assertTrue(len(rdata) == xlen)
         self.assertTrue(rdata == data[pos:pos + rlen])
         pos += xlen

 def test_create(self):
     ss = blockstore.StreamStore(bs=self.bs, ls=self.ls,
                                 entity_set=self.cdef['Streams'])
     s1 = ss.new_stream("text/plain")
     self.assertTrue(isinstance(s1, edm.Entity))
     self.assertTrue(s1.exists)
     try:
         self.assertTrue(s1.key() is not None)
     except KeyError:
         self.fail("stream entity has not key")
     self.assertTrue(s1['mimetype'].value == "text/plain")
     s2 = ss.new_stream(
         params.MediaType('text', 'plain',
                          {'charset': ('charset', 'utf-8')}))
     self.assertTrue(isinstance(s2, edm.Entity))
     self.assertTrue(s2['mimetype'].value == "text/plain; charset=utf-8")
     skey1 = s1.key()
     skey2 = s2.key()
     s1 = ss.get_stream(skey1)
     self.assertTrue(isinstance(s1, edm.Entity))
     for i in range3(10):
         try:
             ss.get_stream(i)
             self.assertTrue(i == skey1 or i == skey2)
         except KeyError:
             self.assertFalse(i == skey1 or i == skey2)

    def test_name_start(self):
        """Productions::

            [4] NameStartChar ::= ":" | [A-Z] | "_" | [a-z] |
                [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] |
                [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] |
                [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] |
                [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]

            [5] NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 |
                [#x0300-#x036F] | [#x203F-#x2040]"""
        n_namestartchars = 0
        n_namechars = 0
        for code in range3(0x10000):
            c = character(code)
            if structures.is_name_char(c):
                n_namechars += 1
                if structures.is_name_start_char(c):
                    n_namestartchars += 1
            else:
                self.assertFalse(structures.is_name_start_char(c),
                                 "NameStart not a name char: %s" % c)
        self.assertTrue(n_namechars == 54129,
                        "name char total %i" % n_namechars)
        self.assertTrue(n_namestartchars == 54002,
                        "name start char total %i" % n_namestartchars)

 def test_make_delimiter(self):
     # function to make a delimiter
     been_there = set()
     for i in range3(100):
         # try it 100 times, should be different each time
         boundary = multipart.make_boundary_delimiter()
         self.assertFalse(boundary in been_there)
         # check the syntax
         self.assertTrue(multipart.is_valid_boundary(boundary))
         # check length, need at least 20 characters in length
         # representing 120 bits of information
         self.assertTrue(len(boundary) >= 20)
         been_there.add(boundary)
         # now do one with a prefix
         boundary = multipart.make_boundary_delimiter(b"-- boundary ")
         self.assertTrue(multipart.is_valid_boundary(boundary))
         self.assertTrue(len(boundary) >= 32)
         been_there.add(boundary)
     # now do an illegal one
     try:
         boundary = multipart.make_boundary_delimiter(b" boundary ")
         self.fail("boundary starts with space")
     except ValueError:
         pass
     try:
         boundary = multipart.make_boundary_delimiter(b"-- {boundary} ")
         self.fail("boundary contains illegal character")
     except ValueError:
         pass

 def test_retries(self):
     request = http.ClientRequest("http://www.domain1.com/", max_retries=10, min_retry_time=4)
     self.assertTrue(request.max_retries == 10)
     self.assertTrue(request.nretries == 0)
     self.assertTrue(request.retry_time == 0)
     MockTime.now = 10.0
     ranges = [
         (10.0, 10.0),  # 10+0 +-0
         (13.0, 15.0),  # 10+4 +-1
         (13.0, 15.0),  # 10+4 +-1
         (16.0, 20.0),  # 10+8 +-2
         (19.0, 25.0),  # 10+12 +-3
         (25.0, 35.0),  # 10+20 +-5
         (34.0, 50.0),  # 10+32 +-8
         (49.0, 75.0),  # 10+52 +-13
         (73.0, 115.0),  # 10+84 +-21
         (112.0, 180.0),
     ]  # 10+136 +-34
     for i in range3(10):
         # simulate a failed send
         request.connect(None, 0)
         request.disconnect(1)
         self.assertTrue(request.can_retry(), "retry %ith time" % i)
         self.assertTrue(request.retry_time >= ranges[i][0], "%f too small in pair %i" % (request.retry_time, i))
         self.assertTrue(request.retry_time <= ranges[i][1], "%f too large in pair %i" % (request.retry_time, i))

 def test_kill(self):
     threads = []
     for i in range3(10):
         threads.append(threading.Thread(target=self.domain3_thread_oneshot))
     for i in range3(10):
         threads.append(threading.Thread(target=self.domain4_thread_oneshot))
     for t in threads:
         t.start()
     # we can't guarantee we'll find active connections unfortunately
     time.sleep(1)
     logging.info("%i active connections", self.client.active_count())
     self.client.active_cleanup(3)
     logging.info("%i active connections after active_cleanup(3)", self.client.active_count())
     self.client.active_cleanup(0)
     logging.info("%i active connections after active_cleanup(0)", self.client.active_count())
     while threads:
         t = threads.pop()
         t.join()

def test_data(mem_cache):
    with mem_cache.open() as collection:
        for i in range3(26):
            e = collection.new_entity()
            e.set_key(str(i))
            e['Value'].set_from_value(character(0x41 + i))
            e['Expires'].set_from_value(
                iso.TimePoint.from_unix_time(time.time() + 10 * i))
            collection.insert_entity(e)

 def compare_strings(self, expected, found, label="Test"):
     for i in range3(len(expected)):
         if i >= len(found):
             self.fail("%s truncation failure:\n%s... expected %s" %
                       (label, found[0:i], expected[i]))
         if expected[i] == found[i]:
             continue
         self.fail("%s mismatch:\n%s... expected %s ; found %s" %
                   (label, repr(found[0:i + 1]),
                    repr(expected[i]), repr(found[i])))

 def test_require_end(self):
     p = unicode5.BasicParser("hello")
     for i in range3(5):
         try:
             p.require_end()
             self.fail("require_end failed to raise exception")
         except unicode5.ParserError as e:
             self.assertTrue(e.production == ul("end"))
         p.next_char()
     p.require_end()

def mock_challenge():
    data = [byte(0)] * 56
    data[0:7] = list(b"NTLMSSP")
    data[8] = byte(2)
    data[16] = byte(56)
    data[20] = byte(1)
    data[21] = byte(0x82)
    for i in range3(8):
        data[24 + i] = byte(random.randint(0, 255))
    return join_bytes(data)