def test_binaryops(self):
        a = flowfilter.parse("~u foobar | ~h voing")
        isinstance(a, flowfilter.FOr)
        self._dump(a)

        a = flowfilter.parse("~u foobar & ~h voing")
        isinstance(a, flowfilter.FAnd)
        self._dump(a)

def test_signals():
    v = view.View()
    rec_add = Record()
    rec_update = Record()
    rec_remove = Record()
    rec_refresh = Record()

    def clearrec():
        rec_add.calls = []
        rec_update.calls = []
        rec_remove.calls = []
        rec_refresh.calls = []

    v.sig_view_add.connect(rec_add)
    v.sig_view_update.connect(rec_update)
    v.sig_view_remove.connect(rec_remove)
    v.sig_view_refresh.connect(rec_refresh)

    assert not any([rec_add, rec_update, rec_remove, rec_refresh])

    # Simple add
    v.add([tft()])
    assert rec_add
    assert not any([rec_update, rec_remove, rec_refresh])

    # Filter change triggers refresh
    clearrec()
    v.set_filter(flowfilter.parse("~m put"))
    assert rec_refresh
    assert not any([rec_update, rec_add, rec_remove])

    v.set_filter(flowfilter.parse("~m get"))

    # An update that results in a flow being added to the view
    clearrec()
    v[0].request.method = "PUT"
    v.update([v[0]])
    assert rec_remove
    assert not any([rec_update, rec_refresh, rec_add])

    # An update that does not affect the view just sends update
    v.set_filter(flowfilter.parse("~m put"))
    clearrec()
    v.update([v[0]])
    assert rec_update
    assert not any([rec_remove, rec_refresh, rec_add])

    # An update for a flow in state but not view does not do anything
    f = v[0]
    v.set_filter(flowfilter.parse("~m get"))
    assert not len(v)
    clearrec()
    v.update([f])
    assert not any([rec_add, rec_update, rec_remove, rec_refresh])

def test_focus():
    # Special case - initialising with a view that already contains data
    v = view.View()
    v.add(tft())
    f = view.Focus(v)
    assert f.index is 0
    assert f.flow is v[0]

    # Start empty
    v = view.View()
    f = view.Focus(v)
    assert f.index is None
    assert f.flow is None

    v.add(tft(start=1))
    assert f.index == 0
    assert f.flow is v[0]

    v.add(tft(start=0))
    assert f.index == 1
    assert f.flow is v[1]

    v.add(tft(start=2))
    assert f.index == 1
    assert f.flow is v[1]

    v.remove(v[1])
    assert f.index == 1
    assert f.flow is v[1]

    v.remove(v[1])
    assert f.index == 0
    assert f.flow is v[0]

    v.remove(v[0])
    assert f.index is None
    assert f.flow is None

    v.add(tft(method="get", start=0))
    v.add(tft(method="get", start=1))
    v.add(tft(method="put", start=2))
    v.add(tft(method="get", start=3))

    f.flow = v[2]
    assert f.flow.request.method == "PUT"

    filt = flowfilter.parse("~m get")
    v.set_filter(filt)
    assert f.index == 2

    filt = flowfilter.parse("~m oink")
    v.set_filter(filt)
    assert f.index is None

    def test_quoting(self):
        a = flowfilter.parse("~u 'foo ~u bar' ~u voing")
        assert a.lst[0].expr == "foo ~u bar"
        assert a.lst[1].expr == "voing"
        self._dump(a)

        a = flowfilter.parse("~u foobar")
        assert a.expr == "foobar"

        a = flowfilter.parse(r"~u 'foobar\"\''")
        assert a.expr == "foobar\"'"

        a = flowfilter.parse(r'~u "foo \'bar"')
        assert a.expr == "foo 'bar"

    def configure(self, options, updated):
        """
            .replacements is a list of tuples (fpat, rex, s):

            fpatt: a string specifying a filter pattern.
            rex: a regular expression, as bytes.
            s: the replacement string, as bytes
        """
        if self.optionName in updated:
            lst = []
            for rep in getattr(options, self.optionName):
                if isinstance(rep, str):
                    fpatt, rex, s = parse_hook(rep)
                else:
                    fpatt, rex, s = rep

                flt = flowfilter.parse(fpatt)
                if not flt:
                    raise exceptions.OptionsError(
                        "Invalid filter pattern: %s" % fpatt
                    )
                try:
                    re.compile(rex)
                except re.error as e:
                    raise exceptions.OptionsError(
                        "Invalid regular expression: %s - %s" % (rex, str(e))
                    )
                lst.append((rex, s, flt))
            self.lst = lst

    def configure(self, updated):
        """
            .replacements is a list of tuples (fpat, rex, s):

            fpatt: a string specifying a filter pattern.
            rex: a regular expression, as string.
            s: the replacement string
        """
        if "replacements" in updated:
            lst = []
            for rep in ctx.options.replacements:
                fpatt, rex, s = parse_hook(rep)

                flt = flowfilter.parse(fpatt)
                if not flt:
                    raise exceptions.OptionsError(
                        "Invalid filter pattern: %s" % fpatt
                    )
                try:
                    # We should ideally escape here before trying to compile
                    re.compile(rex)
                except re.error as e:
                    raise exceptions.OptionsError(
                        "Invalid regular expression: %s - %s" % (rex, str(e))
                    )
                if s.startswith("@") and not os.path.isfile(s[1:]):
                    raise exceptions.OptionsError(
                        "Invalid file path: {}".format(s[1:])
                    )
                lst.append((rex, s, flt))
            self.lst = lst

