You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@royale.apache.org by jo...@apache.org on 2022/11/15 17:56:03 UTC
[royale-compiler] 04/06: linter: tests for rest of rules
This is an automated email from the ASF dual-hosted git repository.
joshtynjala pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/royale-compiler.git
commit fd6ab58cc20bf171fd8e8e58ca5fdfd11db9646a
Author: Josh Tynjala <jo...@apache.org>
AuthorDate: Mon Oct 31 13:15:18 2022 -0700
linter: tests for rest of rules
---
.../linter/rules/TestMXMLEmptyAttributeRule.java | 59 +++++
.../royale/linter/rules/TestMaxBlockDepthRule.java | 91 ++++++++
.../royale/linter/rules/TestMaxParametersRule.java | 91 ++++++++
.../royale/linter/rules/TestMissingASDocRule.java | 250 +++++++++++++++++++++
.../rules/TestMissingConstructorSuperRule.java | 59 +++++
.../linter/rules/TestMissingNamespaceRule.java | 184 +++++++++++++++
.../linter/rules/TestMissingSemicolonRule.java | 47 ++++
.../royale/linter/rules/TestMissingTypeRule.java | 134 +++++++++++
8 files changed, 915 insertions(+)
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMXMLEmptyAttributeRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMXMLEmptyAttributeRule.java
new file mode 100644
index 000000000..7da6188a9
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMXMLEmptyAttributeRule.java
@@ -0,0 +1,59 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.apache.royale.linter.MXMLLinter;
+import org.junit.Test;
+
+public class TestMXMLEmptyAttributeRule {
+ @Test
+ public void testMXMLAttributeNotEmpty() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MXMLEmptyAttributeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ MXMLLinter linter = new MXMLLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.mxml", "<fx:Object attr=\"value\"/>", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMXMLAttributeEmpty() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MXMLEmptyAttributeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ MXMLLinter linter = new MXMLLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.mxml", "<fx:Object attr=\"\"/>", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MXMLEmptyAttributeRule.MXMLEmptyAttributeLinterProblem);
+ }
+}
\ No newline at end of file
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMaxBlockDepthRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMaxBlockDepthRule.java
new file mode 100644
index 000000000..eeb286e15
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMaxBlockDepthRule.java
@@ -0,0 +1,91 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.ASLinter;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.junit.Test;
+
+public class TestMaxBlockDepthRule {
+ @Test
+ public void testZeroBlocks() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxBlockDepthRule rule = new MaxBlockDepthRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction():void{}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testLessThanMaxBlockDepth() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxBlockDepthRule rule = new MaxBlockDepthRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction():void{if(true){}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testEqualToMaxBlockDepth() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxBlockDepthRule rule = new MaxBlockDepthRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction():void{if(true){while(true){}}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMoreThanMaxBlockDepth() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxBlockDepthRule rule = new MaxBlockDepthRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction():void{if(true){while(true){for(;;){}}}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MaxBlockDepthRule.MaxBlockDepthLinterProblem);
+ }
+}
\ No newline at end of file
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMaxParametersRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMaxParametersRule.java
new file mode 100644
index 000000000..3da0048ed
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMaxParametersRule.java
@@ -0,0 +1,91 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.ASLinter;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.junit.Test;
+
+public class TestMaxParametersRule {
+ @Test
+ public void testZeroParameters() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxParametersRule rule = new MaxParametersRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction():void {}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testLessThanMaxParameter() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxParametersRule rule = new MaxParametersRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction(param1:String):void {}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testEqualToMaxParameters() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxParametersRule rule = new MaxParametersRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction(param1:String, param2:Number):void {}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMoreThanMaxParameters() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ MaxParametersRule rule = new MaxParametersRule();
+ rule.maximum = 2;
+ rules.add(rule);
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "function myFunction(param1:String, param2:Number, param3:Boolean):void {}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MaxParametersRule.MaxParametersLinterProblem);
+ }
+}
\ No newline at end of file
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMissingASDocRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingASDocRule.java
new file mode 100644
index 000000000..cf94e0ba4
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingASDocRule.java
@@ -0,0 +1,250 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.ASLinter;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.junit.Test;
+
+public class TestMissingASDocRule {
+ @Test
+ public void testClassWithASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** hello */ public class MyClass{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testClassMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testClassEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** */ public class MyClass{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+
+ @Test
+ public void testInterfaceWithASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** hello */ public interface MyClass{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testInterfaceMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public interface MyClass{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testInterfaceEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** */ public interface MyClass{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+
+ @Test
+ public void testFieldWithASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{/** hello */public var myVar:String;}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testFieldMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{public var myVar:String;}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testFieldEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{/** */public var myVar:String;}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+
+ @Test
+ public void testMethodWithASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{/** hello */public function myMethod():void{}}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMethodMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{public function myMethod():void{}}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testMethodEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** class */ public class MyClass{/** */public function myMethod():void{}}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+
+ @Test
+ public void testPackageVariableWithASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** hello */ public var myVar:String;}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testPackageVariableMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public var myVar:String;}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testPackageVariableEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** */ public var myVar:String;}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+
+ @Test
+ public void testPackageFunctionMissingASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public function myFunction():void{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.MissingASDocLinterProblem);
+ }
+
+ @Test
+ public void testPackageFunctionEmptyASDoc() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingASDocRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{/** */ public function myFunction():void{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingASDocRule.EmptyASDocLinterProblem);
+ }
+}
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMissingConstructorSuperRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingConstructorSuperRule.java
new file mode 100644
index 000000000..2f04121c8
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingConstructorSuperRule.java
@@ -0,0 +1,59 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.ASLinter;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.junit.Test;
+
+public class TestMissingConstructorSuperRule {
+ @Test
+ public void testWithConstructorSuper() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingConstructorSuperRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{class MyClass extends OtherClass{public function MyClass(){super();}}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingConstructorSuper() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingConstructorSuperRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{class MyClass extends OtherClass{public function MyClass(){}}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingConstructorSuperRule.MissingConstructorSuperLinterProblem);
+ }
+}
\ No newline at end of file
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMissingNamespaceRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingNamespaceRule.java
new file mode 100644
index 000000000..b1466a6a3
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingNamespaceRule.java
@@ -0,0 +1,184 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.ASLinter;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.junit.Test;
+
+public class TestMissingNamespaceRule {
+ @Test
+ public void testWithClassNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingClassNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{class MyClass{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnClassLinterProblem);
+ }
+
+ @Test
+ public void testWithInterfaceNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public interface MyInterface{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingInterfaceNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{interface MyInterface{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnInterfaceLinterProblem);
+ }
+
+ @Test
+ public void testWithFieldNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{private var myField:String;}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingFieldNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{var myField:String;}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnFieldLinterProblem);
+ }
+
+ @Test
+ public void testWithMethodNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{private function myMethod():void{}}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingMethodNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public class MyClass{function myMethod():void{}}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnMethodLinterProblem);
+ }
+
+ @Test
+ public void testWithPackageVarNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public var myVar:String;}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingPackageVarNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{var myVar:String;}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnPackageVariableLinterProblem);
+ }
+
+ @Test
+ public void testWithPackageFunctionNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{public function myFunction():void{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingPackageFunctionNamespace() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingNamespaceRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "package{function myFunction():void{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingNamespaceRule.MissingNamespaceOnPackageFunctionLinterProblem);
+ }
+}
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMissingSemicolonRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingSemicolonRule.java
new file mode 100644
index 000000000..2dcbf2c33
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingSemicolonRule.java
@@ -0,0 +1,47 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.apache.royale.linter.ASLinter;
+import org.junit.Test;
+
+public class TestMissingSemicolonRule {
+ @Test
+ public void testMissingSemicolon() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingSemicolonRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "var s:String", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingSemicolonRule.MissingSemicolonLinterProblem);
+ }
+}
diff --git a/linter/src/test/java/org/apache/royale/linter/rules/TestMissingTypeRule.java b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingTypeRule.java
new file mode 100644
index 000000000..5aa0d212f
--- /dev/null
+++ b/linter/src/test/java/org/apache/royale/linter/rules/TestMissingTypeRule.java
@@ -0,0 +1,134 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.apache.royale.linter.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.royale.compiler.problems.ICompilerProblem;
+import org.apache.royale.linter.LinterRule;
+import org.apache.royale.linter.LinterSettings;
+import org.apache.royale.linter.ASLinter;
+import org.junit.Test;
+
+public class TestMissingTypeRule {
+ @Test
+ public void testWithFieldType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{var fieldName:String;}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingFieldType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{var fieldName;}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingTypeRule.MissingVariableTypeLinterProblem);
+ }
+
+ @Test
+ public void testWithLocalVarType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName():void{var fieldName:String;}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingLocalVarType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName():void{var fieldName;}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingTypeRule.MissingVariableTypeLinterProblem);
+ }
+
+ @Test
+ public void testWithParameterType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName(param:String):void{}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingParameterType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName(param):void{}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingTypeRule.MissingFunctionParameterTypeLinterProblem);
+ }
+
+ @Test
+ public void testWithReturnType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName():String{return null;}}", problems);
+ assertEquals(0, problems.size());
+ }
+
+ @Test
+ public void testMissingReturnType() {
+ List<LinterRule> rules = new ArrayList<LinterRule>();
+ rules.add(new MissingTypeRule());
+ LinterSettings settings = new LinterSettings();
+ settings.rules = rules;
+ ASLinter linter = new ASLinter(settings);
+ List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+ linter.lint("file.as", "class MyClass{function methodName(){}}", problems);
+ assertEquals(1, problems.size());
+ assertTrue(problems.get(0) instanceof MissingTypeRule.MissingFunctionReturnTypeLinterProblem);
+ }
+}
\ No newline at end of file