from bears.natural_language.LanguageToolBear import LanguageToolBear
from tests.BearTestHelper import generate_skip_decorator
from tests.LocalBearTestHelper import verify_local_bear
try:
import language_check
import guess_language
language_check
guess_language
except ImportError as err:
raise SkipTest(str(err))
LanguageToolBearTest = verify_local_bear(
LanguageToolBear,
valid_files=('A correct English sentence sounds nice to everyone.',
'Ein korrekter englischer Satz klingt für alle gut.'),
invalid_files=(' ',
'asdgaasdfgahsadf',
'"quoted"'))
LanguageToolBearLanguageTest = verify_local_bear(
LanguageToolBear,
valid_files=('A correct English sentence sounds nice to everyone.',),
invalid_files=('Ein korrekter englischer Satz klingt für alle gut.',),
settings={'language': 'en-US'})
LanguageToolBearDisableRulesTest = verify_local_bear(
LanguageToolBear,
valid_files=('Line without unnecessary spaces at the start.',
from bears.ruby.RuboCopBear import RuboCopBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """def good_name
test if something
end
"""
bad_file = """def badName
test if something
end
"""
RuboCopBearTest = verify_local_bear(RuboCopBear,
invalid_files=(bad_file,),
valid_files=(good_file,))
# Testing Config
rubocop_config = os.path.join(os.path.dirname(__file__),
'test_files',
'rubocop_config.yml')
# bad file becomes good and vice-versa
RuboCopBearConfigFileTest = verify_local_bear(
RuboCopBear,
valid_files=(bad_file,),
invalid_files=(good_file,),
settings={'rubocop_config': rubocop_config})
from bears.ruby.RubySmellBear import RubySmellBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """# Does something
class Something;
end
"""
bad_file1 = 'class Something; end'
bad_file2 = """class Dirty
# This method smells of :reek:NestedIterators but ignores them
def awful(x, y, offset = 0, log = false)
puts @screen.title
@screen = widgets.map { |w| w.each { |key| key += 3 * x } }
puts @screen.contents
end
end
"""
RubySmellBearTest = verify_local_bear(RubySmellBear,
valid_files=(good_file, ''),
invalid_files=(bad_file1, bad_file2))
RubySmellBearConfigTest = verify_local_bear(
RubySmellBear, valid_files=(good_file, bad_file1), invalid_files=(),
settings={'missing_module_description': 'nope'})
var _ os.File // for "os"
""".splitlines(keepends=True)
bad_file = """
package pkg
func addOne(x int) int {
x += 1
return x
}
func subOneInLoop(y int) {
for ; y > 0; y -= 1 {
}
}
""".splitlines(keepends=True)
GoLintBearTest = verify_local_bear(GoLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
GoLintBearWithSettingsTest = verify_local_bear(
GoLintBear,
valid_files=(bad_file, good_file),
invalid_files=(),
settings={"golint_cli_options": "-min_confidence=1"})
</head>
<body>
<button>No type set</button>
<div>
<div class="panel-body">
<p>Something</p>
</div>
</div>
<div id="qunit"></div>
<ol id="bootlint">
<li data-lint="Found one or more `<button>`s
missing a `type` attribute."></li>
</ol>
</body>
</html>
""".splitlines(keepends=True)
# There's a missing type in <button> tag, missing DOCTYPE
# and panel has no body.
BootLintBearTest = verify_local_bear(BootLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ))
BootLintBearDisableTest = verify_local_bear(
BootLintBear,
valid_files=(good_file, bad_file),
invalid_files=(),
settings={'bootlint_ignore': 'W001,W007,E001,E023'})
from bears.c_languages.ClangBear import ClangBear
from tests.LocalBearTestHelper import verify_local_bear
ClangBearTest = verify_local_bear(
ClangBear,
(["int main() {}"], ),
(
["bad things, this is no C code"], # Has no fixit
["struct { int f0; } x = { f0 :1 };"], # Has a fixit and no range
["int main() {int *b; return b}"]), # Has a fixit and a range
'test.c')
ClangBearIgnoreTest = verify_local_bear(
ClangBear,
# Should ignore the warning, valid!
(
["struct { int f0; } x = { f0 :1 };"], ),
(),
'test.c',
settings={'clang_cli_options': '-w'})
t.innerHTML = "New title";
""".splitlines(True)
bad_file = """function findTitle(title) {
let titleElement = 'hello';
return title;
}
let t = findTitle('mytitle');
t.innerHTML = 'New title';
""".splitlines(True)
tslintconfig = os.path.join(os.path.dirname(__file__), "test_files",
"tslint.json")
TSLintBearWithoutConfig = verify_local_bear(TSLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
tempfile_kwargs={"suffix": ".ts"})
TSLintBearTestWithConfig = verify_local_bear(
TSLintBear,
valid_files=(bad_file, ),
invalid_files=(good_file, ),
settings={"tslint_config": tslintconfig},
tempfile_kwargs={"suffix": ".ts"})
TSLintBearOtherOptions = verify_local_bear(TSLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
settings={"rules_dir": "/"},
tempfile_kwargs={"suffix": ".ts"})
from bears.elm.ElmLintBear import ElmLintBear
from tests.LocalBearTestHelper import verify_local_bear
ElmLintBearTest = verify_local_bear(ElmLintBear, ('test', ), ('\t', ))
from bears.ruby.RubySyntaxBear import RubySyntaxBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
class HelloWorld
def initialize(name)
@name = name.capitalize
end
def sayHi
puts "Hello #{@name}!"
end
end
""".splitlines(keepends=True)
bad_file = """
class HelloWorld
def initialize(name)
@name = name.capitalize
end
def sayHi
x = 1 # unused variables invoke a warning
puts "Hello #{@name}!"
end
""".splitlines(keepends=True)
RubySyntaxBearTest = verify_local_bear(RubySyntaxBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ))
}
}
}
})()
"""
complexity_4 = """(function () {
var foo = 1 && 1 || 0;
if (0 || 1) {
return;
}
})()
"""
JSComplexityBearTest = verify_local_bear(JSComplexityBear,
valid_files=(complexity_4,),
invalid_files=(complexity_12,),
tempfile_kwargs={"suffix": ".js"})
JSComplexityBearThresholdTest = verify_local_bear(JSComplexityBear,
valid_files=(),
invalid_files=(
complexity_4,
complexity_12),
settings={"cc_threshold": 2},
tempfile_kwargs={"suffix":
".js"})
# No output for non-js files
JSComplexityBearInvalidFileTest = verify_local_bear(JSComplexityBear,
valid_files=(
complexity_4,
func F() (*MyType, int, error) { return nil, 0, errors.New("foo") }"""\
.splitlines(keepends=True)
good_file2 = """package main
import "os"
func main() {
\tf, _ := os.Open("foo")
}""".splitlines(keepends=True)
bad_file1 = """
func F() (*MyType, int, error) { return errors.New("foo") }
""".splitlines(keepends=True)
bad_file2 = """
package main
func main() {
f, _ := os.Open("foo")
return nil, 0, errors.New("foo")
}
""".splitlines(keepends=True)
GoReturnsBearTest = verify_local_bear(
GoReturnsBear,
(good_file1,
good_file2,),
(bad_file1, bad_file2,))
from bears.natural_language.MarkdownBear import MarkdownBear
from tests.LocalBearTestHelper import verify_local_bear
test_file1 = """1. abc
1. def
""".splitlines()
test_file2 = """1. abc
2. def
""".splitlines()
MarkdownBear1Test = verify_local_bear(MarkdownBear,
valid_files=(test_file2,),
invalid_files=(test_file1,))
MarkdownBear2Test = verify_local_bear(MarkdownBear,
valid_files=(test_file1,),
invalid_files=(test_file2,),
settings={
"markdown_list_increment": False})
from bears.natural_language.AlexBear import AlexBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = ["Their network looks good."]
bad_file = ["His network looks good."]
AlexBearTest = verify_local_bear(AlexBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
from bears.go.GofmtBear import GofmtBear
from tests.LocalBearTestHelper import verify_local_bear
GofmtBear = verify_local_bear(
GofmtBear,
(['package main', '', 'func main() {', '\treturn 1', '}'],),
(['package main', 'func main() {', ' return 1', '}'],))
import unittest
from unittest.case import SkipTest
from bears.natural_language.LanguageToolBear import LanguageToolBear
from tests.BearTestHelper import generate_skip_decorator
from tests.LocalBearTestHelper import verify_local_bear
try:
import language_check
import guess_language
except ImportError as err:
raise SkipTest(str(err))
LanguageToolBearTest = verify_local_bear(
LanguageToolBear,
valid_files=("A correct English sentence sounds nice to everyone.",
"Ein korrekter englischer Satz klingt für alle gut."),
invalid_files=(" ", "asdgaasdfgahsadf", '"quoted"'))
LanguageToolBearLanguageTest = verify_local_bear(
LanguageToolBear,
valid_files=("A correct English sentence sounds nice to everyone.", ),
invalid_files=("Ein korrekter englischer Satz klingt für alle gut.", ),
settings={'language': 'en-US'})
LanguageToolBearDisableRulesTest = verify_local_bear(
LanguageToolBear,
valid_files=("Line without unnecessary spaces at the start.",
"a line beginning with lowercase.",
"A line beginning with uppercase."),
invalid_files=(" Line with unnecessary spaces at the start.", ),
from bears.natural_language.LanguageToolBear import LanguageToolBear
from tests.BearTestHelper import generate_skip_decorator
from tests.LocalBearTestHelper import verify_local_bear
try:
import language_check
import guess_language
except ImportError as err:
raise SkipTest(str(err))
LanguageToolBearTest = verify_local_bear(
LanguageToolBear,
valid_files=("A correct English sentence sounds nice in everyone.",
"Eine korrekte englische Satz klingt nett zu jedermann."),
invalid_files=(" ",
"asdgaasdfgahsadf",
'"quoted"'))
LanguageToolBearLanguageTest = verify_local_bear(
LanguageToolBear,
valid_files=("A correct English sentence sounds nice in everyone.",),
invalid_files=("Eine korrekte englische Satz klingt nett zu jedermann.",),
settings={'language': 'en-US'})
LanguageToolBearDisableRulesTest = verify_local_bear(
LanguageToolBear,
valid_files=("Line without unnecessary spaces at the start.",
from bears.haskell.HaskellLintBear import HaskellLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
myconcat = (++)
""".split("\n")
bad_file = """
myconcat a b = ((++) a b)
""".split("\n")
HaskellLintBear1Test = verify_local_bear(HaskellLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,),
tempfile_kwargs={"suffix": ".hs"})
price: 1.47
quantity: 4
..."""
config_file = """
extends:
default
rules:
colons:
max-spaces-after: -1
indentation: disable
empty-lines: disable
"""
YAMLLintBear1Test = verify_local_bear(YAMLLintBear,
valid_files=(),
invalid_files=(test_file, ))
with prepare_file(config_file,
filename=None,
force_linebreaks=True,
create_tempfile=True) as (conf_lines, conf_file):
YAMLLintBear2Test = verify_local_bear(
YAMLLintBear,
valid_files=(test_file, ),
invalid_files=(),
settings={'yamllint_config': conf_file})
YAMLLintBear3Test = verify_local_bear(YAMLLintBear,
valid_files=(no_start_yml_file, ),
invalid_files=(with_start_yml_file, ))
descrip: Water Bucket (Filled)
price: 1.47
quantity: 4
...
""".splitlines(keepends=True)
config_file = """
extends:
default
rules:
colons:
max-spaces-after: -1
indentation: disable
empty-lines: disable
""".splitlines(keepends=True)
YAMLLintBear1Test = verify_local_bear(YAMLLintBear,
valid_files=(),
invalid_files=(test_file,))
with prepare_file(config_file,
filename=None,
force_linebreaks=True,
create_tempfile=True) as (conf_lines, conf_file):
YAMLLintBear2Test = verify_local_bear(YAMLLintBear,
valid_files=(test_file,),
invalid_files=(),
settings={
'yamllint_config': conf_file})
from bears.css.CSSAutoPrefixBear import CSSAutoPrefixBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
.example {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
}
"""
bad_file = """
.example {
display: flex;
}
"""
CSSAutoPrefixBear = verify_local_bear(CSSAutoPrefixBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
from bears.haskell.HaskellLintBear import HaskellLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
myconcat = (++)
"""
bad_file = """
myconcat a b = ((++) a b)
"""
HaskellLintBearTest = verify_local_bear(HaskellLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
tempfile_kwargs={'suffix': '.hs'})
from bears.hypertext.HTMLLintBear import HTMLLintBear
from tests.LocalBearTestHelper import verify_local_bear
test_file = """
<html>
<body>
<h1>Hello, world!</h1>
</body>
</html>
"""
HTMLLintBearTest = verify_local_bear(
HTMLLintBear, valid_files=(), invalid_files=(test_file,), tempfile_kwargs={"suffix": ".html"}
)
HTMLLintBearIgnoreTest = verify_local_bear(
HTMLLintBear,
valid_files=(test_file,),
invalid_files=(),
settings={"htmllint_ignore": "optional_tag"},
tempfile_kwargs={"suffix": ".html"},
)
HTMLLintBearIgnoreQuotationTest = verify_local_bear(
HTMLLintBear,
valid_files=(),
invalid_files=(test_file,),
settings={"htmllint_ignore": "quotation"},
tempfile_kwargs={"suffix": ".html"},
)
test_file1 = """
def simple():
pass
"""
test_file2 = """
class class1():
pass
"""
test_file3 = "def f():\n" + (" assert True\n" * 50)
RadonBearDefaultsTest = verify_local_bear(
RadonBear,
valid_files=(test_file1, test_file2),
invalid_files=(test_file3,))
RadonBearNoReportsTest = verify_local_bear(
RadonBear,
valid_files=(test_file1, test_file2, test_file3),
invalid_files=(),
settings={"radon_ranks_info": "",
"radon_ranks_normal": "",
"radon_ranks_major": ""})
RadonBearReportsTest = verify_local_bear(
RadonBear,
valid_files=(),
from bears.configfiles.DockerfileLintBear import DockerfileLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
FROM ubuntu:14.04
# Install basic tools
RUN apt-get -y -qq update
RUN apt-get -y -qq upgrade
""".splitlines(keepends=True)
bad_file = """
FROM ubuntu:14.04
# Install basic tools
apt-get -y -qq update
apt-get -y -qq upgrade
""".splitlines(keepends=True)
DockerfileLintBearTest = verify_local_bear(DockerfileLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
from bears.ruby.RubySmellBear import RubySmellBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """# Does something
class Something;
end
""".splitlines(True)
bad_file = ('class Something; end', )
RubySmellBearTest = verify_local_bear(RubySmellBear,
valid_files=(good_file, ('', )),
invalid_files=(bad_file, ))
RubySmellBearConfigTest = verify_local_bear(
RubySmellBear,
valid_files=(good_file, bad_file),
invalid_files=(),
settings={'missing_module_description': "nope"})
ignorepkg_file = """package main
import (
"io"
"log"
"os"
)
func main() {
f, _ := os.Open("foo")
log.Println("opened file")
io.Copy(os.Stdout, f)
}""".splitlines(keepends=True)
GoErrCheckBearTest = verify_local_bear(GoErrCheckBear,
valid_files=(good_file, assert_file,
blank_file),
invalid_files=(bad_file, ),
tempfile_kwargs={"suffix": ".go"})
GoErrCheckBearWithIgnoreTest = verify_local_bear(
GoErrCheckBear,
valid_files=(good_file, assert_file, blank_file),
invalid_files=(bad_file, ),
settings={"ignore": "'[rR]ead|[wW]rite'"},
tempfile_kwargs={"suffix": ".go"})
GoErrCheckBearWithIgnorePkgTest = verify_local_bear(
GoErrCheckBear,
valid_files=(good_file, assert_file, blank_file),
invalid_files=(ignorepkg_file, ),
settings={"ignorepkg": "'io'"},
tempfile_kwargs={"suffix": ".go"})
from bears.vhdl.VHDLLintBear import VHDLLintBear
from tests.LocalBearTestHelper import verify_local_bear
VHDLLintBearTest = verify_local_bear(VHDLLintBear,
(('test',),),
(('\t',),))
from bears.julia.JuliaLintBear import JuliaLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
a = 2
println(2)
""".splitlines(keepends=True)
bad_file = """
println(hello)
""".splitlines(keepends=True)
JuliaLintBearTest = verify_local_bear(JuliaLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
tempfile_kwargs={"suffix": ".jl"},
timeout=45)
"""
cliche_file = """A fine kettle of fish."""
adverb_file = """It really is an extremely hot day."""
so_file = """So it was a bad day, wasn't it?"""
illusion_file = """Many readers are not aware that the the second the is
ignored."""
weasel_file = """Some people say that weasel words are great.
"""
WriteGoodLintBearTest = verify_local_bear(WriteGoodLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
WriteGoodLintBearWithPassiveTest = verify_local_bear(WriteGoodLintBear,
valid_files=(good_file,
weasel_file,
bad_file,
wordy_file,
thereIs_file,
cliche_file,
adverb_file,
so_file,),
invalid_files=(
passive_file,
illusion_file),
settings={
from bears.c_languages.CPPCleanBear import CPPCleanBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
int main() {
return 0;
}
""".splitlines(keepends=True)
bad_file = """
int global_var = 3;
int main() {
return 0;
}
""".splitlines(keepends=True)
CPPCleanBearTest = verify_local_bear(CPPCleanBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
class theGangster
wasItAGoodDay : () ->
yes
"""
invalid_file = """
# Coffeelint is buggy here and will generate an error with invalid CSV on this
var test
"""
CoffeeLintBearTest = verify_local_bear(CoffeeLintBear,
valid_files=(good_file,),
invalid_files=(warning_file,
error_file,
invalid_file))
CoffeeLintBearUseEnglishOperatorTest = verify_local_bear(
CoffeeLintBear,
valid_files=(good_file_use_english_operator,),
invalid_files=(bad_file_use_english_operator,),
settings={"allow_bitwise_operators": "false",
"consistent_line_endings_style": "unix"})
CoffeeLintBearTabWidthTest = verify_local_bear(
CoffeeLintBear,
valid_files=(good_file_tab_width,),
return 0;
}""".splitlines(keepends=True)
warn_file = """
void f1(struct fred_t *p)
{
int x;
if (p)
do_something(x);
}""".splitlines(keepends=True)
bad_file = """
#define f(c) { \
char *p = new char[10]; \
p[c] = 42; \
}
int main() {
f(100);
return 0;
}""".splitlines(keepends=True)
CPPCheckBearTest1 = verify_local_bear(CPPCheckBear,
valid_files=(good_file, warn_file),
invalid_files=(bad_file,))
CPPCheckBearTest2 = verify_local_bear(CPPCheckBear,
valid_files=(good_file,),
invalid_files=(warn_file, bad_file),
settings={'enable': 'unusedFunction'})
from bears.c_languages.ClangBear import ClangBear
from tests.LocalBearTestHelper import verify_local_bear
ClangBearTest = verify_local_bear(
ClangBear,
('int main() {}', ),
('bad things, this is no C code', # Has no fixit
# Has a fixit and no range
'struct { int f0; } x = { f0 :1 };',
'int main() {int *b; return b}'), # Has a fixit and a range
'test.c')
ClangBearIgnoreTest = verify_local_bear(
ClangBear,
# Should ignore the warning, valid!
('struct { int f0; } x = { f0 :1 };',),
(),
'test.c',
settings={'clang_cli_options': '-w'})
}
"""
bad_file = """
printNumber(num aNumber) {
print('The number is $aNumber.')
}
main() {
var answer = 42; // The meaning of life.
printNumber(answer)
}
"""
DartLintBearTest = verify_local_bear(DartLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
tempfile_kwargs={'suffix': '.dart'})
@generate_skip_decorator(DartLintBear)
class DartLintBearConfigTest(LocalBearTestHelper):
def test_config_failure_use_spaces(self):
section = Section('name')
section.append(Setting('use_spaces', False))
bear = DartLintBear(section, Queue())
with self.assertRaises(AssertionError):
self.check_validity(bear, [], good_file)
def test_config_failure_wrong_indent_size(self):
section = Section('name')
cout << "Hello, world!" << endl;
return 0;
}"""
warn_file = """
void f1(struct fred_t *p)
{
int x;
if (p)
do_something(x);
}"""
bad_file = """
#define f(c) { \
char *p = new char[10]; \
p[c] = 42; \
}
int main() {
f(100);
return 0;
}"""
CPPCheckBearTest1 = verify_local_bear(CPPCheckBear,
valid_files=(good_file, warn_file),
invalid_files=(bad_file, ))
CPPCheckBearTest2 = verify_local_bear(CPPCheckBear,
valid_files=(good_file, ),
invalid_files=(warn_file, bad_file),
settings={'enable': 'unusedFunction'})
from bears.python.PyImportSortBear import PyImportSortBear
from tests.LocalBearTestHelper import verify_local_bear
PyImportSortBearTest = verify_local_bear(PyImportSortBear,
(["import os\n", "import sys\n"],
("import os\n", "import sys\n")),
(["import sys\n", "import os\n"],
("import sys\n", "import os\n")))
PyImportSortBearConfigsTest = verify_local_bear(
PyImportSortBear,
(("from os import read\n", "from sys import *\n"),),
(("from os import read\n", "from os import *\n"),),
settings={"combine_star_imports": True})
PyImportSortBearIgnoredConfigsTest = verify_local_bear(
PyImportSortBear,
(("import xyz\n", "\n", "import abc\n"),
("from xyz import *\n", "\n", "import abc\n")),
(("import xyz\n", "import abc\n"),
("import abc\n", "import xyz\n")),
settings={"known_standard_library_imports": "xyz",
"known_first_party_imports": "abc"})
- part_no: A4786
descrip: Water Bucket (Filled)
price: 1.47
quantity: 4
...
""".splitlines(keepends=True)
config_file = """
extends:
default
rules:
colons:
max-spaces-after: -1
indentation: disable
empty-lines: disable
""".splitlines(keepends=True)
YAMLLintBear1Test = verify_local_bear(YAMLLintBear,
valid_files=(),
invalid_files=(test_file, ))
with prepare_file(config_file,
filename=None,
force_linebreaks=True,
create_tempfile=True) as (conf_lines, conf_file):
YAMLLintBear2Test = verify_local_bear(
YAMLLintBear,
valid_files=(test_file, ),
invalid_files=(),
settings={'yamllint_config': conf_file})
test_file9 = """
if (bool) {
return a;
} else {
}"""
test_file10 = """
int main()
{
return 0;
}"""
GNUIndentBearTest = verify_local_bear(GNUIndentBear,
valid_files=(test_file1, ),
invalid_files=(test_file2, test_file3,
test_file4),
settings={
"use_spaces": "true",
"max_line_length": "79"
})
GNUIndentBearWithTabTest = verify_local_bear(GNUIndentBear,
valid_files=(test_file3, ),
invalid_files=(test_file1,
test_file2,
test_file4),
settings={
"use_spaces": "nope",
"max_line_length": "79"
})
GNUIndentBearWidthTest = verify_local_bear(GNUIndentBear,
import platform
import unittest
from bears.natural_language.SpellCheckBear import SpellCheckBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = 'This is correct spelling.'
bad_file = 'tihs si surly som incoreclt speling.'
SpellCheckLintBearTest = unittest.skipIf(
platform.system() == 'Windows',
"SpellCheckBear doesn't work on windows")(
verify_local_bear(SpellCheckBear,
valid_files=(good_file,),
invalid_files=(bad_file,)))
bad_file1 = """
func F() (*MyType, int, error) { return errors.New("foo") }
""".splitlines(keepends=True)
bad_file2 = """
package main
func main() {
f, _ := os.Open("foo")
return nil, 0, errors.New("foo")
}
""".splitlines(keepends=True)
a = [
'import "errors"', '',
'func F() (*MyType, int, error) { return nil, 0, errors.New("foo") }'
]
b = [
'package main', '', 'import "os"', '', 'func main() {',
'\tf, _ := os.Open("foo")', '}'
]
GoReturnsBearTest = verify_local_bear(GoReturnsBear, (
good_file1,
good_file2,
), (
bad_file1,
bad_file2,
))
from bears.lua.LuaLintBear import LuaLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
print("Hello World!")
""".splitlines(keepends=True)
bad_file = """
function factorial(n)
local x = 1
for i = 2, n do;
x = x * i
end
return x
end
""".splitlines(keepends=True)
LuaLintBearTest = verify_local_bear(LuaLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,))
# $Date$
use strict;
use warnings;
use vars qw/ $VERSION /;
$VERSION = '1.00';
exit 1 if !print "Hello, world!\n";
"""
bad_file = """
#!/usr/bin/perl
print "Hello World\n";
"""
conf_file = os.path.abspath(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "testfiles",
".perlcriticrc"))
PerlCriticBearTest = verify_local_bear(PerlCriticBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ))
PerlCriticBearConfigTest = verify_local_bear(
PerlCriticBear,
valid_files=(good_file, bad_file),
invalid_files=(),
settings={"perlcritic_profile": conf_file})
from bears.markdown.MarkdownBear import MarkdownBear
from tests.LocalBearTestHelper import verify_local_bear
test_file1 = """1. abc
1. def
""".splitlines(keepends=True)
test_file2 = """1. abc
2. def
""".splitlines(keepends=True)
MarkdownBearTest = verify_local_bear(MarkdownBear,
valid_files=(test_file2, ),
invalid_files=(test_file1, ))
MarkdownBearConfigsTest = verify_local_bear(
MarkdownBear,
valid_files=(test_file1, ),
invalid_files=(test_file2, ),
settings={"markdown_list_increment": False})
test();
"""
test_import_bad = """
import test from "../test";
test();
"""
test_syntax_error = '{<!@3@^ yeah!/\n'
test_dir = os.path.join(os.path.dirname(__file__), 'test_files')
ESLintBearWithConfigTest = verify_local_bear(
ESLintBear,
valid_files=('', ),
invalid_files=(test_bad, test_good),
settings={'eslint_config': os.path.join(test_dir, 'eslintconfig.json')})
ESLintBearWithoutConfigTest = verify_local_bear(
ESLintBear,
valid_files=(test_good, ''),
invalid_files=(test_syntax_error, test_bad))
# If there is an invalid config file, the results cannot be found. So, no
# file gives a result.
ESLintBearWithUnloadablePluginTest = verify_local_bear(
ESLintBear,
valid_files=(test_bad, test_good),
invalid_files=(),
settings={
test_file3 = """
int
main ()
{
\treturn 0;
}""".split("\n")
test_file4 = """
int main() {
return 0;
}""".split("\n")
IndentBear1Test = verify_local_bear(IndentBear,
valid_files=(test_file1, ),
invalid_files=(test_file3, ),
settings={
"use_spaces": "true",
"max_line_length": "80"
})
IndentBear2Test = verify_local_bear(IndentBear,
valid_files=(test_file3, ),
invalid_files=(),
settings={
"use_spaces": "nope",
"max_line_length": "80"
})
IndentBear3Test = verify_local_bear(IndentBear,
valid_files=(test_file2, ),
invalid_files=(),
from bears.css.CSSAutoPrefixBear import CSSAutoPrefixBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
.example {
display: -webkit-box;
display: -webkit-flex;
display: -ms-flexbox;
display: flex;
}
""".splitlines(keepends=True)
bad_file = """
.example {
display: flex;
}
""".splitlines(keepends=True)
CSSAutoPrefixBear = verify_local_bear(CSSAutoPrefixBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ))
}
'''
good_file2 = '''
$value: 5px;
.foo {
padding: $value;
}
.bar {
margin: $value;
}
.new-class {
display: block;
}
'''
SCSSLintBearTest = verify_local_bear(SCSSLintBear,
valid_files=(good_file, good_file2),
invalid_files=(bad_file, bad_file2))
SCSSLintBearChainedClassesTest = verify_local_bear(
SCSSLintBear,
valid_files=(bad_file2, good_file2),
invalid_files=(bad_file,),
settings={'allow_chained_classes': True})
from bears.vimscript.VintBear import VintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
:let foo = 'bar'
:echo foo
"""
bad_file = """
:let foo = "bar"
:echo foo
"""
VintBearTest = verify_local_bear(VintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ))
from bears.matlab.MatlabIndentationBear import MatlabIndentationBear
from tests.LocalBearTestHelper import verify_local_bear
MatlabIndentationBearTest = verify_local_bear(
MatlabIndentationBear,
valid_files=("if a ~= b\n a\nendif\n",
"if a ~= b\n a\nendif\n",
"if a ~= b\n a\n \nelse\n a\nendif\n"),
invalid_files=(" A",
"if a ~= b\na\nendif\n",
"if a ~= b\n a\nendif\n",
"if a ~= b\n a\nendif\n",
"if a ~= b\n a\n else\n a\nendif\n"))
from bears.yml.RAMLLintBear import RAMLLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
#%RAML 0.8
title: World Music API
baseUri: http://example.api.com/{version}
version: v1
"""
bad_file = """#%RAML 0.8
title: Failing RAML
version: 1
baseUri: http://example.com
/resource:
description: hello
post:
"""
RAMLLintBearTest = verify_local_bear(RAMLLintBear,
valid_files=(good_file,),
invalid_files=(bad_file,),
tempfile_kwargs={"suffix": ".raml"})
"test_files",
"jshintconfig.json")
settings = {
"maxstatements": "False",
"maxparams": 10,
"check_unused_variables": "False",
"shadow": "False",
"allow_last_semicolon": "True",
"es_version": 3,
"allow_latedef": "no_func"}
JSHintBearTest = verify_local_bear(JSHintBear,
valid_files=(),
invalid_files=(test_file1, test_file2,
test_file3))
JSHintBearConfigFileTest = verify_local_bear(
JSHintBear,
valid_files=(test_file1,),
invalid_files=(test_file2,),
settings={"jshint_config": jshintconfig})
JSHintBearCoafileTest = verify_local_bear(
JSHintBear,
invalid_files=(),
valid_files=(test_file3, ),
settings=settings)
from bears.vhdl.VHDLLintBear import VHDLLintBear
from tests.LocalBearTestHelper import verify_local_bear
VHDLLintBearTest = verify_local_bear(VHDLLintBear,
('test',),
('\t',))
from bears.haskell.HaskellLintBear import HaskellLintBear
from tests.LocalBearTestHelper import verify_local_bear
good_file = """
myconcat = (++)
"""
bad_file = """
myconcat a b = ((++) a b)
"""
HaskellLintBearTest = verify_local_bear(HaskellLintBear,
valid_files=(good_file, ),
invalid_files=(bad_file, ),
tempfile_kwargs={"suffix": ".hs"})
from bears.html.HTMLLintBear import HTMLLintBear
from tests.LocalBearTestHelper import verify_local_bear
test_file = """
<html>
<body>
<h1>Hello, world!</h1>
</body>
</html>
""".split("\n")
HTMLLintBear1Test = verify_local_bear(HTMLLintBear,
valid_files=(),
invalid_files=(test_file, ),
tempfile_kwargs={"suffix": ".html"})
HTMLLintBear2Test = verify_local_bear(
HTMLLintBear,
valid_files=(test_file, ),
invalid_files=(),
settings={'htmllint_ignore': 'optional_tag'},
tempfile_kwargs={"suffix": ".html"})
HTMLLintBear3Test = verify_local_bear(
HTMLLintBear,
valid_files=(),
invalid_files=(test_file, ),
settings={'htmllint_ignore': 'quotation'},
tempfile_kwargs={"suffix": ".html"})
from coalib.results.HiddenResult import HiddenResult
from coalib.results.SourceRange import SourceRange
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting
from tests.LocalBearTestHelper import verify_local_bear, execute_bear
test_file = """
test line fix me
to do
error fixme
"""
KeywordBearTest = verify_local_bear(
KeywordBear,
valid_files=(test_file,),
invalid_files=('test line todo',
'test line warNING'),
settings={'keywords': 'todo, warning'})
class KeywordBearDiffTest(unittest.TestCase):
def setUp(self):
self.section = Section('')
self.section.append(Setting('language', 'python3'))
self.section.append(Setting('keywords', 'TODO'))
self.uut = KeywordBear(self.section, Queue())
self.annotation_bear_result_type = namedtuple('result', ['contents'])
self.dep_results = {'AnnotationBear': HiddenResult(
'AnnotationBear', {'comments': ()})}
