示例#1
0
 def testAnchorsBoundary(self):
     parsed = sre_yield.Values("ab\\b")
     self.assertEqual(["ab"], list(parsed))
     parsed = sre_yield.Values("\\bab")
     self.assertEqual(["ab"], list(parsed))
     parsed = sre_yield.Values("\\bab\\b")
     self.assertEqual(["ab"], list(parsed))
示例#2
0
 def testAnchorsBoundary(self):
     parsed = sre_yield.Values('ab\\b')
     self.assertEquals(['ab'], list(parsed))
     parsed = sre_yield.Values('\\bab')
     self.assertEquals(['ab'], list(parsed))
     parsed = sre_yield.Values('\\bab\\b')
     self.assertEquals(['ab'], list(parsed))
示例#3
0
def main(args):
    pattern = args[0]
    sys.stdout.write("%s\t" % (pattern, ))
    sys.stdout.flush()

    name = args[1]

    sys.stdout.write("%s\t" % (name, ))
    sys.stdout.flush()

    min_time = 1.0

    t0 = time.time()
    v = sre_yield.Values(pattern)
    t1 = time.time()

    sys.stdout.write("%.05f\t" % (t1 - t0, ))
    sys.stdout.flush()

    for test in (index(0), index(1), index(-2), index(-1), first_slice,
                 last_slice):
        v2 = sre_yield.Values(pattern)
        t0 = time.time()
        iterations = 0
        delta = 0
        first_delta = None
        while delta < min_time:
            test(v2)
            if isinstance(delta, int):
                first_delta = time.time() - t0
                sys.stdout.write("%.05f\t" % (first_delta, ))
                sys.stdout.flush()

            iterations += 1
            delta = time.time() - t0

        sys.stdout.write("%.05f\t" % (delta / iterations, ))
        sys.stdout.flush()

    with open('/proc/self/status') as f:
        for line in f:
            if line.startswith('VmPeak'):
                print line.split(':')[1].strip().rstrip(' kB')
                return
        else:
            print
 def testContentsNearBreak(self):
     # This specific location is on either side of offset_break in sre_yield.py
     v = sre_yield.Values(".*")
     a = v[70386233652806655][:10]
     self.assertEqual("\xff\xff\xff\xff\xff\xff\xff", a)
     b = v[70386233652806656][:10]
     self.assertEqual("\x00\x00\x00\x00\x00\x00\x00\x00", b)
     c = v[70386233652806657][:10]
     self.assertEqual("\x00\x00\x00\x00\x00\x00\x00\x01", c)
示例#5
0
 def testAnchorsCombined(self):
     parsed = sre_yield.Values('^[ab]$')
     self.assertEquals(['a', 'b'], list(parsed))
示例#6
0
 def testAnchorsZ(self):
     parsed = sre_yield.Values('[ab]\\Z')
     self.assertEquals(['a', 'b'], list(parsed))
示例#7
0
 def testAnchorsMultiCaret(self):
     parsed = sre_yield.Values('^(\\b^([ab]))')
     self.assertEquals(['a', 'b'], list(parsed))
示例#8
0
 def testAnchorsA(self):
     parsed = sre_yield.Values('\\A[ab]')
     self.assertEquals(['a', 'b'], list(parsed))
示例#9
0
 def testAnchorsA(self):
     parsed = sre_yield.Values("\\A[ab]")
     self.assertEqual(["a", "b"], list(parsed))
示例#10
0
 def testAnchorsEmptyString(self):
     parsed = sre_yield.Values(r'^^^$\b$')
     self.assertEquals([''], list(parsed))
示例#11
0
 def testAnchorsEmptyString(self):
     parsed = sre_yield.Values(r"^^^$\b$")
     self.assertEqual([""], list(parsed))
示例#12
0
 def testAnchorsRepeated(self):
     parsed = sre_yield.Values(r"[ab]$\b$")
     self.assertEqual(["a", "b"], list(parsed))
示例#13
0
 def testAnchorsCombined(self):
     parsed = sre_yield.Values("^[ab]$")
     self.assertEqual(["a", "b"], list(parsed))
示例#14
0
 def testAnchorsZ(self):
     parsed = sre_yield.Values("[ab]\\Z")
     self.assertEqual(["a", "b"], list(parsed))
示例#15
0
 def testAnchorsMultiCaret(self):
     parsed = sre_yield.Values("^(\\b^([ab]))")
     self.assertEqual(["a", "b"], list(parsed))
示例#16
0
 def testAnchorsRepeated(self):
     parsed = sre_yield.Values(r'[ab]$\b$')
     self.assertEquals(['a', 'b'], list(parsed))
示例#17
0
 def testAnchorsCaret(self):
     parsed = sre_yield.Values('^[ab]')
     self.assertEqual(['a', 'b'], list(parsed))
示例#18
0
 def testAnchorsDollar(self):
     parsed = sre_yield.Values('[ab]$')
     self.assertEqual(['a', 'b'], list(parsed))
示例#19
0
 def testAnchorsRepeatedBeginning(self):
     parsed = sre_yield.Values(r"^\b^[ab]")
     self.assertEqual(["a", "b"], list(parsed))