From 4af7cff96f8d85f3eee12b84fc592ec7b3ad3b16 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Mon, 15 Apr 2019 17:36:18 +0200 Subject: [PATCH] fixed suppression fro MethodLengthCheck added testcases for ConstantNameCheck added ignoreSingleline to LeftCurlyCheck applied new formatter --- checkstyle.json | 21 +++++- hxformat.json | 1 + resources/checkstyle-schema.json | 10 ++- resources/default-config.json | 1 + schema/CheckstyleSchemaGenerator.hx | 49 +++++++------ schema/JsonSchemaGenerator.hx | 38 +++++----- schema/ObjectDeclField.hx | 2 - schema/SchemaGenerator.hx | 1 - src/checkstyle/CheckerThread.hx | 2 +- src/checkstyle/ParserQueue.hx | 2 +- src/checkstyle/checks/block/LeftCurlyCheck.hx | 69 ++++++++++++++----- src/checkstyle/reporter/ReporterManager.hx | 2 +- src/checkstyle/utils/StringUtils.hx | 6 +- test/TestSuite.hx | 4 -- .../checks/block/LeftCurlyCheckTest.hx | 35 ++++++++-- .../checks/naming/ConstantNameCheckTest.hx | 6 +- .../checks/size/MethodLengthCheckTest.hx | 27 ++++++++ 17 files changed, 185 insertions(+), 91 deletions(-) diff --git a/checkstyle.json b/checkstyle.json index d07efb11..8bc6025d 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -170,7 +170,8 @@ "ENUM_DEF", "ABSTRACT_DEF", "TYPEDEF_DEF", - "INTERFACE_DEF", + "INTERFACE_DEF", + "ARRAY_COMPREHENSION", "FUNCTION", "FOR", "IF", @@ -184,6 +185,17 @@ }, "type": "LeftCurly" }, + { + "props": { + "tokens": [ + "ANON_TYPE" + ], + "ignoreEmptySingleline": true, + "ignoreSingleline": true, + "option": "nl" + }, + "type": "LeftCurly" + }, { "props": { "max": 160, @@ -636,8 +648,9 @@ "checkstyle/checks/metrics/CyclomaticComplexityCheck" ], "MethodLength": [ + "checkstyle/checks/block/LeftCurlyCheck:detectableInstances", "checkstyle/checks/metrics/CyclomaticComplexityCheck", - "checkstyle/checks/whitespace/OperatorWhitespaceCheck", + "checkstyle/checks/whitespace/OperatorWhitespaceCheck:detectableInstances", "checkstyle/checks/whitespace/WhitespaceAfterCheck", "checkstyle/checks/whitespace/WhitespaceAroundCheck", "checkstyle/checks/whitespace/EmptyLinesCheck", @@ -645,7 +658,9 @@ "checkstyle/token/walk/WalkStatement", "checkstyle/utils/ExprUtils", "checkstyle/utils/ComplexTypeUtils", - "checkstyle/Main" + "checkstyle/Main", + "JsonSchemaGenerator:genSchema", + "CheckstyleSchemaGenerator:checkstyleFieldsCallback" ], "NestedForDepth": [ "TestMain" diff --git a/hxformat.json b/hxformat.json index 0c33f220..23b3f6a6 100644 --- a/hxformat.json +++ b/hxformat.json @@ -11,6 +11,7 @@ }, "emptyLines": { "finalNewline": false, + "lineCommentsBetweenFunctions":"none", "interfaceEmptyLines": { "beginType": 1 } diff --git a/resources/checkstyle-schema.json b/resources/checkstyle-schema.json index 26e6156f..61cde352 100644 --- a/resources/checkstyle-schema.json +++ b/resources/checkstyle-schema.json @@ -1087,6 +1087,11 @@ "type": "object", "description": "Checks for the placement of left curly braces (`{`) for code blocks. The policy to verify is specified using the property `option`.", "properties": { + "ignoreSingleline": { + "type": "boolean", + "description": "allow single line blocks", + "propertyOrder": 3 + }, "tokens": { "items": { "enum": [ @@ -1095,6 +1100,7 @@ "ABSTRACT_DEF", "TYPEDEF_DEF", "INTERFACE_DEF", + "ANON_TYPE", "OBJECT_DECL", "FUNCTION", "FOR", @@ -1114,7 +1120,7 @@ }, "ignoreEmptySingleline": { "type": "boolean", - "description": "allow single line blocks", + "description": "allow empty single line blocks", "propertyOrder": 2 }, "option": { @@ -1136,7 +1142,7 @@ ], "type": "string", "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority", - "propertyOrder": 3 + "propertyOrder": 4 } }, "additionalProperties": false diff --git a/resources/default-config.json b/resources/default-config.json index 20ca8e70..fb582271 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -209,6 +209,7 @@ }, { "props": { + "ignoreSingleline": false, "tokens": [ "CLASS_DEF", "ENUM_DEF", diff --git a/schema/CheckstyleSchemaGenerator.hx b/schema/CheckstyleSchemaGenerator.hx index d85bf813..a9ba203b 100644 --- a/schema/CheckstyleSchemaGenerator.hx +++ b/schema/CheckstyleSchemaGenerator.hx @@ -16,7 +16,6 @@ typedef CheckName = { #end class CheckstyleSchemaGenerator { - macro public static function generate(type:String, id:String):Expr { return JsonSchemaGenerator.generateWithCallback(type, id, checkstyleFieldsCallback); } @@ -25,14 +24,14 @@ class CheckstyleSchemaGenerator { static function checkstyleFieldsCallback(fields:Array, name:String, pos:Position, refs:DynamicAccess):Void { switch (name) { case "ExcludeConfig": - var checkList:Array = collectAllChecks(Path.join (["src", "checkstyle", "checks"])); + var checkList:Array = collectAllChecks(Path.join(["src", "checkstyle", "checks"])); sortStrings(checkList); var order:Int = fields.length; for (check in checkList) { var filterListType = Context.getType("checkstyle.config.ExcludeConfig.ExcludeFilterList"); fields.push({ - field:check.name, - expr:JsonSchemaGenerator.genSchema(filterListType, "ExcludeFilterList", pos, null, refs, order++, null) + field: check.name, + expr: JsonSchemaGenerator.genSchema(filterListType, "ExcludeFilterList", pos, null, refs, order++, null) }); } case "Config.checks": @@ -40,11 +39,11 @@ class CheckstyleSchemaGenerator { fields.pop(); refs.remove("CheckConfig"); var checkExprs:Array = []; - var checkList:Array = collectAllChecks(Path.join (["src", "checkstyle", "checks"])); + var checkList:Array = collectAllChecks(Path.join(["src", "checkstyle", "checks"])); sortStrings(checkList); for (check in checkList) { if (check.name == "") continue; - var type:String = check.path.substr (4); + var type:String = check.path.substr(4); checkExprs.push(genCheckSchema(Context.getType(type), check.name, pos, null, refs, -1)); } fields.push({field: "type", expr: macro "array"}); @@ -104,7 +103,7 @@ class CheckstyleSchemaGenerator { } var fullPath:String = ~/[\/\\]/g.replace(Path.join([path, name]), "."); name = name.substr(0, name.length - 5); - checks.push({name:name, path:fullPath}); + checks.push({name: name, path: fullPath}); } return checks; } @@ -113,7 +112,7 @@ class CheckstyleSchemaGenerator { switch (type) { case TInst(_.get() => cl, params): switch [cl, params] { - case [{name:name, fields:fields}, []]: + case [{name: name, fields: fields}, []]: if (!refs.exists(name)) { refs[name] = null; var classFields:Array = []; @@ -122,7 +121,13 @@ class CheckstyleSchemaGenerator { classFields.push({ field: "severity", expr: JsonSchemaGenerator.genSchema(Context.getType("checkstyle.SeverityLevel"), - typeName + ".severity", pos, null, refs, classFields.length, null) + typeName + + ".severity", + pos, + null, + refs, + classFields.length, + null) }); var doc:StructInfo = {name: name, doc: getDescMeta(cl.meta)}; @@ -130,14 +135,11 @@ class CheckstyleSchemaGenerator { var checkName:Array = [macro '$typeName']; var typeExpr:Expr = macro $a{checkName}; var type = SchemaUtils.makeEnum(typeExpr, doc, -1, pos); - var checkFields:Array = [ - {field: "type", expr: type}, - {field: "props", expr: props}, - ]; + var checkFields:Array = [{field: "type", expr: type}, {field: "props", expr: props}]; var classExpr:Expr = SchemaUtils.makeObject(SchemaUtils.makeObjectDecl(checkFields, null, -1, pos), doc, [], -1, pos); refs[name] = classExpr; } - return SchemaUtils.makeObjectDecl([{ field: "@$__hx__$ref", expr: macro '#/definitions/${name}'}], null, order, pos); + return SchemaUtils.makeObjectDecl([{field: "@$__hx__$ref", expr: macro '#/definitions/${name}'}], null, order, pos); default: } default: @@ -151,9 +153,17 @@ class CheckstyleSchemaGenerator { case FVar(_): if (field.isPublic) { var doc:StructInfo = SchemaUtils.makeStructInfo(field.name, field.doc); - classFields.push ({ + classFields.push({ field: field.name, - expr: JsonSchemaGenerator.genSchema(field.type, typeName + "." + field.name, pos, doc, refs, classFields.length, checkstyleFieldsCallback) + expr: JsonSchemaGenerator.genSchema(field.type, + typeName + + "." + + field.name, + pos, + doc, + refs, + classFields.length, + checkstyleFieldsCallback) }); } default: @@ -161,11 +171,8 @@ class CheckstyleSchemaGenerator { } } - static function addSuperClassFields(typeName:String, - classFields:Array, - superClass:Null<{t:Ref, params:Array}>, - pos:Position, - refs:DynamicAccess) { + static function addSuperClassFields(typeName:String, classFields:Array, superClass:Null<{t:Ref, params:Array}>, + pos:Position, refs:DynamicAccess) { if (superClass == null) return; if (superClass.t.get().name == "Check") return; addClassFields(typeName, classFields, superClass.t.get().fields.get(), pos, refs); diff --git a/schema/JsonSchemaGenerator.hx b/schema/JsonSchemaGenerator.hx index 55e4f455..4bc2bf4c 100644 --- a/schema/JsonSchemaGenerator.hx +++ b/schema/JsonSchemaGenerator.hx @@ -12,7 +12,6 @@ typedef ExtendedFieldsCB = Array -> String -> Position -> Dynam // adapted from https://github.com/nadako/haxe-type-to-json-schema class JsonSchemaGenerator { - macro public static function generate(type:String, id:String):Expr { return generateWithCallback(type, id, null); } @@ -25,16 +24,16 @@ class JsonSchemaGenerator { var refList:Array = []; for (name in refs.keys()) { - refList.push({field:name, expr:refs.get(name)}); + refList.push({field: name, expr: refs.get(name)}); } var definitions:Expr = SchemaUtils.makeObjectDecl(refList, null, -1, Context.currentPos()); switch (main.expr) { case EObjectDecl(fields): - fields.push ({field: "definitions", expr:definitions}); - fields.push ({field: "@$__hx__$schema", expr: macro "http://json-schema.org/schema#"}); + fields.push({field: "definitions", expr: definitions}); + fields.push({field: "@$__hx__$schema", expr: macro "http://json-schema.org/schema#"}); if (id != null) { - fields.push ({field: "id", expr: macro '$id'}); + fields.push({field: "id", expr: macro '$id'}); } default: } @@ -71,12 +70,8 @@ class JsonSchemaGenerator { } } - public static function genSchema(type:Type, - typeName:String, - pos:Position, - structInfo:Null, - refs:DynamicAccess, order:Int, - extendCB:ExtendedFieldsCB):Expr { + public static function genSchema(type:Type, typeName:String, pos:Position, structInfo:Null, refs:DynamicAccess, order:Int, + extendCB:ExtendedFieldsCB):Expr { switch (type) { case TType(_.get() => dt, params): return switch [dt, params] { @@ -86,17 +81,16 @@ class JsonSchemaGenerator { if (!refs.exists(dt.name)) { refs[dt.name] = null; var doc:StructInfo = SchemaUtils.makeStructInfo(dt.name, dt.doc); - var schema = genSchema(dt.type.applyTypeParameters(dt.params, params), - dt.name, dt.pos, doc, refs, -1, extendCB); + var schema = genSchema(dt.type.applyTypeParameters(dt.params, params), dt.name, dt.pos, doc, refs, -1, extendCB); refs[dt.name] = schema; } - return SchemaUtils.makeObjectDecl([{ field: "@$__hx__$ref", expr: macro '#/definitions/${dt.name}'}], structInfo, order, pos); - } + return SchemaUtils.makeObjectDecl([{field: "@$__hx__$ref", expr: macro '#/definitions/${dt.name}'}], structInfo, order, pos); + } case TInst(_.get() => cl, params): switch [cl, params] { case [{pack: [], name: "String"}, []]: - return SchemaUtils.makeObjectDecl([{ field: "type", expr: macro "string"}], structInfo, order, pos); + return SchemaUtils.makeObjectDecl([{field: "type", expr: macro "string"}], structInfo, order, pos); case [{pack: [], name: "Array"}, [elemType]]: var fields:Array = [ {field: "type", expr: macro "array"}, @@ -117,14 +111,14 @@ class JsonSchemaGenerator { if (extendCB != null) extendCB(fields, typeName, pos, refs); return SchemaUtils.makeObjectDecl(fields, structInfo, order, pos); case [{pack: [], name: "Float"}, []]: - return SchemaUtils.makeObjectDecl([{ field: "type", expr: macro "number"}], structInfo, order, pos); + return SchemaUtils.makeObjectDecl([{field: "type", expr: macro "number"}], structInfo, order, pos); case [{pack: [], name: "Bool"}, []]: - return SchemaUtils.makeObjectDecl([{ field: "type", expr: macro "boolean"}], structInfo, order, pos); + return SchemaUtils.makeObjectDecl([{field: "type", expr: macro "boolean"}], structInfo, order, pos); case [{pack: [], name: "Any"}, []]: - return SchemaUtils.makeObjectDecl([{ field: "type", expr: macro "object"}], structInfo, order, pos); + return SchemaUtils.makeObjectDecl([{field: "type", expr: macro "object"}], structInfo, order, pos); default: if (ab.meta.has(":enum")) { - if (structInfo == null ) structInfo = SchemaUtils.makeStructInfo(ab.name, ab.doc); + if (structInfo == null) structInfo = SchemaUtils.makeStructInfo(ab.name, ab.doc); var pack:Array = ab.module.split("."); if (pack[pack.length - 1] != ab.name) pack.push(ab.name); return SchemaUtils.makeEnum(getAbstractEnumValues(macro $p{pack}), structInfo, order, pos); @@ -139,7 +133,7 @@ class JsonSchemaGenerator { for (i in 0...anon.fields.length) { var f = anon.fields[i]; var doc:StructInfo = SchemaUtils.makeStructInfo(f.name, f.doc); - props.push ({field: f.name, expr: genSchema(f.type, typeName + "." + f.name, f.pos, doc, refs, i, extendCB)}); + props.push({field: f.name, expr: genSchema(f.type, typeName + "." + f.name, f.pos, doc, refs, i, extendCB)}); if (!f.meta.has(":optional")) { required.push(f.name); } @@ -147,7 +141,7 @@ class JsonSchemaGenerator { if (extendCB != null) { extendCB(props, typeName, pos, refs); } - return SchemaUtils.makeObject({pos: pos, expr:EObjectDecl(props)}, structInfo, required, order, pos); + return SchemaUtils.makeObject({pos: pos, expr: EObjectDecl(props)}, structInfo, required, order, pos); default: } diff --git a/schema/ObjectDeclField.hx b/schema/ObjectDeclField.hx index 0a0ddbb1..141bbbb4 100644 --- a/schema/ObjectDeclField.hx +++ b/schema/ObjectDeclField.hx @@ -6,9 +6,7 @@ typedef ObjectDeclField = { var field:String; var expr:Expr; } - #else typedef ObjectDeclField = haxe.macro.ObjectField; #end - #end \ No newline at end of file diff --git a/schema/SchemaGenerator.hx b/schema/SchemaGenerator.hx index f229cdf3..5b037d19 100644 --- a/schema/SchemaGenerator.hx +++ b/schema/SchemaGenerator.hx @@ -3,7 +3,6 @@ import haxe.io.Path; import sys.io.File; class SchemaGenerator { - public static function main() { #if (haxe_ver < 4.0) var exludeConfig = CheckstyleSchemaGenerator.generate("checkstyle.config.ExcludeConfig", diff --git a/src/checkstyle/CheckerThread.hx b/src/checkstyle/CheckerThread.hx index 944bf4e4..30bffe73 100644 --- a/src/checkstyle/CheckerThread.hx +++ b/src/checkstyle/CheckerThread.hx @@ -1,6 +1,6 @@ package checkstyle; -#if ((haxe_ver >= 4.0) && (neko || macro || cpp || hl || java)) +#if ((haxe_ver >= 4.0) && (neko || macro || eval || cpp || hl || java)) import sys.thread.Thread; #elseif neko import neko.vm.Thread; diff --git a/src/checkstyle/ParserQueue.hx b/src/checkstyle/ParserQueue.hx index 6ecd6150..1b84edd4 100644 --- a/src/checkstyle/ParserQueue.hx +++ b/src/checkstyle/ParserQueue.hx @@ -1,6 +1,6 @@ package checkstyle; -#if ((haxe_ver >= 4.0) && (neko || macro || cpp || hl || java)) +#if ((haxe_ver >= 4.0) && (neko || macro || eval || cpp || hl || java)) import sys.thread.Mutex; import sys.thread.Thread; #elseif neko diff --git a/src/checkstyle/checks/block/LeftCurlyCheck.hx b/src/checkstyle/checks/block/LeftCurlyCheck.hx index 94d6a8bc..b2fc1749 100644 --- a/src/checkstyle/checks/block/LeftCurlyCheck.hx +++ b/src/checkstyle/checks/block/LeftCurlyCheck.hx @@ -35,10 +35,15 @@ class LeftCurlyCheck extends Check { public var option:LeftCurlyCheckOption; /** - allow single line blocks + allow empty single line blocks **/ public var ignoreEmptySingleline:Bool; + /** + allow single line blocks + **/ + public var ignoreSingleline:Bool; + public function new() { super(TOKEN); tokens = [ @@ -58,6 +63,7 @@ class LeftCurlyCheck extends Check { ]; option = EOL; ignoreEmptySingleline = true; + ignoreSingleline = false; } function hasToken(token:LeftCurlyCheckToken):Bool { @@ -70,16 +76,32 @@ class LeftCurlyCheck extends Check { for (brOpen in allBrOpen) { if (isPosSuppressed(brOpen.pos)) continue; - if (ignoreEmptySingleline && isSingleLine(brOpen)) continue; + if (skipSingleLine(brOpen)) continue; + var type:BrOpenType = TokenTreeCheckUtils.getBrOpenType(brOpen); + switch (type) { + case BLOCK: + case TYPEDEFDECL: + if (!hasToken(TYPEDEF_DEF)) continue; + case OBJECTDECL: + if (!hasToken(OBJECT_DECL)) continue; + case ANONTYPE: + if (!hasToken(ANON_TYPE)) continue; + case UNKNOWN: + } var parent:ParentToken = findParentToken(brOpen.parent); if (!parent.hasToken) continue; check(brOpen, isParentWrapped(parent.token, brOpen)); } } - function isSingleLine(brOpen:TokenTree):Bool { + function skipSingleLine(brOpen:TokenTree):Bool { var brClose:TokenTree = brOpen.access().firstOf(BrClose).token; - return (brClose != null && brOpen.pos.max == brClose.pos.min); + if (brClose == null) return false; + if (ignoreEmptySingleline && (brOpen.pos.max == brClose.pos.min)) return true; + var lStart:Int = checker.getLinePos(brOpen.pos.min).line; + var lEnd:Int = checker.getLinePos(brClose.pos.min).line; + if (ignoreSingleline && lStart == lEnd) return true; + return false; } /** @@ -118,7 +140,7 @@ class LeftCurlyCheck extends Check { case Kwd(KwdCase): return {token: token, hasToken: hasToken(OBJECT_DECL)}; case DblDot: - return findParentTokenDblDot(token.parent); + return findParentTokenDblDot(token); case POpen, BkOpen, BrOpen, Kwd(KwdReturn): return {token: token, hasToken: hasToken(OBJECT_DECL)}; case Dollar(_): @@ -138,22 +160,22 @@ class LeftCurlyCheck extends Check { function findParentTokenDblDot(token:TokenTree):ParentToken { if ((token == null) || (token.tok == null)) return {token: token, hasToken: false}; - switch (token.tok) { - case Kwd(KwdCase), Kwd(KwdDefault): + var type:ColonType = TokenTreeCheckUtils.getColonType(token); + switch (type) { + case SWITCH_CASE: return {token: token, hasToken: hasToken(SWITCH)}; - case POpen, BkOpen, BrOpen, Kwd(KwdReturn): - return {token: token, hasToken: hasToken(OBJECT_DECL)}; - case Binop(OpAssign): - // could be OBJECT_DECL or TYPEDEF_DEF - if ((token.parent != null) && (token.parent.parent != null)) { - switch (token.parent.parent.tok) { - case Kwd(KwdTypedef): return {token: token, hasToken: hasToken(TYPEDEF_DEF)}; - default: - } - } + case TYPE_HINT: + return {token: token, hasToken: hasToken(TYPEDEF_DEF)}; + case TYPE_CHECK: + return {token: token, hasToken: hasToken(TYPEDEF_DEF)}; + case TERNARY: + return {token: token, hasToken: false}; + case OBJECT_LITERAL: return {token: token, hasToken: hasToken(OBJECT_DECL)}; - default: - return findParentTokenDblDot(token.parent); + case AT: + return {token: token, hasToken: false}; + case UNKNOWN: + return {token: token, hasToken: false}; } } @@ -253,6 +275,10 @@ class LeftCurlyCheck extends Check { { propertyName: "ignoreEmptySingleline", values: [true, false] + }, + { + propertyName: "ignoreSingleline", + values: [true, false] } ] }, @@ -269,6 +295,10 @@ class LeftCurlyCheck extends Check { { propertyName: "ignoreEmptySingleline", values: [true, false] + }, + { + propertyName: "ignoreSingleline", + values: [true, false] } ] } @@ -288,6 +318,7 @@ abstract LeftCurlyCheckToken(String) { var ABSTRACT_DEF = "ABSTRACT_DEF"; var TYPEDEF_DEF = "TYPEDEF_DEF"; var INTERFACE_DEF = "INTERFACE_DEF"; + var ANON_TYPE = "ANON_TYPE"; var OBJECT_DECL = "OBJECT_DECL"; var FUNCTION = "FUNCTION"; var FOR = "FOR"; diff --git a/src/checkstyle/reporter/ReporterManager.hx b/src/checkstyle/reporter/ReporterManager.hx index 75a630f8..15e8bb1b 100644 --- a/src/checkstyle/reporter/ReporterManager.hx +++ b/src/checkstyle/reporter/ReporterManager.hx @@ -1,6 +1,6 @@ package checkstyle.reporter; -#if ((haxe_ver >= 4.0) && (neko || macro || cpp || hl || java)) +#if ((haxe_ver >= 4.0) && (neko || macro || eval || cpp || hl || java)) import sys.thread.Mutex; #elseif neko import neko.vm.Mutex; diff --git a/src/checkstyle/utils/StringUtils.hx b/src/checkstyle/utils/StringUtils.hx index 619bdab9..1fb36feb 100644 --- a/src/checkstyle/utils/StringUtils.hx +++ b/src/checkstyle/utils/StringUtils.hx @@ -1,10 +1,6 @@ package checkstyle.utils; class StringUtils { - public static inline function contains(s:String, c:String):Bool { - return s.indexOf(c) != -1; - } - public static function isStringInterpolation(s:String, fileContent:byte.ByteData, pos:Position):Bool { var code:Bytes = cast fileContent; var quote:String = code.sub(pos.min, 1).toString(); @@ -13,7 +9,7 @@ class StringUtils { return regex.match(s); } - public static function isEmpty(s:String):Bool { + public static function isEmpty(s:Null):Bool { return (s == null) || (s.length <= 0); } } \ No newline at end of file diff --git a/test/TestSuite.hx b/test/TestSuite.hx index 557f52a0..28d9fb62 100644 --- a/test/TestSuite.hx +++ b/test/TestSuite.hx @@ -3,9 +3,7 @@ import checkstyle.config.ConfigParserTest; import checkstyle.config.ExcludeManagerTest; import checkstyle.detect.DetectCodingStyleTest; import misc.CheckerTest; -#if !eval import misc.ThreadTest; -#end class TestSuite extends massive.munit.TestSuite { public function new() { @@ -18,9 +16,7 @@ class TestSuite extends massive.munit.TestSuite { add(ConfigParserTest); add(ExcludeManagerTest); add(DetectCodingStyleTest); - #if !eval add(ThreadTest); - #end var tests = CompileTime.getAllClasses(CheckTestCase); for (testClass in tests) add(testClass); diff --git a/test/checkstyle/checks/block/LeftCurlyCheckTest.hx b/test/checkstyle/checks/block/LeftCurlyCheckTest.hx index b596b65a..ef519db5 100644 --- a/test/checkstyle/checks/block/LeftCurlyCheckTest.hx +++ b/test/checkstyle/checks/block/LeftCurlyCheckTest.hx @@ -21,6 +21,8 @@ class LeftCurlyCheckTest extends CheckTestCase { assertNoMsg(check, ARRAY_COMPREHENSION_ISSUE_114); assertNoMsg(check, ARRAY_COMPREHENSION_2_ISSUE_114); assertNoMsg(check, ABSTRACT); + assertNoMsg(check, NESTED_OBJECT_LITERAL); + assertNoMsg(check, WRAPPED_FUNCTION); } @Test @@ -47,6 +49,10 @@ class LeftCurlyCheckTest extends CheckTestCase { check.tokens = [OBJECT_DECL]; assertMsg(check, TEST4, MSG_NL); + assertNoMsg(check, TEST14); + assertMsg(check, NESTED_OBJECT_LITERAL, MSG_NL); + + check.tokens = [TYPEDEF_DEF]; assertMsg(check, TEST14, MSG_NL); check.tokens = [IF]; @@ -82,6 +88,7 @@ class LeftCurlyCheckTest extends CheckTestCase { assertMsg(check, TEST17, MSG_NLOW); assertMsg(check, TEST18, MSG_NL_SPLIT); assertMsg(check, TEST19, MSG_NL_SPLIT); + assertMsg(check, WRAPPED_FUNCTION, MSG_NL_SPLIT); } @Test @@ -107,7 +114,7 @@ class LeftCurlyCheckTest extends CheckTestCase { @Test public function testArrayComprehension() { var check = new LeftCurlyCheck(); - check.tokens = [ARRAY_COMPREHENSION]; + check.tokens = [ARRAY_COMPREHENSION, OBJECT_DECL]; assertNoMsg(check, ARRAY_COMPREHENSION_2_ISSUE_114); assertMsg(check, ARRAY_COMPREHENSION_ISSUE_114, MSG_EOL); @@ -283,7 +290,9 @@ abstract LeftCurlyCheckTests(String) to String { x:Int, y:Int, z:Int, - point:{x:Int, y:Int, z:Int} + point:{ + x:Int, y:Int, z:Int + } }"; var TEST15 = " class Test @@ -381,10 +390,9 @@ abstract LeftCurlyCheckTests(String) to String { { switch(val) { case (true || - !false): - { - // do nothing - } + !false): { + // do nothing + } default: } } @@ -475,4 +483,19 @@ abstract LeftCurlyCheckTests(String) to String { this = i; } }"; + var NESTED_OBJECT_LITERAL = " + class Test { + function test() { + var struct = {origin:{x:10, y:10, z:20}, rotation:10}; + } + }"; + var WRAPPED_FUNCTION = " + class Test { + static function addSuperClassFields(typeName:String, classFields:Array, superClass:Null<{t:Ref, params:Array}>, + pos:Position, refs:DynamicAccess) { + if (superClass == null) return; + if (superClass.t.get().name == 'Check') return; + addClassFields(typeName, classFields, superClass.t.get().fields.get(), pos, refs); + } + }"; } \ No newline at end of file diff --git a/test/checkstyle/checks/naming/ConstantNameCheckTest.hx b/test/checkstyle/checks/naming/ConstantNameCheckTest.hx index f34199bb..52f704e5 100644 --- a/test/checkstyle/checks/naming/ConstantNameCheckTest.hx +++ b/test/checkstyle/checks/naming/ConstantNameCheckTest.hx @@ -68,7 +68,7 @@ class ConstantNameCheckTest extends CheckTestCase { @:enum abstract ConstantNameCheckTests(String) to String { var TEST = " - class Test { + abstractAndClass Test { static var COUNT:Int = 1; static inline var COUNT2:Int = 1; var COUNT3:Int = 1; @@ -82,13 +82,13 @@ abstract ConstantNameCheckTests(String) to String { static var count7:Int = 1; }"; var TEST1 = " - class Test { + abstractAndClass Test { static var Count:Int = 1; public function test() { } }"; var TEST2 = " - class Test { + abstractAndClass Test { static inline var Count:Int = 1; public function test() { var Count:Int; diff --git a/test/checkstyle/checks/size/MethodLengthCheckTest.hx b/test/checkstyle/checks/size/MethodLengthCheckTest.hx index 24185b0d..c2a4d575 100755 --- a/test/checkstyle/checks/size/MethodLengthCheckTest.hx +++ b/test/checkstyle/checks/size/MethodLengthCheckTest.hx @@ -30,6 +30,16 @@ class MethodLengthCheckTest extends CheckTestCase { check.countEmpty = false; assertMsg(check, TEST3, "Method `test` length is 14 lines (max allowed is 10)"); } + + @Test + public function testSuppress() { + var check = new MethodLengthCheck(); + check.max = 50; + assertNoMsg(check, SUPPRESS); + + check.max = 5; + assertNoMsg(check, SUPPRESS); + } } @:enum @@ -92,4 +102,21 @@ abstract MethodLengthCheckTests(String) to String { trace('TEST'); } }"; + var SUPPRESS = " + abstractAndClass Test { + @SuppressWarnings('checkstyle:MethodLength') + public function test1() { + trace('TEST'); + + trace('TEST'); + + trace('TEST'); + + trace('TEST'); + + trace('TEST'); + + trace('TEST'); + } + }"; } \ No newline at end of file