Commit 326093f8 authored by E19C506H's avatar E19C506H
Browse files

noPackage

parent d21816e8
<?xml version="1.0" encoding="ASCII"?>
<java:Model xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:java="http://www.eclipse.org/MoDisco/Java/0.2.incubation/java" name="Test">
<ownedElements name="(default package)">
<ownedElements xsi:type="java:ClassDeclaration" originalCompilationUnit="//@compilationUnits.0" name="Foo">
<modifier visibility="public"/>
</ownedElements>
</ownedElements>
<ownedElements name="myPackage">
<ownedElements xsi:type="java:ClassDeclaration" originalCompilationUnit="//@compilationUnits.1" name="ClassWithPackage">
<modifier visibility="public"/>
</ownedElements>
</ownedElements>
<orphanTypes xsi:type="java:PrimitiveTypeInt" name="int"/>
<orphanTypes xsi:type="java:PrimitiveTypeLong" name="long"/>
<orphanTypes xsi:type="java:PrimitiveTypeFloat" name="float"/>
<orphanTypes xsi:type="java:PrimitiveTypeDouble" name="double"/>
<orphanTypes xsi:type="java:PrimitiveTypeBoolean" name="boolean"/>
<orphanTypes xsi:type="java:PrimitiveTypeVoid" name="void"/>
<orphanTypes xsi:type="java:PrimitiveTypeChar" name="char"/>
<orphanTypes xsi:type="java:PrimitiveTypeShort" name="short"/>
<orphanTypes xsi:type="java:PrimitiveTypeByte" name="byte"/>
<compilationUnits name="Foo.java" originalFilePath="D:\workSpace\Test\src\Foo.java" types="//@ownedElements.0/@ownedElements.0"/>
<compilationUnits name="ClassWithPackage.java" originalFilePath="D:\workSpace\Test\src\myPackage\ClassWithPackage.java" package="//@ownedElements.1" types="//@ownedElements.1/@ownedElements.0"/>
</java:Model>
...@@ -28,81 +28,72 @@ rule Java2SMM { ...@@ -28,81 +28,72 @@ rule Java2SMM {
) )
} }
helper def: allMeasures(project : java!Model): Set(smm!Measure) = helper def: allMeasures(project: java!Model): Set(smm!Measure) =
Set{-- Example rule
Set{
-- Example rule
-- --
thisModule.numberOfClasses(), thisModule.numberOfClasses(),
-- Multithreading rules
-- Multithreading rules
-- --
thisModule.dontCallThreadRun(), thisModule.dontCallThreadRun(),
thisModule.avoidThreadGroup(), thisModule.avoidThreadGroup(),
thisModule.useNotifyAllInsteadOfNotify(), thisModule.useNotifyAllInsteadOfNotify(),
-- Code Style rules
-- Code Style rules
-- --
thisModule.shortMethodName(), thisModule.shortMethodName(),
thisModule.tooManyStaticImports(), thisModule.tooManyStaticImports(),
thisModule.avoidDollarSigns(), thisModule.avoidDollarSigns(),
thisModule.shortClassName(), thisModule.shortClassName(),
thisModule.extendsObject(), thisModule.extendsObject(),
thisModule.unnecessaryReturn(), thisModule.unnecessaryReturn(),
thisModule.longVariable(), thisModule.longVariable(),
-- Design rules thisModule.noPackageDeclaration(),
-- Design rules
-- --
thisModule.tooManyFields(), thisModule.tooManyFields(),
thisModule.tooManyMethods(), thisModule.tooManyMethods(),
thisModule.returnFromFinallyBlock(), thisModule.returnFromFinallyBlock(),
thisModule.longInstantiation(), thisModule.longInstantiation(),
thisModule.shortInstantiation(), thisModule.shortInstantiation(),
thisModule.returnEmptyArrayRatherThanNull(), --thisModule.returnEmptyArrayRatherThanNull(),
thisModule.excessiveParameterList(), thisModule.excessiveParameterList(),
thisModule.finalFieldCouldBeStatic(), thisModule.finalFieldCouldBeStatic(),
thisModule.signatureDeclareThrowsException(), thisModule.signatureDeclareThrowsException(),
thisModule.avoidThrowingNullPointerException(), thisModule.avoidThrowingNullPointerException(),
-- Performance rules
-- Performance rules
-- --
thisModule.uselessStringValueOf(), thisModule.uselessStringValueOf(),
thisModule.tooFewBranchesForASwitchStatement(), thisModule.tooFewBranchesForASwitchStatement(),
thisModule.useIndexOfChar(), thisModule.useIndexOfChar(),
thisModule.avoidPrintStackTrace(), thisModule.avoidPrintStackTrace(),
thisModule.avoidUsingShortType(), thisModule.avoidUsingShortType(),
thisModule.emptyStatementBlock(), thisModule.emptyStatementBlock(),
thisModule.avoidRethrowingException(), thisModule.avoidRethrowingException(),
thisModule.integerInstantiation(), thisModule.integerInstantiation(),
-- Documentation rules
-- Documentation rules
-- --
thisModule.commentContent(), thisModule.commentContent(),
thisModule.commentRequired(), thisModule.commentRequired(),
-- Error prone rules
-- Error prone rules
-- --
thisModule.missingBreakInSwitch(), thisModule.missingBreakInSwitch(),
thisModule.suspiciousEqualsMethodName(), thisModule.suspiciousEqualsMethodName(),
thisModule.doNotExtendJavaLangThrowable(), thisModule.doNotExtendJavaLangThrowable(),
thisModule.doNotExtendJavaLangError(), thisModule.doNotExtendJavaLangError(),
thisModule.compareObjectsWithEquals(), thisModule.compareObjectsWithEquals(),
thisModule.avoidCallingFinalize(), thisModule.avoidCallingFinalize(),
thisModule.emptyTryBlock(), thisModule.emptyTryBlock(),
thisModule.emptyWhileStmt(), thisModule.emptyWhileStmt(),
thisModule.dontImportSun(), thisModule.dontImportSun(),
thisModule.finalizeShouldBeProtected(), --thisModule.finalizeShouldBeProtected(),
-- Best practices rules -- Best practices rules
thisModule.avoidThrowingNewInstanceOfSameException(), thisModule.avoidThrowingNewInstanceOfSameException(),
thisModule.switchDensity(), thisModule.switchDensity() --thisModule.avoidStringBufferField()
thisModule.avoidStringBufferField() };
};
-- creates a new Measure when String.valueOf is called to append its argument to a string -- creates a new Measure when String.valueOf is called to append its argument to a string
rule MeasureUselessStringValueOf(method : java!MethodInvocation) { rule MeasureUselessStringValueOf(method: java!MethodInvocation) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -110,20 +101,21 @@ rule MeasureUselessStringValueOf(method : java!MethodInvocation) { ...@@ -110,20 +101,21 @@ rule MeasureUselessStringValueOf(method : java!MethodInvocation) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'Useless string value of', name <- 'Useless string value of',
shortDescription <- 'No need to call String.valueOf to append to a string; just use the valueOf() argument directly.' shortDescription <- 'No need to call String.valueOf to append to a string;'
+ ' just use the valueOf() argument directly.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<- 'The class '+ method.originalCompilationUnit.name + ' violates the rule useless string value of.' error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
) + ' rule useless string value of.'
)
do { do {
noc; noc;
} }
} }
------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------
-- A Measure instance if the class violates the rule 'AvoidDollarSigns'. -- A Measure instance if the class violates the rule 'AvoidDollarSigns'.
rule MesureAvoidDollarSigns(node : java!ASTNode) { rule MesureAvoidDollarSigns(node: java!ASTNode) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -131,7 +123,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) { ...@@ -131,7 +123,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'AvoidDollarSigns', name <- 'AvoidDollarSigns',
shortDescription <- 'Avoid using dollar signs in variable/method/class/interface names.' shortDescription <- 'Avoid using dollar signs in'
+ ' variable/method/class/interface names.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- node.name + ' has dollar in ' + node.originalCompilationUnit.name error <- node.name + ' has dollar in ' + node.originalCompilationUnit.name
...@@ -141,10 +134,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) { ...@@ -141,10 +134,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) {
} }
} }
-- A Measure instance if the class violates the rule 'ShortMethodName'. -- A Measure instance if the class violates the rule 'ShortMethodName'.
rule MesureShortMethodName(method : java!MethodDeclaration) { rule MesureShortMethodName(method: java!MethodDeclaration) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -152,19 +143,20 @@ rule MesureShortMethodName(method : java!MethodDeclaration) { ...@@ -152,19 +143,20 @@ rule MesureShortMethodName(method : java!MethodDeclaration) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'ShortMethodName', name <- 'ShortMethodName',
shortDescription <- 'Method names names that are very short are not helpful to the reader.' shortDescription <- 'Method names names that are very short are not helpful'
+ ' to the reader.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- method.name + ' is too short in ' + method.originalCompilationUnit.name error <- method.name + ' is too short in ' + method.originalCompilationUnit.
name
) )
do { do {
noc; noc;
} }
} }
-- A Measure instance if the class violates the rule 'ShortClassName'. -- A Measure instance if the class violates the rule 'ShortClassName'.
rule MesureShortClassName(class : java!ClassDeclaration) { rule MesureShortClassName(class: java!ClassDeclaration) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -172,7 +164,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) { ...@@ -172,7 +164,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'ShortClassName', name <- 'ShortClassName',
shortDescription <- 'Short Classnames with fewer than e.g. five characters are not recommended.' shortDescription <- 'Short Classnames with fewer than e.g. five characters'
+ ' are not recommended.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- 'The Class ' + class.name + ' is too short.' error <- 'The Class ' + class.name + ' is too short.'
...@@ -182,9 +175,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) { ...@@ -182,9 +175,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) {
} }
} }
-- creates a new Measure when Thread.run() is used instead of Thread.start() -- creates a new Measure when Thread.run() is used instead of Thread.start()
rule MeasureDontCallThreadRun(method : java!MethodInvocation) { rule MeasureDontCallThreadRun(method: java!MethodInvocation) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -192,19 +184,21 @@ rule MeasureDontCallThreadRun(method : java!MethodInvocation) { ...@@ -192,19 +184,21 @@ rule MeasureDontCallThreadRun(method : java!MethodInvocation) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'Don t call Thread.run()', name <- 'Don t call Thread.run()',
shortDescription <- 'Explicitly calling Thread.run() method will execute in the caller s thread of control. Instead, call Thread.start() for the intended behavior.' shortDescription <- 'Explicitly calling Thread.run() method will execute in'
+ ' the caller s thread of control. Instead, call Thread.start() for'
+ ' the intended behavior.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<-'The class '+ method.originalCompilationUnit.name + ' violates the rule don t call Thread.run().' error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule don t call Thread.run().'
) )
do { do {
noc; noc;
} }
} }
-- A Measure instance if the class violates the rule 'TooManyFields'. -- A Measure instance if the class violates the rule 'TooManyFields'.
rule MesureTooManyFields(class : java!ClassDeclaration) { rule MesureTooManyFields(class: java!ClassDeclaration) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -212,7 +206,8 @@ rule MesureTooManyFields(class : java!ClassDeclaration) { ...@@ -212,7 +206,8 @@ rule MesureTooManyFields(class : java!ClassDeclaration) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'TooManyFields', name <- 'TooManyFields',
shortDescription <- 'Classes that have too many fields can become unwieldy and could be redesigned to have fewer field.' shortDescription <- 'Classes that have too many fields can become unwieldy'
+ ' and could be redesigned to have fewer field.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- class.originalCompilationUnit.name + ' have too many fields' error <- class.originalCompilationUnit.name + ' have too many fields'
...@@ -222,9 +217,9 @@ rule MesureTooManyFields(class : java!ClassDeclaration) { ...@@ -222,9 +217,9 @@ rule MesureTooManyFields(class : java!ClassDeclaration) {
} }
} }
-- creates a new Measure when the parameter of String.indexOf(char) is not of type char
-- creates a new Measure when the parameter of String.indexOf(char) is not of type char when checking for the index of a single character -- when checking for the index of a single character
rule MeasureUseIndexOfChar(method : java!MethodInvocation) { rule MeasureUseIndexOfChar(method: java!MethodInvocation) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -232,10 +227,12 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) { ...@@ -232,10 +227,12 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'Use index of char', name <- 'Use index of char',
shortDescription <- 'Use String.indexOf(char) when checking for the index of a single character; it executes faster.' shortDescription <- 'Use String.indexOf(char) when checking for the index of'
+ ' a single character; it executes faster.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<- 'The class '+ method.originalCompilationUnit.name + ' violates the rule index of char.' error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule index of char.'
) )
do { do {
noc; noc;
...@@ -243,7 +240,6 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) { ...@@ -243,7 +240,6 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) {
} }
------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------
rule numberOfClasses() { rule numberOfClasses() {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
...@@ -254,7 +250,8 @@ rule numberOfClasses() { ...@@ -254,7 +250,8 @@ rule numberOfClasses() {
name <- 'Number of Classes' name <- 'Number of Classes'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
value <- java!ClassDeclaration.allInstances() -> reject(each | each.isProxy()) -> size() value <- java!ClassDeclaration.allInstances() -> reject(each | each.
isProxy()) -> size()
) )
do { do {
...@@ -262,8 +259,8 @@ rule numberOfClasses() { ...@@ -262,8 +259,8 @@ rule numberOfClasses() {
} }
} }
-- Rule that creates an instance of Measure for the switch statement with too few
-- Rule that creates an instance of Measure for the switch statement with too few branches passed in parameter -- branches passed in parameter
rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatement) { rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatement) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
...@@ -272,10 +269,15 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem ...@@ -272,10 +269,15 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem
), ),
tooFewBranchesForASwitchStatement: smm!DimensionalMeasure ( tooFewBranchesForASwitchStatement: smm!DimensionalMeasure (
name <- 'TooFewBranchesForASwitchStatement', name <- 'TooFewBranchesForASwitchStatement',
shortDescription <- 'Switch statements are intended to be used to support complex branching behaviour. Using a switch for only a few cases is ill-advised, since switches are not as easy to understand as if-then statements. In these cases use the if-then statement to increase code readability.' shortDescription <- 'Switch statements are intended to be used to support'
+ ' complex branching behaviour. Using a switch for only a few cases'
+ ' is ill-advised, since switches are not as easy to understand as'
+ ' if-then statements. In these cases use the if-then statement to'
+ ' increase code readability.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- 'Too few branches for SwitchStatement in Class : ' + switchStatement.originalCompilationUnit.name, error <- 'Too few branches for SwitchStatement in Class : ' + switchStatement.
originalCompilationUnit.name,
value <- thisModule.nbBranchesOfASwitchStatement(switchStatement) value <- thisModule.nbBranchesOfASwitchStatement(switchStatement)
) )
do { do {
...@@ -283,9 +285,10 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem ...@@ -283,9 +285,10 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem
} }
} }
--------------------------------------------- ShortInstantiation --------------------------------------------- --------------------------------------------- ShortInstantiation
--- ---------------------------------------------
-- A Measure instance if the class violates the rule 'ShortInstantiation'. -- A Measure instance if the class violates the rule 'ShortInstantiation'.
rule MeasureShortInstantiation(variable : java!CompilationUnit) { rule MeasureShortInstantiation(variable: java!CompilationUnit) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -293,10 +296,15 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) { ...@@ -293,10 +296,15 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'ShortInstantiation', name <- 'ShortInstantiation',
shortDescription <- 'Calling new Short() causes memory allocation that can be avoided by the static Short.valueOf(). It makes use of an internal cache that recycles earlier instances making it more memory efficient. Note that new Short() is deprecated since JDK 9 for that reason.' shortDescription <- 'Calling new Short() causes memory allocation that can be'
+ ' avoided by the static Short.valueOf(). It makes use of an'
+ ' internal cache that recycles earlier instances making it more'
+ ' memory efficient. Note that new Short() is deprecated since JDK 9'
+ ' for that reason.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' an instantiation of Short must be Short.ValueOf().' error <- 'In the Class ' + variable.name + ' an instantiation of Short must'
+ ' be Short.ValueOf().'
) )
do { do {
...@@ -304,10 +312,10 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) { ...@@ -304,10 +312,10 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) {
} }
} }
--------------------------------------------- LongInstantiation
--------------------------------------------- LongInstantiation --------------------------------------------- --- ---------------------------------------------
-- A Measure instance if the class violates the rule 'LongInstantiation'. -- A Measure instance if the class violates the rule 'LongInstantiation'.
rule MeasureLongInstantiation(variable : java!CompilationUnit) { rule MeasureLongInstantiation(variable: java!CompilationUnit) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -315,10 +323,15 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) { ...@@ -315,10 +323,15 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'LongInstantiation', name <- 'LongInstantiation',
shortDescription <- 'Calling new Long() causes memory allocation that can be avoided by the static Long.valueOf(). It makes use of an internal cache that recycles earlier instances making it more memory efficient. Note that new Long() is deprecated since JDK 9 for that reason.' shortDescription <- 'Calling new Long() causes memory allocation that can be'
+ ' avoided by the static Long.valueOf(). It makes use of an internal'
+ ' cache that recycles earlier instances making it more memory'
+ ' efficient. Note that new Long() is deprecated since JDK 9 for'
+ ' that reason.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' an instantiation of Long must be Long.ValueOf().' error <- 'In the Class ' + variable.name + ' an instantiation of Long must be'
+ ' Long.ValueOf().'
) )
do { do {
...@@ -326,9 +339,10 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) { ...@@ -326,9 +339,10 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) {
} }
} }
--------------------------------------------- DoNotExtendJavaLangThrowable --------------------------------------------- --------------------------------------------- DoNotExtendJavaLangThrowable
--- ---------------------------------------------
-- A Measure instance if the class violates the rule DoNotExtendJavaLangThrowable. -- A Measure instance if the class violates the rule DoNotExtendJavaLangThrowable.
rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) { rule MeasureDoNotExtendJavaLangThrowable(variable: java!ClassDeclaration) {
to to
om: smm!ObservedMeasure ( om: smm!ObservedMeasure (
measure <- noc, measure <- noc,
...@@ -336,44 +350,45 @@ rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) { ...@@ -336,44 +350,45 @@ rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) {
), ),
noc: smm!DimensionalMeasure ( noc: smm!DimensionalMeasure (
name <- 'DoNotExtendJavaLangThrowable ', name <- 'DoNotExtendJavaLangThrowable ',
shortDescription <- 'Extend Exception or RuntimeException instead of Throwable.' shortDescription <- 'Extend Exception or RuntimeException instead of'
+ ' Throwable.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' should not extend Throwable but RuntimeException or Exception .' error <- 'In the Class ' + variable.name + ' should not extend Throwable but'
+ ' RuntimeException or Exception .'
) )
do { do {
noc; noc;
} }
} }
-- Returns the number of branches in the switch statement passed in parameter -- Returns the number of branches in the switch statement passed in parameter
helper def: nbBranchesOfASwitchStatement(switchStatement:java!SwitchStatement) : Integer = helper def: nbBranchesOfASwitchStatement(switchStatement: java!SwitchStatement): Integer =
switchStatement.statements->select(each | each.oclIsTypeOf(java!SwitchCase)).size() switchStatement.statements -> select(each | each.oclIsTypeOf(java!SwitchCase)).size();
;
-- Returns the number of Fields in Class -- Returns the number of Fields in Class
helper def: numberFieldsInClasse(s:java!ClassDeclaration) : Integer = helper def: numberFieldsInClasse(s: java!ClassDeclaration): Integer =
-- Return the number of FieldDeclaration in a class. -- Return the number of FieldDeclaration in a class.
s.bodyDeclarations-> select(r | r.oclIsTypeOf(java!FieldDeclaration))->size(); s.bodyDeclarations -> select(r | r.oclIsTypeOf(java!FieldDeclaration)) -> size();
-- Returns the number of breaks of the switch statement passed in parameter -- Returns the number of breaks of the switch statement passed in parameter
helper def: nbBreakStatementOfASwitchStatement(ss:java!SwitchStatement) : Integer = helper def: nbBreakStatementOfASwitchStatement(ss: java!SwitchStatement): Integer =
ss.statements->select(each | each.oclIsTypeOf(java!BreakStatement)).size() ss.statements -> select(each | each.oclIsTypeOf(java!BreakStatement)).size();
;
-- Returns the number of expressions of the switch statement passed in parameter -- Returns the number of expressions of the switch statement passed in parameter
helper def: nbExpressionsStatementOfASwitchStatement(ss:java!SwitchStatement) : Integer = helper def: nbExpressionsStatementOfASwitchStatement(ss: java!SwitchStatement): Integer =
ss.statements->select(each | each.oclIsTypeOf(java!ExpressionStatement)).size() ss.statements -> select(each | each.oclIsTypeOf(java!ExpressionStatement)).size();
;
-- Returns the number of intentional fall-through (empty switch cases) of a
-- Returns the number of intentional fall-through (empty switch cases) of a switchStatement -- switchStatement
helper def: nbIntentionalFallThroughOfASwitchStatement(ss:java!SwitchStatement) : Integer = helper def: nbIntentionalFallThroughOfASwitchStatement(ss: java!SwitchStatement): Integer
thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.nbExpressionsStatementOfASwitchStatement(ss) =
; thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.
nbExpressionsStatementOfASwitchStatement(ss);
-- Creates an instance of Measure for the switch statement missing one or more break statements
-- Creates an instance of Measure for the switch statement missing one or more break
-- statements
-- To test, use input model : missing-break-in-switch.xmi -- To test, use input model : missing-break-in-switch.xmi
rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) { rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) {
to to
...@@ -383,12 +398,17 @@ rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) { ...@@ -383,12 +398,17 @@ rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) {
), ),
missingBreakInSwitch: smm!DimensionalMeasure ( missingBreakInSwitch: smm!DimensionalMeasure (
name <- 'Missing break in Switch', name <- 'Missing break in Switch',
shortDescription <- 'Switch statements without break or return statements for each case option may indicate problematic behaviour. Empty cases are ignored as these indicate an intentional fall-through.' shortDescription <- 'Switch statements without break or return statements for'
+ ' each case option may indicate problematic behaviour. Empty cases'
+ ' are ignored as these indicate an intentional fall-through.'
), ),
measurement: smm!DirectMeasurement ( measurement: smm!DirectMeasurement (
error <- 'Missing breaks in Switch in Class : ' + ss.originalCompilationUnit.name + '', error <- 'Missing breaks in Switch in Class : ' + ss.originalCompilationUnit.
name + '',
-- Indicates the number of breaks missing in the switch statement -- Indicates the number of breaks missing in the switch statement
value <- (thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.nbIntentionalFallThroughOfASwitchStatement(ss)) - thisModule.nbBreakStatementOfASwitchStatement(ss) value <- (thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.