模糊测试之书-二十-

模糊测试之书（二十）

原文：exploringjs.com/ts/book/index.html

译者：飞龙

协议：CC BY-NC-SA 4.0

控制流图

www.fuzzingbook.org/html/ControlFlow.html

这个笔记本中的代码有助于获取 Python 函数的控制流图。

先决条件

这个笔记本需要对 Python 的高级概念有所了解，特别是
- 类

控制流图

PyCFG类允许用户获取控制流图。

from ControlFlow import gen_cfg, to_graph
cfg = gen_cfg(inspect.getsource(my_function))
to_graph(cfg)

import [bookutils.setup](https://github.com/uds-se/fuzzingbook//tree/master/notebooks/shared/bookutils)

from [bookutils](https://github.com/uds-se/fuzzingbook//tree/master/notebooks/shared/bookutils) import print_content

import [ast](https://docs.python.org/3/library/ast.html)
import [re](https://docs.python.org/3/library/re.html)

from [graphviz](https://graphviz.readthedocs.io/) import Source, Digraph

注册

REGISTRY_IDX = 0

REGISTRY = {}

def get_registry_idx():
    global REGISTRY_IDX
    v = REGISTRY_IDX
    REGISTRY_IDX += 1
    return v

def reset_registry():
    global REGISTRY_IDX
    global REGISTRY
    REGISTRY_IDX = 0
    REGISTRY = {}

def register_node(node):
    node.rid = get_registry_idx()
    REGISTRY[node.rid] = node

def get_registry():
    return dict(REGISTRY)

CFGNode

我们从表示控制流图每个节点的CFGNode开始。\todo{增强和注解赋值（a += 1），（a:int = 1）}。

class CFGNode(dict):
    def __init__(self, parents=[], ast=None):
        assert type(parents) is list
        register_node(self)
        self.parents = parents
        self.ast_node = ast
        self.update_children(parents)  # requires self.rid
        self.children = []
        self.calls = []

    def i(self):
        return str(self.rid)

    def update_children(self, parents):
        for p in parents:
            p.add_child(self)

    def add_child(self, c):
        if c not in self.children:
            self.children.append(c)

    def lineno(self):
        return self.ast_node.lineno if hasattr(self.ast_node, 'lineno') else 0

    def __str__(self):
        return "id:%d line[%d] parents: %s : %s" % (
            self.rid, self.lineno(), str([p.rid for p in self.parents]),
            self.source())

    def __repr__(self):
        return str(self)

    def __eq__(self, other):
        return self.rid == other.rid

    def __neq__(self, other):
        return self.rid != other.rid

    def set_parents(self, p):
        self.parents = p

    def add_parent(self, p):
        if p not in self.parents:
            self.parents.append(p)

    def add_parents(self, ps):
        for p in ps:
            self.add_parent(p)

    def add_calls(self, func):
        self.calls.append(func)

    def source(self):
        return ast.unparse(self.ast_node).strip()

    def to_json(self):
        return {
            'id': self.rid,
            'parents': [p.rid for p in self.parents],
            'children': [c.rid for c in self.children],
            'calls': self.calls,
            'at': self.lineno(),
            'ast': self.source()
        }

PyCFG

接下来是负责解析和持有图的PyCFG类。

class PyCFG:
    def __init__(self):
        self.founder = CFGNode(
            parents=[], ast=ast.parse('start').body[0])  # sentinel
        self.founder.ast_node.lineno = 0
        self.functions = {}
        self.functions_node = {}

class PyCFG(PyCFG):
    def parse(self, src):
        return ast.parse(src)

class PyCFG(PyCFG):
    def walk(self, node, myparents):
        fname = "on_%s" % node.__class__.__name__.lower()
        if hasattr(self, fname):
            fn = getattr(self, fname)
            v = fn(node, myparents)
            return v
        else:
            return myparents

class PyCFG(PyCFG):
    def on_module(self, node, myparents):
  """
 Module(stmt* body)
 """
        # each time a statement is executed unconditionally, make a link from
        # the result to next statement
        p = myparents
        for n in node.body:
            p = self.walk(n, p)
        return p

class PyCFG(PyCFG):
    def on_augassign(self, node, myparents):
  """
 AugAssign(expr target, operator op, expr value)
 """
        p = [CFGNode(parents=myparents, ast=node)]
        p = self.walk(node.value, p)

        return p

class PyCFG(PyCFG):
    def on_annassign(self, node, myparents):
  """
 AnnAssign(expr target, expr annotation, expr? value, int simple)
 """
        p = [CFGNode(parents=myparents, ast=node)]
        p = self.walk(node.value, p)

        return p

class PyCFG(PyCFG):
    def on_assign(self, node, myparents):
  """
 Assign(expr* targets, expr value)
 """
        if len(node.targets) > 1:
            raise NotImplemented('Parallel assignments')

        p = [CFGNode(parents=myparents, ast=node)]
        p = self.walk(node.value, p)

        return p

class PyCFG(PyCFG):
    def on_pass(self, node, myparents):
        return [CFGNode(parents=myparents, ast=node)]

class PyCFG(PyCFG):
    def on_break(self, node, myparents):
        parent = myparents[0]
        while not hasattr(parent, 'exit_nodes'):
            # we have ordered parents
            parent = parent.parents[0]

        assert hasattr(parent, 'exit_nodes')
        p = CFGNode(parents=myparents, ast=node)

        # make the break one of the parents of label node.
        parent.exit_nodes.append(p)

        # break doesn't have immediate children
        return []

class PyCFG(PyCFG):
    def on_continue(self, node, myparents):
        parent = myparents[0]
        while not hasattr(parent, 'exit_nodes'):
            # we have ordered parents
            parent = parent.parents[0]
        assert hasattr(parent, 'exit_nodes')
        p = CFGNode(parents=myparents, ast=node)

        # make continue one of the parents of the original test node.
        parent.add_parent(p)

        # return the parent because a continue is not the parent
        # for the just next node
        return []

class PyCFG(PyCFG):
    def on_for(self, node, myparents):
        # node.target in node.iter: node.body
        # The For loop in python (no else) can be translated
        # as follows:
        # 
        # for a in iterator:
        #      mystatements
        #
        # __iv = iter(iterator)
        # while __iv.__length_hint() > 0:
        #     a = next(__iv)
        #     mystatements

        init_node = CFGNode(parents=myparents,
            ast=ast.parse('__iv = iter(%s)' % ast.unparse(node.iter).strip()).body[0])
        ast.copy_location(init_node.ast_node, node.iter)

        _test_node = CFGNode(
            parents=[init_node],
            ast=ast.parse('_for: __iv.__length__hint__() > 0').body[0])
        ast.copy_location(_test_node.ast_node, node)

        # we attach the label node here so that break can find it.
        _test_node.exit_nodes = []
        test_node = self.walk(node.iter, [_test_node])

        extract_node = CFGNode(parents=test_node,
            ast=ast.parse('%s = next(__iv)' % ast.unparse(node.target).strip()).body[0])
        ast.copy_location(extract_node.ast_node, node.iter)

        # now we evaluate the body, one at a time.
        p1 = [extract_node]
        for n in node.body:
            p1 = self.walk(n, p1)

        # the test node is looped back at the end of processing.
        _test_node.add_parents(p1)

        return _test_node.exit_nodes + test_node

class PyCFG(PyCFG):
    def on_while(self, node, myparents):
        # For a while, the earliest parent is the node.test
        _test_node = CFGNode(
            parents=myparents,
            ast=ast.parse(
                '_while: %s' % ast.unparse(node.test).strip()).body[0])
        ast.copy_location(_test_node.ast_node, node.test)
        _test_node.exit_nodes = []
        test_node = self.walk(node.test, [_test_node])

        # we attach the label node here so that break can find it.

        # now we evaluate the body, one at a time.
        assert len(test_node) == 1
        p1 = test_node
        for n in node.body:
            p1 = self.walk(n, p1)

        # the test node is looped back at the end of processing.
        _test_node.add_parents(p1)

        # link label node back to the condition.
        return _test_node.exit_nodes + test_node

class PyCFG(PyCFG):
    def on_if(self, node, myparents):
        _test_node = CFGNode(
            parents=myparents,
            ast=ast.parse(
                '_if: %s' % ast.unparse(node.test).strip()).body[0])
        ast.copy_location(_test_node.ast_node, node.test)
        test_node = self.walk(node.test, [ _test_node])
        assert len(test_node) == 1
        g1 = test_node
        for n in node.body:
            g1 = self.walk(n, g1)
        g2 = test_node
        for n in node.orelse:
            g2 = self.walk(n, g2)
        return g1 + g2

class PyCFG(PyCFG):
    def on_binop(self, node, myparents):
        left = self.walk(node.left, myparents)
        right = self.walk(node.right, left)
        return right

class PyCFG(PyCFG):
    def on_compare(self, node, myparents):
        left = self.walk(node.left, myparents)
        right = self.walk(node.comparators[0], left)
        return right

class PyCFG(PyCFG):
    def on_unaryop(self, node, myparents):
        return self.walk(node.operand, myparents)

class PyCFG(PyCFG):
    def on_call(self, node, myparents):
        def get_func(node):
            if type(node.func) is ast.Name:
                mid = node.func.id
            elif type(node.func) is ast.Attribute:
                mid = node.func.attr
            elif type(node.func) is ast.Call:
                mid = get_func(node.func)
            else:
                raise Exception(str(type(node.func)))
            return mid
            #mid = node.func.value.id

        p = myparents
        for a in node.args:
            p = self.walk(a, p)
        mid = get_func(node)
        myparents[0].add_calls(mid)

        # these need to be unlinked later if our module actually defines these
        # functions. Otherwise we may leave them around.
        # during a call, the direct child is not the next
        # statement in text.
        for c in p:
            c.calllink = 0
        return p

class PyCFG(PyCFG):
    def on_expr(self, node, myparents):
        p = [CFGNode(parents=myparents, ast=node)]
        return self.walk(node.value, p)

class PyCFG(PyCFG):
    def on_return(self, node, myparents):
        if type(myparents) is tuple:
            parent = myparents[0][0]
        else:
            parent = myparents[0]

        val_node = self.walk(node.value, myparents)
        # on return look back to the function definition.
        while not hasattr(parent, 'return_nodes'):
            parent = parent.parents[0]
        assert hasattr(parent, 'return_nodes')

        p = CFGNode(parents=val_node, ast=node)

        # make the break one of the parents of label node.
        parent.return_nodes.append(p)

        # return doesnt have immediate children
        return []

class PyCFG(PyCFG):
    def on_functiondef(self, node, myparents):
        # a function definition does not actually continue the thread of
        # control flow
        # name, args, body, decorator_list, returns
        fname = node.name
        args = node.args
        returns = node.returns

        enter_node = CFGNode(
            parents=[],
            ast=ast.parse('enter: %s(%s)' % (node.name, ', '.join(
                [a.arg for a in node.args.args]))).body[0])  # sentinel
        enter_node.calleelink = True
        ast.copy_location(enter_node.ast_node, node)
        exit_node = CFGNode(
            parents=[],
            ast=ast.parse('exit: %s(%s)' % (node.name, ', '.join(
                [a.arg for a in node.args.args]))).body[0])  # sentinel
        exit_node.fn_exit_node = True
        ast.copy_location(exit_node.ast_node, node)
        enter_node.return_nodes = []  # sentinel

        p = [enter_node]
        for n in node.body:
            p = self.walk(n, p)

        for n in p:
            if n not in enter_node.return_nodes:
                enter_node.return_nodes.append(n)

        for n in enter_node.return_nodes:
            exit_node.add_parent(n)

        self.functions[fname] = [enter_node, exit_node]
        self.functions_node[enter_node.lineno()] = fname

        return myparents

class PyCFG(PyCFG):
    def get_defining_function(self, node):
        if node.lineno() in self.functions_node:
            return self.functions_node[node.lineno()]
        if not node.parents:
            self.functions_node[node.lineno()] = ''
            return ''
        val = self.get_defining_function(node.parents[0])
        self.functions_node[node.lineno()] = val
        return val

class PyCFG(PyCFG):
    def link_functions(self):
        for nid, node in REGISTRY.items():
            if node.calls:
                for calls in node.calls:
                    if calls in self.functions:
                        enter, exit = self.functions[calls]
                        enter.add_parent(node)
                        if node.children:
                            # # until we link the functions up, the node
                            # # should only have succeeding node in text as
                            # # children.
                            # assert(len(node.children) == 1)
                            # passn = node.children[0]
                            # # We require a single pass statement after every
                            # # call (which means no complex expressions)
                            # assert(type(passn.ast_node) == ast.Pass)

                            # # unlink the call statement
                            assert node.calllink > -1
                            node.calllink += 1
                            for i in node.children:
                                i.add_parent(exit)
                            # passn.set_parents([exit])
                            # ast.copy_location(exit.ast_node, passn.ast_node)

                            # #for c in passn.children: c.add_parent(exit)
                            # #passn.ast_node = exit.ast_node

class PyCFG(PyCFG):
    def update_functions(self):
        for nid, node in REGISTRY.items():
            _n = self.get_defining_function(node)

class PyCFG(PyCFG):
    def update_children(self):
        for nid, node in REGISTRY.items():
            for p in node.parents:
                p.add_child(node)

class PyCFG(PyCFG):
    def gen_cfg(self, src):
  """
 >>> i = PyCFG()
 >>> i.walk("100")
 5
 """
        node = self.parse(src)
        nodes = self.walk(node, [self.founder])
        self.last_node = CFGNode(parents=nodes, ast=ast.parse('stop').body[0])
        ast.copy_location(self.last_node.ast_node, self.founder.ast_node)
        self.update_children()
        self.update_functions()
        self.link_functions()

支持函数

def compute_dominator(cfg, start=0, key='parents'):
    dominator = {}
    dominator[start] = {start}
    all_nodes = set(cfg.keys())
    rem_nodes = all_nodes - {start}
    for n in rem_nodes:
        dominator[n] = all_nodes

    c = True
    while c:
        c = False
        for n in rem_nodes:
            pred_n = cfg[n][key]
            doms = [dominator[p] for p in pred_n]
            i = set.intersection(*doms) if doms else set()
            v = {n} | i
            if dominator[n] != v:
                c = True
            dominator[n] = v
    return dominator

def compute_flow(pythonfile):
    cfg, first, last = get_cfg(pythonfile)
    return cfg, compute_dominator(
        cfg, start=first), compute_dominator(
            cfg, start=last, key='children')

def gen_cfg(fnsrc, remove_start_stop=True):
    reset_registry()
    cfg = PyCFG()
    cfg.gen_cfg(fnsrc)
    cache = dict(REGISTRY)
    if remove_start_stop:
        return {
            k: cache[k]
            for k in cache if cache[k].source() not in {'start', 'stop'}
        }
    else:
        return cache

def get_cfg(src):
    reset_registry()
    cfg = PyCFG()
    cfg.gen_cfg(src)
    cache = dict(REGISTRY)
    g = {}
    for k, v in cache.items():
        j = v.to_json()
        at = j['at']
        parents_at = [cache[p].to_json()['at'] for p in j['parents']]
        children_at = [cache[c].to_json()['at'] for c in j['children']]
        if at not in g:
            g[at] = {'parents': set(), 'children': set()}
        # remove dummy nodes
        ps = set([p for p in parents_at if p != at])
        cs = set([c for c in children_at if c != at])
        g[at]['parents'] |= ps
        g[at]['children'] |= cs
        if v.calls:
            g[at]['calls'] = v.calls
        g[at]['function'] = cfg.functions_node[v.lineno()]
    return (g, cfg.founder.ast_node.lineno, cfg.last_node.ast_node.lineno)

def to_graph(cache, arcs=[]):
    graph = Digraph(comment='Control Flow Graph')
    colors = {0: 'blue', 1: 'red'}
    kind = {0: 'T', 1: 'F'}
    cov_lines = set(i for i, j in arcs)
    for nid, cnode in cache.items():
        lineno = cnode.lineno()
        shape, peripheries = 'oval', '1'
        if isinstance(cnode.ast_node, ast.AnnAssign):
            if cnode.ast_node.target.id in {'_if', '_for', '_while'}:
                shape = 'diamond'
            elif cnode.ast_node.target.id in {'enter', 'exit'}:
                shape, peripheries = 'oval', '2'
        else:
            shape = 'rectangle'
        graph.node(cnode.i(), "%d: %s" % (lineno, unhack(cnode.source())),
                   shape=shape, peripheries=peripheries)
        for pn in cnode.parents:
            plineno = pn.lineno()
            if hasattr(pn, 'calllink') and pn.calllink > 0 and not hasattr(
                    cnode, 'calleelink'):
                graph.edge(pn.i(), cnode.i(), style='dotted', weight=100)
                continue

            if arcs:
                if (plineno, lineno) in arcs:
                    graph.edge(pn.i(), cnode.i(), color='green')
                elif plineno == lineno and lineno in cov_lines:
                    graph.edge(pn.i(), cnode.i(), color='green')
                # child is exit and parent is covered
                elif hasattr(cnode, 'fn_exit_node') and plineno in cov_lines:
                    graph.edge(pn.i(), cnode.i(), color='green')
                # parent is exit and one of its parents is covered.
                elif hasattr(pn, 'fn_exit_node') and len(
                        set(n.lineno() for n in pn.parents) | cov_lines) > 0:
                    graph.edge(pn.i(), cnode.i(), color='green')
                # child is a callee (has calleelink) and one of the parents is covered.
                elif plineno in cov_lines and hasattr(cnode, 'calleelink'):
                    graph.edge(pn.i(), cnode.i(), color='green')
                else:
                    graph.edge(pn.i(), cnode.i(), color='red')
            else:
                order = {c.i(): i for i, c in enumerate(pn.children)}
                if len(order) < 2:
                    graph.edge(pn.i(), cnode.i())
                else:
                    o = order[cnode.i()]
                    graph.edge(pn.i(), cnode.i(), color=colors[o], label=kind[o])
    return graph

def unhack(v):
    for i in ['if', 'while', 'for', 'elif']:
        v = re.sub(r'^_%s:' % i, '%s:' % i, v)
    return v

示例

check_triangle

def check_triangle(a, b, c):
    if a == b:
        if a == c:
            if b == c:
                return "Equilateral"
            else:
                return "Isosceles"
        else:
            return "Isosceles"
    else:
        if b != c:
            if a == c:
                return "Isosceles"
            else:
                return "Scalene"
        else:
            return "Isosceles"

import [inspect](https://docs.python.org/3/library/inspect.html)

to_graph(gen_cfg(inspect.getsource(check_triangle)))

cgi_decode

注意，我们目前还不支持增强赋值：即类似于+=的赋值。

def cgi_decode(s):
    hex_values = {
        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
        'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,
        'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
    }

    t = ""
    i = 0
    while i < len(s):
        c = s[i]
        if c == '+':
            t += ' '
        elif c == '%':
            digit_high, digit_low = s[i + 1], s[i + 2]
            i += 2
            if digit_high in hex_values and digit_low in hex_values:
                v = hex_values[digit_high] * 16 + hex_values[digit_low]
                t += chr(v)
            else:
                raise ValueError("Invalid encoding")
        else:
            t += c
        i += 1
    return t

to_graph(gen_cfg(inspect.getsource(cgi_decode)))

gcd

def gcd(a, b):
    if a<b:
        c: int = a
        a: int = b
        b: int = c

    while b != 0 :
        c: int = a
        a: int = b
        b: int = c % b
    return a

to_graph(gen_cfg(inspect.getsource(gcd)))

def compute_gcd(x, y):
    if x > y:
        small = y
    else:
        small = x
    for i in range(1, small+1):
        if((x % i == 0) and (y % i == 0)):
            gcd = i

    return gcd

to_graph(gen_cfg(inspect.getsource(compute_gcd)))

length__hint() > 0 6->7 7->11 F 8 6: i = next(__iv) 7->8 T 10 8: gcd = i 10->7 9 7: if: x % i == 0 and y % i == 0 9->7 F 9->10 T 8->9

fib

注意，for 循环需要额外的处理。虽然我们正确显示了标签，但比较节点需要提取。因此，表示并不准确。

def fib(n,):
    ls = [0, 1]
    for i in range(n-2):
        ls.append(ls[-1] + ls[-2])
    return ls

to_graph(gen_cfg(inspect.getsource(fib)))

length__hint() > 0 4->5 5->8 F 6 3: i = next(__iv) 5->6 T 7 4: ls.append(ls[-1] + ls[-2]) 7->5 6->7

quad_solver

def quad_solver(a, b, c):
    discriminant = b² - 4*a*c
    r1, r2 = 0, 0
    i1, i2 = 0, 0
    if discriminant >= 0:
        droot = math.sqrt(discriminant)
        r1 = (-b + droot) / (2*a)
        r2 = (-b - droot) / (2*a)
    else:
        droot = math.sqrt(-1 * discriminant)
        droot_ = droot/(2*a)
        r1, i1 = -b/(2*a), droot_
        r2, i2 = -b/(2*a), -droot_
    if i1 == 0 and i2 == 0:
        return (r1, r2)
    return ((r1,i1), (r2,i2))

to_graph(gen_cfg(inspect.getsource(quad_solver)))

调用图

安装：Pyan 静态调用图提升器

import [os](https://docs.python.org/3/library/os.html)

import [networkx](https://networkx.org/) as nx

调用图辅助工具

import [shutil](https://docs.python.org/3/library/shutil.html)

PYAN = 'pyan3' if shutil.which('pyan3') is not None else 'pyan'

if shutil.which(PYAN) is None:
    # If installed from pypi, pyan may still be missing
    os.system('pip install "git+https://github.com/uds-se/pyan#egg=pyan"')
    PYAN = 'pyan3' if shutil.which('pyan3') is not None else 'pyan'

assert shutil.which(PYAN) is not None

def construct_callgraph(code, name="callgraph"):
    file_name = name + ".py"
    with open(file_name, 'w') as f:
        f.write(code)
    cg_file = name + '.dot'
    os.system(f'{PYAN}  {file_name} --uses --defines --colored --grouped --annotated --dot > {cg_file}')

def callgraph(code, name="callgraph"):
    if not os.path.isfile(name + '.dot'):
        construct_callgraph(code, name)
    return Source.from_file(name + '.dot')

def get_callgraph(code, name="callgraph"):
    if not os.path.isfile(name + '.dot'):
        construct_callgraph(code, name)

    # This is deprecated:
    # return nx.drawing.nx_pydot.read_dot(name + '.dot')

    return nx.nx_agraph.read_dot(name + '.dot')

示例：迷宫

为了提供一个有意义的示例，你可以轻松地更改代码复杂度和目标位置，我们从提供的字符串形式的迷宫生成迷宫源代码。这个例子大致基于 Felipe Andres Manzano 关于符号执行的旧博客文章（快速致意！）。

你只需将迷宫指定为一个字符串。就像这样。

maze_string = """
+-+-----+
|X|     |
| | --+ |
| |   | |
| +-- | |
|     |#|
+-----+-+
"""

maze_string中的每个字符代表一个方块。对于每个方块，生成一个方块函数。

如果当前方块是“良性”（），则调用对应下一个输入字符（D，U，L，R）的方块函数。意外的输入字符将被忽略。如果没有更多的输入字符，则返回“VALID”以及当前迷宫状态。`

* 如果当前方块是“陷阱”（`+`,`|`,`-`），则返回“INVALID”以及当前迷宫状态。* 如果当前方块是“目标”（`#`），则返回“SOLVED”以及当前迷宫状态。

代码是通过函数 `generate_maze_code` 生成的。 py` def generate_print_maze(maze_string): return """ def print_maze(out, row, col): output = out +"\n" c_row = 0 c_col = 0 for c in list("""%s"""): if c == '\n': c_row += 1 c_col = 0 output += "\n" else: if c_row == row and c_col == col: output += "X" elif c == "X": output += " " else: output += c c_col += 1 return output """ % maze_string py def generate_trap_tile(row, col): return """ def tile_%d_%d(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", %d, %d) """ % (row, col, row, col) py def generate_good_tile(c, row, col): code = """ def tile_%d_%d(input, index): if (index == len(input)): return print_maze("VALID", %d, %d) elif input[index] == 'L': return tile_%d_%d(input, index + 1) elif input[index] == 'R': return tile_%d_%d(input, index + 1) elif input[index] == 'U': return tile_%d_%d(input, index + 1) elif input[index] == 'D': return tile_%d_%d(input, index + 1) else : return tile_%d_%d(input, index + 1) """ % (row, col, row, col, row, col - 1, row, col + 1, row - 1, col, row + 1, col, row, col) if c == "X": code += """ def maze(input): return tile_%d_%d(list(input), 0) """ % (row, col) return code py def generate_target_tile(row, col): return """ def tile_%d_%d(input, index): return print_maze("SOLVED", %d, %d) def target_tile(): return "tile_%d_%d" """ % (row, col, row, col, row, col) py def generate_maze_code(maze, name="maze"): row = 0 col = 0 code = generate_print_maze(maze) for c in list(maze): if c == '\n': row += 1 col = 0 else: if c == "-" or c == "+" or c == "|": code += generate_trap_tile(row, col) elif c == " " or c == "X": code += generate_good_tile(c, row, col) elif c == "#": code += generate_target_tile(row, col) else: print("无效的迷宫！请尝试另一个。") col += 1 return code py Now you can generate the maze code for an arbitrary maze. maze_code = generate_maze_code(maze_string) py print_content(maze_code, filename='.py') py def print_maze(out, row, col): output = out +"\n" c_row = 0 c_col = 0 for c in list(""" +-+-----+ |X| | | | --+ | | | | | | +-- | | | |#| +-----+-+ """): if c == '\n': c_row += 1 c_col = 0 output += "\n" else: if c_row == row and c_col == col: output += "X" elif c == "X": output += " " else: output += c c_col += 1 return output def tile_1_0(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 0) def tile_1_1(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 1) def tile_1_2(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 2) def tile_1_3(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 3) def tile_1_4(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 4) def tile_1_5(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 5) def tile_1_6(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 6) def tile_1_7(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 7) def tile_1_8(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 1, 8) def tile_2_0(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 2, 0) def tile_2_1(input, index): if (index == len(input)): return print_maze("VALID", 2, 1) elif input[index] == 'L': return tile_2_0(input, index + 1) elif input[index] == 'R': return tile_2_2(input, index + 1) elif input[index] == 'U': return tile_1_1(input, index + 1) elif input[index] == 'D': return tile_3_1(input, index + 1) else : return tile_2_1(input, index + 1) def maze(input): return tile_2_1(list(input), 0) def tile_2_2(input, index): try: HTMLParser().feed(input) except: pass return print_maze("INVALID", 2, 2) def tile_2_3(input, index): if (index == len(input)): return print_maze("VALID", 2, 3) elif input[index] == 'L': return tile_2_2(input, index + 1) elif input[index] == 'R': return tile_2_4(input, index + 1) elif input[index] == 'U': return tile_1_3(input, index + 1) elif input[index] == 'D': return tile_3_3(input, index + 1) else : return tile_2_3(input, index + 1) def tile_2_4(input, index): if (index == len(input)): return print_maze("VALID", 2, 4) elif input[index] == 'L': return tile_2_3(input, index + 1) elif input[index] == 'R': return tile_2_5(input, index + 1) elif input[index] == 'U': return tile_1_4(input, index + 1) elif input[index] == 'D': return tile_3_4(input, index + 1) else : return tile_2_4(input, index + 1) def tile_2_5(input, index): if (index == len(input)): return print_maze("VALID", 2, 5) elif input[index] == 'L': return tile_2_4(input, index + 1) elif input[index] == 'R': return tile_2_6(input, index + 1) elif input[index] == 'U': return tile_1_5(input, index + 1) elif input[index] == 'D': return tile_3_5(input, index + 1) else : return tile_2_5(input, index + 1) def tile_2_6(input, index): if (index == len(input)): return print_maze("VALID", 2, 6) elif input[index] == 'L': return tile_2_5(input, index + 1) elif input[index] == 'R': return tile_2_7(input, index + 1) elif input[index] == 'U': return tile_1_6(input, index + 1) elif input[index] == 'D': return tile_3_6(input, index + 1) else : return tile_2_6(input, index + 1) def tile_2_7(input, index): if (index == len(input)): return print_maze("VALID", 2, 7) elif input[index] == 'L': return tile_2_6(input, index + 1) elif input[index] == 'R': return tile_2_8(input, index + 1) elif input[index] == 'U': return tile_1_7(input, index + 1) elif input[index] == 'D': return tile_3_7(input, index + 1) else : return tile_2_7(input, index + 1) def tile_

索引

原文：www.fuzzingbook.org/html/00_Index.html

A - E

A

自动化软件测试效率的概率分析 — 灰盒模糊测试（背景）
一个解决方案 — 约束性模糊测试（解决约束）
A() — 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（AssignmentTracker）
A1_GRAMMAR — 解析输入（语法和推导树）, 解析输入（递归）, 解析输入（歧义）, 解析输入（背景）, 解析输入（练习 8：非终结符的首集）, 解析输入（练习 9：非终结符的后续集）
A2_GRAMMAR — 解析输入（语法和推导树）, 解析输入（背景）
A3_GRAMMAR — 解析输入（歧义解析）
抽象语法树语法 — 测试编译器（AST 语法）, 测试编译器（复合）
抽象语法树 — 解析输入（解析器类）
abs_max() — 约束性模糊测试（示例：绝对最大值）, 符号模糊测试（获取使用的变量名称和类型）
abs_value() — 约束性模糊测试（示例：绝对最大值）, 符号模糊测试（函数摘要）
actions — 测试图形用户界面（检索用户界面动作）, 测试图形用户界面（实现检索动作）
ACTIONS — 测试图形用户界面（探索大型网站）, 测试图形用户界面（探索大型网站）, 测试图形用户界面（探索大型网站）
add() — 解析输入（列）
add-operator — 基于语法的灰盒模糊测试（基于片段的变异）
addDebug() — 铁路图（铁路图实现）
addTo() — 铁路图 (铁路图实现：探险)
add_call() — 挖掘函数规范 (跟踪调用)，单元测试裁剪 (记录调用)
add_calls() — 控制流图 (CFGNode)
add_child() — 约束模糊测试 (表示决策)，控制流图 (CFGNode)
add_coverage() — 语法覆盖率 (模糊测试时的跟踪扩展)，概率语法模糊测试 (计数扩展)
add_element() — 模糊测试：使用随机输入破坏事物 (程序特定检查器)
add_fragment() — 基于语法的灰盒模糊测试 (构建片段池)
add_group() — 测试配置 (选项和参数的语法挖掘器)
add_int_rule() — 测试配置 (选项和参数的语法挖掘器)
add_metavar_rule() — 测试配置 (选项和参数的语法挖掘器)
add_new_airport() — 模糊测试：使用随机输入破坏事物 (程序特定检查器)
add_new_airport_2() — 模糊测试：使用随机输入破坏事物 (程序特定检查器)
add_parameter() — 测试配置 (选项和参数的语法挖掘器)
add_parent() — 控制流图 (CFGNode)
add_parents() — 控制流图 (CFGNode)
add_result() — 单元测试裁剪 (第一部分：存储函数结果)
add_str_rule() — 测试配置 (选项和参数的语法挖掘器)
add_to_fragment_pool() — 基于语法的灰盒模糊测试 (构建片段池)，基于语法的灰盒模糊测试 (基于区域的变异)
add_trace() — 约束模糊测试 (表示决策)，约束模糊测试 (SimpleConcolicFuzzer 类)
add_transitive() — 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
add_tree() — 概率语法模糊测试（计数扩展）, 挖掘输入语法（从推导树恢复语法）
add_tree_coverage() — 使用生成器模糊测试（生成器和语法覆盖率）
add_type_rule() — 测试配置（选项和参数的语法挖掘器）
__add__() — 跟踪信息流（连接）, 约束模糊测试（字符串连接）
advance() — 解析输入（项目）, 解析输入（状态）
AdvancedMutationFuzzer类 — 灰盒模糊测试（高级黑盒突变模糊测试）
AdvMutant类 — 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）
AdvMutator类 — 突变分析（模块和测试套件的突变器）
AdvPMIterator类 — 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）
AdvStmtDeletionMutator类 — 突变分析（模块和测试套件的突变器）
AFL — 基于突变的模糊测试（通过覆盖率引导）, 灰盒模糊测试（基于突变的灰盒模糊测试）
AFLFastSchedule类 — 灰盒模糊测试（增强灰盒模糊测试）
AFLGoSchedule类 — 灰盒模糊测试（改进的定向功率调度）
AFLSmart — 基于语法的灰盒模糊测试（输入区域模糊测试）, 基于语法的灰盒模糊测试（背景）
AFLSmartSchedule 类 — 使用语法的灰盒模糊测试（关注有效种子）
airport_codes_repOK() — 模糊测试：使用随机输入破坏事物（程序特定检查器）
Alex 框架 — 测试图形用户界面（背景）
所有 — 基于搜索的模糊测试（示例的爬山法），突变分析（注入人工故障），使用语法的灰盒模糊测试（经验教训），符号模糊测试（练习 3：实现一个约束模糊测试器），何时停止模糊测试（发现概率量化残余风险）
所有路径 — 符号模糊测试（获取使用的变量名称和类型）
所有种子 — 使用语法的灰盒模糊测试（与灰盒模糊测试集成）
all_terminals() — 高效语法模糊测试（探索结束）
alternate_reductions() — 减少导致失败的输入（可选扩展）
AlternatingSequence 类 — 铁路图（探索：铁路图实现）
可选方案 — 使用语法的模糊测试（规则和扩展）
美国模糊跳鼠 — 基于突变的模糊测试（由覆盖率引导）
美国模糊跳鼠 — 灰盒模糊测试（AFL：一个有效的灰盒模糊测试器）
美国模糊跳鼠](http://lcamtuf.coredump.cx/afl/) (AFL) 发布。从那时起，AFL 已经成为最成功的模糊测试工具之一，并且有多种变体，例如 AFLFast，AFLGo，和 AFLSmart — [基于突变的模糊测试（使用突变进行模糊测试）
angr — 符号模糊测试（背景）
annotate_arg() — 挖掘函数规范（使用给定类型注释函数）
annotate_edge() — 高效语法模糊测试（探索：display_annotated_tree()的源代码和示例）`)
annotate_function_ast_with_invariants() — 挖掘函数规范（练习 9：将不变量嵌入为断言）
annotate_function_ast_with_types() — 挖掘函数规范（用挖掘的类型注释函数）
annotate_function_with_invariants() — 挖掘函数规范（练习 9：将不变量嵌入为断言）
annotate_function_with_types() — 挖掘函数规范（用挖掘的类型注释函数）
annotate_invariants() — 挖掘函数规范（练习 9：将不变量嵌入为断言）
annotate_node() — 高效语法模糊测试（远足：display_annotated_tree()的源代码和示例）`)
annotate_types() — 挖掘函数规范（用挖掘的类型注释函数）
any — 高效语法模糊测试（远足：实现display_tree()）`)
ANYTHING_BUT_DOUBLE_QUOTES_AND_BACKSLASH — 测试编译器（常量）
ANYTHING_BUT_SINGLE_QUOTES_AND_BACKSLASH — 测试编译器（常量）
any_possible_expansions() — 高效语法模糊测试（扩展树）
any_sqrt() — 挖掘函数规范（规范和断言）
append_from_dictionary() — 灰盒模糊测试（第一次尝试）
apply_new_definition() — 挖掘输入语法（组装推导树），挖掘输入语法（恢复推导树）
apply_result() — 使用生成器进行模糊测试（在扩展前生成元素）
apply_twice() — 使用生成器进行模糊测试（在扩展前调用的函数）
arbitrary — 解析输入（远足：测试解析器）
arc() — 铁路图（远足：铁路图实现）
ArcCoverage 类 — 约束模糊测试（跟踪约束）
arcs() — 约束模糊测试（跟踪约束）
arc_8() — 铁路图（远足：铁路图实现）
arguments() — 切割单元测试（记录调用）
ARGUMENTS_SYMBOL — 测试配置（选项和参数的语法挖掘器）
算术表达式 — 基于语法的模糊测试（算术表达式）
arith_expr() — 突变分析（练习 1：算术表达式突变器）
AR — 铁路图（远足：铁路图实现）
ascii_chr() — 大规模模糊测试（远足：escapelines()实现）`-implementatipn)
ASCII_STRING_GRAMMAR — 模糊测试 API（概要）, 模糊测试 API（字符串）, 模糊测试 API（概要）
assertEquals() — 软件测试简介（自动化测试执行）
assertion — 使用随机输入破坏事物（程序特定检查器）
assignEnergy() — 灰盒模糊测试（种子和功率计划）, 灰盒模糊测试（增强灰盒模糊测试）, 灰盒模糊测试（定向功率计划）, 灰盒模糊测试（改进的定向功率计划）, 基于语法的灰盒模糊测试（关注有效种子）
assignment — 使用随机输入破坏事物（测试任务）
assignments() — 挖掘输入语法（DefineTracker）
AssignmentTracker类 — 挖掘输入语法（AssignmentTracker）, 挖掘输入语法（AssignmentTracker）, 挖掘输入语法（AssignmentTracker）
AssignmentVars 类 — 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）, 挖掘输入语法（AssignmentVars）
ast_fitness() — 测试编译器（适应度）
at() — 挖掘输入语法（调用堆栈）
ATTR_GRAMMAR — 使用生成器进行模糊测试（练习 2：属性语法）
at_dot() — 解析输入（项目）
自动机理论 — 使用语法进行模糊测试（输入语言）
autopep8() — 测试配置（autopep8 设置）
average_length_until_full_coverage() — 语法覆盖率（整合事物）
A_Class 类 — 类图（获取类层次结构）, 类图（获取类层次结构）

B

B() — 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（AssignmentTracker）
back() — 解析输入（练习 5：Leo 解析器）
巴科斯-诺尔范式 — 使用语法进行模糊测试（语法快捷方式）
bad_fitness() — 基于搜索的模糊测试（示例的爬山法）
bar() — 类图（获取类层次结构）
before — 挖掘输入语法（AssignmentTracker）
BetterHTTPRequestHandler 类 — 测试 Web 应用程序（第一部分：静默失败）, 测试 Web 应用程序（第二部分：净化 HTML）, 测试 Web 应用程序（第三部分：净化 SQL）, 测试 Web 应用程序（第四部分：健壮的服务器）
BETTER_HTML_INTERNAL_SERVER_ERROR — 测试网络应用程序（第一部分：静默失败）
依赖图二进制化简 — 减少导致失败的输入（背景）
BinaryProgramRunner 类 — 模糊测试：使用随机输入破坏事物（运行器类）
binomial() — 约束模糊测试（示例：二项式系数）
BinOpMutator 类 — 变异分析（练习 1：算术表达式变异器）, 变异分析（练习 1：算术表达式变异器）
BIRD — 模糊测试：使用随机输入破坏事物（检查内存访问）
bit() — 约束模糊测试（表示决策）
位图起源 — 跟踪信息流（跟踪单个字符）
BIT_OPS — 约束模糊测试（练习 2：位操作）
黑盒测试 — 代码覆盖率（黑盒测试）
BletchleyPark 类 — 何时停止模糊测试（模糊测试恩尼格玛）, 何时停止模糊测试（图灵的观察）, 何时停止模糊测试（图灵的观察）
博客文章 — 基于变异的模糊测试（练习 3）, 灰盒模糊测试（解决迷宫）, 减少导致失败的输入（背景）, 控制流图（示例：迷宫）
BNF — 使用语法进行模糊测试（语法快捷方式）
BODY — 代码覆盖率（覆盖率类）, 代码覆盖率（覆盖率类）, 代码覆盖率（覆盖率类）
Bomba — 何时停止模糊测试（恩尼格玛机）
__bool__() — 约束模糊测试（在条件上注册谓词）, 约束模糊测试（在布尔上下文中使用整数）, 约束模糊测试（练习 1：实现约束浮点代理类）
BoostedBletchleyPark 类 — 何时停止模糊测试（图灵的观察）
分支覆盖率 — 代码覆盖率（白盒测试）
BranchCoverage 类 — 代码覆盖率（第一部分：计算分支覆盖率）
BranchTransformer 类 — 基于搜索的模糊测试（自动对源代码进行仪器化）
branch_coverage() — 代码覆盖率（第一部分：计算分支覆盖率）
break_max_attempts() — 何时停止模糊测试（图灵的观察）
break_message() — 何时停止模糊测试（模糊测试恩尼格玛），何时停止模糊测试（图灵的观察），何时停止模糊测试（图灵的观察），何时停止模糊测试（图灵的观察）
break_n_messages() — 何时停止模糊测试（图灵的观察）
"Mozilla 中的浏览器模糊测试" — 大规模模糊测试（背景）
BROWSER — 测试图形用户界面（使用 Selenium 进行远程控制）
buggy_my_sqrt_with_postcondition() — 挖掘函数规范（使用前条件和后条件注释函数）
B_Class 类 — 类图（获取类层次结构）

C

C 预处理器 — 测试配置（练习 1：#ifdef 配置模糊测试）
C() — 挖掘输入语法（跟踪变量赋值位置），挖掘输入语法（AssignmentTracker）
C-Reduce — 减少导致失败的输入（背景）
CachingReducer 类 — 减少导致失败的输入（Delta Debugging）
calculate_distance() — 基于搜索的模糊测试（定义搜索景观：适应度函数）
调用 — 挖掘输入语法（跟踪变量赋值位置），挖掘输入语法（跟踪变量赋值位置），挖掘输入语法（跟踪变量赋值位置）
调用图 — 灰盒模糊测试（解决迷宫）
调用栈 — 软件测试简介（系统输入与函数输入）
CallCarver 类 — 单元测试切割（记录调用）, 单元测试切割（记录调用）
called_functions() — 单元测试切割（记录调用）
callers() — 类图（使用方法名称绘制类层次结构）
CallGrammarMiner 类 — 单元测试切割（调用语法挖掘器）, 单元测试切割（初始语法）, 单元测试切割（从参数生成语法）, 单元测试切割（从调用生成语法）, 单元测试切割（从所有调用生成语法）
callgraph() — 控制流图（调用图辅助工具）
calls — 灰盒模糊测试（计算函数级距离）
calls() — 挖掘函数规范（跟踪调用）, 单元测试切割（记录调用）
CallStack 类 — 挖掘输入语法（CallStack）, 挖掘输入语法（CallStack）
CallTracker 类 — 挖掘函数规范（跟踪调用）, 挖掘函数规范（跟踪调用）, 挖掘函数规范（跟踪调用）, 挖掘函数规范（跟踪调用）, 挖掘函数规范（跟踪调用）
call_string() — 单元测试切割（序列化对象）
CALL_SYMBOL — 单元测试切割（初始语法）
call_value() — 单元测试切割（序列化对象）
__call__() — 控制流模糊测试（插曲：实现 ConcolicTracer）
cancel() — 超时（变体 1：Unix（使用信号，高效）), 超时（变体 2：通用/Windows（使用跟踪，不太高效）)
canonical() — 解析输入（插曲：规范语法）
can_be_satisfied() — 符号模糊测试（练习 2：静态检查循环是否应该进一步展开）
capitalize() — 跟踪信息流（不改变原点的字符串方法）
Carver类 — 切割单元测试（记录调用）
cc() — 条件模糊测试（表示决策）
CFG — 解析输入（解析表达式语法）, 解析输入（结束插曲）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（Earley 解析器）, 解析输入（提取树）, 解析输入（背景）
CFGNode类 — 控制流图（CFGNode）
CFGs — 解析输入（实现EarleyParser的插曲）, 解析输入（背景）
CFLAGS — 大规模模糊测试（收集代码覆盖率）
CFLs — 解析输入（背景）, 解析输入（背景）, 解析输入（背景）
cgi_decode() — 代码覆盖率（一个 CGI 解码器）, 基于搜索的模糊测试（测试更复杂的程序）, 条件模糊测试（示例：解码 CGI 字符串）, 控制流图（cgi_decode）
cgi_decode_instrumented() — 基于搜索的模糊测试（自动源代码注入）
cgi_decode_traced() — 代码覆盖率（跟踪执行）
cgi_encode() — 测试 Web 应用程序（实现 cgi_decode()的插曲）)
CGI_GRAMMAR — 测试 Web 应用程序（挖掘网页语法）
CG — 灰盒模糊测试（计算函数级距离）
关于解析器的章节](Parser.ipynb)指出，当输入格式包含仅在代码中表达的具体细节时，粗略的语法在模糊测试中效果不佳。也就是说，尽管我们有 CSV 文件的正式规范(RFC 4180 — [挖掘输入语法（语法挑战）]
字符级别 — 跟踪信息流（跟踪单个字符）
CHARACTERS_WITHOUT_QUOTE — 使用语法进行模糊测试（练习 1：JSON 语法）
CHARGE_GRAMMAR — 使用生成器进行模糊测试（示例：数值范围）
chart_parse() — 解析输入（解析算法）
CHAR_WIDTH — 铁路图（探索：铁路图实现）
check() — 测试图形用户界面（探索：实现执行 UI 操作）
checkpoint() — 符号模糊测试（使用简单符号模糊测试器）
校验和 — 跟踪信息流（跟踪单个字符）
check_grammar() — 高效语法模糊测试（探索：check_grammar() 实现）`-implementation)，概率语法模糊测试（通过概率扩展）
check_param() — 挖掘输入语法（练习 1：简化复杂对象）
check_time() — 超时（变体 2：通用/Windows（使用跟踪，效率不高））)
check_triangle() — 符号模糊测试（获取覆盖路径条件），控制流图（check_triangle）
child nodes — 高效语法模糊测试（推导树）
children — 高效语法模糊测试（推导树）
CHILDREN — 高效语法模糊测试（表示推导树），高效语法模糊测试（表示推导树）
choice 表达式 — 解析输入（解析表达式语法）
ChoiceNode 类 — 解析输入（树提取器）
Choice 类 — 铁路图（探索：铁路图实现）
choose() — 灰盒模糊测试（种子和功率调度）
choose_a_node_to_explore() — 解析输入（练习 7：迭代 Earley 解析器）
choose_covered_node_expansion() — 语法覆盖率（覆盖语法扩展）, 概率语法模糊测试（练习 1：具有覆盖率的概率模糊测试）
choose_node_expansion() — 高效语法模糊测试（选择一个子节点进行扩展）, 语法覆盖率（在模糊测试时跟踪扩展）, 语法覆盖率（覆盖语法扩展）, 语法覆盖率（探险：实现 choose_node_expansion()）`), 概率语法模糊测试（按概率扩展）, 概率语法模糊测试（练习 1：具有覆盖率的概率模糊测试）
choose_path() — 解析输入（树提取器）, 解析输入（树提取器）
choose_tree_expansion() — 高效语法模糊测试（探险：expand_tree_once() 实现）`-implementation), 使用生成器进行模糊测试（排序扩展）
choose_uncovered_node_expansion() — 语法覆盖率（覆盖语法扩展）, 概率语法模糊测试（练习 1：具有覆盖率的概率模糊测试）
chosen() — 解析输入（树提取器）
chromedriver 程序 — 测试图形用户界面（设置 Chrome）
类图 — 学术原型设计（可重复实验）
CLASS_COLOR — 类图（通过方法名称绘制类层次结构）, 类图（通过方法名称绘制类层次结构）
CLASS_FONT — 类图（通过方法名称绘制类层次结构）, 类图（通过方法名称绘制类层次结构）
class_hierarchy() — 类图（获取类层次结构）
class_items() — 类图（获取方法和变量）
_class_items() — 类图（获取方法和变量）
class_methods() — 类图（获取方法和变量）
class_methods_string() — 类图（使用方法名称绘制类层次结构）
class_set() — 类图（获取类树）
class_tree() — 类图（获取类树）
class_vars() — 类图（获取方法和变量）
class_vars_string() — 类图（使用方法名称绘制类层次结构）
clean_grammar() — 挖掘输入语法（语法挖掘）
clear_httpd_messages() — 测试 Web 应用程序（日志记录）
clear_origin() — 跟踪信息流（一个用于跟踪字符来源的类）
clear_symbol_table() — 使用生成器进行模糊测试（定义和用法）
clear_taint() — 跟踪信息流（一个用于污点字符串的类）, 跟踪信息流（一个用于跟踪字符来源的类）
click() — 测试图形用户界面（探索：实现执行 UI 操作）
clock() — 计时器（测量时间）
coalesce() — 解析输入（解析器类）, Concolic Fuzzing（探索：实现 ConcolicGrammarFuzzer）
代码覆盖率 — 代码覆盖率
StackOverflow 中的代码片段 — 挖掘函数规范（使用前置和后置条件注释函数）
code_repOK() — 模糊测试：使用随机输入破坏事物（程序特定检查器）
collapse_if_too_large() — 模糊测试：使用随机输入破坏事物（缺少错误检查）
collect_conditions() — 学术原型设计（Python 中的静态分析：仍然简单）, 使用 Python 进行原型设计（Python 中的静态分析：仍然简单）
collect_path_conditions() — 学术原型设计（一个符号测试生成器）, 使用 Python 进行原型设计（一个符号测试生成器）
颜色 — 跟踪信息流（跟踪单个字符）
column() — 跟踪信息流（表示表格）, Concolic Fuzzing（示例：数据库）
Column类 — 解析输入（列）, 解析输入（列）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
combination() — Concolic Fuzzing（示例：二项式系数）
逗号 — 解析输入（一个临时解析器）
comma_split() — 解析输入（一个临时解析器）
COMMENT_CHAR_WIDTH — 铁路图（远足：铁路图实现）
Comment类 — 铁路图（远足：铁路图实现）
比较节点 — 控制流图（fib）
熟练程序员假设 — 突变分析（注入人工故障）
编译器测试 — 使用语法进行模糊测试（背景）, 减少导致失败的输入（背景）
输入样本的补集 — 概率语法模糊测试（测试不常见特征）
complete() — 解析输入（完成处理）, 解析输入（练习 5：Leo 解析器）
compute_dominator() — 控制流图（支持函数）
compute_flow() — 控制流图（支持函数）
compute_gcd() — 控制流图（gcd）
Concolic — 符号模糊测试（在循环之前检查）
concolic 执行 — 挖掘输入语法（练习 2：从 InformationFlow 中引入污点）, 符号模糊测试（练习 3：实现 Concolic 模糊器）
Concolic 执行 — Concolic Fuzzing（解决约束）
concolic() — 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（生成新名称）
ConcolicDB 类 — 具体化模糊测试（示例：数据库）
ConcolicGrammarFuzzer 类 — 具体化模糊测试（探索：实现 ConcolicGrammarFuzzer）, 具体化模糊测试（剪枝和更新）, 具体化模糊测试（剪枝和更新）
ConcolicTracer 类 — 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（探索：实现 ConcolicTracer）, 具体化模糊测试（将表达式转换为 SMT 表达式格式）, 具体化模糊测试（生成新名称）, 具体化模糊测试（生成新名称）, 具体化模糊测试（评估具体化表达式）, 符号模糊测试（练习 3：实现一个具体化模糊测试器）, 符号模糊测试（练习 3：实现一个具体化模糊测试器）
具体语法树 — 高效的语法模糊测试（推导树）
condition() — 挖掘函数规范（使用前置和后置条件注释函数）
条件编译 — 测试配置（练习 1：#ifdef 配置模糊测试）
CONDITION — 代码覆盖率（练习 2：分支覆盖率）, 代码覆盖率（练习 2：分支覆盖率）, 代码覆盖率（练习 2：分支覆盖率）
CONSTRAINED_VAR_GRAMMAR — 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（定义和用法）, 使用生成器进行模糊测试（排序扩展）, 使用生成器进行模糊测试（排序扩展）
约束 — 使用生成器进行模糊测试（扩展后的函数调用）
CONSTRAINT — 使用约束进行模糊测试（量词）
construct_callgraph() — 控制流图（调用图辅助器）
自由文法 — 使用语法进行模糊测试（语法）
CONTEXT — 使用约束进行模糊测试（量词）
Context 类 — 挖掘输入语法（上下文）, 挖掘输入语法（上下文）, 挖掘输入语法（练习 1：简化复杂对象）
合同 — 挖掘功能规范（为什么通用的错误检查是不够的）
convert() — 跟踪信息流（插入数据）
convert_ebnf_grammar() — 使用语法进行模糊测试（全部一起）
convert_ebnf_operators() — 使用语法进行模糊测试（扩展操作符）
convert_ebnf_parentheses() — 使用语法进行模糊测试（扩展括号表达式）
copy() — 解析输入（状态）, 解析输入（练习 5：Leo 解析器）, 符号模糊测试（跟踪赋值）
COUNTER — Concolic Fuzzing（生成新名称）, Concolic Fuzzing（生成新名称）
CountingGreyboxFuzzer 类 — 灰盒模糊测试（增强灰盒模糊测试）
counts() — 概率语法模糊测试（计数扩展）
count_expansions() — 概率语法模糊测试（计数扩展）
count_nodes() — 基于语法的灰盒模糊测试（基于片段的突变）
耦合效应 — 突变分析（注入人工故障）
覆盖率标准 — 代码覆盖率（白盒测试）
Fuzzing Book 中的覆盖率模块 — 测试编译器（获取覆盖率）
coverage() — 代码覆盖率（覆盖率类）, 代码覆盖率（第一部分：计算分支覆盖率）, 基于突变的模糊测试（由覆盖率引导）
基于覆盖率的灰盒模糊测试作为马尔可夫链 — 灰盒模糊测试（增强灰盒模糊测试）
Coverage类 — 代码覆盖率（覆盖率类）
cpp_identifiers() — 测试配置（第一部分：提取预处理器变量）
crange() — 基于语法的模糊测试（字符类）
crashme() — 灰盒模糊测试（运行器和示例程序）
crash_if_too_long() — 模糊测试：使用随机输入破坏事物（缓冲区溢出）
crawl() — 测试 Web 应用程序（探险：实现爬虫）
爬虫 — 测试 Web 应用程序（爬取用户界面）
create() — 跟踪信息流（字符串运算符）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（创建）, 跟踪信息流（第二部分：算术表达式）, Concolic Fuzzing（布尔代理类）, Concolic Fuzzing（整数代理类）, Concolic Fuzzing（字符串代理类）, Concolic Fuzzing（练习 1：实现 Concolic Float 代理类）
create_assignments() — 挖掘输入语法（AssignmentTracker）, 挖掘输入语法（作用域跟踪器）, 挖掘输入语法（练习 2：结合来自 InformationFlow 的污点）
create_call_stack() — 挖掘输入语法（作用域变量），挖掘输入语法（练习 2：从 InformationFlow 中引入污点）
create_candidate() — 基于变异的模糊测试（多次变异），灰盒模糊测试（高级黑盒基于变异的模糊测试），基于语法的灰盒模糊测试（基于片段的模糊测试），基于语法的灰盒模糊测试（与灰盒模糊测试集成）
create_context() — 挖掘输入语法（上下文）
create_foo_py() — 测试配置（创建 Autopep8 选项）
create_instrumented_function() — 基于搜索的模糊测试（自动对源代码进行仪器化）
create_population() — 基于搜索的模糊测试（遗传算法）
create_table() — 跟踪信息流（表示表格）
create_tracker() — 挖掘输入语法（从推导树中恢复语法），挖掘输入语法（恢复语法），挖掘输入语法（语法挖掘），挖掘输入语法（练习 2：从 InformationFlow 中引入污点）
create_tree_miner() — 挖掘输入语法（从推导树中恢复语法），挖掘输入语法（恢复语法），挖掘输入语法（语法挖掘），挖掘输入语法（练习 2：从 InformationFlow 中引入污点）
跨站脚本 — 测试网络应用程序（跨站脚本攻击）
crossover — 基于搜索的模糊测试（遗传算法）
crossover() — 基于搜索的模糊测试（遗传算法）
CSmith — 基于语法的模糊测试（背景）
CSV — 解析输入（一个临时的解析器）
当前 — 挖掘输入语法（赋值变量）
C_Class 类 — 类图（获取类层次结构）
C_SAMPLE_GRAMMAR — 解析输入（插曲：实现 EarleyParser）
C 类 — 铁路图（插曲：铁路图实现）

D

DAIKON 动态不变性检测器](https://plse.cs.washington.edu/daikon/) 可以被认为是函数规范挖掘器的鼻祖。经过 20 多年的持续维护和扩展，它以本章所述的风格为包括 C、C++、C#、Eiffel、F#、Java、Perl 和 Visual Basic 在内的多种语言挖掘可能的恒等式。在上述功能的基础上，它拥有丰富的可能恒等式模式库，支持数据不变性，可以消除由其他恒等式暗示的恒等式，并确定统计置信度以忽略不太可能的恒等式。相应的论文[未解决引用：Ernst2001.]是软件工程领域的开创性且被引用最多的论文之一。基于 DAIKON 和检测恒等式的众多作品已经发表；请参阅此精选列表 — [挖掘函数规范（背景）]
数据字典 — 测试 Web 应用程序（泄露内部信息）
数据库 — 测试 Web 应用程序（存储订单）
db_select() — Concolic Fuzzing（示例：数据库）
DB — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（执行 SQL 语句）, 跟踪信息流（跟踪不受信任的输入）, 跟踪信息流（污染数据库）, Concolic Fuzzing（示例：数据库）
DB 类 — 跟踪信息流（一个易受攻击的数据库），跟踪信息流（表示表），跟踪信息流（表示表），跟踪信息流（表示表），跟踪信息流（执行 SQL 语句），跟踪信息流（选择数据），跟踪信息流（选择数据），跟踪信息流（选择数据），跟踪信息流（插入数据），跟踪信息流（插入数据），跟踪信息流（更新数据），跟踪信息流（删除数据）
调试器 — 软件测试简介（调试一个函数）
DEBUG — 铁路图（远足：铁路图实现）
declarations() — 符号模糊测试（获取使用的变量名称和类型）
decorator() — 挖掘函数规范（使用前/后条件注释函数），挖掘函数规范（练习 3：冗长的不变量检查器）
decrange() — 概率语法模糊测试（上下文中的概率）
default_edge_attr() — 高效语法模糊测试（远足：实现 display_tree()）`)
default_graph_attr() — 高效语法模糊测试（远足：实现 display_tree()）`)
default_node_attr() — 高效语法模糊测试（远足：实现 display_tree()）`)
DEFAULT_ORIGIN — 跟踪信息流（跟踪字符来源的类）
DEFAULT_STYLE — 铁路图（远足：铁路图实现）
延迟解析 — 基于语法的灰盒模糊测试（基于片段的模糊测试）
defined_in() — 类图（获取方法和变量）
defined_vars() — 挖掘输入语法（赋值变量）, 挖掘输入语法（作用域变量）
DefineTracker 类 — 挖掘输入语法（DefineTracker）, 挖掘输入语法（DefineTracker）, 挖掘输入语法（DefineTracker）, 挖掘输入语法（DefineTracker）, 挖掘输入语法（DefineTracker）, 挖掘输入语法（DefineTracker）
define_expr() — 使用语法进行模糊测试（第一部分 (b)：替代表示）:-Alternative-representations)
define_ex_grammar() — 使用语法进行模糊测试（第一部分 (b)：替代表示）:-Alternative-representations)
define_grammar() — 使用语法进行模糊测试（第一部分 (a)：单一函数）:-One-Single-Function)
define_id() — 使用生成器进行模糊测试（定义和用法）
define_name() — 使用语法进行模糊测试（第一部分 (b)：替代表示）:-Alternative-representations)
define_symbolic_vars() — 符号模糊测试（获取使用的变量名称和类型）
def_used_nonterminals() — 使用语法进行模糊测试（探险：实现 is_valid_grammar()）`)
有效度 — 使用语法进行灰盒模糊测试（确定符号区域）
degree_of_validity() — 使用语法进行灰盒模糊测试（关注有效种子）
DELAY_AFTER_CHECK — 测试图形用户界面（探险：实现执行 UI 操作）
DELAY_AFTER_CLICK — 测试图形用户界面（探险：实现执行 UI 操作）, 大范围模糊测试（探险：启动服务器）
DELAY_AFTER_FILL — 测试图形用户界面（探险：实现执行 UI 操作）
DELAY_AFTER_START — 大范围模糊测试（探险：启动服务器）
DELAY_AFTER_SUBMIT — 测试图形用户界面（探险：实现执行 UI 操作）
delete_element() — 使用随机输入破坏事物（程序特定检查器）
delete_fragment() — 基于语法的灰盒模糊测试（基于片段的变异）, 基于语法的灰盒模糊测试（基于区域的变异）
delete_last_character() — 灰盒模糊测试（第一次尝试）
delete_random_character() — 基于变异的模糊测试（变异输入）, 灰盒模糊测试（变异器）
DELETE — 测试 Web 应用程序（SQL 注入攻击）
Delta Debugging — 测试编译器（进化）
DeltaDebuggingReducer类 — 减少导致失败的输入（Delta 调试）
依赖关系 — 学术原型（可复现实验）
推导树 — 高效语法模糊测试（推导树）
determineGaps() — 铁路图（铁路图实现：铁路图实现）
deterministic_reduction() — 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
DiagramItem类 — 铁路图（铁路图实现：铁路图实现）
DIAGRAM_CLASS — 铁路图（铁路图实现：铁路图实现）
Diagram类 — 铁路图（铁路图实现：铁路图实现）
DictMutator类 — 灰盒模糊测试（第一次尝试）, 基于语法的灰盒模糊测试（使用字典模糊测试）
diff() — 变异分析（函数的简单变异器）, 变异分析（模块和测试套件的变异器）
不同 — 挖掘输入语法（语法挖掘器重分配的问题）
DIGIT_GRAMMAR — 基于语法的模糊测试（在 Python 中表示语法）
定向灰盒模糊测试" [未解决引用：boehme2017greybox.] 并查看在 AFL 中的实现 [github.com/aflgo/aflgo — 灰盒模糊测试（改进的定向功率调度）
DirectedSchedule 类 — 灰盒模糊测试（定向功率调度）
发现 — 何时停止模糊测试（图灵的观察）
发现概率 — 何时停止模糊测试（图灵的观察）
display_annotated_tree() — 高效语法模糊测试（display_annotated_tree() 的源代码和示例）`)
display_class_hierarchy() — 类图（使用方法名称绘制类层次结构）
display_class_node() — 类图（使用方法名称绘制类层次结构）
display_class_trees() — 类图（使用方法名称绘制类层次结构）
display_httpd_message() — 测试 Web 应用程序（日志记录）
display_legend() — 类图（使用方法名称绘制类层次结构）
display_stack() — 挖掘输入语法（调用栈）
display_trace_tree() — 条件模糊测试（SimpleConcolicFuzzer 类）
display_tree() — 高效语法模糊测试（实现 display_tree()）`)
distance_character() — 基于搜索的模糊测试（分支距离）
docstring() — 类图（获取文档）
doc_class_methods() — 类图（获取方法和变量）
DOC_INDENT — 类图（获取文档）
Domato — 使用语法进行模糊测试（背景）
dot_escape() — 高效语法模糊测试（实现 display_tree()）`)
doubleenumerate() — 铁路图（铁路图实现）
down() — 铁路图（铁路图实现）
do_call() — 模糊测试 API（代码合成）
do_check() — 测试图形用户界面（执行 UI 动作的实现）
do_click() — 测试图形用户界面（执行 UI 动作的实现）
do_delete() — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（删除数据）
do_fill() — 测试图形用户界面（实现执行 UI 操作）
do_GET() — 测试 Web 应用程序（处理 HTTP 请求）
do_HEAD() — 测试 Web 应用程序（其他 HTTP 命令）
do_insert() — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（插入数据）
do_select() — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（选择数据）
do_submit() — 测试图形用户界面（实现执行 UI 操作）
do_update() — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（更新数据）
Dragon Book — 高效语法模糊测试（背景）
Driller — 符号模糊测试（背景）
duplicate_context() — 语法覆盖率（以编程方式扩展语法以进行上下文覆盖率）
_duplicate_context() — 语法覆盖率（实现 _duplicate_context()）`)
期间 — 灰盒模糊测试（经验教训）
动态分析 — 代码覆盖率（跟踪执行）
动态污点 — 挖掘输入语法（练习 2：从信息流中引入污点）
动态污点分析 — 跟踪信息流（Eval 的邪恶）
动态污点 — 挖掘输入语法（练习 2：从信息流中引入污点）, 挖掘输入语法（练习 2：从信息流中引入污点）
D_Class 类 — 类图（获取类层次结构）, 类图（获取类层次结构）

