<script src="does_not_exist_here_just_to_trigger_preload_scanner.js" type="text/javascript"></script>
<link href="non_existent_stylesheet1&ab-" rel="stylesheet">
<link href="non_existent_stylesheet2&#xY" rel="stylesheet">
<link href="non_existent_stylesheet3&#XY" rel="stylesheet">
<p><a href="rdar://problem/6904095">rdar://problem/6904095</a> Query parameters are sometimes incorrect in URL</p>
<p>Check with the web inspector that the page tried to load 3 stylesheet resources (and not more).</p>

