internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: qutebrowser/qutebrowser

Issue:
Apostrophes in errors in the log page add a "&amp" each time the page is refreshed
<!-- If this is a bug report, please remember to mention your version info from
the `qute:version` page or `qutebrowser --version` -->

1. `:message-error \'`
2. `:messages`
3. Refresh the log page multiple times
4. you get something like "&amp;amp;amp;amp;#x27;"


Discussion:
I was pretty sure there already was an issue for this (I'm aware of it since a long time), but apparently not - thanks!

Resolving patch:
diff --git a/qutebrowser/utils/log.py b/qutebrowser/utils/log.py
--- a/qutebrowser/utils/log.py
+++ b/qutebrowser/utils/log.py
@@ -25,6 +25,7 @@
 import logging
 import contextlib
 import collections
+import copy
 import faulthandler
 import traceback
 import warnings
@@ -568,16 +569,14 @@ def dump_log(self, html=False, level='vdebug'):
         https://github.com/qutebrowser/qutebrowser/issues/34
         """
         minlevel = LOG_LEVELS.get(level.upper(), VDEBUG_LEVEL)
-        lines = []
         fmt = self.html_formatter.format if html else self.format
         self.acquire()
         try:
-            records = list(self._data)
+            lines = [fmt(record)
+                     for record in self._data
+                     if record.levelno >= minlevel]
         finally:
             self.release()
-        for record in records:
-            if record.levelno >= minlevel:
-                lines.append(fmt(record))
         return '\n'.join(lines)
 
     def change_log_capacity(self, capacity):
@@ -637,17 +636,18 @@ def __init__(self, fmt, datefmt, log_colors):
         self._colordict['reset'] = '</font>'
 
     def format(self, record):
-        record.__dict__.update(self._colordict)
-        if record.levelname in self._log_colors:
-            color = self._log_colors[record.levelname]
-            record.log_color = self._colordict[color]
+        record_clone = copy.copy(record)
+        record_clone.__dict__.update(self._colordict)
+        if record_clone.levelname in self._log_colors:
+            color = self._log_colors[record_clone.levelname]
+            record_clone.log_color = self._colordict[color]
         else:
-            record.log_color = ''
+            record_clone.log_color = ''
         for field in ['msg', 'filename', 'funcName', 'levelname', 'module',
                       'name', 'pathname', 'processName', 'threadName']:
-            data = str(getattr(record, field))
-            setattr(record, field, pyhtml.escape(data))
-        msg = super().format(record)
+            data = str(getattr(record_clone, field))
+            setattr(record_clone, field, pyhtml.escape(data))
+        msg = super().format(record_clone)
         if not msg.endswith(self._colordict['reset']):
             msg += self._colordict['reset']
         return msg


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
':navigate up' should strip queries from URL
Similar to #1318, `:navigate up` should take

`https://example.com/foo/?query=bar` to `https://example.com/foo`

since queries are specific to each page, and some websites use `https://example.com/?query=bar` whose parent is `https://example.com`.

I'd submit a pull request but I'm not sure whether [`url`](https://github.com/qutebrowser/qutebrowser/blob/master/qutebrowser/browser/commands.py#L656) should be replaced with `url.adjusted(QUrl.RemoveQuery)` for all the options `up`, `increment`, and `down`, or if `up` should be handled independently.


Discussion:
A few lines before the one you linked, `url = self._current_url().adjusted(QUrl.RemoveFragment)` is done - I think doing `QUrl.RemoveFragment | QUrl.RemoveQuery` instead there should be fine.

Resolving patch:
diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -635,7 +635,8 @@ def navigate(self, where: str, tab=False, bg=False, window=False, count=1):
 
         cmdutils.check_exclusive((tab, bg, window), 'tbw')
         widget = self._current_widget()
-        url = self._current_url().adjusted(QUrl.RemoveFragment)
+        url = self._current_url().adjusted(QUrl.RemoveFragment |
+                                           QUrl.RemoveQuery)
 
         handlers = {
             'prev': functools.partial(navigate.prevnext, prev=True),


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
closing tab or opening it in background shows tab bar with tabs.show = never
Updated to new version. I dont use tab bar at all but now it always appears anytime I close tab or open a new tab in background.



Discussion:
Whoops, this is probably because https://github.com/qutebrowser/qutebrowser/blob/v1.5.0/qutebrowser/mainwindow/tabwidget.py#L218-L237 doesn't check whether it was visible in the first place... cc @jgkamat 
Ah, that seems right, I forgot to check for that case, sorry. I'll submit a PR fixing it in ~3 hours if @The-Compiler dosen't beat me
The fix seems easy:

```diff
diff --git a/qutebrowser/mainwindow/tabwidget.py b/qutebrowser/mainwindow/tabwidget.py
index 9a8fdbc64..398f9a826 100644
--- a/qutebrowser/mainwindow/tabwidget.py
+++ b/qutebrowser/mainwindow/tabwidget.py
@@ -225,8 +225,9 @@ class TabWidget(QTabWidget):
         non-visible. To avoid flickering, disable repaint updates whlie we
         work.
         """
-        toggle = self.count() > 10
         bar = self.tabBar()
+        toggle = self.count() > 10 and bar.isVisible()
+
         if toggle:
             bar.setUpdatesEnabled(False)
             bar.setVisible(False)
```

but it'd be great to also have a test, and I'm going to bed :wink:

Resolving patch:
diff --git a/qutebrowser/mainwindow/tabwidget.py b/qutebrowser/mainwindow/tabwidget.py
--- a/qutebrowser/mainwindow/tabwidget.py
+++ b/qutebrowser/mainwindow/tabwidget.py
@@ -225,8 +225,8 @@ def _toggle_visibility(self):
         non-visible. To avoid flickering, disable repaint updates whlie we
         work.
         """
-        toggle = self.count() > 10
         bar = self.tabBar()
+        toggle = self.count() > 10 and bar.isVisible()
         if toggle:
             bar.setUpdatesEnabled(False)
             bar.setVisible(False)


Test patch:
diff --git a/tests/unit/mainwindow/test_tabwidget.py b/tests/unit/mainwindow/test_tabwidget.py
--- a/tests/unit/mainwindow/test_tabwidget.py
+++ b/tests/unit/mainwindow/test_tabwidget.py
@@ -134,6 +134,14 @@ def test_tab_max_width(self, widget, fake_web_tab, config_stub, qtbot):
         config_stub.val.tabs.max_width = max_size
         assert widget.tabBar().tabRect(0).width() == max_size
 
+    def test_tab_stays_hidden(self, widget, fake_web_tab, config_stub):
+        assert widget.tabBar().isVisible()
+        config_stub.val.tabs.show = "never"
+        assert not widget.tabBar().isVisible()
+        for i in range(12):
+            widget.addTab(fake_web_tab(), 'foobar' + str(i))
+        assert not widget.tabBar().isVisible()
+
     @pytest.mark.parametrize("num_tabs", [4, 100])
     @pytest.mark.parametrize("rev", [True, False])
     def test_add_remove_tab_benchmark(self, benchmark, widget,
Repository: qutebrowser/qutebrowser

Issue:
Shift-home doesn't mark anything in commandline
Shift-end works fine, but shift-home doesn't - probably due to qutebrowser changing the cursor position to after the `:`.


Discussion:

Resolving patch:
diff --git a/qutebrowser/misc/miscwidgets.py b/qutebrowser/misc/miscwidgets.py
--- a/qutebrowser/misc/miscwidgets.py
+++ b/qutebrowser/misc/miscwidgets.py
@@ -94,7 +94,7 @@ def __on_cursor_position_changed(self, _old, new):
         We use __ here to avoid accidentally overriding it in subclasses.
         """
         if new < self._promptlen:
-            self.setCursorPosition(self._promptlen)
+            self.cursorForward(self.hasSelectedText(), self._promptlen - new)
 
     def set_prompt(self, text):
         """Set the current prompt to text.
@@ -105,13 +105,6 @@ def set_prompt(self, text):
         self._validator.prompt = text
         self._promptlen = len(text)
 
-    def home(self, mark):
-        """Override home so it works properly with our cursor restriction."""
-        oldpos = self.cursorPosition()
-        self.setCursorPosition(self._promptlen)
-        if mark:
-            self.setSelection(self._promptlen, oldpos - self._promptlen)
-
 
 class _CommandValidator(QValidator):
 


Test patch:
diff --git a/tests/unit/misc/test_miscwidgets.py b/tests/unit/misc/test_miscwidgets.py
--- a/tests/unit/misc/test_miscwidgets.py
+++ b/tests/unit/misc/test_miscwidgets.py
@@ -59,8 +59,8 @@ def test_position(self, qtbot, cmd_edit):
         assert cmd_edit.text() == ':hello'
         assert cmd_edit.cursorPosition() == len(':hello')
 
-        cmd_edit.home(mark=True)
-        assert cmd_edit.cursorPosition() == len(':hello')
+        cmd_edit.home(True)
+        assert cmd_edit.cursorPosition() == len(':')
         qtbot.keyClick(cmd_edit, Qt.Key_Delete)
         assert cmd_edit.text() == ':'
         qtbot.keyClick(cmd_edit, Qt.Key_Backspace)
@@ -74,6 +74,25 @@ def test_invalid_prompt(self, qtbot, cmd_edit):
         qtbot.keyClicks(cmd_edit, '$hello')
         assert cmd_edit.text() == ''
 
+    def test_selection_home(self, qtbot, cmd_edit):
+        """Test selection persisting when pressing home."""
+        qtbot.keyClicks(cmd_edit, ':hello')
+        assert cmd_edit.text() == ':hello'
+        assert cmd_edit.cursorPosition() == len(':hello')
+        cmd_edit.home(True)
+        assert cmd_edit.cursorPosition() == len(':')
+        assert cmd_edit.selectionStart() == len(':')
+
+    def test_selection_backspace(self, qtbot, cmd_edit):
+        """Test selection persisting when backspacing to the first char."""
+        qtbot.keyClicks(cmd_edit, ':hello')
+        assert cmd_edit.text() == ':hello'
+        assert cmd_edit.cursorPosition() == len(':hello')
+        for _ in range(len(':hello')):
+            qtbot.keyClick(cmd_edit, Qt.Key_Left, modifier=Qt.ShiftModifier)
+        assert cmd_edit.cursorPosition() == len(':')
+        assert cmd_edit.selectionStart() == len(':')
+
 
 class WrappedWidget(QWidget):
Repository: qutebrowser/qutebrowser

Issue:
Match color does not show up in completion
**Version info (see `:version`)**:
Broken:
- https://paste.the-compiler.org/view/13d147a2
- https://paste.the-compiler.org/view/afa000e3

Working:
- https://paste.the-compiler.org/view/fcd00119

**Does the bug happen if you start with `--temp-basedir`?** (if applicable):
Yes

**Description**
I don't have enough time to debug this issue myself anymore so I'm filing an issue

On master, since switching to `QSyntaxHighlighter` on #4220, matches no longer show up for me on qt 5.11.3. qt 5.12 and 5.11.1 seems fine.

Breaking the SyntaxHighlighter so that it highlights everything does not help, so I think this is some issue we're triggering in qt...

Broken:
![2019-01-10-170110_358x61_scrot](https://user-images.githubusercontent.com/4349709/51006700-651aff80-153c-11e9-88e5-d727b8c24925.png)

Working:

![2019-01-10-170048_421x44_scrot](https://user-images.githubusercontent.com/4349709/51006707-69471d00-153c-11e9-897e-2cce67d7d410.png)


**How to reproduce**
<!-- Link to the affected site, or steps to reproduce the issue
(if possible/applicable). -->

type `:version` and expect a match.



Discussion:
I see this now in fedora 28 testing as well, they're currently pushing from 5.11.1->5.11.3:

Broken:
https://paste.the-compiler.org/view/9447e8d8
Given that I currently don't use my laptop too much anyways (learning for exams), I'll spend some CPU cycles to bisecting this in Qt.

Also, cc @rcorre, though indeed this looks like something broken in Qt somehow.
Reproduced with a Qt build on the current 5.11 branch. Trying 5.11.1 now (only qtbase, hope that's enough), then I'll start bisecting.
https://codereview.qt-project.org/#/c/244699/ is to blame: https://github.com/qt/qtbase/commit/dec7961709c90f6977d2447f7fa6c6625af41cb2 (fix for https://bugreports.qt.io/browse/QTBUG-71307)

Now the more interesting question is why it works on 5.12...
This commit didn't made it to 5.12.0, but it will be in 5.12.1.

Resolving patch:
diff --git a/qutebrowser/completion/completiondelegate.py b/qutebrowser/completion/completiondelegate.py
--- a/qutebrowser/completion/completiondelegate.py
+++ b/qutebrowser/completion/completiondelegate.py
@@ -212,11 +212,11 @@ def _get_textdoc(self, index):
             view = self.parent()
             pattern = view.pattern
             columns_to_filter = index.model().columns_to_filter(index)
-            self._doc.setPlainText(self._opt.text)
             if index.column() in columns_to_filter and pattern:
                 pat = re.escape(pattern).replace(r'\ ', r'|')
                 _Highlighter(self._doc, pat,
                              config.val.colors.completion.match.fg)
+            self._doc.setPlainText(self._opt.text)
         else:
             self._doc.setHtml(
                 '<span style="font: {};">{}</span>'.format(


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
AltGr handled as both modifier and normal key, breaks g$
**Version info (see `:version`)**:
qutebrowser v1.5.2
Git commit: 17eff15 (2019-02-14 20:14:15 -0800)
Backend: QtWebEngine (Chromium 65.0.3325.230)

Full version info:
https://paste.the-compiler.org/view/4307eaf2

**Background**
This bug occurs when using a Swedish language keyboard layout. To generate a $-sign on a swedish layout, the AltGr modifier is pressed together with "4".

**Symptoms**
g$ command does not work.
The g command is cancelled the instant AltGr is pressed down.

**Further information**
Running scripts.keytester, the following is reported:

When first pressing altgr:
<AltGr+AltGr>
key: 0x1001103
modifiers: 0x40000000

It seems to think AltGr is both a modifier and a regular key, which would explain why the g command is cancelled when it is pressed down.

continuing to hold down AltGr and pressing the "4" key:
<AltGr+$>
key: 0x24
modifiers: 0x40000000

Which is the correct behaviour and explains why $ works fine in other contexts such as in visual mode.



Discussion:

Resolving patch:
diff --git a/qutebrowser/keyinput/keyutils.py b/qutebrowser/keyinput/keyutils.py
--- a/qutebrowser/keyinput/keyutils.py
+++ b/qutebrowser/keyinput/keyutils.py
@@ -34,6 +34,7 @@
     Qt.Key_Control: Qt.ControlModifier,
     Qt.Key_Alt: Qt.AltModifier,
     Qt.Key_Meta: Qt.MetaModifier,
+    Qt.Key_AltGr: Qt.GroupSwitchModifier,
     Qt.Key_Mode_switch: Qt.GroupSwitchModifier,
 }
 


Test patch:
diff --git a/tests/unit/keyinput/test_keyutils.py b/tests/unit/keyinput/test_keyutils.py
--- a/tests/unit/keyinput/test_keyutils.py
+++ b/tests/unit/keyinput/test_keyutils.py
@@ -158,9 +158,16 @@ def test_missing(self, monkeypatch):
     (Qt.Key_A,
      Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier | Qt.ShiftModifier,
      '<Meta+Ctrl+Alt+Shift+a>'),
+    (ord('Œ'), Qt.NoModifier, '<Œ>'),
+    (ord('Œ'), Qt.ShiftModifier, '<Shift+Œ>'),
+    (ord('Œ'), Qt.GroupSwitchModifier, '<AltGr+Œ>'),
+    (ord('Œ'), Qt.GroupSwitchModifier | Qt.ShiftModifier, '<AltGr+Shift+Œ>'),
 
     (Qt.Key_Shift, Qt.ShiftModifier, '<Shift>'),
     (Qt.Key_Shift, Qt.ShiftModifier | Qt.ControlModifier, '<Ctrl+Shift>'),
+    (Qt.Key_Alt, Qt.AltModifier, '<Alt>'),
+    (Qt.Key_Shift, Qt.GroupSwitchModifier | Qt.ShiftModifier, '<AltGr+Shift>'),
+    (Qt.Key_AltGr, Qt.GroupSwitchModifier, '<AltGr>'),
 ])
 def test_key_info_str(key, modifiers, expected):
     assert str(keyutils.KeyInfo(key, modifiers)) == expected
Repository: qutebrowser/qutebrowser

Issue:
Launching keyhint widget causes 100% usage of one CPU core
That's how it was for as long as I can remember, reproducible with all of my hardware (pressing _g_ or _;_ is enough). I don't think that's an intended behavior.


Discussion:
What Qt and qutebrowser version? Can you reproduce it with `--temp-basedir`?
qutebrowser v1.6.1
Backend: QtWebEngine (Chromium 69.0.3497.128)
Qt: 5.12.3 (compiled 5.12.2)
I'm on Wayland if it makes a diiference.
Sorry, I can't reproduce it with --temp-basedir, really should've checked. But the only non-default keyhint-related setting is keyhint.delay=0.
Sorry for the noise. I've noticed that the browser is much snappier with ``--temp-basedir``. Turns out, software rendering was enforced for some reason, and I have a gradient fill keyhint widget, which kills the CPU.
Actually, disregard the upper post, it's not the fault of software rendering.
The problem still occurs, and the culprit is ``keyhint.delay=0``. CPU usage is reversely proportional to delay - 0 ms leads to 100% usage, 10 ms brings it down to ~50%, 100 ms brings it to 5% on start (goes down to usual 2% the second after).
Ah, indeed - looks like we set up `self._show_timer` in `keyhintwidget.py` to show the keyhint widget (delayed), but we never stop it after it's shown.

cc @rcorre 

Resolving patch:
diff --git a/qutebrowser/misc/keyhintwidget.py b/qutebrowser/misc/keyhintwidget.py
--- a/qutebrowser/misc/keyhintwidget.py
+++ b/qutebrowser/misc/keyhintwidget.py
@@ -71,6 +71,7 @@ def __init__(self, win_id, parent=None):
         self.hide()
         self._show_timer = usertypes.Timer(self, 'keyhint_show')
         self._show_timer.timeout.connect(self.show)
+        self._show_timer.setSingleShot(True)
         config.set_register_stylesheet(self)
 
     def __repr__(self):


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
Disable Tab Title?
I think it's really annoying when hovering. With Firefox, I can disable it and even element titles inside webpages. 
Thanks!


Discussion:
By element titles do you mean tooltips? And you want to disable them globally?
Apparently they themed via some Qt mechanism, see the discussion on this issue: https://github.com/qutebrowser/qutebrowser/issues/4520
Without actually having looked into whether you can disable them you could probably make their background, foreground and border transparent.

Resolving patch:
diff --git a/qutebrowser/mainwindow/tabwidget.py b/qutebrowser/mainwindow/tabwidget.py
--- a/qutebrowser/mainwindow/tabwidget.py
+++ b/qutebrowser/mainwindow/tabwidget.py
@@ -153,8 +153,9 @@ def update_tab_title(self, idx, field=None):
         if tabbar.tabText(idx) != title:
             tabbar.setTabText(idx, title)
 
-        # always show only plain title in tooltips
-        tabbar.setTabToolTip(idx, fields['current_title'])
+        if config.cache['tabs.tooltips']:
+            # always show only plain title in tooltips
+            tabbar.setTabToolTip(idx, fields['current_title'])
 
     def get_tab_fields(self, idx):
         """Get the tab field data."""


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
Downloads bar shown over fullscreen videos
Is downloads bar supposed to be shown in full screen mode?

qutebrowser v1.0.4
Git commit: d4cadcc62 (2017-12-07 08:17:15 +0100)
Backend: QtWebEngine (Chromium 56.0.2924.122)


Discussion:
I think this is intended behavior (at least for now), but you might like the `downloads.remove_finished` setting though.


Sorry, I was not very clear.
What I mean is that it is shown when full screen video is being played. Showing downloads bar in full screen mode is ok in general case.
Ah, I can reproduce that, and I don't think that's intended.
May I suggest giving it a function to either show or hide.. Like you can do with tabs and statusbar, xx, xb, xt. In some cases if you only have a single download it can be nice to still keep an eye on it's progress when watching video fullscreen while waiting for it to finish. But in cases where you have 15 downloads running it is pita because it takes up so much screen space..

Resolving patch:
diff --git a/qutebrowser/browser/downloadview.py b/qutebrowser/browser/downloadview.py
--- a/qutebrowser/browser/downloadview.py
+++ b/qutebrowser/browser/downloadview.py
@@ -103,6 +103,14 @@ def __repr__(self):
             count = model.rowCount()
         return utils.get_repr(self, count=count)
 
+    @pyqtSlot(bool)
+    def on_fullscreen_requested(self, on):
+        """Hide/show the downloadview when entering/leaving fullscreen."""
+        if on:
+            self.hide()
+        else:
+            self.show()
+
     @pyqtSlot('QModelIndex')
     def on_clicked(self, index):
         """Handle clicking of an item.
diff --git a/qutebrowser/mainwindow/mainwindow.py b/qutebrowser/mainwindow/mainwindow.py
--- a/qutebrowser/mainwindow/mainwindow.py
+++ b/qutebrowser/mainwindow/mainwindow.py
@@ -511,6 +511,10 @@ def _connect_signals(self):
             self._on_fullscreen_requested)
         self.tabbed_browser.cur_fullscreen_requested.connect(status.maybe_hide)
 
+        # downloadview
+        self.tabbed_browser.cur_fullscreen_requested.connect(
+            self._downloadview.on_fullscreen_requested)
+
         # command input / completion
         mode_manager.entered.connect(self.tabbed_browser.on_mode_entered)
         mode_manager.left.connect(self.tabbed_browser.on_mode_left)


Test patch:
Repository: qutebrowser/qutebrowser

Issue:
IP with port doesn't open as URL anymore
Since 5008b3b1648617e9651770dc878a7f9544b7b17c, opening something like `192.168.0.118:8083` causes a search instead of opening the IP as URL.

@arza-zara could you please take a look?


Discussion:
We do this currently:

```python
    if not utils.raises(ValueError, ipaddress.ip_address, urlstr):
        # Valid IPv4/IPv6 address
        return True
```

which catches cases like `192.168.0.118` but not `192.168.0.118:8083`. Maybe we should just use `url.host()` (or `host`) instead of `urlstr` there?

Resolving patch:
diff --git a/qutebrowser/utils/urlutils.py b/qutebrowser/utils/urlutils.py
--- a/qutebrowser/utils/urlutils.py
+++ b/qutebrowser/utils/urlutils.py
@@ -138,18 +138,15 @@ def _is_url_naive(urlstr: str) -> bool:
     """
     url = qurl_from_user_input(urlstr)
     assert url.isValid()
+    host = url.host()
 
-    if not utils.raises(ValueError, ipaddress.ip_address, urlstr):
-        # Valid IPv4/IPv6 address
+    # Valid IPv4/IPv6 address. Qt converts things like "23.42" or "1337" or
+    # "0xDEAD" to IP addresses, which we don't like, so we check if the host
+    # from Qt is part of the input.
+    if (not utils.raises(ValueError, ipaddress.ip_address, host) and
+            host in urlstr):
         return True
 
-    # Qt treats things like "23.42" or "1337" or "0xDEAD" as valid URLs
-    # which we don't want to. Note we already filtered *real* valid IPs
-    # above.
-    if not QHostAddress(urlstr).isNull():
-        return False
-
-    host = url.host()
     tld = r'\.([^.0-9_-]+|xn--[a-z0-9-]+)$'
     forbidden = r'[\u0000-\u002c\u002f\u003a-\u0060\u007b-\u00b6]'
     return bool(re.search(tld, host) and not re.search(forbidden, host))


Test patch:
diff --git a/tests/unit/utils/test_urlutils.py b/tests/unit/utils/test_urlutils.py
--- a/tests/unit/utils/test_urlutils.py
+++ b/tests/unit/utils/test_urlutils.py
@@ -346,7 +346,9 @@ def test_get_search_url_invalid(url):
     (True, True, False, '127.0.0.1'),
     (True, True, False, '::1'),
     (True, True, True, '2001:41d0:2:6c11::1'),
+    (True, True, True, '[2001:41d0:2:6c11::1]:8000'),
     (True, True, True, '94.23.233.17'),
+    (True, True, True, '94.23.233.17:8000'),
     # Special URLs
     (True, True, False, 'file:///tmp/foo'),
     (True, True, False, 'about:blank'),