E

e() — 铁路图（铁路图实现）
Earley 解析器 — 解析输入（歧义）
EarleyParser 类 — 解析输入（解析算法）, 解析输入（预测状态）, 解析输入（扫描标记）, 解析输入（完成处理）, 解析输入（填充图表）, 解析输入（解析方法）, 解析输入（解析方法）, 解析输入（解析路径）, 解析输入（解析森林）, 解析输入（提取树）, 解析输入（歧义解析）, 解析输入（可空性）
earley_complete() — 解析输入（完成处理）
EBNF — 使用语法进行模糊测试（语法快捷方式）
ebnf_grammar() — 测试配置（用于模糊测试配置选项的类）
"有效的软件测试：开发者指南" — 软件测试简介（背景）
elapsed_time() — 计时器（测量时间）
元素 — 何时停止模糊测试（肯尼格鲁本）, 何时停止模糊测试（肯尼格鲁本）
ELSE — 符号模糊测试（获取使用的变量名称和类型）
将有限状态机嵌入到语法中 — 测试图形用户界面（状态机作为语法）
EmbeddedInvariantAnnotator 类 — 挖掘函数规范（练习 9：将不变量嵌入为断言）
EmbeddedInvariantTransformer 类 — 挖掘函数规范（练习 9：将不变量嵌入为断言）, 挖掘函数规范（练习 9：将不变量嵌入为断言）
EMI 项目 — 使用语法进行模糊测试（背景）
End 类 — 铁路图（远足：铁路图实现）
能量 — 灰盒模糊测试（种子和功率计划）
EnhancedExtractor 类 — 解析输入（树提取器）, 解析输入（树提取器）, 解析输入（树提取器）, 解析输入（树提取器）
Enigma — 何时停止模糊测试
Enigma 机器 — 何时停止模糊测试（Enigma 机器）
EnigmaMachine 类 — 何时停止模糊测试（模糊测试 Enigma）, 何时停止模糊测试（模糊测试 Enigma）
enter() — 挖掘输入语法（调用栈）, 挖掘输入语法（输入栈）
__enter__() — 代码覆盖率（覆盖率类）, 突变分析（评估突变）, Concolic 模糊测试（探险：实现 ConcolicTracer）, Concolic 模糊测试（生成新名称）, 挖掘函数规范（跟踪调用）, 切割单元测试（记录调用）, 错误处理（捕获错误）, 计时器（测量时间）, 超时（变体 1：Unix（使用信号，高效））), 超时（变体 2：通用 / Windows（使用跟踪，不太高效））)
EOF — 模糊测试：使用随机输入破坏事物（缺少错误检查）, 模糊测试：使用随机输入破坏事物（缺少错误检查）, 模糊测试：使用随机输入破坏事物（缺少错误检查）, 解析输入（练习 9：非终结符的后续集）, 解析输入（练习 9：非终结符的后续集）, 解析输入（练习 9：非终结符的后续集）
epsilon expansion — 使用语法进行模糊测试（探险：实现 convert_ebnf_grammar()）`), 高效语法模糊测试（探险结束）
EPSILON — 软件测试简介（自动化测试执行），解析输入（艾科克 epsilon 修复），解析输入（练习 8：非终结符的第一个集合），挖掘函数规范（使用前置和后置条件注释函数）
等效突变体 — 突变分析（等效突变体问题）
__eq__() — 解析输入（状态），一致性模糊测试（整数之间的相等性），一致性模糊测试（字符串之间的相等性），铁路图（远足：铁路图实现），控制流图（CFGNode）
escape() — 类图（获取文档）
escapelines() — 大规模模糊测试（远足：escapelines() 实现）`-implementatipn)
escape_doc() — 类图（获取文档）
使用不等捕捞能力估计捕获-再捕获数据的种群大小 — 何时停止模糊测试（背景）
EvalMysteryRunner 类 — 减少诱导失败的输入（词法减少与句法规则）
evaluate_condition() — 基于搜索的模糊测试（原子条件的仪器化），基于搜索的模糊测试（原子条件的仪器化）
evaluate_population() — 基于搜索的模糊测试（遗传算法）
eval_function() — 使用生成器的模糊测试（扩展后的元素检查和修复）
eval_with_exception() — 使用生成器的模糊测试（示例：负表达式）
更多内容 — 基于搜索的模糊测试（示例的爬山法）
EvenFasterGrammarFuzzer 类 — 高效语法模糊测试（练习 2：语法预编译）
evolve() — 测试编译器（进化输入）
来自 Tab Atkins jr. 的优秀库 — 铁路图
executable() — 测试配置（模糊测试配置选项的类）
ExerciseGrammarFuzzer 类 — 高效语法模糊测试（练习 4：交替随机扩展）
__exit__() — 代码覆盖率（覆盖率类）, 突变分析（评估突变）, 约束模糊测试（拓展：实现 ConcolicTracer）, 约束模糊测试（生成新名称）, 挖掘函数规范（跟踪调用）, 切割单元测试（记录调用）, 错误处理（捕获错误）, 错误处理（捕获超时）, 计时器（测量时间）, 超时（变体 1：Unix（使用信号，高效））), 超时（变体 2：通用 / Windows（使用跟踪，不太高效））)
expandtabs() — 跟踪信息流（展开制表符）
expand_node() — 高效语法模糊测试（拓展：expand_node_randomly() 实现）`-implementation), 高效语法模糊测试（拓展结束）, 高效语法模糊测试（节点膨胀）
expand_node_by_cost() — 高效语法模糊测试（拓展：expand_node_by_cost() 实现）`-implementation)
expand_node_max_cost() — 高效语法模糊测试（节点膨胀）
expand_node_min_cost() — 高效语法模糊测试（拓展结束）
expand_node_randomly() — 高效语法模糊测试（拓展：expand_node_randomly() 实现）`-implementation), 高效语法模糊测试（练习 4：交替随机扩展）, 解析输入（为什么为模糊测试进行解析？）
expand_tree() — 高效语法模糊测试（拓展：三阶段 expand_tree() 实现）`)
expand_tree_once() — 高效语法模糊测试（拓展：expand_tree_once() 实现）`-implementation), 使用生成器的模糊测试（局部检查和修复）
expand_tree_with_strategy() — 高效语法模糊测试（探索：三阶段expand_tree()的实现）`)
expand_tstate() — 解析输入（练习 5：Leo 解析器）
扩展选项 — 使用语法进行模糊测试（规则和扩展）
expansion rules — 使用语法进行模糊测试（规则和扩展）
ExpansionCountMiner类 — 概率语法模糊测试（计数扩展），概率语法模糊测试（计数扩展），概率语法模糊测试（计数扩展）
ExpansionError类 — 使用语法进行模糊测试（一个简单的语法模糊测试器）
expansion_cost() — 高效语法模糊测试（探索：实现成本函数），跟踪信息流（污染语法模糊测试器）
expansion_coverage() — 语法覆盖（跟踪扩展）
expansion_key() — 语法覆盖（跟踪扩展）
expansion_to_children() — 高效语法模糊测试（探索：实现expansion_to_children()）`)，高效语法模糊测试（探索结束），高效语法模糊测试（练习 1：缓存方法结果）
ExpectError类 — 错误处理（捕获错误）
ExpectTimeout类 — 错误处理（捕获超时）
exploit — 使用语法进行灰盒模糊测试（解析和重组 JavaScript，或如何在四周内赚取 50,000 美元）
explore() — 符号模糊测试（路径的逐步探索）
explore_all() — 测试图形用户界面（覆盖状态）
expression_clause() — 跟踪信息流（选择数据）
expression_grammar_fn() — 使用语法进行模糊测试（练习 4：将语法定义为函数（高级））)
EXPR_GRAMMAR_BNF — 高效语法模糊测试（一个不足够的算法）
EXPR_GRAMMAR — 语法覆盖（覆盖语法元素）, 语法覆盖（覆盖语法扩展）, 语法覆盖（探险结束）, 解析输入（探险：规范语法）, 使用生成器模糊测试（示例：更多数值范围）
exp_opt() — 使用语法模糊测试（探险：实现 opts()）`)
exp_opts() — 使用语法模糊测试（探险：实现 opts()）`)
exp_order() — 使用生成器模糊测试（排序扩展）
exp_post_expansion_function() — 使用生成器模糊测试（一个用于整合约束的类）
exp_pre_expansion_function() — 使用生成器模糊测试（一个用于整合约束的类）
exp_prob() — 概率语法模糊测试（指定概率）
exp_probabilities() — 概率语法模糊测试（分配概率）
exp_string() — 使用语法模糊测试（探险：实现 opts()）`)
extended_nonterminals() — 使用语法模糊测试（扩展操作符）
extend_grammar() — 使用语法模糊测试（扩展语法）
extract_a_node() — 解析输入（树提取器）, 解析输入（树提取器）
extract_a_tree() — 解析输入（提取树）, 解析输入（树提取器）, 解析输入（树提取器）, 解析输入（练习 7：迭代 Earley 解析器）
extract_constraints() — 符号模糊测试（提取所有约束）, 符号模糊测试（在循环之前检查）
extract_node() — 高效语法模糊测试（探险：实现 display_tree()）`)
extract_trees() — 解析输入（提取树）, 解析输入（歧义解析）, 解析输入（练习 7：迭代 Earley 解析器）
extract_vars() — 挖掘输入文法（上下文），挖掘输入文法（练习 1：展平复杂对象）
极其高效 — 灰盒模糊测试（定向功率调度）
E_GRAMMAR_1 — 解析输入（艾克科克 epsilon 修复）

F - J

F

f() — 测试编译器（探险：函数定义）
阶乘值 — 约束性模糊测试（跟踪约束）
factorial() — 约束性模糊测试（跟踪约束），约束性模糊测试（示例：二项式系数）
fail_test() — 错误处理（捕获错误）
FAIL — 模糊测试：使用随机输入破坏事物（概要），模糊测试：使用随机输入破坏事物（概要），模糊测试：使用随机输入破坏事物（运行类），模糊测试：使用随机输入破坏事物（运行器），模糊测试：使用随机输入破坏事物（运行器），减少导致失败的输入（概要），减少导致失败的输入（概要），减少导致失败的输入（概要），减少导致失败的输入（概要），减少导致失败的输入（概要），减少导致失败的输入（概要），减少导致失败的输入（概要）
FasterGrammarFuzzer 类 — 高效语法模糊测试（练习 1：缓存方法结果）
fib() — 控制流图（fib）
FILE — 模糊测试：使用随机输入破坏事物（创建输入文件）
fill() — 测试图形用户界面（探险：实现执行 UI 操作）
fill_chart() — 解析输入（填充图表）
FilteredLeoParser 类 — 解析输入（练习 6：过滤 Earley 解析器）
FINAL_STATE — 测试图形用户界面（探险：实现提取状态文法）
find() — 约束性模糊测试（查找子串）
find_alternatives() — 约束性模糊测试（探险：实现约束性语法模糊测试器）
find_comma() — 解析输入（临时解析器）
find_contents() — 测试配置（用于模糊测试配置选项的类）
find_element() — 测试图形用户界面（探险：实现执行 UI 操作）
find_executable() — 测试配置（Autopep8 设置）
find_expansion() — 使用生成器进行模糊测试（扩展后的元素检查和修复）
find_grammar() — 测试配置（用于模糊测试配置选项的类）
_find_reachable_nonterminals() — 使用语法进行模糊测试（探险：实现is_valid_grammar()）`)
finish() — 突变分析（函数的简单突变器），突变分析（评估突变）
finished() — 解析输入（项目），解析输入（树提取器）
有限邻域假设 — 突变分析（注入人工故障）
状态机 — 测试图形用户界面（用户界面作为有限状态机）
有限状态机 — 使用语法进行模糊测试（输入语言）
first — 突变分析（模块和测试套件的突变器）
firstset() — 解析输入（练习 8：非终结符的第一个集合）
firstset_() — 解析输入（练习 8：非终结符的第一个集合）
first_digit_via_log() — 概率语法模糊测试（首位数字定律）
first_digit_via_string() — 概率语法模糊测试（首位数字定律）
first_expr() — 解析输入（练习 8：非终结符的第一个集合）
first 和 follow — 解析输入（练习 8：非终结符的第一个集合）
fitness — 基于搜索的模糊测试（定义搜索景观：适应度函数）
适应度函数 — 基于搜索的模糊测试（定义搜索景观：适应度函数）
fixed_cgi_decode() — 代码覆盖率（练习 1：修复cgi_decode()）`)
FIXME — 测试编译器（探险结束）
fixpoint() — 解析输入（不动点）
fix_luhn_checksum() — 基于生成器的模糊测试（扩展后的函数调用）
flatten() — 挖掘输入语法（练习 1：扁平化复杂对象）
flip_random_character() — 基于变异的模糊测试（变异输入）, 灰盒模糊测试（变异器）, 基于搜索的模糊测试（全局搜索）
FLOAT_BINARY_OPS — 基于 Concolic 的模糊测试（练习 1：实现 Concolic 浮点代理类）
FLOAT_BOOL_OPS — 基于 Concolic 的模糊测试（练习 1：实现 Concolic 浮点代理类）
float_grammar_with_range() — 模糊测试 API（浮点数）
FLOAT_GRAMMAR — 模糊测试 API（概要）, 模糊测试 API（浮点数）, 模糊测试 API（概要）
fmt() — 挖掘输入语法（赋值变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）
followset() — 解析输入（练习 9：非终结符的后续集）
followset_() — 解析输入（练习 9：非终结符的后续集）
follow_link() — 测试图形用户界面（链接元素动作）
foo() — 类图（获取类层次结构）, 类图（获取类层次结构）, 类图（获取类层次结构）
for 循环 — 控制流图（fib）
forest() — 解析输入（解析森林）, 解析输入（练习 6：过滤 Earley 解析器）
形式语言 — 基于语法的模糊测试（输入语言）, 基于语法的模糊测试（自然语言语法）
format() — 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）, 铁路图（分支：铁路图实现）
FormatFuzzer — 使用语法的灰盒模糊测试（背景）
FormHTMLParser 类 — 测试 Web 应用程序（搜索 HTML 输入字段）, 测试 Web 应用程序（搜索 HTML 输入字段）, 测试 Web 应用程序（搜索 HTML 输入字段）
片段 — 基于语法的灰盒模糊测试（构建片段池），基于语法的灰盒模糊测试（经验教训）
FragmentMutator 类 — 基于语法的灰盒模糊测试（构建片段池），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异）
fragments() 函数 — 挖掘输入语法（DefineTracker）
FRAGMENT_LEN — 挖掘输入语法（DefineTracker），挖掘输入语法（DefineTracker），挖掘输入语法（练习 2：从信息流中引入污点）
frame_module() 函数 — 类图（使用方法名称绘制类层次结构）
fresh_name() 函数 — 基于冲突的模糊测试（生成新名称）
fsm_diagram() 函数 — 测试图形用户界面（探索：实现提取状态语法）
fsm_last_state_symbol() 函数 — 测试图形用户界面（探索：实现 GUIFuzzer）
fsm_path() 函数 — 测试图形用户界面（探索：实现 GUIFuzzer）
FunctionCoverageRunner 类 — 基于变异的模糊测试（通过覆盖率引导）
FunctionRunner 类 — 基于变异的模糊测试（通过覆盖率引导）
functions_with_invariants() 函数 — 挖掘函数规范（将挖掘的不变量转换为注释），挖掘函数规范（练习 9：将不变量嵌入为断言）
functions_with_invariants_ast() — 挖掘函数规范（练习 9：将不变量嵌入为断言）
function_names() — 代码覆盖率（覆盖率类）
function_symbol() — 从调用中雕刻单元测试（一个语法）
function_with_invariants() — 挖掘函数规范（将挖掘的不变量转换为注释），挖掘函数规范（练习 9：将不变量嵌入为断言）
function_with_invariants_ast() — 挖掘函数规范（练习 9：将不变量嵌入为断言）
funct_parser() — 使用语法进行模糊测试（练习 4：将语法定义为函数（高级））)
fuzz — 突变分析（使用突变分析播种人工故障）
fuzz() — 模糊测试：使用随机输入破坏事物（Fuzzer 类），模糊测试：使用随机输入破坏事物（Fuzzer 类），基于突变的模糊测试（多次突变），灰盒模糊测试（高级黑盒基于突变的模糊测试），高效语法模糊测试（整合一切），跟踪信息流（污染语法模糊测试器），符号模糊测试（使用简单的符号模糊测试器），测试编译器（用于模糊测试 Python 的类）
fuzzed_url_element() — 模糊测试 API（合成预言机）
fuzzer — 模糊测试：使用随机输入破坏事物（Fuzzer 类）
fuzzer() — 模糊测试：使用随机输入破坏事物（一个简单的 Fuzzer）
Fuzzer 类 — 模糊测试：使用随机输入破坏事物（Fuzzer 类）
fuzzing — 模糊测试：使用随机输入破坏事物，解析输入（PEG 的问题）
语法模糊测试书的格式 — 测试编译器（具体代码的语法）
fuzzingbook.org — 切割单元测试（系统测试与单元测试），测试图形用户界面（探索大型网站）
FUZZINGBOOK_SWAG — 测试 Web 应用程序（接收订单），测试 Web 应用程序（接收订单），测试 Web 应用程序（接收订单）
FuzzManager — 大规模模糊测试（运行崩溃服务器），大规模模糊测试（探险：设置服务器）
FuzzManager 覆盖率页面 — 大规模模糊测试（收集代码覆盖率）
FuzzManager 崩溃页面 — 大规模模糊测试（探险结束）
FuzzManager. 它的 GitHub 页面 — [大规模模糊测试（背景）]
fuzz_tree() — 高效语法模糊测试（整合所有内容），使用生成器进行模糊测试（支持 Python 生成器），使用生成器进行模糊测试（扩展后的元素检查和修复），使用生成器进行模糊测试（局部检查和修复），使用生成器进行模糊测试（生成器和语法覆盖率），跟踪信息流（污染语法模糊测试器）

G

gcd — 符号模糊测试（使用高级符号模糊测试器）
gcd() — 突变分析（评估突变），符号模糊测试（简单模糊测试器的问题），控制流图（gcd）
geckodriver 程序 — 测试图形用户界面（设置 Firefox）
generate_good_tile() — 控制流图（示例：迷宫）
generate_maze_code() — 控制流图（示例：迷宫）
generate_mutant() — 突变分析（函数的简单突变器），突变分析（模块和测试套件的突变器）
generate_print_maze() — 控制流图（示例：迷宫）
generate_target_tile() — 控制流图（示例：迷宫）
generate_trap_tile() — 控制流图 (示例：迷宫)
基于代数的 — 灰盒模糊测试 (基于灰盒变异的模糊测试)
GENERATIONS — 测试编译器 (进化), 测试编译器 (进化)
Python 中的生成器函数 — 使用生成器进行模糊测试 (支持 Python 生成器)
GeneratorGrammarFuzzer 类 — 使用生成器进行模糊测试 (一个用于集成约束的类), 使用生成器进行模糊测试 (在扩展前生成元素), 使用生成器进行模糊测试 (在扩展前生成元素), 使用生成器进行模糊测试 (支持 Python 生成器), 使用生成器进行模糊测试 (在扩展后检查和修复元素), 使用生成器进行模糊测试 (在扩展后检查和修复元素), 使用生成器进行模糊测试 (在扩展后检查和修复元素), 使用生成器进行模糊测试 (在扩展后检查和修复元素), 使用生成器进行模糊测试 (在扩展后检查和修复元素), 使用生成器进行模糊测试 (本地检查和修复), 使用生成器进行模糊测试 (本地检查和修复), 使用生成器进行模糊测试 (本地检查和修复), 使用生成器进行模糊测试 (排序扩展)
GenericTimeout 类 — 超时 (变体 2: 通用 / Windows (使用跟踪，效率不高)))
遗传算法 — 基于搜索的模糊测试 (遗传算法)
genetic_algorithm() — 基于搜索的模糊测试 (遗传算法)
gen_cfg() — 控制流图 (PyCFG), 控制流图 (支持函数)
gen_fn_summary() — 符号模糊测试 (获取使用的变量名称和类型)
几何平均 — 灰盒模糊测试 (计算函数级距离)
__getFunctions__() — 灰盒模糊测试（定向功率调度）
__getitem__() — 突变分析（模块和测试套件的突变器）, 跟踪信息流（索引）, 控制流模糊测试（实现 ConcolicTracer 的探索）, 控制流模糊测试（生成子字符串）, 测试配置（第三部分：挖掘配置语法）
getPathID() — 灰盒模糊测试（增强灰盒模糊测试）
getTraceHash() — 何时停止模糊测试（跟踪覆盖率）
get_all_paths() — 符号模糊测试（生成所有可能的路径）, 符号模糊测试（生成所有路径）, 符号模糊测试（练习 2：静态检查是否应该进一步展开循环）, 符号模糊测试（练习 3：实现控制流模糊测试器）
get_all_vars() — 控制流模糊测试（使用字符的 ASCII 值的小技巧）
get_alternatives() — 使用语法的模糊测试（练习 4：将语法定义为函数（高级））)
get_annotations() — 符号模糊测试（控制流图）
get_arguments() — 挖掘函数规范（跟踪调用）, 雕刻单元测试（记录调用）
get_callgraph() — 控制流图（调用图辅助器）
get_cfg() — 控制流图（支持函数）
get_children() — 控制流模糊测试（表示决策）
get_defining_function() — 控制流图（PyCFG）
get_derivation_tree() — 挖掘输入语法（组装推导树）, 挖掘输入语法（组装推导树）, 挖掘输入语法（恢复推导树）, 挖掘输入语法（恢复推导树）
get_expression() — 符号模糊测试（函数摘要）
get_field_values() — 测试 Web 应用程序（处理订单）
get_fitness() — 基于搜索的模糊测试（仪器化）, 测试编译器（适者生存）
get_fitness_cgi() — 基于搜索的模糊测试（创建有效十六进制输入的适应度函数）
get_func() — 控制流图（PyCFG）
get_grammar() — 测试 Web 应用程序（Web 表单的模糊器）, 测试 Web 应用程序（全自动 Web 攻击）
get_html() — 测试 Web 应用程序（Web 表单的模糊器）
get_mutation_count() — 突变分析（函数的简单突变器）
get_newpath() — 约束模糊测试（SimpleConcolicFuzzer 类）
get_next_path() — 符号模糊测试（使用简单的符号模糊器进行模糊测试）, 符号模糊测试（生成所有路径）
get_path_to_root() — 约束模糊测试（表示决策）, 符号模糊测试（路径的逐步探索）
get_qualified_name() — 切割单元测试（记录调用）
get_registry() — 控制流图（注册表）
get_registry_idx() — 控制流图（注册表）
get_replacements() — 挖掘输入语法（语法挖掘）
get_symbolicparams() — 符号模糊测试（控制流图）
get_top() — 解析输入（练习 5：Leo 解析器）
GET — 测试 Web 应用程序（处理 HTTP 请求）, 测试 Web 应用程序（其他 HTTP 命令）, 测试 Web 应用程序（Web 表单的模糊器）
__ge__() — 约束模糊测试（整数之间的比较）
全局地 — 基于搜索的模糊测试（全局搜索）
GNU bc — 基于突变的模糊测试（第二部分：引导突变）
语法构造函数 — 模糊测试 API（概要）, 模糊测试 API（概要）
语法模糊测试 — 使用语法的模糊测试（算术表达式）
grammar() — 解析输入（解析器类）, 测试配置（模糊配置选项的类）
GrammarCoverageFuzzer 类 — 语法覆盖率（确定尚未覆盖的子节点）, 语法覆盖率（旁白：实现new_coverage()）), 语法覆盖率（旁白：实现choose_node_expansion()）)
GrammarFuzzer 类 — 高效语法模糊测试（扩展节点）, 高效语法模糊测试（旁白：check_grammar() 实现方法）-implementation), 高效语法模糊测试（旁白结束）, 高效语法模糊测试（选择要扩展的子节点）, 高效语法模糊测试（旁白结束）, 高效语法模糊测试（旁白：expand_node_randomly() 实现方法）-implementation), 高效语法模糊测试（旁白：expand_node_randomly() 实现方法）-implementation), 高效语法模糊测试（旁白：expand_node_randomly() 实现方法）-implementation), 高效语法模糊测试（扩展树）, 高效语法模糊测试（扩展树）, 高效语法模糊测试（旁白：expand_tree_once() 实现方法）-implementation), 高效语法模糊测试（旁白：实现成本函数）, 高效语法模糊测试（旁白：expand_node_by_cost() 实现方法）-implementation), 高效语法模糊测试（旁白结束）, 高效语法模糊测试（旁白结束）, 高效语法模糊测试（节点膨胀）, 高效语法模糊测试（节点膨胀）, 高效语法模糊测试（旁白：实现三阶段expand_tree()）`), 高效语法模糊测试（整合一切）
Grammarinator — 使用语法进行模糊测试（背景）
GrammarMiner 类 — 挖掘输入语法（从推导树中恢复语法）, 挖掘输入语法（从推导树中恢复语法）, 挖掘输入语法（从推导树中恢复语法）, 挖掘输入语法（从推导树中恢复语法）, 挖掘输入语法（恢复语法）
GrammarReducer 类 — 减少导致失败的输入（探索：使用语法的类）, 减少导致失败的输入（寻找子树）, 减少导致失败的输入（替代扩展）, 减少导致失败的输入（两种策略结合）, 减少导致失败的输入（减少策略）, 减少导致失败的输入（减少策略）, 减少导致失败的输入（减少策略）, 减少导致失败的输入（减少策略）, 减少导致失败的输入（深度导向策略）
语法 — 使用语法的模糊测试（语法）
graph_attr() — 高效语法模糊测试（探索：display_annotated_tree() 的源代码和示例）`)
灰盒模糊器 — 灰盒模糊测试（AFL：一个有效的灰盒模糊器）, 灰盒模糊测试（经验教训）
基于语法的灰盒模糊测试 — 测试编译器（突变输入）
GreyboxFuzzer 类 — 灰盒模糊测试（基于灰盒变异的模糊测试）
GreyboxGrammarFuzzer 类 — 基于语法的灰盒模糊测试（与灰盒模糊测试的集成）
__gt__() — 约束模糊测试（整数之间的比较）
GUI 捕获 — 测试图形用户界面（背景）
GUICoverageFuzzer 类 — 测试图形用户界面（覆盖状态）, 测试图形用户界面（覆盖状态）
GUIFuzzer 类 — 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer), 测试图形用户界面 (实践：实现 GUIFuzzer)
GUIGrammarMiner 类 — 测试图形用户界面 (检索动作), 测试图形用户界面 (实践：实现检索动作), 测试图形用户界面 (输入元素动作), 测试图形用户界面 (按钮元素动作), 测试图形用户界面 (链接元素动作), 测试图形用户界面 (链接元素动作), 测试图形用户界面 (实践：实现提取状态文法), 测试图形用户界面 (实践：实现提取状态文法)
GUIRunner类 — 测试图形用户界面（执行用户界面操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）, 测试图形用户界面（实现执行 UI 操作）
GUI_GRAMMAR — 测试图形用户界面（实现提取状态语法）

H

h() — 铁路图（铁路图实现）
handle_endtag() — 测试 Web 应用程序（搜索 HTML 中的输入字段）
handle_order() — 测试 Web 应用程序（处理订单）, 测试 Web 应用程序（第四部分：一个健壮的服务器）
handle_starttag() — 测试 Web 应用程序（搜索 HTML 中的输入字段）, 测试 Web 应用程序（爬取用户界面）
hang_if_no_space() — 模糊测试：使用随机输入破坏事物（缺少错误检查）, 条件模糊测试（实现简单 ConcolicFuzzer）
__hash__() — 解析输入（状态）
has_distributive_law() — 测试编译器（突变的有效性）
has_origin() — 跟踪信息流（一个用于跟踪字符来源的类）
has_taint() — 跟踪信息流（一个用于污点字符串的类）, 跟踪信息流（一个用于跟踪字符来源的类）
HDD — 减少导致故障的输入（背景）
HEADLESS — 测试图形用户界面（运行无头浏览器）, 测试图形用户界面（运行无头浏览器）
HEAD — 测试 Web 应用程序（其他 HTTP 命令）
心跳 — 模糊测试：使用随机输入破坏事物（检查内存访问）
heartbeat() — 模糊测试：使用随机输入破坏事物（信息泄露）
HeartBleed 公告页面 — 模糊测试：使用随机输入破坏事物（检查内存访问）
HeartBleed 漏洞 — 模糊测试：使用随机输入破坏事物（检查内存访问）
hello() — 挖掘函数规范（跟踪调用）
helper() — 解析输入（固定点）
启发式方法 — 基于搜索的模糊测试
层次化 Delta 调试 — 减少导致失败的输入（背景）
更高的覆盖率 — 基于语法的灰盒模糊测试（与灰盒模糊测试集成）
highlight_node() — 解析输入（临时解析器）
高度准确 — 何时停止模糊测试（评估发现概率估计）
high_charge() — 使用生成器模糊测试（扩展前调用的函数）
hillclimber() — 基于搜索的模糊测试（爬山示例）
hillclimb_cgi() — 基于搜索的模糊测试（爬山有效的十六进制输入）
hillclimb_cgi_limited() — 基于搜索的模糊测试（进化搜索）
hl_node() — 解析输入（临时解析器）
hl_predicate() — 解析输入（临时解析器）
钩子到__new__() — 跟踪信息流（污染字符串的类）
HorizontalChoice类 — 铁路图（远足：铁路图实现）
how_many_mutations() — 测试编译器（突变有多有效？）
HTML 注入 — 测试 Web 应用程序（HTML 注入攻击）
HTML 解析器 — 灰盒模糊测试（复杂示例：HTMLParser）
HTMLGrammarMiner 类 — 测试 Web 应用程序（搜索 HTML 输入字段）, 测试 Web 应用程序（挖掘网页语法）, 测试 Web 应用程序（挖掘网页语法）
HTMLParser — 何时停止模糊测试（测量随时间变化的跟踪覆盖率）
HTML_INTERNAL_SERVER_ERROR — 测试 Web 应用程序（内部错误）
HTML_NOT_FOUND — 测试 Web 应用程序（页面未找到）
HTML_ORDER_FORM — 测试 Web 应用程序（接收订单）
HTML_ORDER_RECEIVED — 测试 Web 应用程序（订单确认）
html_parser() — 何时停止模糊测试（第二部分：种群）
HTML_TERMS_AND_CONDITIONS — 测试 Web 应用程序（条款和条件）
HTTPD_MESSAGE_QUEUE — 测试 Web 应用程序（日志记录）
http_program() — 基于变异的模糊测试（模糊测试 URL 解析器）
hundred_inputs() — 代码覆盖率（基本模糊测试的覆盖率）
hypothesis 包 — 模糊测试 API（背景）
Hypothesis](https://hypothesis.works)模糊器具有多种特定类型的缩小策略；这篇博客文章 — [减少导致失败的输入（背景）

I

i() — 控制流图（CFGNode）
identifiers_with_types() — 符号模糊测试（循环前检查）
identifier_grammar_fn() — 基于语法的模糊测试（第二部分：扩展语法）
idx() — 解析输入（状态）
ID_CONTINUE — 测试编译器（探索：名称和函数调用）
ID_START — 测试编译器（探索：名称和函数调用）
ID — 使用约束进行模糊测试（匹配扩展元素）
IF — 符号模糊测试（获取使用的变量名称和类型）
ignored() — 挖掘输入语法（输入栈）, 挖掘输入语法（练习 2：结合信息流中的污点）
立即 — 使用约束进行模糊测试（访问元素）
不可变 — 跟踪信息流（污染字符串的类）
import_code() — 突变分析（模块和测试套件的突变器）
为了 — 解析输入（统一键）
在相同的方法调用中 — 挖掘输入语法（跟踪变量赋值位置）
在这个非常流行的 XKCD 漫画中 — 测试 Web 应用程序（SQL 注入攻击）
内存数据库 — 跟踪信息流（易受攻击的数据库）
发生频率 — 何时停止模糊测试（练习）
increment() — 解析输入（树提取器）
indent() — 挖掘输入语法（调用栈）
ineffective_test_1() — 突变分析（结构覆盖率不足的原因）
ineffective_test_2() — 突变分析（结构覆盖率不足的原因）
推断循环不变量 — 符号模糊测试（函数摘要）
informationflow_init_1() — 跟踪信息流（字符串运算符）
informationflow_init_2() — 跟踪信息流（通用包装器）
informationflow_init_3() — 跟踪信息流（尚未翻译的方法）
继承 — 模糊测试：用随机输入破坏事物（运行器类）
initialize() — 跟踪信息流（字符串运算符），条件模糊测试（整数二进制运算符）
INITIALIZER_LIST — 跟踪信息流（字符串运算符）
initial_grammar() — 切割单元测试（初始语法）
initial_population() — 测试编译器（演变输入）
init_concolic_1() — 条件模糊测试（整数二进制运算符）
init_concolic_2() — 条件模糊测试（整数一元运算符）
init_concolic_3() — 条件模糊测试（触发器）
init_concolic_4() — 条件模糊测试（练习 2：位操作）
init_db() — 测试 Web 应用程序（存储订单）
init_tainted_grammar() — 跟踪信息流（污染语法模糊器）
init_tree() — 高效语法模糊测试（探险结束）
__init__() — 模糊测试：使用随机输入破坏事物（运行类），模糊测试：使用随机输入破坏事物（运行类），模糊测试：使用随机输入破坏事物（模糊类），模糊测试：使用随机输入破坏事物（模糊类），模糊测试：使用随机输入破坏事物（练习 2：运行模拟 Troff），代码覆盖率（覆盖率类），基于变异的模糊测试（多次变异），基于变异的模糊测试（由覆盖率引导），灰盒模糊测试（变异器），灰盒模糊测试（种子和功率计划），灰盒模糊测试（种子和功率计划），灰盒模糊测试（高级黑盒基于变异的模糊测试），灰盒模糊测试（增强灰盒模糊测试），灰盒模糊测试（第一次尝试），灰盒模糊测试（第一次尝试），灰盒模糊测试（定向功率计划），变异分析（函数的简单变异器），变异分析（函数的简单变异器），变异分析（函数的简单变异器），变异分析（函数的简单变异器），变异分析（模块和测试套件的变异器），变异分析（模块和测试套件的变异器），变异分析（模块和测试套件的变异器），变异分析（模块和测试套件的变异器），变异分析（模块和测试套件的变异器），变异分析（模块和测试套件的变异器），高效语法模糊测试（节点扩展），高效语法模糊测试（练习 1：缓存方法结果），高效语法模糊测试（练习 2：语法预编译），语法覆盖率（跟踪语法覆盖率），解析输入（为什么解析用于模糊测试？），解析输入（解析器类），解析输入（逸出：规范语法），解析输入（列），解析输入（项），解析输入（状态），解析输入（解析算法），解析输入（可空），解析输入（树提取器），解析输入（树提取器），解析输入（树提取器），解析输入（练习 5：Leo 解析器），解析输入（练习 5：Leo 解析器），概率语法模糊测试（计数扩展），使用生成器的模糊测试（局部检查和修复），使用生成器的模糊测试（生成器和概率模糊测试），使用生成器的模糊测试（生成器和语法覆盖率），基于语法的灰盒模糊测试（使用字典进行模糊测试），基于语法的灰盒模糊测试（构建片段池），基于语法的灰盒模糊测试（构建片段池），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（基于片段的变异），基于语法的灰盒模糊测试（与灰盒模糊测试集成），基于语法的灰盒模糊测试（基于区域的变异），基于语法的灰盒模糊测试（关注有效种子），减少导致失败的输入（Delta 调试），减少导致失败的输入（词法减少与句法规则），减少导致失败的输入（逸出：使用语法减少的类），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（DefineTracker），挖掘输入语法（组装推导树），挖掘输入语法（从推导树恢复语法），挖掘输入语法（CallStack），挖掘输入语法（Vars），挖掘输入语法（AssignmentVars），挖掘输入语法（AssignmentTracker），挖掘输入语法（输入栈），挖掘输入语法（作用域跟踪器），挖掘输入语法（练习 1：展平复杂对象），跟踪信息流（一个易受攻击的数据库），跟踪信息流（一个用于污点字符串的类），跟踪信息流（污点感知模糊测试），跟踪信息流（跟踪字符来源的类），跟踪信息流（切片），跟踪信息流（TaintedGrammarFuzzer），跟踪信息流（第一部分：创建），跟踪信息流（第四部分：从字符串传递污点到整数），符号模糊测试（简单的符号模糊测试），符号模糊测试（跟踪赋值），符号模糊测试（练习 3：实现符号模糊测试器），挖掘函数规范（跟踪调用），挖掘函数规范（使用给定类型注释函数），挖掘函数规范（提取不变量），挖掘函数规范（练习 9：将不变量嵌入断言中），测试配置（选项和参数的语法挖掘器），测试配置（模糊配置选项的类），测试配置（模糊配置选项的类），切割单元测试（记录调用），切割单元测试（调用语法挖掘器），测试编译器（模糊 Python 的类），测试 Web 应用程序（使用意外值进行模糊测试），测试 Web 应用程序（在 HTML 中搜索输入字段），测试 Web 应用程序（Web 表单的模糊测试器），测试 Web 应用程序（全自动 Web 攻击），测试 Web 应用程序（全自动 Web 攻击），测试图形用户界面（检索操作），测试图形用户界面（执行用户界面操作），测试图形用户界面（逸出：实现 GUIFuzzer），测试图形用户界面（覆盖状态），何时停止模糊测试（模糊 Enigma），何时停止模糊测试（模糊 Enigma），何时停止模糊测试（图灵的观察），何时停止模糊测试（图灵的观察），错误处理（捕获错误），错误处理（捕获超时），计时器（测量时间），超时（变体 1：Unix（使用信号，高效））)，超时（变体 2：通用/Windows（使用跟踪，不太高效））)，铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），铁路图（逸出：铁路图实现），控制流图（CFGNode），控制流图（PyCFG）
"输入不变量" — 基于约束的模糊测试（背景）
输入字符串 — 挖掘输入语法（上下文）
InputStack 类 — 挖掘输入语法（输入栈）, 挖掘输入语法（输入栈）, 挖掘输入语法（输入栈）, 挖掘输入语法（输入栈）, 挖掘输入语法（输入栈）, 挖掘输入语法（输入栈）
insert_assertions() — 挖掘函数规范（练习 9：将不变量嵌入为断言）, 挖掘函数规范（练习 9：将不变量嵌入为断言）
insert_from_dictionary() — 灰盒模糊测试（第一次尝试）, 基于语法的灰盒模糊测试（使用字典模糊测试）
insert_into_tree() — 挖掘输入语法（组装推导树）, 挖掘输入语法（恢复推导树）
insert_random_character() — 基于变异的模糊测试（变异输入）, 灰盒模糊测试（变异器）
INSERT — 测试 Web 应用程序（存储订单）, 测试 Web 应用程序（SQL 注入攻击）
instantiate_prop() — 挖掘函数规范（实例化属性）
instantiate_prop_ast() — 挖掘函数规范（实例化属性）
仪器化 — 基于搜索的模糊测试（仪器化）
INTERNAL_ALIGNMENT — 铁路图（远足：铁路图实现）
internal_msg2key() — 何时停止模糊测试（模糊测试恩尼格玛）
internal_server_error() — 测试 Web 应用程序（内部错误）, 测试 Web 应用程序（第一部分：静默失败）
INT_BINARY_OPS — 约束模糊测试（整数二进制运算符）
int_grammar_with_range() — 模糊测试 API（整数）
INT_GRAMMAR — 模糊测试 API（概要）, 模糊测试 API（整数）, 模糊测试 API（概要）
INT_UNARY_OPS — 约束模糊测试（整数一元运算符）
__int__() — 约束模糊测试（整数代理类）
invalid — 使用语法的灰盒模糊测试（输入区域模糊测试）
InvariantAnnotator 类 — 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（练习 3：冗长的不变量检查器）, 挖掘函数规范（练习 3：冗长的不变量检查器）
invariants — 挖掘函数规范（指定和检查不变量）
invariants() — 挖掘函数规范（提取不变量）
InvariantTracker 类 — 挖掘函数规范（提取不变量）, 挖掘函数规范（提取不变量）
INVARIANT_PROPERTIES — 挖掘函数规范（定义属性）
INVENTORY_GRAMMAR_F — 跟踪信息流（探索：定义 SQL 语法）
INVENTORY_GRAMMAR_NEW — 约束模糊测试（探索：实现 ConcolicGrammarFuzzer）
INVENTORY_GRAMMAR — 跟踪信息流（探索：定义 SQL 语法）
INVENTORY_METHODS — 挖掘输入语法（一个简单的语法挖掘器）
INVENTORY — 挖掘输入语法（语法挑战）, 跟踪信息流（易受攻击的数据库）, 跟踪信息流（探索结束）
inverse — 何时停止模糊测试（图灵的观察）
invert_expansion() — 概率语法模糊测试（测试不常见特性）
invert_probs() — 概率语法模糊测试（测试不常见功能）
__invert__() — 约束性模糊测试（练习 2：位操作）
invoker() — 测试配置（用于模糊测试配置选项的类）
in_current_record() — 挖掘输入语法（输入栈），挖掘输入语法（练习 2：结合信息流中的污点）
in_scope() — 挖掘输入语法（输入栈）
IP_ADDRESS_TOKENS — 概率语法模糊测试（计数扩展）
isascii() — 大规模模糊测试（插曲：escapelines()实现）`-implementatipn)
ISLa — 带有约束的模糊测试，带有约束的模糊测试（指定约束），带有约束的模糊测试（概要）
ISLa 项目 — 带有约束的模糊测试（背景）
is_abstract() — 类图（使用方法名称绘制类层次结构）
is_excluded() — 使用语法的灰盒模糊测试（构建片段池）
is_fragment() — 挖掘输入语法（练习 2：结合信息流中的污点）
is_input_fragment() — 挖掘输入语法（定义跟踪器），挖掘输入语法（作用域跟踪器）
is_local_class() — 类图（使用方法名称绘制类层次结构）
is_nonterminal() — 使用语法的模糊测试（一些定义）
is_overloaded() — 类图（使用方法名称绘制类层次结构）
is_permutation() — 软件测试简介（第二部分：随机输入）
is_public() — 类图（使用方法名称绘制类层次结构）
is_sorted() — 软件测试简介（第二部分：随机输入）
is_valid_grammar() — 使用语法的模糊测试（插曲：实现is_valid_grammar()）`)
is_valid_probabilistic_grammar() — 概率语法模糊测试（检查概率）
is_valid_url() — 基于突变的模糊测试（突变 URL）
is_var() — 类图（获取方法和变量）
is_z3_var() — 约束性模糊测试（使用字符的 ASCII 值的技巧。）
它是不高效的 — 高效语法模糊测试（一个不足的算法）
Item 类 — 解析输入（项目）, 解析输入（项目）
可迭代对象 — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）
iterate() — 使用生成器的模糊测试（对 Python 生成器的支持）
IterativeEarleyParser 类 — 解析输入（练习 7：迭代 Earley 解析器）, 解析输入（练习 7：迭代 Earley 解析器）, 解析输入（练习 7：迭代 Earley 解析器）
迭代器 — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）
迭代器对象 — 使用生成器的模糊测试（对 Python 生成器的支持）
iter_paths() — 解析输入（练习 7：迭代 Earley 解析器）
__iter__() — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）, 跟踪信息流（切片）, 约束性模糊测试（生成子字符串）

J

J-Reduce — 减少故障诱导输入（背景）
JavaScript — 测试 Web 应用程序（跨站脚本攻击）
JerryScript — 使用语法的模糊测试（背景）
join() — 跟踪信息流（展开选项卡）
js-vuln-db — 概率语法模糊测试（练习 2：从过去的错误中学习）
JSON 规范 — 使用语法的模糊测试（练习 1：JSON 语法）
JSON_GRAMMAR — 使用文法进行模糊测试（练习 1：JSON 文法）

K - O

K

Kenngruppenbuch — 何时停止模糊测试（恩尼格玛机）
键盘记录器 — 测试网络应用程序（跨站脚本攻击）
已杀死 — 突变分析（注入人工故障）
KLEE — 符号模糊测试（背景）

L

lambda — 使用生成器进行模糊测试（扩展前调用的函数）
LangFuzz — 使用文法进行模糊测试（背景）
LangFuzzer 类 — 基于文法的灰盒模糊测试（基于片段的模糊测试）
语言规范 — 使用文法进行模糊测试（输入语言）
LD_LIBRARY_PATH — 测试配置（第一部分：Getopt 模糊测试）
叶子 — 高效文法模糊测试（推导树）
leave() — 挖掘输入文法（调用栈）, 挖掘输入文法（输入栈）
从左到右 — 解析输入（临时解析器）
left() — 铁路图（探险：铁路图实现）
left_align() — 测试图形用户界面（探险：实现提取状态文法）
length() — 符号模糊测试（字符串长度）
__len__() — 挖掘输入文法（调用栈）, 符号模糊测试（字符串长度）, 符号模糊测试（字符串的迭代器类）
LeoParser 类 — 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
leo_complete() — 解析输入（练习 5：Leo 解析器）
较低的代码覆盖率 — 基于语法的灰盒模糊测试（基于片段的模糊测试）
令牌化器 — 解析输入（解析器类）
令牌化 — 解析输入（解析器类）
__le__() — 约束模糊测试（整数比较）
行 — 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）, 挖掘输入语法（跟踪变量赋值位置）
行号 — 挖掘输入语法（带重新赋值的语法分析器）
linear_to_tree() — 解析输入（第二部分：解析器）
lineno() — 控制流图（CFGNode）
LinkHTMLParser 类 — 测试 Web 应用程序（抓取用户界面）
link_functions() — 控制流图（PyCFG）
所定义的所有 SMT-LIB 理论列表 — 使用约束进行模糊测试（探险结束）
list_grammar() — 模糊测试 API（列表）
LIST_GRAMMAR — 模糊测试 API（列表）
list_length() — 挖掘函数规范（一些示例）
ljust() — 跟踪信息流（对齐）
LL — 解析输入（背景），解析输入（背景），解析输入（背景），解析输入（背景），解析输入（背景），解析输入（背景）
ll() — 铁路图（远足：铁路图实现）
LL1Parser类 — 解析输入（第一部分：LL(1)解析表）-Parsing-Table)，解析输入（第一部分：LL(1)解析表）-Parsing-Table)，解析输入（第二部分：解析器）
LLVM 地址检查器 — 模糊测试：使用随机输入破坏事物（检查内存访问）
loc() — 挖掘输入语法（赋值变量）
本地主机 — 测试 Web 应用程序（运行服务器）
局部最优解 — 基于搜索的模糊测试（示例的爬山法）
log_call() — 挖掘输入语法（组装推导树）
log_event() — 挖掘输入语法（上下文）
log_message() — 测试 Web 应用程序（记录日志）
log_tree() — 高效语法模糊测试（远足：三阶段expand_tree()的实现）`)
LOG_VALUES — 基于搜索的模糊测试（示例的爬山法）
LONG_FOO — 测试配置（练习 1：#ifdef 配置模糊测试）
long_running_test() — 错误处理（捕获超时）
Loup Vaillant — 解析输入（解析方法）
lower() — 跟踪信息流（不改变原点的字符串方法），约束模糊测试（转换为上下文等价）
LOW — 跟踪信息流（字符串运算符）
LR — 解析输入（背景），解析输入（背景）
LR 解析 — 解析输入（项目）
LR(k) — 解析输入（Earley 解析器）
LR0 — 解析输入（项目）
LR_GRAMMAR — 解析输入（递归）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
lr_graph() — 解析输入（临时解析器）
lstrip() — 跟踪信息流（剥离）, 约束模糊测试（移除末尾空格）
__lt__() — 约束模糊测试（整数比较）
Luhn 算法 — 使用生成器进行模糊测试（扩展后的函数调用）
luhn_checksum() — 使用生成器进行模糊测试（扩展后的函数调用）
LUHN_ODD_LOOKUP — 使用生成器进行模糊测试（扩展后的函数调用）

