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': ()})}