def test_get_line(self):
"""Test that the context generator returns the proper line."""
d = open("tests/resources/contextgenerator/data.txt").read()
c = ContextGenerator(d)
eq_(c.get_line(30), 3)
eq_(c.get_line(11), 2)
eq_(c.get_line(10000), 11)
def test_get_line(self):
"""Test that the context generator returns the proper line."""
d = open("tests/resources/contextgenerator/data.txt").read()
c = ContextGenerator(d)
eq_(c.get_line(30), 3)
eq_(c.get_line(11), 2)
eq_(c.get_line(10000), 11)
def test_get_context_trimming_inverse(self):
"""
Tests that surrounding lines are trimmed properly; the error line is
ignored if it is less than 140 characters.
"""
d = open("tests/resources/contextgenerator/longdata.txt").read()
c = ContextGenerator(d)
trimmed = c.get_context(line=6, column=0)
eq_(trimmed[1], "This line should be entirely visible.")
assert trimmed[0][0] != "X"
assert trimmed[2][-1] != "X"
def test_get_context_trimming(self):
"""
Test that contexts are generated properly when lines are >140
characters.
"""
d = open("tests/resources/contextgenerator/longdata.txt").read()
c = ContextGenerator(d)
trimmed = c.get_context(line=2, column=89)
proper_lengths = (140, 148, 140)
for i, length in enumerate([140, 148, 140]):
eq_(len(trimmed[i]), length)
def test_get_context_trimming_inverse(self):
"""
Tests that surrounding lines are trimmed properly; the error line is
ignored if it is less than 140 characters.
"""
d = open("tests/resources/contextgenerator/longdata.txt").read()
c = ContextGenerator(d)
trimmed = c.get_context(line=6, column=0)
eq_(trimmed[1], "This line should be entirely visible.")
assert trimmed[0][0] != "X"
assert trimmed[2][-1] != "X"
def test_get_context_trimming(self):
"""
Test that contexts are generated properly when lines are >140
characters.
"""
d = open("tests/resources/contextgenerator/longdata.txt").read()
c = ContextGenerator(d)
trimmed = c.get_context(line=2, column=89)
proper_lengths = (140, 148, 140)
for i, length in enumerate([140, 148, 140]):
eq_(len(trimmed[i]), length)
def test_json_constructs(self):
"""This tests some of the internal JSON stuff so we don't break zamboni."""
self.err.warning((), "Context test",
context=ContextGenerator("x\ny\nz\n"),
line=2, column=0)
self.err.notice((), "none")
self.err.notice((), "line", line=1)
self.err.notice((), "column", column=0)
self.err.notice((), "line column", line=1, column=1)
j = self.get_json_results()
assert "messages" in j
assert all(m["context"] == ["x", "y", "z"] for m in j["messages"] if
m["type"] == "warning"), "Warning had wrong context."
for m in (m for m in j["messages"] if m["type"] == "notice"):
if "line" in m["message"]:
assert m["line"] is not None
assert isinstance(m["line"], int)
assert m["line"] > 0
else:
assert m["line"] is None
if "column" in m["message"]:
assert m["column"] is not None
assert isinstance(m["column"], int)
assert m["column"] > -1
else:
assert m["column"] is None
def test_css_file(err, filename, data, line_start=1):
"Parse and test a whole CSS file."
tokenizer = cssutils.tokenize2.Tokenizer()
context = ContextGenerator(data)
data = "".join(c for c in data if 8 < ord(c) < 127)
token_generator = tokenizer.tokenize(data)
try:
_run_css_tests(err,
tokens=token_generator,
filename=filename,
line_start=line_start - 1,
context=context)
except: # pragma: no cover
# This happens because tokenize is a generator.
# Bravo, Mr. Bond, Bravo.
err.warning(
("testcases_markup_csstester", "test_css_file", "could_not_parse"),
"Could not parse CSS file",
"CSS file could not be parsed by the tokenizer.", filename)
#raise
return
def test_load_data(self):
"""Test that data is loaded properly into the CG."""
d = """abc
def
ghi"""
c = ContextGenerator(d)
eq_(len(c.data), 3)
# Through inductive reasoning, we can assert that every other line
# is imported properly.
eq_(c.data[0].strip(), "abc")
eq_(c.data[1].strip(), "def")
def process(self, filename, data, extension="html"):
"""Processes data by splitting it into individual lines, then
incrementally feeding each line into the parser, increasing the
value of the line number with each line."""
self.line = 0
self.filename = filename
self.extension = extension.lower()
self.reported = set()
self.context = ContextGenerator(data)
lines = data.split("\n")
buffering = False
pline = 0
for line in lines:
self.line += 1
search_line = line
while True:
# If a CDATA element is found, push it and its contents to the
# buffer. Push everything previous to it to the parser.
if "<![CDATA[" in search_line and not buffering:
# Find the CDATA element.
cdatapos = search_line.find("<![CDATA[")
# If the element isn't at the start of the line, pass
# everything before it to the parser.
if cdatapos:
self._feed_parser(search_line[:cdatapos])
# Collect the rest of the line to send it to the buffer.
search_line = search_line[cdatapos:]
buffering = True
continue
elif "]]>" in search_line and buffering:
# If we find the end element on the line being scanned,
# buffer everything up to the end of it, and let the rest
# of the line pass through for further processing.
end_cdatapos = search_line.find("]]>") + 3
self._save_to_buffer(search_line[:end_cdatapos])
search_line = search_line[end_cdatapos:]
buffering = False
break
if buffering:
self._save_to_buffer(search_line + "\n")
else:
self._feed_parser(search_line)
def test_get_context(self):
"""Test that contexts are generated properly."""
d = open("tests/resources/contextgenerator/data.txt").read()
c = ContextGenerator(d)
c_start = c.get_context(line=1, column=0)
c_end = c.get_context(line=11, column=0)
# Contexts are always length 3
eq_(len(c_start), 3)
eq_(c_start[0], None)
eq_(len(c_end), 3)
eq_(c_end[2], None)
eq_(c_start[1], "0123456789")
eq_(c_end[0], "9012345678")
eq_(c_end[1], "")
c_mid = c.get_context(line=5)
eq_(len(c_mid), 3)
eq_(c_mid[0], "3456789012")
eq_(c_mid[2], "5678901234")
def test_get_context(self):
"""Test that contexts are generated properly."""
d = open("tests/resources/contextgenerator/data.txt").read()
c = ContextGenerator(d)
c_start = c.get_context(line=1, column=0)
c_end = c.get_context(line=11, column=0)
# Contexts are always length 3
eq_(len(c_start), 3)
eq_(c_start[0], None)
eq_(len(c_end), 3)
eq_(c_end[2], None)
eq_(c_start[1], "0123456789")
eq_(c_end[0], "9012345678")
eq_(c_end[1], "")
c_mid = c.get_context(line=5)
eq_(len(c_mid), 3)
eq_(c_mid[0], "3456789012")
eq_(c_mid[2], "5678901234")
def get_tree(code, err=None, filename=None, shell=None):
"""Retrieve the parse tree for a JS snippet."""
if not code:
return None
try:
return _get_tree(code, shell or SPIDERMONKEY_INSTALLATION)
except JSReflectException as exc:
str_exc = str(exc).strip("'\"")
if "SyntaxError" in str_exc or "ReferenceError" in str_exc:
err.warning(err_id=("testcases_scripting", "test_js_file",
"syntax_error"),
warning="JavaScript Compile-Time Error",
description=[
"A compile-time error in the JavaScript halted "
"validation of that file.",
"Message: %s" % str_exc.split(":", 1)[-1].strip()
],
filename=filename,
line=exc.line,
context=ContextGenerator(code))
elif "InternalError: too much recursion" in str_exc:
err.notice(
err_id=("testcases_scripting", "test_js_file",
"recursion_error"),
notice="JS too deeply nested for validation",
description="A JS file was encountered that could not be "
"valiated due to limitations with Spidermonkey. "
"It should be manually inspected.",
filename=filename)
else:
err.error(err_id=("testcases_scripting", "test_js_file",
"retrieving_tree"),
error="JS reflection error prevented validation",
description=[
"An error in the JavaScript file prevented it "
"from being properly read by the Spidermonkey JS "
"engine.",
str(exc)
],
filename=filename)
def run(data, expectation, line=2):
# Strip blank lines.
data = '\n'.join(filter(None, data.split('\n')))
# Get the context and assert its equality.
c = ContextGenerator(data)
eq_(c.get_context(line), expectation)
def run(data, expectation, line=2):
# Strip blank lines.
data = '\n'.join(filter(None, data.split('\n')))
# Get the context and assert its equality.
c = ContextGenerator(data)
eq_(c.get_context(line), expectation)