M

m() — 铁路图（远足：铁路图实现）
宏定义 — 符号模糊测试（函数摘要）
main() — 测试编译器（抽象语法树）
大多数三元组 — 何时停止模糊测试（图灵的观察）
make_basic_str_wrapper() — 跟踪信息流（通用包装器）
make_float_binary_wrapper() — 约束模糊测试（练习 1：实现约束浮点代理类）
make_float_bool_wrapper() — 约束模糊测试（练习 1：实现约束浮点代理类）
make_grammar() — 解析输入（远足：测试解析器）
make_int_binary_wrapper() — 约束模糊测试（整数二进制运算符）, 约束模糊测试（练习 1：实现约束浮点代理类）
make_int_bit_wrapper() — 约束模糊测试（练习 2：位操作）
make_int_unary_wrapper() — 约束模糊测试（整数一元运算符）
make_int_wrapper() — 跟踪信息流（第二部分：算术表达式）
make_rule() — 解析输入（探索：测试解析器）
make_split_wrapper() — 跟踪信息流（分割）
make_str_abort_wrapper() — 跟踪信息流（尚未翻译的方法）, 条件模糊测试（触发器）
make_str_wrapper() — 跟踪信息流（字符串操作符）
手头有字典编写语法]lcamtuf.blogspot.com/2015/01/afl-fuzz-making-up-grammar-with.html 和从空气中提取 JPEG 图像 — [使用语法的灰盒模糊测试（使用字典模糊测试）
Marpa 解析器 — 解析输入（更多 Earley 解析）
math.isclose() — 软件测试简介（自动化测试执行）
MAX_DEPTH — 挖掘输入语法（练习 1：简化复杂对象）, 挖掘输入语法（练习 1：简化复杂对象）, 挖掘输入语法（练习 1：简化复杂对象）, 符号模糊测试（简单符号模糊测试）, 符号模糊测试（简单符号模糊测试）, 符号模糊测试（在循环前检查）, 符号模糊测试（在循环前检查）
_max_expansion_coverage() — 语法覆盖率（计算可能的扩展）
max_expansion_coverage() — 语法覆盖率（计算可能的扩展）
max_height() — 减少导致失败的输入（一些辅助工具）
MAX_ITER — 符号模糊测试（简单符号模糊测试）, 符号模糊测试（简单符号模糊测试）
MAX_TRIES — 符号模糊测试（简单符号模糊测试）, 符号模糊测试（简单符号模糊测试）
MAX — 基于搜索的模糊测试（将程序输入表示为搜索问题）, 基于搜索的模糊测试（将程序输入表示为搜索问题）, 基于搜索的模糊测试（示例的爬山法）, 基于搜索的模糊测试（示例的爬山法）, 基于搜索的模糊测试（示例的爬山法）
maze() — 灰盒模糊测试（解决迷宫）, 控制流图（示例：迷宫）, 控制流图（示例：迷宫）
MazeMutator 类 — 灰盒模糊测试（第一次尝试）
进度衡量 — 何时停止模糊测试（随时间测量跟踪覆盖率）
元启发式算法 — 基于搜索的模糊测试
metavars() — 挖掘函数规范（提取元变量）
METHOD_COLOR — 类图（使用方法名称绘制类层次结构）
method_enter() — 挖掘输入语法（赋值变量）, 挖掘输入语法（作用域变量）
method_exit() — 挖掘输入语法（赋值变量）
METHOD_FONT — 类图（使用方法名称绘制类层次结构）
method_init() — 挖掘输入语法（赋值变量）, 挖掘输入语法（作用域变量）
method_statement() — 挖掘输入语法（赋值变量）
method_string() — 类图（使用方法名称绘制类层次结构）
mine_arguments_grammar() — 切割单元测试（从参数中提取语法）
mine_a_element_actions() — 测试图形用户界面（探险：实现检索动作）, 测试图形用户界面（链接元素动作）
mine_button_element_actions() — 测试图形用户界面（探险：实现检索动作）, 测试图形用户界面（按钮元素动作）
mine_call_grammar() — 切割单元测试（从所有调用中提取语法）
mine_ebnf_grammar() — 测试配置（选项和参数的语法挖掘器）
mine_function_grammar() — 切割单元测试（从调用中提取语法）
mine_grammar() — 测试配置（选项和参数的语法挖掘器），测试 Web 应用程序（挖掘网页语法）
mine_input_element_actions() — 测试图形用户界面（探险：实现检索动作），测试图形用户界面（输入元素动作）
mine_probabilistic_grammar() — 概率语法模糊测试（分配概率）
mine_state_actions() — 测试图形用户界面（探险：实现检索动作）
mine_state_grammar() — 测试图形用户界面（探险：实现提取状态语法）
MIN — 基于搜索的模糊测试（将程序输入表示为搜索问题），基于搜索的模糊测试（将程序输入表示为搜索问题），基于搜索的模糊测试（示例的爬山法），基于搜索的模糊测试（示例的爬山法），基于搜索的模糊测试（示例的爬山法）
missing_expansion_coverage() — 语法覆盖率（在模糊测试时跟踪扩展）
现代重实现](https://git.gavinhoward.com/gavin/bc) 的作者是一位坚定的模糊测试支持者 — [模糊测试：使用随机输入破坏事物（模糊器找到的漏洞）
__mod__() — 跟踪信息流（mod）
MonkeyType — 挖掘函数规范（背景）
对平均距离较低的种子提供更多能量 — 灰盒模糊测试（定向功率调度）
更多有效输入 — 基于语法的灰盒模糊测试（基于片段的模糊测试）
大多数 — 基于搜索的模糊测试（示例的爬山法）
Mozilla 的grcov工具 — 大规模模糊测试（收集代码覆盖率）
mseq() — 挖掘输入语法（恢复推导树）
MuBinOpAnalyzer 类 — 突变分析（练习 1：算术表达式突变器）
MuFunctionAnalyzer 类 — 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）, 突变分析（评估突变）, 突变分析（评估突变）
多重继承 — 概率语法模糊测试（练习 1：具有覆盖率的概率模糊测试）, 使用生成器的模糊测试（全部一起）
MultipleChoice 类 — 铁路图（远足：铁路图实现）
MuProgramAnalyzer 类 — 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）, 突变分析（模块和测试套件的突变器）
mutable_visit() — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）
突变体 — 突变分析（注入人工故障）
MutantTestRunner 类 — 突变分析（模块和测试套件的突变器）
Mutant 类 — 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）, 突变分析（评估突变）, 突变分析（评估突变）
mutate() — 基于变异的模糊测试（变异输入）, 基于变异的模糊测试（多次变异）, 灰盒模糊测试（变异器）, 基于搜索的模糊测试（遗传算法）, 基于语法的灰盒模糊测试（基于片段的变异）
mutated — 基于搜索的模糊测试（全局搜索）
mutated_gcd() — 变异分析（等效变异体的问题）
mutation — 基于搜索的模糊测试（全局搜索）
mutation analysis — 变异分析（概要）, 变异分析（概要）
mutation-based fuzzer — 灰盒模糊测试（AFL：一个有效的灰盒模糊测试器）
mutational fuzzing — 基于变异的模糊测试, 基于变异的模糊测试（变异输入）
MutationCoverageFuzzer 类 — 基于变异的模糊测试（通过覆盖率引导）
MutationFuzzer 类 — 基于变异的模糊测试（多次变异）, 基于变异的模糊测试（多次变异）, 基于变异的模糊测试（多次变异）, 基于变异的模糊测试（多次变异）, 灰盒模糊测试（兼容性）
mutations — 变异分析, 变异分析（使用变异分析播种人工故障）
mutation_visit() — 变异分析（函数的简单变异器）, 变异分析（模块和测试套件的变异器）, 变异分析（练习 1：算术表达式变异器）
mutator — 灰盒模糊测试（高级黑盒变异模糊测试）, 灰盒模糊测试（经验教训）
mutator_object() — 变异分析（函数的简单变异器）, 变异分析（模块和测试套件的变异器）, 变异分析（练习 1：算术表达式变异器）
Mutator类 — 灰盒模糊测试（突变器）, 灰盒模糊测试（突变器）, 灰盒模糊测试（突变器）, 灰盒模糊测试（突变器）, 灰盒模糊测试（突变器）, 突变分析（函数的简单突变器）
MyPy — 模糊测试：使用随机输入破坏事物（静态代码检查器）
Mypy — 挖掘函数规范（静态类型检查）
MysteryRunner类 — 减少导致失败的输入（为什么减少？）
my_edge_attr() — Concolic Fuzzing（SimpleConcolicFuzzer 类）
my_eval() — 跟踪信息流（选择数据）, 跟踪信息流（TaintedDB）, 跟踪信息流（TrackingDB）
my_extract_node() — Concolic Fuzzing（SimpleConcolicFuzzer 类）
my_fn() — Concolic Fuzzing（练习 2：位操作）
my_parser() — 灰盒模糊测试（一个复杂示例：HTMLParser）, 使用语法的灰盒模糊测试（背景）, 何时停止模糊测试（随时间测量跟踪覆盖率）
my_sqrt() — 软件测试简介（简单测试）, 解析输入（固定点）, 挖掘函数规范（为什么泛型错误检查不够）
_my_sqrt() — 解析输入（固定点）
my_sqrt_annotated() — 挖掘函数规范（获取类型）
my_sqrt_checked() — 软件测试简介（运行时验证）
my_sqrt_fixed() — 软件测试简介（测试的局限性）, 软件测试简介（练习 4：无限与更远）
my_sqrt_with_invariants() — 挖掘函数规范（使用前置和后置条件注释函数）
my_sqrt_with_local_types() — 挖掘函数规范（练习 2：局部变量的类型）
my_sqrt_with_log() — 软件测试简介（调试函数）
my_sqrt_with_postcondition() — 挖掘函数规范（使用前条件和后条件注释函数）
my_sqrt_with_precondition() — 挖掘函数规范（使用前条件和后条件注释函数）
my_sqrt_with_type_annotations() — 挖掘函数规范（指定和检查数据类型）
my_sqrt_with_union_type() — 挖掘函数规范（练习 1：联合类型）

N

\(n\)]语法来访问类型为的n-th子项。要访问第一个子项，n`等于一，而不是零，正如在 XPath 简化语法 — [基于约束的模糊测试（访问元素）
names() — 符号模糊测试（获取使用的变量名称和类型）
自然语言 — 基于语法的模糊测试（自然语言语法）
naval_enigma() — 何时停止模糊测试（模糊测试恩尼格玛）
neighbors — 基于搜索的模糊测试（将程序输入表示为搜索问题）
neighbors() — 基于搜索的模糊测试（将程序输入表示为搜索问题）
neighbor_strings() — 基于搜索的模糊测试（CGI 解码器作为搜索问题）
__neq__() — 控制流图 (CFGNode)
networkx — 灰盒模糊测试（计算函数级距离）
牛顿-拉夫森方法 — 软件测试简介（简单测试）
new_child_coverage() — 语法覆盖率（确定尚未覆盖的子项）
_new_child_coverage() — 语法覆盖率（确定尚未覆盖的子项）
new_coverages() — 语法覆盖率（探索：实现 new_coverage()）`)
new_expansion_cost() — 高效语法模糊测试（练习 2：语法预编译）
new_gcd() — 突变分析（等效突变的问题）
new_state_symbol() — 测试图形用户界面（探索：实现提取状态文法）
new_symbol() — 使用语法进行模糊测试（创建新符号）
new_symbol_cost() — 高效语法模糊测试（练习 2：语法预编译）
__new__() — 跟踪信息流（污染字符串类）, 跟踪信息流（跟踪字符来源类）, 跟踪信息流（第一部分：创建）, 约束模糊测试（整数代理类）, 约束模糊测试（字符串代理类）, 约束模糊测试（练习 1：实现约束浮点代理类）, 铁路图（远足：铁路图实现）, 铁路图（远足：铁路图实现）, 铁路图（远足：铁路图实现）
next_choice() — 约束模糊测试（SimpleConcolicFuzzer 类）
__next__() — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）, 跟踪信息流（切片）, 约束模糊测试（字符串迭代器类）
__ne__() — 约束模糊测试（整数之间的相等性）, 铁路图（远足：铁路图实现）
no() — 约束模糊测试（表示决策）
节点 — 高效语法模糊测试（推导树）
NodeTransformer — 符号模糊测试（处理重新分配）
对人群中的类别数量的非参数估计 — 何时停止模糊测试（背景）
非终结符号 — 高效语法模糊测试（表示推导树）
nonterminals() — 使用语法进行模糊测试（一些定义）
NonTerminal 类 — 铁路图（远足：铁路图实现）
non_canonical() — 解析输入 (远足：规范语法)
normalize — 基于搜索的模糊测试 (创建有效十六进制输入的适应度函数)
normalize() — 基于搜索的模糊测试 (创建有效十六进制输入的适应度函数)
normalizedEnergy() — 灰盒模糊测试 (种子和功率计划)
not — 灰盒模糊测试 (高级黑盒基于变异的模糊测试), 解析输入 (练习 3：PEG 断言)
not_found() — 测试网络应用程序 (页面未找到)
__not__() — Concolic 模糊测试 (编码公式的否定)
no_8bit() — 模糊测试：使用随机输入破坏事物 (练习 1：模拟 Troff)
no_backslash_d() — 模糊测试：使用随机输入破坏事物 (练习 1：模拟 Troff)
no_dot() — 模糊测试：使用随机输入破坏事物 (练习 1：模拟 Troff)
nt_var() — 挖掘输入语法 (组装推导树), 挖掘输入语法 (恢复推导树)
nullable() — 解析输入 (可空)
nullable_() — 解析输入 (可空)
nullable_expr() — 解析输入 (可空)
number_of_nodes() — 减少导致失败的输入 (一些辅助工具)

