def test_lazycache_provide_after_failed_lookup(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     linecache.getlines(NONEXISTENT_FILENAME)
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     self.assertEqual(lines, linecache.updatecache(NONEXISTENT_FILENAME))
예제 #2
0
 def test_lazycache_provide_after_failed_lookup(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     linecache.getlines(NONEXISTENT_FILENAME)
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     self.assertEqual(lines, linecache.updatecache(NONEXISTENT_FILENAME))
예제 #3
0
 def test_basics(self):
     linecache.clearcache()
     linecache.lazycache("f", fake_module)
     f = traceback.FrameSummary("f", 1, "dummy")
     self.assertEqual(
         ("f", 1, "dummy", '"""Test cases for traceback module"""'),
         tuple(f))
     self.assertEqual(None, f.locals)
예제 #4
0
 def test_lazy_lines(self):
     linecache.clearcache()
     f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
     self.assertEqual(None, f._line)
     linecache.lazycache("f", fake_module)
     self.assertEqual(
         '"""Test cases for traceback module"""',
         f.line)
 def test_basics(self):
     linecache.clearcache()
     linecache.lazycache("f", fake_module)
     f = traceback.FrameSummary("f", 1, "dummy")
     self.assertEqual(
         ("f", 1, "dummy", '"""Test cases for traceback module"""'),
         tuple(f))
     self.assertEqual(None, f.locals)
예제 #6
0
    def extract(klass,
                frame_gen,
                *,
                limit=None,
                lookup_lines=True,
                capture_locals=False):
        """Create a StackSummary from a traceback or stack object.

        :param frame_gen: A generator that yields (frame, lineno) tuples to
            include in the stack.
        :param limit: None to include all frames or the number of frames to
            include.
        :param lookup_lines: If True, lookup lines for each frame immediately,
            otherwise lookup is deferred until the frame is rendered.
        :param capture_locals: If True, the local variables from each frame will
            be captured as object representations into the FrameSummary.
        """
        if limit is None:
            limit = getattr(sys, 'tracebacklimit', None)
            if limit is not None and limit < 0:
                limit = 0
        if limit is not None:
            if limit >= 0:
                frame_gen = itertools.islice(frame_gen, limit)
            else:
                frame_gen = collections.deque(frame_gen, maxlen=-limit)

        result = klass()
        fnames = set()
        for f, lineno in frame_gen:
            co = f.f_code
            filename = co.co_filename
            name = co.co_name

            fnames.add(filename)
            print("traceback2:  f.f_globals", filename, f.f_globals.items(),
                  '__loader__' in f.f_globals)
            linecache.lazycache(filename, f.f_globals)
            # Must defer line lookups until we have called checkcache.
            if capture_locals:
                f_locals = f.f_locals
            else:
                f_locals = None
            result.append(
                FrameSummary(filename,
                             lineno,
                             name,
                             lookup_line=False,
                             locals=f_locals))
        for filename in fnames:
            linecache.checkcache(filename)
        # If immediate lookup was desired, trigger lookups now.
        if lookup_lines:
            for f in result:
                f.line
        return result
 def test_lazycache_already_cached(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     self.assertEqual(
         False,
         linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(4, len(linecache.cache[NONEXISTENT_FILENAME]))
 def test_lazycache_smoke(self):
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     self.assertEqual(
         True, linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(1, len(linecache.cache[NONEXISTENT_FILENAME]))
     # Note here that we're looking up a non existant filename with no
     # globals: this would error if the lazy value wasn't resolved.
     self.assertEqual(lines, linecache.getlines(NONEXISTENT_FILENAME))
예제 #9
0
 def test_lazycache_smoke(self):
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     self.assertEqual(True,
                      linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(1, len(linecache.cache[NONEXISTENT_FILENAME]))
     # Note here that we're looking up a non existant filename with no
     # globals: this would error if the lazy value wasn't resolved.
     self.assertEqual(lines, linecache.getlines(NONEXISTENT_FILENAME))
예제 #10
0
    def extract(klass, frame_gen, limit=None, lookup_lines=True,
            capture_locals=False):
        """Create a StackSummary from a traceback or stack object.

        :param frame_gen: A generator that yields (frame, lineno) tuples to
            include in the stack.
        :param limit: None to include all frames or the number of frames to
            include.
        :param lookup_lines: If True, lookup lines for each frame immediately,
            otherwise lookup is deferred until the frame is rendered.
        :param capture_locals: If True, the local variables from each frame will
            be captured as object representations into the FrameSummary.
        """
        if limit is None:
            limit = getattr(sys, 'tracebacklimit', None)

        result = klass()
        fnames = set()
        for pos, (f, lineno) in enumerate(frame_gen):
            if limit is not None and pos >= limit:
                break
            co = f.f_code
            filename = co.co_filename
            name = co.co_name

            fnames.add(filename)
            linecache.lazycache(filename, f.f_globals)
            # Must defer line lookups until we have called checkcache.
            if capture_locals:
                f_locals = f.f_locals
            else:
                f_locals = None
            result.append(FrameSummary(
                filename, lineno, name, lookup_line=False, locals=f_locals))
        for filename in fnames:
            linecache.checkcache(filename)
        # If immediate lookup was desired, trigger lookups now.
        if lookup_lines:
            for f in result:
                f.line
        return result
예제 #11
0
 def test_lazycache_no_globals(self):
     lines = linecache.getlines(FILENAME)
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache(FILENAME, None))
     self.assertEqual(lines, linecache.getlines(FILENAME))
예제 #12
0
 def test_lazycache_already_cached(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     self.assertEqual(False,
                      linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(4, len(linecache.cache[NONEXISTENT_FILENAME]))
예제 #13
0
 def test_lazycache_bad_filename(self):
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache('', globals()))
     self.assertEqual(False, linecache.lazycache('<foo>', globals()))
예제 #14
0
 def test_lazycache_check(self):
     linecache.clearcache()
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     linecache.checkcache()
예제 #15
0
 def test_lazycache_no_globals(self):
     lines = linecache.getlines(FILENAME)
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache(FILENAME, None))
     self.assertEqual(lines, linecache.getlines(FILENAME))
예제 #16
0
 def test_lazycache_check(self):
     linecache.clearcache()
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     linecache.checkcache()
예제 #17
0
 def test_lazycache_bad_filename(self):
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache('', globals()))
     self.assertEqual(False, linecache.lazycache('<foo>', globals()))