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 0000000..7da6188
--- /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 0000000..eeb286e
--- /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 0000000..3da0048
--- /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 0000000..cf94e0b
--- /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 0000000..2f04121
--- /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 0000000..b1466a6
--- /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 0000000..2dcbf2c
--- /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 0000000..5aa0d21
--- /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