O

OBJECT — 代码覆盖率 (覆盖率类)
observed — 何时停止模糊测试 (图灵的观察)
offsets_from_entry() — 符号模糊测试 (练习 3：实现 Concolic Fuzzer)
OFFSPRING — 测试编译器 (进化输入)
OneOrMore 类 — 铁路图 (远足：铁路图实现)
on_annassign() — 控制流图 (PyCFG)
on_assign() — 控制流图 (PyCFG)
on_augassign() — 控制流图 (PyCFG)
on_binop() — 控制流图 (PyCFG)
on_break() — 控制流图 (PyCFG)
on_call() — 挖掘输入语法 (AssignmentTracker), 控制流图 (PyCFG)
on_compare() — 控制流图 (PyCFG)
on_continue() — 控制流图 (PyCFG)
on_event() — 挖掘输入语法 (上下文)
on_exception() — 挖掘输入语法 (AssignmentTracker)
on_expr() — 控制流图 (PyCFG)
on_for() — 控制流图 (PyCFG)
on_functiondef() — 控制流图 (PyCFG)
on_if() — 控制流图 (PyCFG)
on_line() — 挖掘输入语法 (AssignmentTracker)
on_module() — 控制流图 (PyCFG)
on_pass() — 控制流图 (PyCFG)
on_return() — 挖掘输入语法 (AssignmentTracker), 控制流图 (PyCFG)
on_unaryop() — 控制流图 (PyCFG)
on_while() — 控制流图 (PyCFG)
优化 — 大规模模糊测试 (远足结束)
Optional() — 铁路图 (铁路图实现：远足)
OptionalSequence 类 — 铁路图 (铁路图实现：远足)
OptionFuzzer 类 — 测试配置 (模糊配置选项的类), 测试配置 (模糊配置选项的类)
OptionGrammarMiner 类 — 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器), 测试配置 (选项和参数的语法挖掘器)
OptionRunner类 — 测试配置（用于模糊测试配置选项的类）, 测试配置（用于模糊测试配置选项的类）, 测试配置（用于模糊测试配置选项的类）, 测试配置（用于模糊测试配置选项的类）
options() — 挖掘输入语法（上下文）, 挖掘输入语法（定义跟踪器）, 挖掘输入语法（组装推导树）, 挖掘输入语法（调用栈）, 挖掘输入语法（赋值跟踪器）, 符号模糊测试（简单符号模糊测试）, 符号模糊测试（高级符号模糊测试）
OPTION_SYMBOL — 测试配置（选项和参数的语法挖掘器）
opts() — 使用语法模糊测试（实现opts()的插曲）`)
opts_used() — 使用语法模糊测试（实现is_valid_grammar()的插曲）`)
或更多 — 何时停止模糊测试（练习）
占卜师 — 代码覆盖率（使用基本模糊测试查找错误）, 模糊测试 API（合成占卜师）
oracle() — 突变分析（评估突变）
占卜师 — 挖掘函数规范（检查规范）
有序选择 — 解析输入（概要）, 解析输入（解析表达式语法）, 解析输入（概要）
扩展顺序 — 使用生成器模糊测试（扩展顺序）
orders_db_is_empty() — 测试 Web 应用程序（全自动 Web 攻击）
ORDERS_DB — 测试 Web 应用程序（存储订单）
ORDER_GRAMMAR_WITH_SQL_INJECTION — 测试 Web 应用程序（SQL 注入攻击）
ORDER_GRAMMAR — 测试 Web 应用程序（使用预期值模糊测试）
ostr_iterator类 — 跟踪信息流（切片）
ostr 类 — 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（跟踪字符来源的类）, 跟踪信息流（创建）, 跟踪信息流（索引）, 跟踪信息流（切片）, 跟踪信息流（连接）, 跟踪信息流（连接）, 跟踪信息流（提取源字符串）, 跟踪信息流（替换）, 跟踪信息流（分割）, 跟踪信息流（删除空格）, 跟踪信息流（展开制表符）, 跟踪信息流（展开制表符）, 跟踪信息流（分区）, 跟踪信息流（调整对齐）, 跟踪信息流（调整对齐）, 跟踪信息流（mod）, 跟踪信息流（mod）, 跟踪信息流（不改变源字符串的字符串方法）
overloaded_class_methods() — 类图（获取方法和变量）
OWASP Zed Attack Proxy 项目 — 测试 Web 应用程序（背景）

