Home | History | Annotate | Download | only in pybench
      1 from pybench import Test
      2 from string import join
      3 
      4 class ConcatStrings(Test):
      5 
      6     version = 2.0
      7     operations = 10 * 5
      8     rounds = 100000
      9 
     10     def test(self):
     11 
     12         # Make sure the strings are *not* interned

     13         s = join(map(str,range(100)))
     14         t = join(map(str,range(1,101)))
     15 
     16         for i in xrange(self.rounds):
     17             t + s
     18             t + s
     19             t + s
     20             t + s
     21             t + s
     22 
     23             t + s
     24             t + s
     25             t + s
     26             t + s
     27             t + s
     28 
     29             t + s
     30             t + s
     31             t + s
     32             t + s
     33             t + s
     34 
     35             t + s
     36             t + s
     37             t + s
     38             t + s
     39             t + s
     40 
     41             t + s
     42             t + s
     43             t + s
     44             t + s
     45             t + s
     46 
     47             t + s
     48             t + s
     49             t + s
     50             t + s
     51             t + s
     52 
     53             t + s
     54             t + s
     55             t + s
     56             t + s
     57             t + s
     58 
     59             t + s
     60             t + s
     61             t + s
     62             t + s
     63             t + s
     64 
     65             t + s
     66             t + s
     67             t + s
     68             t + s
     69             t + s
     70 
     71             t + s
     72             t + s
     73             t + s
     74             t + s
     75             t + s
     76 
     77     def calibrate(self):
     78 
     79         s = join(map(str,range(100)))
     80         t = join(map(str,range(1,101)))
     81 
     82         for i in xrange(self.rounds):
     83             pass
     84 
     85 
     86 class CompareStrings(Test):
     87 
     88     version = 2.0
     89     operations = 10 * 5
     90     rounds = 200000
     91 
     92     def test(self):
     93 
     94         # Make sure the strings are *not* interned

     95         s = join(map(str,range(10)))
     96         t = join(map(str,range(10))) + "abc"
     97 
     98         for i in xrange(self.rounds):
     99             t < s
    100             t > s
    101             t == s
    102             t > s
    103             t < s
    104 
    105             t < s
    106             t > s
    107             t == s
    108             t > s
    109             t < s
    110 
    111             t < s
    112             t > s
    113             t == s
    114             t > s
    115             t < s
    116 
    117             t < s
    118             t > s
    119             t == s
    120             t > s
    121             t < s
    122 
    123             t < s
    124             t > s
    125             t == s
    126             t > s
    127             t < s
    128 
    129             t < s
    130             t > s
    131             t == s
    132             t > s
    133             t < s
    134 
    135             t < s
    136             t > s
    137             t == s
    138             t > s
    139             t < s
    140 
    141             t < s
    142             t > s
    143             t == s
    144             t > s
    145             t < s
    146 
    147             t < s
    148             t > s
    149             t == s
    150             t > s
    151             t < s
    152 
    153             t < s
    154             t > s
    155             t == s
    156             t > s
    157             t < s
    158 
    159     def calibrate(self):
    160 
    161         s = join(map(str,range(10)))
    162         t = join(map(str,range(10))) + "abc"
    163 
    164         for i in xrange(self.rounds):
    165             pass
    166 
    167 
    168 class CompareInternedStrings(Test):
    169 
    170     version = 2.0
    171     operations = 10 * 5
    172     rounds = 300000
    173 
    174     def test(self):
    175 
    176         # Make sure the strings *are* interned

    177         s = intern(join(map(str,range(10))))
    178         t = s
    179 
    180         for i in xrange(self.rounds):
    181             t == s
    182             t == s
    183             t >= s
    184             t > s
    185             t < s
    186 
    187             t == s
    188             t == s
    189             t >= s
    190             t > s
    191             t < s
    192 
    193             t == s
    194             t == s
    195             t >= s
    196             t > s
    197             t < s
    198 
    199             t == s
    200             t == s
    201             t >= s
    202             t > s
    203             t < s
    204 
    205             t == s
    206             t == s
    207             t >= s
    208             t > s
    209             t < s
    210 
    211             t == s
    212             t == s
    213             t >= s
    214             t > s
    215             t < s
    216 
    217             t == s
    218             t == s
    219             t >= s
    220             t > s
    221             t < s
    222 
    223             t == s
    224             t == s
    225             t >= s
    226             t > s
    227             t < s
    228 
    229             t == s
    230             t == s
    231             t >= s
    232             t > s
    233             t < s
    234 
    235             t == s
    236             t == s
    237             t >= s
    238             t > s
    239             t < s
    240 
    241     def calibrate(self):
    242 
    243         s = intern(join(map(str,range(10))))
    244         t = s
    245 
    246         for i in xrange(self.rounds):
    247             pass
    248 
    249 
    250 class CreateStringsWithConcat(Test):
    251 
    252     version = 2.0
    253     operations = 10 * 5
    254     rounds = 200000
    255 
    256     def test(self):
    257 
    258         for i in xrange(self.rounds):
    259             s = 'om'
    260             s = s + 'xbx'
    261             s = s + 'xcx'
    262             s = s + 'xdx'
    263             s = s + 'xex'
    264 
    265             s = s + 'xax'
    266             s = s + 'xbx'
    267             s = s + 'xcx'
    268             s = s + 'xdx'
    269             s = s + 'xex'
    270 
    271             s = s + 'xax'
    272             s = s + 'xbx'
    273             s = s + 'xcx'
    274             s = s + 'xdx'
    275             s = s + 'xex'
    276 
    277             s = s + 'xax'
    278             s = s + 'xbx'
    279             s = s + 'xcx'
    280             s = s + 'xdx'
    281             s = s + 'xex'
    282 
    283             s = s + 'xax'
    284             s = s + 'xbx'
    285             s = s + 'xcx'
    286             s = s + 'xdx'
    287             s = s + 'xex'
    288 
    289             s = s + 'xax'
    290             s = s + 'xbx'
    291             s = s + 'xcx'
    292             s = s + 'xdx'
    293             s = s + 'xex'
    294 
    295             s = s + 'xax'
    296             s = s + 'xbx'
    297             s = s + 'xcx'
    298             s = s + 'xdx'
    299             s = s + 'xex'
    300 
    301             s = s + 'xax'
    302             s = s + 'xbx'
    303             s = s + 'xcx'
    304             s = s + 'xdx'
    305             s = s + 'xex'
    306 
    307             s = s + 'xax'
    308             s = s + 'xbx'
    309             s = s + 'xcx'
    310             s = s + 'xdx'
    311             s = s + 'xex'
    312 
    313             s = s + 'xax'
    314             s = s + 'xbx'
    315             s = s + 'xcx'
    316             s = s + 'xdx'
    317             s = s + 'xex'
    318 
    319     def calibrate(self):
    320 
    321         for i in xrange(self.rounds):
    322             pass
    323 
    324 
    325 class StringSlicing(Test):
    326 
    327     version = 2.0
    328     operations = 5 * 7
    329     rounds = 160000
    330 
    331     def test(self):
    332 
    333         s = join(map(str,range(100)))
    334 
    335         for i in xrange(self.rounds):
    336 
    337             s[50:]
    338             s[:25]
    339             s[50:55]
    340             s[-1:]
    341             s[:1]
    342             s[2:]
    343             s[11:-11]
    344 
    345             s[50:]
    346             s[:25]
    347             s[50:55]
    348             s[-1:]
    349             s[:1]
    350             s[2:]
    351             s[11:-11]
    352 
    353             s[50:]
    354             s[:25]
    355             s[50:55]
    356             s[-1:]
    357             s[:1]
    358             s[2:]
    359             s[11:-11]
    360 
    361             s[50:]
    362             s[:25]
    363             s[50:55]
    364             s[-1:]
    365             s[:1]
    366             s[2:]
    367             s[11:-11]
    368 
    369             s[50:]
    370             s[:25]
    371             s[50:55]
    372             s[-1:]
    373             s[:1]
    374             s[2:]
    375             s[11:-11]
    376 
    377     def calibrate(self):
    378 
    379         s = join(map(str,range(100)))
    380 
    381         for i in xrange(self.rounds):
    382             pass
    383 
    384 ### String methods

    385 
    386 if hasattr('', 'lower'):
    387 
    388     class StringMappings(Test):
    389 
    390         version = 2.0
    391         operations = 3 * (5 + 4 + 2 + 1)
    392         rounds = 70000
    393 
    394         def test(self):
    395 
    396             s = join(map(chr,range(20)),'')
    397             t = join(map(chr,range(50)),'')
    398             u = join(map(chr,range(100)),'')
    399             v = join(map(chr,range(256)),'')
    400 
    401             for i in xrange(self.rounds):
    402 
    403                 s.lower()
    404                 s.lower()
    405                 s.lower()
    406                 s.lower()
    407                 s.lower()
    408 
    409                 s.upper()
    410                 s.upper()
    411                 s.upper()
    412                 s.upper()
    413                 s.upper()
    414 
    415                 s.title()
    416                 s.title()
    417                 s.title()
    418                 s.title()
    419                 s.title()
    420 
    421                 t.lower()
    422                 t.lower()
    423                 t.lower()
    424                 t.lower()
    425 
    426                 t.upper()
    427                 t.upper()
    428                 t.upper()
    429                 t.upper()
    430 
    431                 t.title()
    432                 t.title()
    433                 t.title()
    434                 t.title()
    435 
    436                 u.lower()
    437                 u.lower()
    438 
    439                 u.upper()
    440                 u.upper()
    441 
    442                 u.title()
    443                 u.title()
    444 
    445                 v.lower()
    446 
    447                 v.upper()
    448 
    449                 v.title()
    450 
    451         def calibrate(self):
    452 
    453             s = join(map(chr,range(20)),'')
    454             t = join(map(chr,range(50)),'')
    455             u = join(map(chr,range(100)),'')
    456             v = join(map(chr,range(256)),'')
    457 
    458             for i in xrange(self.rounds):
    459                 pass
    460 
    461     class StringPredicates(Test):
    462 
    463         version = 2.0
    464         operations = 10 * 7
    465         rounds = 100000
    466 
    467         def test(self):
    468 
    469             data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
    470             len_data = len(data)
    471 
    472             for i in xrange(self.rounds):
    473                 s = data[i % len_data]
    474 
    475                 s.isalnum()
    476                 s.isalpha()
    477                 s.isdigit()
    478                 s.islower()
    479                 s.isspace()
    480                 s.istitle()
    481                 s.isupper()
    482 
    483                 s.isalnum()
    484                 s.isalpha()
    485                 s.isdigit()
    486                 s.islower()
    487                 s.isspace()
    488                 s.istitle()
    489                 s.isupper()
    490 
    491                 s.isalnum()
    492                 s.isalpha()
    493                 s.isdigit()
    494                 s.islower()
    495                 s.isspace()
    496                 s.istitle()
    497                 s.isupper()
    498 
    499                 s.isalnum()
    500                 s.isalpha()
    501                 s.isdigit()
    502                 s.islower()
    503                 s.isspace()
    504                 s.istitle()
    505                 s.isupper()
    506 
    507                 s.isalnum()
    508                 s.isalpha()
    509                 s.isdigit()
    510                 s.islower()
    511                 s.isspace()
    512                 s.istitle()
    513                 s.isupper()
    514 
    515                 s.isalnum()
    516                 s.isalpha()
    517                 s.isdigit()
    518                 s.islower()
    519                 s.isspace()
    520                 s.istitle()
    521                 s.isupper()
    522 
    523                 s.isalnum()
    524                 s.isalpha()
    525                 s.isdigit()
    526                 s.islower()
    527                 s.isspace()
    528                 s.istitle()
    529                 s.isupper()
    530 
    531                 s.isalnum()
    532                 s.isalpha()
    533                 s.isdigit()
    534                 s.islower()
    535                 s.isspace()
    536                 s.istitle()
    537                 s.isupper()
    538 
    539                 s.isalnum()
    540                 s.isalpha()
    541                 s.isdigit()
    542                 s.islower()
    543                 s.isspace()
    544                 s.istitle()
    545                 s.isupper()
    546 
    547                 s.isalnum()
    548                 s.isalpha()
    549                 s.isdigit()
    550                 s.islower()
    551                 s.isspace()
    552                 s.istitle()
    553                 s.isupper()
    554 
    555         def calibrate(self):
    556 
    557             data = ('abc', '123', '   ', '\u1234\u2345\u3456', '\uFFFF'*10)
    558             data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
    559             len_data = len(data)
    560 
    561             for i in xrange(self.rounds):
    562                 s = data[i % len_data]
    563