def test_filter():
    v = view.View()
    f = flowfilter.parse("~m get")
    v.request(tft(method="get"))
    v.request(tft(method="put"))
    v.request(tft(method="get"))
    v.request(tft(method="put"))
    assert(len(v)) == 4
    v.set_filter(f)
    assert [i.request.method for i in v] == ["GET", "GET"]
    assert len(v._store) == 4
    v.set_filter(None)

    assert len(v) == 4
    v.toggle_marked()
    assert len(v) == 0
    v.toggle_marked()
    assert len(v) == 4

    v[1].marked = True
    v.toggle_marked()
    assert len(v) == 1
    assert v[0].marked
    v.toggle_marked()
    assert len(v) == 4

 def set_intercept(self, txt):
     if txt:
         flt = flowfilter.parse(txt)
         if not flt:
             return "Invalid filter expression."
         self.intercept = flt
     else:
         self.intercept = None

 def set_filter(self, input_filter: typing.Optional[str]) -> None:
     filt = matchall if not input_filter else flowfilter.parse(input_filter)
     if not filt:
         raise CommandError(
             "Invalid interception filter: %s" % filt
         )
     self.filter = filt
     self._refilter()

 def configure(self, options, updated):
     if options.stickyauth:
         flt = flowfilter.parse(options.stickyauth)
         if not flt:
             raise exceptions.OptionsError(
                 "stickyauth: invalid filter expression: %s" % options.stickyauth
             )
         self.flt = flt

 def configure(self, updated):
     if "readfile_filter" in updated:
         filt = None
         if ctx.options.readfile_filter:
             filt = flowfilter.parse(ctx.options.readfile_filter)
             if not filt:
                 raise exceptions.OptionsError(
                     "Invalid readfile filter: %s" % ctx.options.readfile_filter
                 )
         self.filter = filt

 def is_error(self, col, val):
     if col == 0:
         if not flowfilter.parse(val):
             return "Invalid filter specification."
     elif col == 1:
         try:
             re.compile(val)
         except re.error:
             return "Invalid regular expression."
     return False

 def configure(self, updated):
     if "intercept" in updated:
         if not ctx.options.intercept:
             self.filt = None
             return
         self.filt = flowfilter.parse(ctx.options.intercept)
         if not self.filt:
             raise exceptions.OptionsError(
                 "Invalid interception filter: %s" % ctx.options.intercept
             )

 def configure(self, updated):
     if "view_filter" in updated:
         if ctx.options.view_filter:
             self.filter = flowfilter.parse(ctx.options.view_filter)
             if not self.filter:
                 raise exceptions.OptionsError(
                     "Invalid filter expression: %s" % ctx.options.view_filter
                 )
         else:
             self.filter = None

 def configure(self, updated):
     if "stickycookie" in updated:
         if ctx.options.stickycookie:
             flt = flowfilter.parse(ctx.options.stickycookie)
             if not flt:
                 raise exceptions.OptionsError(
                     "stickycookie: invalid filter expression: %s" % ctx.options.stickycookie
                 )
             self.flt = flt
         else:
             self.flt = None

 def set_filter_cmd(self, f: str) -> None:
     """
         Sets the current view filter.
     """
     filt = None
     if f:
         filt = flowfilter.parse(f)
         if not filt:
             raise exceptions.CommandError(
                 "Invalid interception filter: %s" % f
             )
     self.set_filter(filt)

 def configure(self, options, updated):
     if options.filtstr:
         self.filter = flowfilter.parse(options.filtstr)
         if not self.filter:
             raise exceptions.OptionsError(
                 "Invalid filter expression: %s" % options.filtstr
             )
     else:
         self.filter = None
     self.flow_detail = options.flow_detail
     self.outfp = options.tfile
     self.showhost = options.showhost

    def configure(self, updated):
        if "setheaders" in updated:
            self.lst = []
            for shead in ctx.options.setheaders:
                fpatt, header, value = parse_setheader(shead)

                flt = flowfilter.parse(fpatt)
                if not flt:
                    raise exceptions.OptionsError(
                        "Invalid setheader filter pattern %s" % fpatt
                    )
                self.lst.append((fpatt, header, value, flt))

 def test_simple(self):
     assert not flowfilter.parse("~b")
     assert flowfilter.parse("~q")
     assert flowfilter.parse("~c 10")
     assert flowfilter.parse("~m foobar")
     assert flowfilter.parse("~u foobar")
     assert flowfilter.parse("~q ~c 10")
     p = flowfilter.parse("~q ~c 10")
     self._dump(p)
     assert len(p.lst) == 2

 def set_view_filter(self, txt):
     if txt == self.filter_txt:
         return
     if txt:
         flt = flowfilter.parse(txt)
         if not flt:
             return "Invalid filter expression."
         self.view._close()
         self.view = FlowView(self.flows, flt)
     else:
         self.view._close()
         self.view = FlowView(self.flows, None)