P - T

P

P1 — 挖掘输入语法（组装推导树）, 挖掘输入语法（组装推导树）, 挖掘输入语法（组装推导树）
packrat — 解析输入（PEG 的问题）
PackratParser 类 — 解析输入（练习 1：替代 Packrat）
页面 — 测试图形用户界面（用户界面动作）
pairwise() — 测试配置（组合测试）
parameters() — 挖掘输入语法（上下文），挖掘输入语法（练习 1：简化复杂对象）
params() — 挖掘函数规范（将挖掘的不变量转换为注解）
parenthesized_expressions() — 使用语法的模糊测试（展开括号表达式）
parsable() — 使用语法的灰盒模糊测试（关注有效种子）
parse tree — 高效语法模糊测试（推导树），使用语法的灰盒模糊测试（解析和重组 HTML）
parse() — 解析输入（解析器类），解析输入（解析方法），解析输入（练习 1：替代 Packrat），解析输入（练习 5：Leo 解析器），解析输入（第二部分：解析器），减少失败诱导输入（减少策略），控制流图（PyCFG）
parseCSSGrammar() — 铁路图（远足：铁路图实现）
ParseInterrupt class — 测试配置（选项和参数的语法挖掘器）
parser — 解析输入（为什么解析用于模糊测试？）
Parser — 解析输入（解析器类）
parsers — 高效语法模糊测试（背景）
Parser class — 解析输入（解析器类），解析输入（远足：规范语法），解析输入（远足：规范语法）
parse_csv() — 解析输入（临时解析器）
parse_forest() — 解析输入（解析森林），解析输入（练习 5：Leo 解析器），解析输入（练习 6：过滤 Earley 解析器）
parse_helper() — 解析输入（第二部分：解析器）
parse_on() — 解析输入（解析器类）
parse_paths() — 解析输入（解析路径）, 解析输入（练习 7：迭代 Earley 解析器）
parse_prefix() — 解析输入（解析器类）, 解析输入（谓词表达式语法的 Packrat 解析器）, 解析输入（解析方法）, 解析输入（练习 1：替代 Packrat）
parse_quote() — 解析输入（临时解析器）
parse_sexp() — Concolic Fuzzing（使用命令行）
parse_table() — 解析输入（第一部分：LL(1)解析表）-Parsing-Table), 解析输入（第一部分：LL(1)解析表）-Parsing-Table)
parse_type() — 挖掘函数规范（使用给定类型注释函数）
解析 — 解析输入（解析器类）
解析表达式语法 — 解析输入（解析表达式语法）
解析表达式语法 — 解析输入（歧义）
partition() — 挖掘输入语法（组装推导树）, 挖掘输入语法（恢复推导树）, 挖掘输入语法（练习 2：结合信息流中的污点）, 跟踪信息流（分区）
partition_by_part() — 挖掘输入语法（组装推导树）, 挖掘输入语法（恢复推导树）
PASS — 模糊测试：使用随机输入破坏事物（概要）, 模糊测试：使用随机输入破坏事物（概要）, 模糊测试：使用随机输入破坏事物（概要）, 模糊测试：使用随机输入破坏事物（运行类）, 模糊测试：使用随机输入破坏事物（运行器）, 模糊测试：使用随机输入破坏事物（运行器）, 模糊测试：使用随机输入破坏事物（运行器）
疯狂之路 — 解析输入（临时解析器）
paths() — 解析输入（解析路径）
path_expression() — Concolic Fuzzing（表示决策）
Path 类 — 铁路图（远足：铁路图实现）
pattern() — 一致性模糊测试（表示决策）
PEG — 解析输入（解析表达式语法）, 解析输入（远足结束）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（背景）
PEG1 — 解析输入（解析表达式语法）
PEG2 — 解析输入（解析表达式语法）
PEGParser 类 — 解析输入（谓词表达式语法的 Packrat 解析器）, 解析输入（统一键）, 解析输入（统一规则）, 解析输入（统一规则）
PEGs — 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（PEG 的问题）, 解析输入（背景）, 解析输入（背景）
Python 代码的 PEP 8 风格指南 — 测试配置（测试 Autopep8）
permutation() — 一致性模糊测试（示例：二项式系数）
PGGCFuzzer 类 — 使用生成器模糊测试（生成器和语法覆盖率）
PICKED_US_PHONE_GRAMMAR — 使用生成器模糊测试（概要）
pick_area_code() — 使用生成器模糊测试（概要）
PlausibleChild 类 — 一致性模糊测试（表示决策）, 一致性模糊测试（表示决策）, 一致性模糊测试（表示决策）
图形 — 学术原型（可复现实验）
plotting_hillclimber() — 基于搜索的模糊测试（示例的爬山法）
PMIterator 类 — 突变分析（函数的简单突变器）, 突变分析（函数的简单突变器）
PNode类 — 符号模糊测试（跟踪赋值）, 符号模糊测试（跟踪赋值）, 符号模糊测试（逐步探索路径）, 符号模糊测试（逐步探索路径）, 符号模糊测试（逐步探索路径）
PooledGrammarFuzzer类 — 解析输入（为什么解析用于模糊测试？）
population_branch_coverage() — 代码覆盖率（第二部分：比较语句覆盖率和分支覆盖率）
population_coverage() — 代码覆盖率（基本模糊测试的覆盖率）
POPULATION_SIZE — 测试编译器（适者生存）, 测试编译器（适者生存）, 测试编译器（适者生存）
population_stmt_coverage() — 何时停止模糊测试（第一部分：种群覆盖率）
population_trace_coverage() — 何时停止模糊测试（随时间测量跟踪覆盖率）
possible_combinations() — 减少导致失败的输入（一些辅助工具）
possible_expansions() — 高效语法模糊测试（扩展树）
后序遍历 — 解析输入（背景）
postcondition() — 挖掘函数规范（使用前置和后置条件注释函数）
postconditions() — 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（练习 3：冗长的不变性检查器）, 挖掘函数规范（练习 9：将不变量嵌入为断言）
POST — 测试 Web 应用程序（Web 表单模糊器）
__pos__() — 约束模糊测试（整数代理类）
功率运算符 — 何时停止模糊测试（肯尼格鲁本）
功率调度 — 灰盒模糊测试（种子和功率调度）, 灰盒模糊测试（种子和功率调度）, 灰盒模糊测试（基于高级黑盒变异的模糊测试）, 灰盒模糊测试（经验教训）
power() — 切割单元测试（从调用到语法）
PowerSchedule 类 — 灰盒模糊测试（种子和功率调度）
POWER_GRAMMAR — 切割单元测试（从调用到语法）
预先计算 — 灰盒模糊测试（定向功率调度）
预购 — 解析输入（背景）
precompute_costs() — 高效语法模糊测试（练习 2：语法预编译）
precondition() — 挖掘函数规范（使用前缀和后缀条件注释函数）
preconditions() — 挖掘函数规范（将挖掘的不变量转换为注释）, 挖掘函数规范（练习 3：冗长的不变量检查器）, 挖掘函数规范（练习 9：将不变量嵌入为断言）
PreconditionTransformer 类 — 挖掘函数规范（练习 9：将不变量嵌入为断言）
predict — 何时停止模糊测试（外推模糊测试成功）
predict() — 解析输入（预测状态）, 解析输入（可空）, 解析输入（第一部分：LL(1)解析表）-Parsing-Table)
预测进一步分类采样中新物种的数量 — 何时停止模糊测试（背景）
前缀 — 符号模糊测试（函数摘要）
prefix_vars() — 符号模糊测试（函数摘要）
pretty_invariants() — 挖掘函数规范（提取不变量）
在上一章 MutationFuzzer.ipynb 中，我们介绍了基于变异的模糊测试，这是一种通过向给定输入应用小变异来生成模糊输入的技术。在本章中，我们展示了如何将这些变异引导到特定目标，例如覆盖率。本章中的算法源自流行的美国模糊跳蚤 (AFL) 模糊器，特别是其 AFLFast 和 AFLGo
PrintRunner 类 — 模糊测试：使用随机输入破坏事物（运行器类）
print_httpd_messages() — 测试网络应用程序（记录日志）
print_maze() — 控制流图（示例：迷宫）
print_more_stats() — 基于语法的灰盒模糊测试（与灰盒模糊测试集成）
print_stats() — 灰盒模糊测试（初次尝试）, 基于语法的灰盒模糊测试（基于片段的模糊测试）
print_sum() — 挖掘函数规范（一些示例）
print_url() — 测试网络应用程序（直接浏览器访问）
ProbabilisticGeneratorGrammarCoverageFuzzer 类 — 使用生成器的模糊测试（生成器和语法覆盖率）, 使用生成器的模糊测试（生成器和语法覆盖率）, 使用生成器的模糊测试（生成器和语法覆盖率）
ProbabilisticGeneratorGrammarFuzzer 类 — 使用生成器的模糊测试（生成器和概率模糊测试）
ProbabilisticGrammarCoverageFuzzer 类 — 概率语法模糊测试（练习 1：具有覆盖率的概率模糊测试）
ProbabilisticGrammarFuzzer 类 — 概率语法模糊测试（通过概率扩展）, 概率语法模糊测试（通过概率扩展）
ProbabilisticGrammarMiner 类 — 概率语法模糊测试（分配概率）, 概率语法模糊测试（分配概率）
prob_distribution() — 概率语法模糊测试（分配概率）
prob_leading_digit() — 概率语法模糊测试（首位数字定律）
process() — 挖掘输入语法（DefineTracker），符号模糊测试（简单的符号模糊测试），符号模糊测试（生成所有可能的路径）
process_arg() — 测试配置（选项和参数的语法挖掘器）
process_argument() — 测试配置（选项和参数的语法挖掘器）
process_car() — 解析输入（为什么解析用于模糊测试？）
process_car_with_obj() — 挖掘输入语法（练习 1：简化复杂对象）
process_chosen_children() — 高效语法模糊测试（探索：expand_node_randomly() 实现）`-implementation)，使用生成器模糊测试（在扩展前生成元素）
process_inventory() — 解析输入（为什么解析用于模糊测试？）
process_inventory_with_obj() — 挖掘输入语法（练习 1：简化复杂对象）
process_numbers() — 测试配置（Python 中的选项）
PROCESS_NUMBERS_EBNF_GRAMMAR — 测试配置（配置的语法）
PROCESS_NUMBERS_GRAMMAR — 测试配置（配置的语法）
process_van() — 解析输入（为什么解析用于模糊测试？）
process_van_with_obj() — 挖掘输入语法（练习 1：简化复杂对象）
process_vehicle() — 解析输入（为什么解析用于模糊测试？）
process_vehicle_with_obj() — 挖掘输入语法（练习 1：简化复杂对象）
prod_line_grammar() — 解析输入（探索：测试解析器）
程序光谱 — 学术原型（可复现实验）
ProgramRunner 类 — 模糊测试：使用随机输入破坏事物（运行器类）
模糊测试活动完成进度 — 何时停止模糊测试（发现概率量化残余风险）
prop_function() — 挖掘函数规范（评估属性）
prop_function_text() — 挖掘函数规范（评估属性）
proxy() — 跟踪信息流（字符串运算符）, 跟踪信息流（分割）, 跟踪信息流（通用包装器）, 跟踪信息流（尚未翻译的方法）, 跟踪信息流（第二部分：算术表达式）, Concolic Fuzzing（整数二进制运算符）, Concolic Fuzzing（整数一元运算符）, Concolic Fuzzing（触发器）, Concolic Fuzzing（练习 1：实现 Concolic Float Proxy 类）, Concolic Fuzzing（练习 1：实现 Concolic Float Proxy 类）, Concolic Fuzzing（练习 1：实现 Concolic Float Proxy 类）, Concolic Fuzzing（练习 2：位操作）
prune_tokens() — Concolic Fuzzing（剪枝和更新）
prune_tree() — 解析输入（解析器类）, 解析输入（远足：规范语法）, Concolic Fuzzing（远足：实现 ConcolicGrammarFuzzer）
public_class_methods() — 类图（获取方法和变量）
PUBLIC — 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）
PyAnnotate — 挖掘函数规范（背景）
PYAN — 控制流图（调用图辅助工具）, 控制流图（调用图辅助工具）
PyCFG 类 — 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）, 控制流图（PyCFG）
Python — 挖掘输入语法（语法挖掘）
Python ast 文档 — 测试编译器（抽象语法树）
Python AST 模块 — 测试编译器（抽象语法树）
Python 文档 — 条件模糊测试（整数二进制运算符）
Python 教程 — 软件测试简介（理解 Python 程序）, 模糊测试：使用随机输入破坏事物
Python 类型到 Z3 类型 — 符号模糊测试（获取使用的变量名称和类型）
Python ast 模块文档 — 测试编译器（概要）, 测试编译器（概要）
PythonFuzzer 类 — 测试编译器（用于模糊测试 Python 的类）
PYTHON_AST_COMPOSITES_GRAMMAR — 测试编译器（探索：复合）
PYTHON_AST_GRAMMAR — 测试编译器（概要）, 测试编译器（探索结束）, 测试编译器（调整语法）, 测试编译器（概要）

Q

Q0 — 何时停止模糊测试（第三部分：计算和评估外推器）
Q1 — 何时停止模糊测试（第二部分：计算估计）
Q2 — 何时停止模糊测试（第二部分：计算估计）
QEMU](github.com/mirrorer/afl/blob/master/qemu_mode)) 或动态插桩工具（例如，Intel PinTool — [灰盒模糊测试（AFL：一个有效的灰盒模糊测试器）
quadratic_solver() — 软件测试简介（练习 3：二次求解器）
quadratic_solver_fixed() — 软件测试简介（第二部分：修复问题）
quad_solver() — 控制流图（quad_solver）
qualified() — 挖掘输入语法（上下文），挖掘输入语法（练习 1：简化复杂对象）
quux() — 类图（获取类层次结构）
qux() — 类图（获取类层次结构）

R

__radd__() — 跟踪信息流（字符串运算符），跟踪信息流（连接），约束模糊测试（字符串连接）
铁路图 — 学术原型（可重复实验）
随机重启 — 基于搜索的模糊测试（Hillclimbing 示例）
RandomFuzzer 类 — 使用随机输入破坏事物（模糊器类）
randomized_hillclimb() — 基于搜索的模糊测试（全局搜索）
random_list() — 软件测试简介（第二部分：随机输入）
random_string() — 基于搜索的模糊测试（Hillclimbing Valid Hexadecimal Inputs）
random_unicode_string() — 基于搜索的模糊测试（进化搜索）
reachable_nonterminals() — 使用语法进行模糊测试（插曲：实现 is_valid_grammar()）`)
readable() — 挖掘输入语法（从推导树中恢复语法）
readable_rule() — 挖掘输入语法（从推导树中恢复语法）
read_gcov_coverage() — 代码覆盖率（从外部程序获取覆盖率）
rearrange() — 解析输入（练习 5：Leo 解析器）
recover_grammar() — 挖掘输入语法（从推导树中恢复语法），挖掘输入语法（语法挖掘）
recover_grammar_with_taints() — 挖掘输入语法（练习 2：结合信息流中的污点）
recurse_grammar() — 解析输入（远足：规范语法）
递归 — 解析输入（远足：递归）
递归 — 使用语法进行模糊测试（规则和扩展）
recursive_delete() — 使用语法进行灰盒模糊测试（基于片段的突变）
recursive_swap() — 使用语法进行灰盒模糊测试（基于片段的突变）
红黑树 — 模糊测试：使用随机输入破坏程序（程序特定检查器）
RedBlackTree 类 — 模糊测试：使用随机输入破坏程序（程序特定检查器）
reduce() — 减少导致失败的输入（Delta Debugging），减少导致失败的输入（Delta Debugging），减少导致失败的输入（减少策略）
Reducer 类 — 减少导致失败的输入（Delta Debugging）
reduce_subtree() — 减少导致失败的输入（减少策略）
reduce_tree() — 减少导致失败的输入（减少策略），减少导致失败的输入（深度导向策略）
调试书籍中的“减少导致失败的输入” — 减少导致失败的输入（背景）
区域 — 使用语法进行灰盒模糊测试（使用输入区域进行模糊测试），使用语法进行灰盒模糊测试（确定符号区域）
基于区域的突变器 — 使用语法进行灰盒模糊测试（使用输入区域进行模糊测试）
RegionMutator 类 — 基于语法的灰盒模糊测试（基于区域的突变），基于语法的灰盒模糊测试（基于区域的突变），基于语法的灰盒模糊测试（基于区域的突变）
register() — 突变分析（函数的简单突变器）
register_event() — 挖掘输入语法（赋值变量）
register_node() — 控制流图（注册表）
REGISTRY_IDX — 控制流图（注册表），控制流图（注册表）
REGISTRY — 控制流图（注册表），控制流图（注册表）
正则表达式 — 解析输入（背景）
正则表达式 — 基于语法的模糊测试（输入语言）
正则表达式 — 解析输入（临时解析器）
常规语言 — 解析输入（解析器类）
移除 — 基于语法的灰盒模糊测试（基于片段的突变）
remove_first_char() — 挖掘函数规范（练习 3：冗长不变性检查器），挖掘函数规范（练习 3：冗长不变性检查器）
rename_variables() — 符号模糊测试（处理重新分配）
修复 — 基于生成器的模糊测试（扩展后的函数调用）
replace() — 跟踪信息流（替换）
replace_symbol() — 测试图形用户界面（实现 GUIFuzzer 的探索）
repOK() — 使用随机输入破坏事物（程序特定检查器）
表示 — 基于搜索的模糊测试（测试生成作为搜索问题）
表示不变性 — 使用随机输入破坏事物（程序特定检查器）
代表性路径 — 符号模糊测试（练习 3：实现并发式模糊测试器）
__repr__() — 代码覆盖率（覆盖率类）, 解析输入（树提取器）, 挖掘输入语法（上下文）, 挖掘输入语法（调用栈）, 跟踪信息流（受污染字符串类）, 跟踪信息流（跟踪字符来源类）, 跟踪信息流（第三部分：从整数传递污点至字符串）, 符号模糊测试（表示决策）, 符号模糊测试（跟踪赋值）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 铁路图（铁路图实现：远足）, 控制流图（CFG 节点）
REQUIRED_FIELDS — 测试 Web 应用程序（第四部分：一个健壮的服务器）
__req__() — 条件模糊测试（整数之间的相等性）, 条件模糊测试（字符串之间的相等性）
reset() — 基于变异的模糊测试（多次变异）, 基于变异的模糊测试（由覆盖率引导）, 灰盒模糊测试（高级黑盒基于变异的模糊测试）, 灰盒模糊测试（灰盒基于变异的模糊测试）, 灰盒模糊测试（增强灰盒模糊测试）, 概率语法模糊测试（计数扩展）, 减少导致失败的输入（Delta 调试）, 减少导致失败的输入（Delta 调试）, 挖掘函数规范（跟踪调用）, 切割单元测试（记录调用）, 切割单元测试（第一部分：存储函数结果）, 测试 Web 应用程序（搜索 HTML 中的输入字段）, 测试 Web 应用程序（爬取用户界面）, 何时停止模糊测试（模糊测试恩尼格玛）
reset_counter() — 条件模糊测试（生成新名称）
reset_coverage() — 语法覆盖率（跟踪扩展）
reset_generators() — 使用生成器进行模糊测试（支持 Python 生成器）
reset_registry() — 控制流图（注册表）
残余风险 — 何时停止模糊测试, 何时停止模糊测试（发现概率量化残余风险）
restart() — 测试图形用户界面（探险：实现 GUIFuzzer）
RestartExpansionException 类 — 使用生成器进行模糊测试（局部检查和修复）
restarting_hillclimber() — 基于搜索的模糊测试（示例的爬山法）
restart_expansion() — 使用生成器进行模糊测试（扩展后的元素检查和修复），使用生成器进行模糊测试（局部检查和修复），使用生成器进行模糊测试（生成器和语法覆盖率）
result() — 切割单元测试（第二部分：访问结果）
ResultCarver 类 — 切割单元测试（练习），切割单元测试（第一部分：存储函数结果），切割单元测试（第二部分：访问结果）
结果检查器 — 代码覆盖率（使用基本模糊测试查找错误）
返回 — 挖掘输入语法（跟踪变量赋值位置），挖掘输入语法（跟踪变量赋值位置），挖掘输入语法（跟踪变量赋值位置）
RETURN_VALUE — 挖掘函数规范（提取不变量）
RE_EXTENDED_NONTERMINAL — 使用语法进行模糊测试（扩展运算符）
RE_NONTERMINAL — 使用语法进行模糊测试（一些定义）
RE_PARENTHESIZED_EXPR — 使用语法进行模糊测试（展开括号表达式）
RFC 4180 — 解析输入（临时解析器）
right() — 铁路图（铁路图实现：远足）
RISKY_NUMBERS — 概率语法模糊测试（练习 2：从过去的错误中学习），概率语法模糊测试（练习 2：从过去的错误中学习）
rjust() — 跟踪信息流（对齐）
__rmod__() — 跟踪信息流（mod）
根节点 — 高效语法模糊测试（推导树）
rootIsBlack() — 模糊测试：使用随机输入破坏事物（程序特定检查器）
roots() — 符号模糊测试（示例：二次方程的根）
roots2() — 符号模糊测试（根 - 分割前检查）
roots3() — 符号模糊测试（消除零除错误 - 根）
round10() — 符号模糊测试（示例：轮次）
rpartition() — 跟踪信息流（分区）
RR_GRAMMAR2 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR3 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR4 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR5 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR6 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR7 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR8 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR9 — 解析输入（练习 5：Leo 解析器）
RR_GRAMMAR — 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
rsplit() — 跟踪信息流（分割）
rstrip() — 跟踪信息流（去除末尾空格）, 符号模糊测试（从末尾移除空格）
rules — 使用语法进行模糊测试（规则和扩展）
rules() — 解析输入（可空）, 解析输入（第一部分：LL(1) 解析表）-Parsing-Table)
run() — 模糊测试：使用随机输入破坏事物（运行类）, 模糊测试：使用随机输入破坏事物（运行类）, 模糊测试：使用随机输入破坏事物（运行类）, 模糊测试：使用随机输入破坏事物（模糊类）, 模糊测试：使用随机输入破坏事物（练习 2：运行模拟 Troff）, 基于变异的模糊测试（通过覆盖率引导）, 基于变异的模糊测试（通过覆盖率引导）, 灰盒模糊测试（基于灰盒变异的模糊测试）, 灰盒模糊测试（增强灰盒模糊测试）, 减少导致失败的输入（为什么减少？）, 减少导致失败的输入（词汇减少与句法规则）, 减少导致失败的输入（概要）, 测试配置（模糊测试配置选项类）, 测试 Web 应用程序（使用意外值进行模糊测试）, 测试图形用户界面（探索：实现执行 UI 操作）, 测试图形用户界面（探索：实现 GUIFuzzer）, 何时停止模糊测试（模糊测试 Enigma）
Runner类 — 模糊测试：使用随机输入破坏事物（运行类）
runs() — 模糊测试：使用随机输入破坏事物（模糊类）
runTest() — 变异分析（模块和测试套件的变异器）
run_function() — 基于变异的模糊测试（通过覆盖率引导）, 基于变异的模糊测试（通过覆盖率引导）
run_fuzzmanager() — 大规模模糊测试（探索：启动服务器）
run_fuzzmanager_forever() — 大规模模糊测试（探索：启动服务器）
run_generator() — 使用生成器进行模糊测试（在扩展前生成元素）, 使用生成器进行模糊测试（支持 Python 生成器）
run_httpd_forever() — 测试 Web 应用程序（运行服务器）
run_post_functions() — 使用生成器进行模糊测试（扩展后的检查和修复元素）
run_post_functions_locally() — 使用生成器进行模糊测试（本地检查和修复）
run_process() — 模糊测试：使用随机输入破坏事物（运行器类）, 模糊测试：使用随机输入破坏事物（运行器类）

