` elements and have blank lines between paragraphs. This first paragraph does not need the `
` elements.
#### [JavadocStyle](http://checkstyle.sourceforge.net/config_javadoc.html#JavadocStyle)
Checks the formatting of the Javadoc blocks. See the official [Checkstyle documentation](http://checkstyle.sourceforge.net/config_javadoc.html#JavadocStyle) for all the checks that are applied.
#### [JavadocType](http://checkstyle.sourceforge.net/config_javadoc.html#JavadocType)
Checks the format for Javadoc for classes and enums. Javadoc must be present, not have any unknown tags and not missing any `@param` tags. The `@author` tag must have a name and, in brackets, an email address.
#### [JavaNCSS](http://checkstyle.sourceforge.net/config_metrics.html#JavaNCSS)
Restricts the NCSS score for methods, classes and files to 50, 1500 and 2000 respectively. The NCSS score is a measure of the number of statements within a scope.
Too high an NCSS score suggests that the method or class is doing too much and should be decomposed into smaller units.
> TODO: methodMaximum = 40 - reduce by 20%
> TODO: classMaximum = 1200
> TODO: fileMaximum = 1600
#### [LeftCurly](http://checkstyle.sourceforge.net/config_blocks.html#LeftCurly)
Checks that the left curly brace ('{') is placed at the end of the line. Does not check enums.
Valid:
````
class Foo {
}
````
Invalid:
````
class Bar
{
}
````
#### [LineLength](http://checkstyle.sourceforge.net/config_sizes.html#LineLength)
Limits the line length to 120 characters.
Doesn't check package or import lines.
#### [LocalFinalVariableName](http://checkstyle.sourceforge.net/config_naming.html#LocalFinalVariableName)
Checks the format of local, `final` variable names, including `catch` parameters.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [LocalVariableName](http://checkstyle.sourceforge.net/config_naming.html#LocalVariableName)
Checks the format of local, non-`final` variable names.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [MagicNumber](http://checkstyle.sourceforge.net/config_coding.html#MagicNumber)
Checks that numeric literals are defined as constants. Being constants they then have a name that aids in making them non-magical.
The numbers -1, 0, 1 and 2 are not considered to be magical.
Valid:
````
static final int SECONDS_PER_DAY = 24 * 60 * 60;
static final Border STANDARD_BORDER = BorderFactory.createEmptyBorder(3, 3, 3, 3);
````
Invalid
````
String item = getItem(200);
````
#### [MemberName](http://checkstyle.sourceforge.net/config_naming.html#MemberName)
Checks the format of non-static field names.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [MethodCount](http://checkstyle.sourceforge.net/config_sizes.html#MethodCount)
Restricts the number of methods in a type to 30.
#### [MethodLength](http://checkstyle.sourceforge.net/config_sizes.html#MethodLength)
Restricts the number of lines in a method to 60. Include blank lines and single line comments. You should be able to see an entire method without needing to scroll.
> TODO: max = 40
#### [MethodName](http://checkstyle.sourceforge.net/config_naming.html#MethodName)
Checks the format of method names.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [MethodParamPad](http://checkstyle.sourceforge.net/config_whitespace.html#MethodParamPad)
Checks that the padding between the method identifier and the left parenthesis is on the same line and doesn't have a space in-between.
Valid:
````
void getInstance();
````
Invalid:
````
void getInstance ();
void getValue
();
````
#### [MissingDeprecated](http://checkstyle.sourceforge.net/config_annotation.html#MissingDeprecated)
Both the `@Deprecated` annotation and the Javadoc tag `@deprecated` must be used in pairs.
Valid:
````
/**
* Foo.
*
* @deprecated
*/
@Deprecated
void foo() {}
````
Invalid:
````
/**
* Foo.
*/
@Deprecated
void foo() {}
/**
* Bar.
*
* @deprecated
*/
void bar() {}
````
#### [MissingSwitchDefault](http://checkstyle.sourceforge.net/config_coding.html#MissingSwitchDefault)
Checks that `switch` statement has a `default` case.
Valid:
````
switch (foo) {
case 1:
//
break;
case 2:
//
break;
default:
throw new IllegalStateExcetion("Foo: " + foo);
}
````
Invalid:
````
switch (foo) {
case 1:
//
break;
case 2:
//
break;
}
````
#### [ModifiedControlVariable](http://checkstyle.sourceforge.net/config_coding.html#ModifiedControlVariable)
Checks that the control variable in a `for` loop is not modified inside the loop.
Invalid:
````
for (int i = 0; i < 1; i++) {
i++;
}
````
> TODO: skipEnhancesForLoopVariable = true
#### [ModifierOrder](http://checkstyle.sourceforge.net/config_modifier.html#ModifierOrder)
Check that modifiers are in the following order:
* `public`
* `protected`
* `private`
* `abstract`
* `static`
* `final`
* `transient`
* `volatile`
* `synchronized`
* `native`
* `strictfp`
Type annotations are ignored.
#### [MultipleStringLiterals](http://checkstyle.sourceforge.net/config_coding.html#MultipleStringLiterals)
Checks for multiple occurrences of the same string literal within a single file. Does not apply to empty strings ("").
Invalid:
````
String fooFoo = "foo" + "foo";
````
#### [MultipleVariableDeclarations](http://checkstyle.sourceforge.net/config_coding.html#MultipleVariableDeclarations)
Checks that each variable is declared in its own statement and line.
Valid:
````
int a;
int b;
````
Invalid:
````
int a, b;
````
#### [MutableException](http://checkstyle.sourceforge.net/config_design.html#MutableException)
Checks that `Exception` classes are immutable. However, you can still call `setStackTrace`.
Classes checked are those whose name ends with the following. Or that the class they extend does.
* `Exception`
* `Error`
* `Throwable`
#### [NeedBraces](http://checkstyle.sourceforge.net/config_blocks.html#NeedBraces)
Check that code blocks are surrounded by braces.
Valid:
````
if (obj.isValid()) {
return true;
}
while (obj.isValid()) {
return true;
}
do {
this.notify();
} while (o != null);
for (int i = 0; ;) {
this.notify();
}
````
Invalid:
````
if (obj.isValid()) return true;
while (obj.isValid()) return true;
do this.notify(); while (o != null);
for (int i = 0; ;) this.notify();
````
#### [NestedForDepth](http://checkstyle.sourceforge.net/config_coding.html#NestedForDepth)
Checks that `for` loops are not nested more than 1 deep.
Valid:
````
for (int i = 0; i < 1; i++) { // depth 0
for (int j = 0; j < 1; j++) { // depth 1
//
}
}
````
Invalid:
````
for (int i = 0; i < 1; i++) { // depth 0
for (int j = 0; j < 1; j++) { // depth 1
for (int k = 0; j < 1; k++) { // depth 2!
//
}
}
}
````
#### [NestedIfDepth](http://checkstyle.sourceforge.net/config_coding.html#NestedIfDepth)
Checks that `if` blocks are not nested more than 1 deep.
Valid:
````
if (isValid()) { // depth 0
if (isExpected()) { // depth 1
doIt();
}
}
````
Invalid:
````
if (isValid()) { // depth 0
if (isExpected()) { // depth 1
if (isNecessary()) { // depth 2!
doIt();
}
}
}
````
#### [NestedTryDepth](http://checkstyle.sourceforge.net/config_coding.html#NestedTryDepth)
Checks that `try` blocks are not nested more than 1 deep.
Valid:
````
try {
doSomething();
try {
doSomeOtherThing();
} catch (OtherExceptions oe) {
// handle it
}
} catch (SomeException se) {
// handle it
}
````
Invalid:
````
try {
doSomething();
try {
doSomeOtherThing();
} catch (OtherExceptions oe) {
// handle it
}
} catch (SomeException se) {
// handle it
}
````
> TODO: max = 0 - don't nest try blocks
#### [NewlineAtEndOfFile](http://checkstyle.sourceforge.net/config_misc.html#NewlineAtEndOfFile)
Checks that files end with a line-feed character, (i.e. unix-style line ending).
#### [NoClone](http://checkstyle.sourceforge.net/config_coding.html#NoClone)
Checks that the `clone()` method from `Object` has not been overridden. Use a copy constructor, or better yet, a static factory method.
> See [Effective Java], 2nd Edition by Josh Bloch: Item 11: Override clone judiciously.
#### [NonEmptyAtclauseDescription](http://checkstyle.sourceforge.net/config_javadoc.html#NonEmptyAtclauseDescription)
Checks that the Javadoc clauses `@param`, `@return`, `@throws` and `@deprecated` all have descriptions.
Valid:
````
/**
* Foo.
*
* @returns the foo
*/
````
Invalid:
````
/**
* Foo.
*
* @returns
*/
````
#### [NoWhitespaceAfter](http://checkstyle.sourceforge.net/config_whitespace.html#NoWhitespaceAfter)
Checks that there is no whitespace after the array init ('{'), prefix increment ('++'), prefix decrement ('--'), bitwise complement ('~'), logical complement ('!'), array declaration ('[' in `int[] a;`) or array index operator ('[' in `a[2]`).
Valid:
````
int[] y = {1, 2};
++i;
--i;
int j = -1;
int k = +1;
int l = ~2;
boolean state = !isReady();
int b = o.getValue();
int[] a;
int d = a[2];
````
Invalid:
````
int[] y = { 1, 2 };
++ i;
-- i;
int j = - 1;
int k = + 1;
int l = ~ 2;
boolean state = ! isReady();
int b = o. getValue();
int[ ] a;
int d = a[ 2];
````
> TODO: tokens = DOT & allowLineBreaks = false
#### [NoWhitespaceBefore](http://checkstyle.sourceforge.net/config_whitespace.html#NoWhitespaceBefore)
Checks that there is no whitespace before the comma operator (','), statement terminator (';'), postfix increment ('++') or postfix decrement ('--').
Valid:
````
int y = {1, 2};
doSomething();
i++;
i--;
````
Invalid:
````
int y = {1 , 2};
doSomething() ;
i ++;
i --;
````
#### [NPathComplexity](http://checkstyle.sourceforge.net/config_metrics.html#NPathComplexity)
Checks that the NPATH score (number of paths) through a method is no more than 200. This is similar to [Cyclomatic Complexity](#cyclomaticcomplexity).
> TODO: max = 5 - same as cyclomatic complexity
#### [OneStatementPerLine](http://checkstyle.sourceforge.net/config_coding.html#OneStatementPerLine)
Checks that there is only one statement per line.
Valid:
````
doSomething();
doSomethingElse();
````
Invalid:
````
doSomething(); doSomethingElse();
````
#### [OneTopLevelClass](http://checkstyle.sourceforge.net/config_design.html#OneTopLevelClass)
Checks that each source file contains only one top-level class, interface or enum.
#### [OperatorWrap](http://checkstyle.sourceforge.net/config_whitespace.html#OperatorWrap)
Checks that when wrapping a line on an operator that the operator appears on the new line.
Valid:
````
int answer = getTheAnswerToLife() + getTheAnswerToTheUniverse()
+ getTheAnswerToEverything();
````
Invalid:
````
int answer = getTheAnswerToLife() + getTheAnswerToTheUniverse() +
getTheAnswerToEverything();
````
#### [OuterTypeFilename](http://checkstyle.sourceforge.net/config_misc.html#OuterTypeFilename)
Checks that the source filename matches the name of the top-level class. e.g. `class Foo {}` is in file `Foo.java`.
#### [OverloadMethodsDeclarationOrder](http://checkstyle.sourceforge.net/config_coding.html#OverloadMethodsDeclarationOrder)
Checks that overload methods are grouped together in the source file.
#### [PackageDeclaration](http://checkstyle.sourceforge.net/config_coding.html#PackageDeclaration)
Checks that the class has a `package` definition.
#### [PackageName](http://checkstyle.sourceforge.net/config_naming.html#PackageName)
Checks the format of package names.
Identifiers must match `^[a-z]+(\.[a-zA-Z_][a-zA-Z0-9_]*)*$`.
> TODO: format = `^[a-z]+(\.[a-z]+)*$` - only lowercase letters, no numbers or underscores
#### [ParameterName](http://checkstyle.sourceforge.net/config_naming.html#ParameterName)
Checks the format of method parameter names, including `catch` parameters.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [ParameterNumber](http://checkstyle.sourceforge.net/config_sizes.html#ParameterNumber)
Restricts the number of parameters in a method or constructor to 7.
> TODO: ignoreOverriddenMethods = true
#### [ParenPad](http://checkstyle.sourceforge.net/config_whitespace.html#ParenPad)
Checks that there are no spaces padding parentheses.
Valid:
````
doSomething();
doSomethingElse(5);
````
Invalid:
````
doSomething( );
doSomethingElse( 5);
doSomethingElse(5 );
````
#### [RedundantImport](http://checkstyle.sourceforge.net/config_imports.html#RedundantImport)
Checks for redundant `import`s. Checks for duplicates, imports from the `java.lang` package or from the current package.
> TODO: remove - [UnusedImports](#unusedimports) performs all the same checks and more
#### [RedundantModifier](http://checkstyle.sourceforge.net/config_modifier.html#RedundantModifier)
Checks for redundant modifiers. Checks for:
* Interface and annotation definitions.
* Final modifier on methods of final and anonymous classes.
* Inner interface declarations that are declared as static.
* Class constructors.
* Nested enum definitions that are declared as static.
#### [ReturnCount](http://checkstyle.sourceforge.net/config_coding.html#ReturnCount)
Restricts methods to have at most 2 `return` statements in non-void methods, and at most 1 in void methods.
Valid:
````
int getNumber(int a) {
if (a > 1) {
return a;
}
return 0;
}
void getName(int a) {
String name = "default";
if (a > 1) {
name = "Bob";
}
return name;
}
````
Invalid:
````
int getNumber(int a) {
if (a > 1) {
return a;
}
if (a < 2) {
return a * a;
}
return 0;
}
void getName(int a) {
if (a > 1) {
return "Bob";
}
return "default";
}
````
#### [RightCurly](http://checkstyle.sourceforge.net/config_blocks.html#RightCurly)
Checks that the right curly brace ('}') is placed on the same line as the next part of a multi-block statement (e.g. try-catch-finally, if-then-else).
Valid:
````
try {
//
} catch (Exception e) {
//
} finally {
//
}
if (a > 0) {
//
} else {
//
}
````
Invalid:
````
try {
//
}
catch (Exception e) {
//
}
finally {
//
}
if (a > 0) {
//
}
else {
//
}
if (a > 0) {
//
} a = 2;
public long getId() {return id;}
````
#### [SeparatorWrap](http://checkstyle.sourceforge.net/config_whitespace.html#SeparatorWrap)
Checks the line wrapping around separators.
* The comma separator (',') should be at the end of the line.
* The dot separator ('.') should be on the new line.
Valid:
````
doSomething(alpha, beta,
gamma);
doSomethingElse().stream()
.forEach(System.out::println);
````
Invalid:
````
doSomething(alpha, beta
, gamma);
doSomethingElse().stream().
forEach(System.out::println);
````
#### [SimplifyBooleanExpression](http://checkstyle.sourceforge.net/config_coding.html#SimplifyBooleanExpression)
Checks for overly complicated boolean expressions. Checks for code like `b == true`, `b || true`, `!false`, etc.
Valid:
````
if (b) {}
if (true) {}
````
Invalid:
````
if (b == true) {}
if (b || true) {}
if (!false) {}
````
#### [SimplifyBooleanReturn](http://checkstyle.sourceforge.net/config_coding.html#SimplifyBooleanReturn)
Checks for overly complicated boolean `return` statements.
Valid:
````
return !valid();
````
Invalid:
````
if (valid()) {
return false;
} else {
return true;
}
````
#### [SingleSpaceSeparator](http://checkstyle.sourceforge.net/config_whitespace.html#SingleSpaceSeparator)
Checks that non-whitespace characters on the same line are separated by no more than one whitespace.
Valid:
````
if (a < 0) {}
public long toNanos(long d) { return d; };
````
Invalid:
````
if (a < 0) {}
public long toNanos(long d) { return d; };
````
#### [StaticVariableName](http://checkstyle.sourceforge.net/config_naming.html#StaticVariableName)
Checks the format of `static`, non-`final` variable names.
Identifiers must match `^[a-z][a-zA-Z0-9]*$`.
#### [StringLiteralEquality](http://checkstyle.sourceforge.net/config_coding.html#StringLiteralEquality)
Checks that string literals are not used with `==` or `!=`.
Valid:
````
if ("something".equals(x)) {}
````
Invalid:
````
if (x == "something") {}
````
#### [SuppressWarningsHolder](http://checkstyle.sourceforge.net/config_annotation.html#SuppressWarningsHolder)
Used by Checkstyle to hold the checks to be suppressed from `@SuppressWarnings(...)` annotations.
#### [ThrowsCount](http://checkstyle.sourceforge.net/config_design.html#ThrowsCount)
Restricts non-private methods to only `throws` 4 distinct Exception types. Exceptions should be hierarchical to allow catching suitable root Exceptions.
See [Effective Java], 2nd Edition, Chapter 9: Exceptions
Valid:
````
void doSomething() throws IllegalStateException, DowsingServiceException,
BalancedBudgetException, ManagementInterferanceException {}
````
Invalid:
````
void doSomething() throws IllegalStateException,
DowsingNotPermittedException, DowsingServiceNotReadyException,
BalancedBudgetException, ManagementInterferanceException {}
````
#### [TodoComment](http://checkstyle.sourceforge.net/config_misc.html#TodoComment)
Checks for remaining `TODO` and `FIXME` comments left in code. Their presence indicates that the program isn't finished yet.
> TODO: format = "(//\*).*((TODO)|(FIXME))" - only where in comments
#### [TrailingComment](http://checkstyle.sourceforge.net/config_misc.html#TrailingComment)
Checks for comments at the end of lines.
Valid:
````
// comment on line by itself
// comment after white space
if (a < 1) {
//
} // comment on closing brace
int[] a = new int[2](
1, 2
); // comment on closing parenthesis of statement
````
Invalid:
````
int a = 1; // comment in line with statement
if (a < 1) { // comment on line with if statement
//
}
int[] a = new int[2](
1, // first value - invalid comment
2 // second value - also invalid comment
);
````
#### [TypecastParenPad](http://checkstyle.sourceforge.net/config_whitespace.html#TypecastParenPad)
Checks that there are no spaces within the typecasting parentheses.
Valid:
````
String s = (String) list.get(2);
````
Invalid:
````
String s = (String ) list.get(2);
String s = ( String) list.get(2);
String s = ( String ) list.get(2);
````
#### [TypeName](http://checkstyle.sourceforge.net/config_naming.html#TypeName)
Checks the format of `class`, `interface`, `enum` identifiers, including annotations.
Identifiers must match `^[A-Z][a-zA-Z0-9]*$`.
#### [UnnecessaryParentheses](http://checkstyle.sourceforge.net/config_coding.html#UnnecessaryParentheses)
Checks for the use of unnecessary parentheses.
Valid:
````
if (a < 1) {}
````
Invalid:
````
if ((a < 1)) {}
````
#### [UnusedImports](http://checkstyle.sourceforge.net/config_imports.html#UnusedImports)
Checks for unused imports. Does not inspect wildcard imports, which should be blocked by [AvoidStarImport](#avoidstarimport) anyway.
Imports are unused if:
* They are not referenced in the file.
* It duplicates another import.
* It import from the `java.lang` package.
* It imports a class from the same package.
* It is only references from the Javadoc.
#### [UpperEll](http://checkstyle.sourceforge.net/config_misc.html#UpperEll)
Checks that `long` numeric literal values are marked by an upper-case ell ('L'). The lower-case ell ('l') can be mistaken for the numeral one ('1').
Valid:
````
long id = 12345L;
````
Invalid:
````
long id = 12345l;
````
#### [VariableDeclarationUsageDistance](http://checkstyle.sourceforge.net/config_coding.html#VariableDeclarationUsageDistance)
Checks that a variable declaration and its first usage are not more than 3 lines. Blocks of initialisation methods don't count toward this total.
See the official [Checkstyle documentation](http://checkstyle.sourceforge.net/config_coding.html#VariableDeclarationUsageDistance) for examples.
#### [VisibilityModifier](http://checkstyle.sourceforge.net/config_design.html#VisibilityModifier)
Checks the visibility of class members to help enforce encapsulation. Only `static final` fields, immutable (see list below) fields or field with special annotation (see list below), may be public.
The following are considered immutable when `final`, and can be `public`:
* java.lang.String
* java.lang.Integer
* java.lang.Byte
* java.lang.Character
* java.lang.Short
* java.lang.Boolean
* java.lang.Long
* java.lang.Double
* java.lang.Float
* java.lang.StackTraceElement
* java.math.BigInteger
* java.math.BigDecimal
* java.io.File
* java.util.Locale
* java.util.UUID
* java.net.URL
* java.net.URI
* java.net.Inet4Address
* java.net.Inet6Address
* java.net.InetSocketAddress
Fields with the following annotations may be `public`:
* org.junit.Rule
* org.junit.ClassRule
* com.google.common.annotations.VisibleForTesting
Valid:
````
class Foo {
public final Long id;
public final String name;
private String description;
@VisibleForTesting
public State state;
Foo(final Long id, final String name) {
this.id = id;
this.name = name;
}
}
````
Invalid:
````
class Foo {
public Long id;
public String name;
private String description;
public State state;
Foo(final Long id, final String name) {
this.id = id;
this.name = name;
}
}
````
#### [WhitespaceAfter](http://checkstyle.sourceforge.net/config_whitespace.html#WhitespaceAfter)
Checks that commas (','), statement terminators (';') and typecasts are all followed by a space.
Valid:
````
doSomething(1, 2, 3);
if (a > 1) { return true; }
String name = (String) list.get(9);
````
Inalid:
````
doSomething(1,2,3);
if (a > 1) { return true;}
String name = (String)list.get(9);
````
#### [WhitespaceAround](http://checkstyle.sourceforge.net/config_whitespace.html#WhitespaceAround)
Checks that tokens are surrounded by whitespace.
### Sevntu
#### [AvoidConstantAsFirstOperandInCondition](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/coding/AvoidConstantAsFirstOperandInConditionCheck.html)
Checks that condition expressions don't become less readable by attempting to use a constant on the left-hand-side of a comparison.
Valid:
````
if (a == 12) {}
````
Invalid:
````
if (12 == a) {}
````
#### [AvoidHidingCauseException](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/coding/AvoidHidingCauseExceptionCheck.html)
Ensures that an exception is re-thrown properly and is not swallowed by a `catch` block.
Valid:
````
try {
doSomething();
} catch (MyException e) {
throw new MyOtherException(e);
}
````
Invalid:
````
try {
doSomething();
} catch (MyException e) {
throw new MyOtherException();
}
````
#### [AvoidNotShortCircuitOperatorsForBoolean](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheck.html)
Prevents the use of boolean operators that don't allow short-circuiting the expression. (e.g. '|', '&', '|=' and '&=')
Valid:
````
if ((a < b) || (b > getExpensiveValue())) {}
````
Invalid:
````
if ((a < b) | (b > getExpensiveValue())) {}
````
#### [ConfusingCondition](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/coding/ConfusingConditionCheck.html)
Checks that the expression with the `if` condition in an `if-then-else` statement is not negated.
Valid:
````
if (isValid()) {
handleValidCondition();
} else {
handleInvalidCondition();
}
````
Invalid:
````
if (!isValid()) {
handleInvalidCondition();
} else {
handleValidCondition();
}
````
#### [ConstructorWithoutParams](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/design/ConstructorWithoutParamsCheck.html)
Exception class constructors must accept parameters for message and/or cause. This check is applied to classes whose name ends with `Exception`.
#### [DiamondOperatorForVariableDefinition](http://sevntu-checkstyle.github.io/sevntu.checkstyle/apidocs/com/github/sevntu/checkstyle/checks/coding/DiamondOperatorForVariableDefinitionCheck.html)
Checks that the diamond operator is used where possible.
Valid:
````
Map