S

S-EXP — 约束性模糊测试（转换为 SMT 表达式格式）, 约束性模糊测试（转换为 SMT 表达式格式）
SAGE — 符号模糊测试（背景）
样本覆盖率 — 何时停止模糊测试（图灵的观察）
sample_db() — 跟踪信息流（表示表）
清理 — 跟踪信息流（跟踪不受信任的输入）
sanitize() — 跟踪信息流（跟踪不受信任的输入）
保存 — 大规模模糊测试（崩溃桶）
Scalene — 符号模糊测试（带有路径的 CFG）
scan() — 解析输入（扫描标记）
扫描器 — 解析输入（解析器类）
范围 — 挖掘输入语法（恢复推导树）
ScopedGrammarMiner 类 — 挖掘输入语法（语法挖掘）, 挖掘输入语法（语法挖掘）, 挖掘输入语法（语法挖掘）, 挖掘输入语法（语法挖掘）
ScopedVars 类 — 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）, 挖掘输入语法（作用域变量）
ScopeTracker 类 — 挖掘输入语法（范围跟踪器）, 挖掘输入语法（范围跟踪器）
ScopeTreeMiner 类 — 挖掘输入语法（恢复推导树）, 挖掘输入语法（恢复推导树）, 挖掘输入语法（恢复推导树）, 挖掘输入语法（恢复推导树）, 挖掘输入语法（恢复推导树）
score() — 变异分析（评估变异）, 变异分析（模块和测试套件的变异器）
搜索 — 基于搜索的模糊测试
搜索空间 — 基于搜索的模糊测试（测试生成作为搜索问题）
基于搜索的模糊测试](SearchBasedFuzzer.ipynb). 如果你对如何解决上述问题感兴趣，可以查看我们关于“定向灰盒模糊测试 — [灰盒模糊测试（计算函数级距离）
search_superclasses() — 类图（获取方法和变量）
second() — 类图（获取类层次结构）
SECRET_ORIGIN — 跟踪信息流（隐私泄露重访）, 跟踪信息流（隐私泄露重访）, 跟踪信息流（隐私泄露重访）
SECRET — 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）
种子 — 基于语法的模糊测试（语法作为变异种子）
SeedWithRegions 类 — 基于语法的灰盒模糊测试（基于区域的变异）
SeedWithStructure 类 — 基于语法的灰盒模糊测试（构建片段池）
Seed 类 — 灰盒模糊测试（种子和功率计划）
select() — 测试编译器（适者生存）
selection() — 基于搜索的模糊测试（遗传算法）
选择性压力 — 基于搜索的模糊测试（遗传算法）
Selenium — 测试图形用户界面（自动 GUI 交互）
Selenium 测试 — 测试图形用户界面（编写测试用例）
Selenium](www.seleniumhq.org) 是一个通过 自动化浏览器交互 来测试 Web 应用的框架。Selenium 提供了一个 API，允许用户启动 Web 浏览器，查询用户界面的状态，并与单个用户界面元素进行交互。Selenium API 支持多种语言；我们使用的是 Selenium API for Python — [测试图形用户界面（使用 Selenium 的远程控制）
send_back() — 跟踪信息流（防止隐私泄露）
send_order_form() — 测试 Web 应用（订单表单）
send_order_received() — 测试 Web 应用（处理订单），测试 Web 应用（第二部分：净化 HTML）
send_terms_and_conditions() — 测试 Web 应用（订单表单）
Sequence 类 — 铁路图（探险：铁路图实现）
seq_vars() — 挖掘输入语法（赋值变量），挖掘输入语法（作用域变量）
会话 cookie — 测试 Web 应用（跨站脚本攻击）
__setitem__() — 挖掘输入语法（变量）
set_arguments() — 测试配置（模糊测试配置选项类）
set_expansion_probabilities() — 概率语法模糊测试（分配概率）
set_flatten_depth() — 挖掘输入语法（练习 1：简化复杂对象）
set_grammar() — 测试图形用户界面（GUIFuzzer 的实现：探险）
set_invocation() — 测试配置（模糊测试配置选项类）
_set_kv() — 挖掘输入语法（变量），挖掘输入语法（赋值变量）
set_opts() — 使用语法进行模糊测试（远足：实现opts()）`)
set_parents() — 控制流图（CFGNode）
set_prob() — 概率语法模糊测试（定向模糊测试）
set_probabilities() — 概率语法模糊测试（分配概率）
SEXPR_TOKEN — 基于命令行的符号模糊测试
Shellsort — 软件测试简介（练习 2：测试 Shellsort）
shellsort() — 软件测试简介（练习 2：测试 Shellsort）
短路求值 — 基于搜索的模糊测试（处理复杂条件）
showast — 突变分析（突变 Python 代码）, 挖掘函数规范（访问函数结构）
show_ast() — 符号模糊测试（函数摘要）, 学术原型（Python 中的静态分析：仍然简单）, 使用 Python 进行原型设计（Python 中的静态分析：仍然简单）
show_cfg() — 符号模糊测试（控制流图）
show_coverage() — 突变分析（通过示例展示结构覆盖充分性）, 符号模糊测试（可视化覆盖范围）, 测试编译器（获取覆盖范围）
show_diagram() — 铁路图（远足：铁路图实现）
show_grammar() — 解析输入（远足：规范语法）
show_table() — 解析输入（第一部分：LL(1)解析表）-Parsing-Table)
SIGALRM — 超时（概要）, 超时（概要）
SIGALRM 信号](https://docs.python.org/3.10/library/signal.html)（中断）用于实现超时；这对跟踪代码的性能没有影响。在其他系统（特别是 Windows）上，Timeout 使用了 sys.settrace() — 超时（概要）, 超时（概要）
SignalTimeout 类 — 超时（变体 1：Unix（使用信号，高效））)
签名 — 大规模模糊测试（崩溃签名）
simple-crash — 大规模模糊测试（收集崩溃）
SimpleConcolicFuzzer 类 — 条件模糊测试（SimpleConcolicFuzzer 类）, 条件模糊测试（SimpleConcolicFuzzer 类）, 条件模糊测试（SimpleConcolicFuzzer 类）, 条件模糊测试（模糊测试方法）
SimpleExtractor 类 — 解析输入（树提取器）
SimpleGrammarCoverageFuzzer 类 — 语法覆盖（覆盖语法扩展）, 语法覆盖（覆盖语法扩展）
SimpleHTTPRequestHandler 类 — 测试 Web 应用程序（实现 Web 服务器的探索）, 测试 Web 应用程序（处理 HTTP 请求）, 测试 Web 应用程序（订单表单）, 测试 Web 应用程序（订单表单）, 测试 Web 应用程序（处理订单）, 测试 Web 应用程序（处理订单）, 测试 Web 应用程序（处理订单）, 测试 Web 应用程序（处理订单）, 测试 Web 应用程序（其他 HTTP 命令）, 测试 Web 应用程序（页面未找到）, 测试 Web 应用程序（内部错误）, 测试 Web 应用程序（日志记录）
SimpleSymbolicFuzzer — 符号模糊测试（简单模糊测试的问题）
SimpleSymbolicFuzzer 类 — 符号模糊测试（简单符号模糊测试）, 符号模糊测试（简单符号模糊测试）, 符号模糊测试（生成所有可能的路径）, 符号模糊测试（生成所有可能的路径）, 符号模糊测试（提取所有约束）, 符号模糊测试（使用简单符号模糊测试进行模糊测试）, 符号模糊测试（使用简单符号模糊测试进行模糊测试）, 符号模糊测试（使用简单符号模糊测试进行模糊测试）
simple_call_string() — Mining Function Specifications (Tracking Calls), Carving Unit Tests (Recording my_sqrt()))
simple_grammar_fuzzer() — Fuzzing with Grammars (A Simple Grammar Fuzzer)
simple_parse_csv() — Parsing Inputs (An Ad Hoc Parser)
single — Parsing Inputs (Exercise 5: Leo Parser), Parsing Inputs (Exercise 5: Leo Parser)
single-alternative — Parsing Inputs (The Earley Parser)
singleton species — When To Stop Fuzzing (Exercises)
single_char_tokens() — Parsing Inputs (Excursion: Canonical Grammars)
sinks — Tracking Information Flow (The Evil of Eval)
Skip class — Railroad Diagrams (Excursion: Railroad diagrams implementation)
smaller number of valid inputs — Greybox Fuzzing with Grammars (Integration with Greybox Fuzzing)
Smart Greybox Fuzzing by Pham and co-authors. Download and improve AFLSmart: [github.com/aflsmart/aflsmart — Greybox Fuzzing with Grammars (Focusing on Valid Seeds)
SMT Solver — Concolic Fuzzing (Concolic Execution)
SMT solvers — Concolic Fuzzing
SMT solvers](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories), especially Z3 — [Symbolic Fuzzing
SMT-LIB — Concolic Fuzzing (Translating to the SMT Expression Format)
SMT-LIB string library — Fuzzing with Constraints (Part 2: Semantics)
smt_expr() — Concolic Fuzzing (Translating to the SMT Expression Format)
smt_val() — Concolic Fuzzing (Representing Decisions)
solve_path_constraint() — Symbolic Fuzzing (Fuzzing with Simple Symbolic Fuzzer), Symbolic Fuzzing (Solving Path Constraints)
some — Greybox Fuzzing (AFL: An Effective Greybox Fuzzer), Greybox Fuzzing with Grammars (Integration with Greybox Fuzzing)
some_long_running_function() — 计时器（测量时间）, 超时（变体 1：Unix（使用信号，高效））)
sooo very slow — 基于语法的灰盒模糊测试（基于片段的模糊测试）
sort_by_prob() — 概率语法模糊测试（测试不常见功能）
source() — 控制流图（CFGNode）
sources — 跟踪信息流（Eval 的邪恶）
span() — 约束模糊测试（逸出：实现 ConcolicGrammarFuzzer）
specific — 基于搜索的模糊测试
split() — 解析输入（逸出：规范语法）, 跟踪信息流（分割）, 约束模糊测试（分割字符串）
_split_helper() — 跟踪信息流（分割）
_split_space() — 跟踪信息流（分割）
SQL 命令 — 测试 Web 应用程序（存储订单）
SQL 注入 — 测试 Web 应用程序（SQL 注入攻击）
sql() — 跟踪信息流（执行 SQL 语句）, 跟踪信息流（跟踪不受信任的输入）
SQLException类 — 跟踪信息流（易受攻击的数据库）
SQLInjectionFuzzer类 — 测试 Web 应用程序（全自动 Web 攻击）
SQLInjectionGrammarMiner类 — 测试 Web 应用程序（全自动 Web 攻击）
sqrt_program() — 软件测试简介（系统输入与函数输入）, 软件测试简介（系统输入与函数输入）, 软件测试简介（系统输入与函数输入）
srange() — 基于语法的模糊测试（字符类）
src() — 突变分析（函数的简单突变器）, 突变分析（模块和测试套件的突变器）
stack_to_tree() — 挖掘输入语法（调用栈）
Stack类 — 铁路图（逸出：铁路图实现）
STADS：软件测试作为物种发现 — 何时停止模糊测试（背景）
起始符号 — 使用文法模糊测试（规则和扩展），高效文法模糊测试（推导树）
startswith() — Concolic 模糊测试（检查字符串前缀）
start_httpd() — 测试 Web 应用程序（运行服务器）
START_STATE — 测试图形用户界面（探险：实现提取状态文法）
start_symbol() — 解析输入（解析器类）
START_SYMBOL — 使用文法模糊测试（一些定义）
start_webdriver() — 测试图形用户界面（启动 Web 驱动程序）
Start类 — 铁路图（探险：铁路图实现）
状态 — 测试图形用户界面（探险结束）
状态机 — 学术原型（可复现实验）
语句覆盖率 — 代码覆盖率（白盒测试）
状态 — 测试图形用户界面（用户界面作为有限状态机）
State类 — 解析输入（状态），解析输入（练习 5：Leo 解析器）
最陡上升爬山法 — 基于搜索的模糊测试（爬山示例）
steepest_ascent_hillclimber() — 基于搜索的模糊测试（爬山示例）
StmtDeletionMutator类 — 突变分析（函数的简单突变器），突变分析（函数的简单突变器）
store_order() — 测试 Web 应用程序（处理订单），测试 Web 应用程序（第三部分：净化 SQL）
字符串 — 挖掘输入文法（文法挖掘）
字符串包含 — 挖掘输入文法（练习 2：结合来自 InformationFlow 的污点）
string_part_of_value() — 挖掘输入文法（组装推导树），挖掘输入文法（练习 2：结合来自 InformationFlow 的污点）
strip() — 跟踪信息流（strip），Concolic Fuzzing（移除末尾空格）
strip_all_info() — 跟踪信息流（转换）
strip_all_info_again() — 跟踪信息流（隐式信息流）
STROKE_ODD_PIXEL_LENGTH — 铁路图（探索：铁路图实现）
StrongShapeTest 类 — 突变分析（模块和测试套件的突变器）
strong_oracle() — 突变分析（通过示例的结构覆盖充分性）
__str__() — 灰盒模糊测试（种子和功率调度），解析输入（列），解析输入（状态），解析输入（树提取器），挖掘输入语法（调用栈），跟踪信息流（一个用于污点字符串的类），跟踪信息流（污点感知模糊测试），跟踪信息流（跟踪字符来源的类），跟踪信息流（第三部分：从整数传递污点到字符串），Concolic Fuzzing（表示决策），符号模糊测试（路径逐步探索），控制流图（CFGNode）
Style 类 — 铁路图（探索：铁路图实现）
子类 — 模糊测试：使用随机输入破坏事物（运行类）
submit() — 测试图形用户界面（实现执行 UI 操作的探索）
subtrees_with_symbol() — 减少导致失败的输入（查找子树）
suite() — 突变分析（模块和测试套件的突变器）
sum() — 挖掘函数规范（概要），测试编译器（解析输入）
sum2() — 挖掘函数规范（一些示例）
sum3() — 挖掘函数规范（多种类型）
supported_opts() — Efficient Grammar Fuzzing (Excursion: check_grammar() implementation)`-implementation), Probabilistic Grammar Fuzzing (Expanding by Probability), Fuzzing with Generators (A Class for Integrating Constraints), Fuzzing with Generators (Generators and Probabilistic Fuzzing), Fuzzing with Generators (Generators and Grammar Coverage)
swapcase() — Tracking Information Flow (String methods that do not change origin)
swap_fragment() — Greybox Fuzzing with Grammars (Fragment-Based Mutation), Greybox Fuzzing with Grammars (Region-Based Mutation)
符号表 — Fuzzing with Generators (Definitions and Uses)
符号化 — Symbolic Fuzzing (Check Before You Loop)
符号化模糊器 — Symbolic Fuzzing (Simple Symbolic Fuzzing)
符号阴影变量 — Concolic Fuzzing (Solving Constraints)
符号化地 — Symbolic Fuzzing (Simple Symbolic Fuzzing)
SymbolicFuzzer — Symbolic Fuzzing (Roots - Eliminating the Zero Division Error)
SymbolicFuzzer 类 — Symbolic Fuzzing (Advanced Symbolic Fuzzing), Symbolic Fuzzing (Check Before You Loop), Symbolic Fuzzing (Solving Path Constraints), Symbolic Fuzzing (Generating All Paths), Symbolic Fuzzing (Generating All Paths), Symbolic Fuzzing (Exercise 2: Statically checking if a loop should be unrolled further), Symbolic Fuzzing (Exercise 2: Statically checking if a loop should be unrolled further)
symbol_cost() — Efficient Grammar Fuzzing (Excursion: Implementing Cost Functions)
SYMBOL_NAME — Efficient Grammar Fuzzing (Representing Derivation Trees)
symbol_reductions() — Reducing Failure-Inducing Inputs (Both Strategies Together)
SYMBOL_TABLE — 使用生成器进行模糊测试（定义和用法）
sym_to_float() — 符号模糊测试（示例：二次方程的根）
SYM_VARS_STR — 符号模糊测试（获取使用的变量名称和类型）
SYM_VARS — 符号模糊测试（控制流图）
语法结构 — 使用语法进行模糊测试（语法）
syntax_diagram() — 使用语法进行模糊测试（实现syntax_diagram()的探索）`)
syntax_diagram_alt() — 使用语法进行模糊测试（实现syntax_diagram()的探索）`)
syntax_diagram_expr() — 使用语法进行模糊测试（实现syntax_diagram()的探索）`)
syntax_diagram_symbol() — 使用语法进行模糊测试（实现syntax_diagram()的探索）`)
系统输入 — 软件测试简介（系统输入与函数输入）

T

_t() — 解析输入（状态），挖掘输入语法（上下文）
table() — 跟踪信息流（表示表），条件模糊测试（示例：数据库）
污点 — 跟踪信息流（Eval 的邪恶）
污点清理器 — 跟踪信息流（Eval 的邪恶）
TaintedDB 类 — 跟踪信息流（TaintedDB）
TaintedGrammarFuzzer 类 — 跟踪信息流（TaintedGrammarFuzzer），跟踪信息流（TaintedGrammarFuzzer），跟踪信息流（TaintedGrammarFuzzer），跟踪信息流（TaintedGrammarFuzzer）
TaintedInputStack 类 — 挖掘输入语法（练习 2：从 InformationFlow 中引入污点），挖掘输入语法（练习 2：从 InformationFlow 中引入污点）
TaintedScopedGrammarMiner 类 — 挖掘输入语法（练习 2：从 InformationFlow 中引入污点）
TaintedScopedVars 类 — 挖掘输入语法（练习 2：结合信息流中的污点）
TaintedScopeTracker 类 — 挖掘输入语法（练习 2：结合信息流中的污点）
TaintedScopeTreeMiner 类 — 挖掘输入语法（练习 2：结合信息流中的污点）
Tainted 类 — 跟踪信息流（污点感知模糊测试）
target_tile() — 灰盒模糊测试（解决迷宫），控制流图（示例：迷宫），控制流图（示例：迷宫）
终端符号 — 高效语法模糊测试（表示推导树）
terminals() — 解析输入（可空）
terminal_repr() — 基于搜索的模糊测试（进化搜索）
Terminal 类 — 铁路图（远足：铁路图实现）
test — 软件测试简介（运行一个函数）
test() — 减少导致失败的输入（Delta Debugging），减少导致失败的输入（Delta Debugging）
TestGCD 类 — 突变分析（模块和测试套件的突变器），突变分析（概要）
test_equilateral() — 突变分析（模块和测试套件的突变器），突变分析（模块和测试套件的突变器）
test_isosceles() — 突变分析（模块和测试套件的突变器），突变分析（模块和测试套件的突变器）
test_me() — 基于搜索的模糊测试（将程序输入表示为搜索问题）
test_me2() — 基于搜索的模糊测试（示例的爬山法）
test_me2_instrumented() — 基于搜索的模糊测试（示例的爬山法）
test_me_instrumented() — 基于搜索的模糊测试（仪表化），基于搜索的模糊测试（仪表化）
test_mirror() — 模块和测试套件的突变分析（突变器）, 突变分析（概要）
test_samples() — 测试编译器（常量）
test_scalene() — 模块和测试套件的突变分析（突变器）, 模块和测试套件的突变分析（突变器）
test_simple() — 模块和测试套件的突变分析（突变器）, 突变分析（概要）
test_successful_order() — 测试图形用户界面（编写测试用例）
ConfigParser 文档 — 测试配置（练习 2：.ini 配置模糊测试）
"Python 中类型提示的状态" — 挖掘函数规范（背景）
这个 — 挖掘输入语法（赋值变量）
这篇文章 — 概率语法模糊测试（背景）
这个提交 — 约束模糊测试（使用字符的 ASCII 值的技巧）
这个实用的技巧 — 大规模模糊测试（远足：设置服务器）
丢弃结果 — 解析输入（练习 5：Leo 解析器）
tile_() — 控制流图（示例：迷宫）, 控制流图（示例：迷宫）, 控制流图（示例：迷宫）
timeout_handler() — 超时（变体 1：Unix（使用信号，高效））)
Timer 类 — 计时器（测量时间）
tint 类 — 跟踪信息流（第一部分：创建）, 跟踪信息流（第二部分：算术表达式）, 跟踪信息流（第三部分：从整数传递污点至字符串）, 跟踪信息流（第三部分：从整数传递污点至字符串）, 跟踪信息流（第四部分：从字符串传递污点至整数）
title() — 跟踪信息流（不改变原点的字符串方法）
一起 — Mutation Analysis (Exercise 4: Estimating Residual Defect Density)
分词器 — Parsing Inputs (A Parser Class)
从上到下 — Parsing Inputs (An Ad Hoc Parser)
顶部到底部 — Parsing Inputs (Exercise 5: Leo Parser)
比赛选择 — Search-Based Fuzzing (Genetic Algorithms)
to_graph() — Control Flow Graph (Supporting Functions)
to_json() — Control Flow Graph (CFGNode)
to_nonterminal() — Mining Input Grammars (Assembling a Derivation Tree)
to_single_assignment_predicates() — Symbolic Fuzzing (Renaming Used Variables)
to_src() — Symbolic Fuzzing (Function Summaries)
trace() — Code Coverage (A Coverage Class)
traceit() — Code Coverage (Tracing Executions), Code Coverage (A Coverage Class), Mining Input Grammars (Tracer), Mining Input Grammars (Context), Mining Input Grammars (Context), Concolic Fuzzing (Tracking Constraints), Mining Function Specifications (Tracking Calls), Mining Function Specifications (Tracking Calls), Testing Configurations (A Grammar Miner for Options and Arguments), Carving Unit Tests (Recording Calls), Carving Unit Tests (Exercises), Carving Unit Tests (Part 1: Store function results), Academic Prototyping (Dynamic Analysis in Python: So Easy it Hurts), Prototyping with Python (Dynamic Analysis in Python: So Easy it Hurts)
TraceNode 类 — Concolic Fuzzing (Representing Decisions), Concolic Fuzzing (Representing Decisions), Concolic Fuzzing (Representing Decisions), Concolic Fuzzing (Representing Decisions)
Tracer 类 — 挖掘输入语法（Tracer），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（上下文），挖掘输入语法（上下文）
TraceTree 类 — Concolic 模糊测试（表示决策），Concolic 模糊测试（表示决策）
trace_call() — 挖掘函数规范（跟踪调用）
trace_locals() — 测试配置（跟踪参数）
trace_options() — 测试配置（跟踪参数）
trace_return() — 挖掘函数规范（跟踪调用）
跟踪函数 — 代码覆盖率（跟踪执行）
tracing_context() — 挖掘输入语法（上下文）
tracing_var() — 挖掘输入语法（上下文）
Tracker 类 — 挖掘函数规范（跟踪调用）
TrackingArcCoverage 类 — 符号模糊测试（练习 3：实现 Concolic 模糊器）
TrackingConfigParser 类 — 测试配置（第三部分：挖掘配置语法）
TrackingDB 类 — 跟踪信息流（TrackingDB）
TrackingGrammarCoverageFuzzer 类 — 语法覆盖率（跟踪语法覆盖率），语法覆盖率（跟踪扩展），语法覆盖率（计算可能的扩展），语法覆盖率（模糊时跟踪扩展），语法覆盖率（模糊时跟踪扩展）
track_event() — 挖掘输入语法（DefineTracker），挖掘输入语法（AssignmentTracker）
传递性 — 解析输入（练习 5：Leo 解析器）
translate_to_z3_name() — 符号模糊测试（获取使用的变量名称和类型）
traverse() — Academic Prototyping (Static Analysis in Python: Still Easy), Academic Prototyping (A Symbolic Test Generator), Prototyping with Python (Static Analysis in Python: Still Easy), Prototyping with Python (A Symbolic Test Generator)
traverse_if_children() — Academic Prototyping (A Symbolic Test Generator), Prototyping with Python (A Symbolic Test Generator)
traverse_tree() — Efficient Grammar Fuzzing (Excursion: Implementing display_tree())`), Class Diagrams (Getting a Class Tree)
traverse_z3() — Concolic Fuzzing (Excursion: Implementing ConcolicGrammarFuzzer)
tree — Efficient Grammar Fuzzing (Derivation Trees)
Tree Maps — Academic Prototyping (Replicable Experiments)
TreeMiner class — Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Assembling a Derivation Tree), Mining Input Grammars (Recovering a Derivation Tree)
tree_fitness() — Testing Compilers (Fitness)
tree_list_to_string() — Reducing Failure-Inducing Inputs (A Few Helpers)
TREE_NODES — Concolic Fuzzing (The SimpleConcolicFuzzer class)
tree_to_grammar() — Mining Input Grammars (Recovering Grammars from Derivation Trees), Mining Input Grammars (Grammar Mining)
tree_to_string() — 高效语法 Fuzzing（探险结束）, 跟踪信息流（污染语法 Fuzzer）, Concolic Fuzzing（探险：实现 ConcolicGrammarFuzzer）
tree_type() — 跟踪信息流（污染语法 Fuzzer）
TRIALS — 大规模 Fuzzing（探险结束）, 大规模 Fuzzing（收集代码覆盖率）
triangle() — 突变分析（通过示例进行结构覆盖率充分性分析）, Concolic Fuzzing（转换为 SMT 表达式格式）, 学术原型设计（Python 很简单）, 使用 Python 进行原型设计（Python 很简单）
triangle_m1() — 突变分析（注入人工故障）
triangle_traced() — 学术原型设计（Python 中的动态分析：简单到令人痛苦）, 使用 Python 进行原型设计（Python 中的动态分析：简单到令人痛苦）
trigram — 何时停止 Fuzzing（恩尼格玛机）
trim_grammar() — 使用语法进行 Fuzzing（探险：实现is_valid_grammar()）`)
TroffRunner类 — Fuzzing：使用随机输入破坏事物（练习 2：运行模拟 Troff）
true_property_instantiations() — 挖掘函数规范（检查不变量）
TrustedDB类 — 跟踪信息流（跟踪不受信任的输入）
TRUSTED — 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）
TState类 — 解析输入（练习 5：Leo 解析器）
tstr1() — Concolic Fuzzing（字符串之间的相等性）, Concolic Fuzzing（字符串之间的相等性）
tstr10() — Concolic Fuzzing（移除末尾空格）
tstr11() — Concolic Fuzzing（分割字符串）
tstr2() — Concolic Fuzzing（字符串长度）
tstr3() — 约束模糊测试（字符串迭代器类）
tstr4() — 约束模糊测试（转换为上下文等价）
tstr5() — 约束模糊测试（转换为上下文等价）
tstr6() — 约束模糊测试（检查字符串前缀）
tstr7() — 约束模糊测试（查找子字符串）
tstr8() — 约束模糊测试（移除末尾空格）
tstr9() — 约束模糊测试（移除末尾空格）
tstr 类 — 跟踪信息流（受污染字符串类）, 跟踪信息流（受污染字符串类）, 跟踪信息流（受污染字符串类）, 跟踪信息流（受污染字符串类）, 跟踪信息流（字符串运算符）, 跟踪信息流（字符串运算符）, 跟踪信息流（字符串运算符）
图灵机 — 基于语法的模糊测试（输入语言）
twice — 基于搜索的模糊测试（处理复杂条件）
twice() — 测试配置（创建 Autopep8 选项）
two — 符号模糊测试（函数摘要）, 何时停止模糊测试（测量时间覆盖的跟踪）
类型注释 — 符号模糊测试
TypeAnnotator 类 — 挖掘函数规范（一站式注释）
typed_functions() — 挖掘函数规范（一站式注释）
typed_functions_ast() — 挖掘函数规范（一站式注释）
typed_triangle() — 学术原型设计（类型检查）-Type-Checking), 使用 Python 原型设计（类型检查）-Type-Checking)
types — 挖掘函数规范（指定和检查数据类型）
TypeTracker 类 — 挖掘函数规范（一站式注释）
TypeTransformer 类 — 挖掘函数规范（使用给定类型注释函数）, 挖掘函数规范（使用给定类型注释函数）, 挖掘函数规范（使用给定类型注释函数）
type_string() — 挖掘函数规范（使用挖掘的类型注释函数）
TYPE — 使用约束进行模糊测试（量词）

U - Y

U

UNEXPLORED_STATE — 测试图形用户界面（探险：实现提取状态语法）
unhack() — 控制流图（支持函数）
unicode_escape() — 大规模模糊测试（探险：escapelines() 实现）`-implementatipn)
unicode_string_neighbors() — 基于搜索的模糊测试（进化搜索）
unify_key() — 解析输入（统一键）, 解析输入（统一规则）, 解析输入（练习 1：替代 Packrat）
unify_rule() — 解析输入（统一规则）, 解析输入（练习 1：替代 Packrat）
uniq_postdot() — 解析输入（练习 5：Leo 解析器）, 解析输入（练习 5：Leo 解析器）
universal grammars — 使用语法进行模糊测试（输入语言）
unknown() — 类图（获取文档）
UNKNOWN_ORIGIN — 跟踪信息流（一个跟踪字符来源的类）, 跟踪信息流（隐私泄露重访）
unobserved — 何时停止模糊测试（图灵的观察）
unparse — 符号模糊测试（函数摘要）
unreachable_nonterminals() — 使用语法进行模糊测试（探险：实现 is_valid_grammar()）`)
UNRESOLVED — 模糊测试：使用随机输入破坏事物（概要）, 模糊测试：使用随机输入破坏事物（概要）, 模糊测试：使用随机输入破坏事物（运行类）, 模糊测试：使用随机输入破坏事物（运行器）, 模糊测试：使用随机输入破坏事物（运行器）, 减少导致失败的输入（探索结束）
循环展开 — 符号模糊测试（高级符号模糊测试）
UNTRUSTED — 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）, 跟踪信息流（防止隐私泄露）
不寻常的路径 — 灰盒模糊测试（增强灰盒模糊测试）
unwrap_substrings() — 约束模糊测试（探索：实现 ConcolicGrammarFuzzer）
up() — 铁路图（探索：铁路图实现）
update() — 挖掘输入语法（变量）, 挖掘输入语法（赋值变量）, 挖掘输入语法（作用域变量）
update_cache() — 解析输入（为什么解析用于模糊测试？）
update_children() — 控制流图（CFGNode）, 控制流图（PyCFG）
update_existing_state() — 测试图形用户界面（探索：实现 GUIFuzzer）, 测试图形用户界面（探索：实现 GUIFuzzer）
update_functions() — 控制流图（PyCFG）
update_grammar() — 挖掘输入语法（从推导树恢复语法）, 挖掘输入语法（恢复语法）, 挖掘输入语法（语法挖掘）, 跟踪信息流（污染语法模糊测试器）, 约束模糊测试（剪枝和更新）
update_inventory() — 跟踪信息流（探索结束）
update_maps() — 基于搜索的模糊测试（原子条件的仪器化）
update_new_state() — 测试图形用户界面（远足：实现 GUIFuzzer）
update_state() — 测试图形用户界面（远足：实现 GUIFuzzer）
update_tree() — 跟踪信息流（污染语法模糊器）
upper() — 跟踪信息流（不改变原点的字符串方法）, 一致性模糊化（转换为上下文等价）
urllib/parse.py — 挖掘输入语法（AssignmentTracker）
URLPARSE_ORACLE_GRAMMAR — 模糊化 API（练习 1：深层参数）
URLS_X — 挖掘输入语法（简单挖掘器的问题）
URLS — 挖掘输入语法（示例 2：恢复 URL 语法）
url_parse() — 挖掘输入语法（示例 2：恢复 URL 语法）
used_identifiers() — 符号模糊化（获取使用的变量名称和类型）
used_vars() — 符号模糊化（获取使用的变量名称和类型）
user interface elements — 测试图形用户界面（使用 Selenium 进行远程控制）
use_id() — 使用生成器进行模糊化（定义和用法）

V

v() — 铁路图（远足：铁路图实现）
V1 — 挖掘输入语法（组装推导树）, 挖掘输入语法（组装推导树）
valid — 突变分析（注入人工故障）
valid_luhn_checksum() — 使用生成器进行模糊化（扩展后的函数调用）
VALUES — 跟踪信息流（插入数据）
VARIABLE — 代码覆盖率（覆盖率类）, 有约束的模糊化（量词）, 有约束的模糊化（匹配扩展元素）, 有约束的模糊化（匹配扩展元素）
Vars 类 — 挖掘输入语法（Vars）, 挖掘输入语法（Vars）
var_access() — 挖掘输入语法（AssignmentVars）, 挖掘输入语法（ScopedVars）
var_assign() — 挖掘输入语法（AssignmentVars）, 挖掘输入语法（ScopedVars）
VAR_GRAMMAR — 使用生成器进行模糊测试（定义和用途）, 使用生成器进行模糊测试（定义和用途）
var_location_register() — 挖掘输入语法（AssignmentVars）
var_name() — 挖掘输入语法（AssignmentVars）, 挖掘输入语法（ScopedVars）
var_string() — 类图（使用方法名称绘制类层次结构）
var_symbol() — 从论证中构建单元测试（语法）
VAR — 类图（获取类层次结构）
VEHICLES — 挖掘输入语法（一个简单的语法挖掘器）, 跟踪信息流（一个易受攻击的数据库）, 跟踪信息流（探险结束）
Vehicle 类 — 挖掘输入语法（练习 1：简化复杂对象）
verbose_condition() — 挖掘函数规范（练习 3：冗余不变性检查器）
verbose_postcondition() — 挖掘函数规范（练习 3：冗余不变性检查器）
verbose_precondition() — 挖掘函数规范（练习 3：冗余不变性检查器）
虚拟变量 — 挖掘输入语法（AssignmentTracker）
visit_AnnAssign() — 突变分析（函数的简单突变器）
visit_Assert() — 突变分析（函数的简单突变器）
visit_Assign() — 突变分析（函数的简单突变器）
visit_AugAssign() — 突变分析（函数的简单突变器）
visit_BinOp() — 突变分析（练习 1：算术表达式突变器）
visit_Break() — 突变分析（函数的简单突变器）
visit_Compare() — 基于搜索的模糊测试（自动源代码注入）
visit_Continue() — 突变分析（函数的简单突变器）
visit_Delete() — 突变分析（函数的简单突变器）
visit_Expr() — 突变分析（函数的简单突变器），挖掘函数规范（使用给定类型注释函数）
visit_FunctionDef() — 基于搜索的模糊测试（自动源代码注入），挖掘函数规范（使用给定类型注释函数），挖掘函数规范（练习 9：将不变量嵌入为断言）
visit_Global() — 突变分析（函数的简单突变器）
visit_Name() — 挖掘函数规范（提取元变量），挖掘函数规范（实例化属性）
visit_Nonlocal() — 突变分析（函数的简单突变器）
visit_Pass() — 突变分析（函数的简单突变器）
visit_Raise() — 突变分析（函数的简单突变器）
visit_Return() — 突变分析（函数的简单突变器）
visit_z3_expr() — 符号化模糊测试（使用字符的 ASCII 值）
VisualCoverage 类 — 突变分析（通过示例展示结构覆盖率充分性）
VisualizedArcCoverage 类 — 符号模糊测试（可视化覆盖率）
VS — 铁路图（铁路图实现）

W

walk() — 控制流图（PyCFG）
was_seen() — 解析输入（练习 6：过滤 Earley 解析器）
WeakShapeTest 类 — 突变分析（模块和测试套件的突变器）
weak_oracle() — 突变分析（通过示例进行结构覆盖率充分性分析）
网络驱动程序 — 测试图形用户界面（使用 Selenium 进行远程控制）
webbrowser() — 雕刻单元测试（系统测试与单元测试），测试 Web 应用程序（日志记录）
WebFormFuzzer 类 — 测试 Web 应用程序（Web 表单模糊测试器）
WebRunner 类 — 测试 Web 应用程序（使用意外值进行模糊测试）
权重 — 何时停止模糊测试（肯尼格鲁本）
WHERE — 跟踪信息流（删除数据）
白盒测试 — 代码覆盖率（白盒测试）
文件格式维基百科页面 — 使用语法进行模糊测试（输入语言）
渗透测试维基百科页面 — 测试 Web 应用程序（背景）
Web 应用程序安全维基百科页面 — 测试 Web 应用程序（背景）
在此方法中 — 挖掘输入语法（赋值变量）
wrapper() — 挖掘函数规范（使用前置和后置条件注释函数），挖掘函数规范（练习 3：冗长不变性检查器）
wrapString() — 铁路图（远足：铁路图实现）
writeSvg() — 铁路图（远足：铁路图实现），铁路图（远足：铁路图实现），铁路图（远足：铁路图实现）

X

x() — 跟踪信息流（提取源字符串）
XKCD 漫画 — 使用随机输入破坏事物（检查内存访问）
XML 文档 — 使用生成器进行模糊测试（示例：匹配 XML 标签）
XML_GRAMMAR — 使用语法进行灰盒模糊测试（构建片段池）
XML_UNICODE_WCHAR_T — 测试配置（第三部分：C 预处理器配置模糊测试）
XSS — 测试 Web 应用程序（跨站脚本攻击）

Y

yes() — 条件模糊测试（表示决策）

Z - Z

Z

Z3 求解器 — 学术原型设计（Python 中的符号推理：有一个包可以做到这一点）, 使用 Python 进行原型设计（Python 中的符号推理：有一个包可以做到这一点）
z3_as_string() — 条件模糊测试（探索：实现 ConcolicGrammarFuzzer）
Z3_BINARY — 条件模糊测试（使用命令行）
z3_chr() — 条件模糊测试（使用字符的 ASCII 值的技巧）
z3_names_and_types() — 符号模糊测试（获取使用的变量名称和类型）
Z3_OPTIONS — 条件模糊测试（使用命令行）
z3_ord() — 条件模糊测试（使用字符的 ASCII 值的技巧）
zbool 类 — 条件模糊测试（布尔代理类）, 条件模糊测试（编码公式的否定）, 条件模糊测试（在条件上注册谓词）
zchr() — 条件模糊测试（将序数值转换为 ASCII）
ZeroDivisionRunner 类 — 减少导致失败的输入（概要）
ZeroOrMore() — 铁路图（探索：铁路图实现）
zeval() — 条件模糊测试（评估条件表达式）
zeval_py() — 条件模糊测试（使用 Python API）
zeval_smt() — 条件模糊测试（使用命令行）
zfloat 类 — 条件模糊测试（练习 1：实现条件浮点代理类）, 条件模糊测试（练习 1：实现条件浮点代理类）, 条件模糊测试（练习 1：实现条件浮点代理类）, 条件模糊测试（练习 1：实现条件浮点代理类）
zint 类 — Concolic Fuzzing (整数代理类), Concolic Fuzzing (整数之间的相等性), Concolic Fuzzing (整数之间的比较), Concolic Fuzzing (在布尔上下文中使用整数), Concolic Fuzzing (练习 2：位操作)
zord() — Concolic Fuzzing (检索序数值)
zproxy_create() — Concolic Fuzzing (Concolic 代理对象)
zstr_iterator 类 — Concolic Fuzzing (字符串迭代器类)
zstr 类 — Concolic Fuzzing (字符串代理类), Concolic Fuzzing (字符串之间的相等性), Concolic Fuzzing (字符串长度), Concolic Fuzzing (字符串连接), Concolic Fuzzing (生成子字符串), Concolic Fuzzing (转换为大小写等效形式), Concolic Fuzzing (检查字符串前缀), Concolic Fuzzing (查找子字符串), Concolic Fuzzing (从末尾移除空格), Concolic Fuzzing (分割字符串)
_zv() — Concolic Fuzzing (整数代理类), Concolic Fuzzing (字符串代理类), Concolic Fuzzing (练习 1：实现一个 Concolic 浮点代理类)

本项目的内容受Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License许可。作为内容一部分的源代码，以及用于格式化和显示该内容的源代码，均受MIT License许可。最后修改：2020-09-27 19:14:05+02:00 • 引用 • 版权信息

如何引用本作品

Andreas Zeller, Rahul Gopinath, Marcel Böhme, Gordon Fraser, and Christian Holler: "索引". In Andreas Zeller, Rahul Gopinath, Marcel Böhme, Gordon Fraser, and Christian Holler, "模糊测试书", www.fuzzingbook.org/html/00_Index.html. Retrieved 2020-09-27 19:14:05+02:00.

@incollection{fuzzingbook2020:00_Index,
    author = {Andreas Zeller and Rahul Gopinath and Marcel B{\"o}hme and Gordon Fraser and Christian Holler},
    booktitle = {The Fuzzing Book},
    title = {Index},
    year = {2020},
    publisher = {CISPA Helmholtz Center for Information Security},
    howpublished = {\url{https://www.fuzzingbook.org/html/00_Index.html}},
    note = {Retrieved 2020-09-27 19:14:05+02:00},
    url = {https://www.fuzzingbook.org/html/00_Index.html},
    urldate = {2020-09-27 19:14:05+02:00}
}

posted @ 2025-12-13 18:14 绝不原创的飞龙阅读(1) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

模糊测试之书-二十-

模糊测试之书（二十）

控制流图

控制流图

注册

CFGNode

PyCFG

支持函数

示例

check_triangle

cgi_decode

gcd

fib

quad_solver

调用图

安装：Pyan 静态调用图提升器

调用图辅助工具

示例：迷宫

索引

A - E

A

B

C

D

E

F - J

F

G

H

I

J

K - O

K

L

M

N

O

P - T

P

Q

R

S

T

U - Y

U

V

W

X

Y

Z - Z

Z

如何引用本作品

公告