AV Rule 1

Any one function (or method) will contain no more than 200 logical source lines of code (L-SLOCs).

Will

Yes

AV Rule 3

All functions shall have a cyclomatic complexity number of 20 or less.

Shall

Yes

AV Rule 5

To break a "will" or a "shall" Rule , the following approvals must be received by the developer: - approval from the software engineering lead (obtained by the unit approval in the developmental CM tool) - approval from the software product manager (obtained by the unit approval in the developmental CM tool).

Shall

NSE

AV Rule 7

Approval will not be required for a deviation from a "shall" or "will" Rule that complies with an exception specified by that Rule.

Will

NSE

AV Rule 9

Only those characters specified in the C++ basic source character set will be used.

Will

Yes

AV Rule 11

Trigraphs will not be used.

Will

Yes

AV Rule 13

Multi-byte characters and wide string literals will not be used.

Will

Yes

AV Rule 15

Provision shall be made for run-time checking (defensive programming).

Shall

NSE

AV Rule 17

The error indicator errno shall not be used.

Shall

Yes

AV Rule 19

Shall

Yes

AV Rule 21

The signal handling facilities of  shall not be used.

Shall

Yes

AV Rule 23

The library functions atof, atoi and atol from library  shall not be used.

Shall

Yes

AV Rule 25

The time handling functions of library  shall not be used.

Shall

Yes

AV Rule 27

#ifndef, #define and #endif will be used to prevent multiple inclusions of the same header file. Other techniques to prevent the multiple inclusions of header files will not be used.

Will

Yes

AV Rule 29

The #define pre-processor directive shall not be used to create inline macros. Inline functions shall be used instead.

Shall

Yes

AV Rule 31

The #define pre-processor directive will only be used as part of the technique to prevent multiple inclusions of the same header file.

Will

Yes

AV Rule 33

The #include directive shall use the  notation to include header files.

Shall

Yes

AV Rule 35

A header file will contain a mechanism that prevents multiple inclusions of itself.

Will

Yes

AV Rule 37

Header (include) files should include only those header files that are required for them to successfully compile. Files that are only used by the associated .cpp file should be placed in the .cpp file-not the .h file.

Should

Yes

AV Rule 39

Header files (*.h) will not contain non-const variable definitions or function definitions.

Will

Yes

AV Rule 41

Source lines will be kept to a length of 120 characters or less.

Will

Yes

AV Rule 43

Tabs should be avoided.

Should

Yes

AV Rule 45

All words in an identifier will be separated by the '_' character.

Will

No

AV Rule 47

Identifiers will not begin with the underscore character '_'.

Will

Yes

AV Rule 49

All acronyms in an identifier will be composed of uppercase letters.

Will

No

AV Rule 51

All letters contained in function and variable names will be composed entirely of lowercase letters.

Will

Yes

AV Rule 53

Header files will always have a file name extension of ".h".

Will

Yes

AV Rule 54

Implementation files will always have a file name extension of ".cpp".

Will

Yes

AV Rule 56

The name of an implementation file should reflect the logical entity for which it provides definitions and have a ".cpp" extension (this name will normally be identical to the header file that provides the corresponding declarations.)

Should

Yes

AV Rule 58

When declaring and defining functions with more than two parameters, the leading parenthesis and the first argument will be written on the same line as the function name. Each additional argument will be written on a separate line (with the closing parenthesis directly after the last argument).

Will

Yes

AV Rule 60

Braces ("{}") which enclose a block will be placed in the same column, on separate lines directly before and after the block.

Will

Yes

AV Rule 62

The dereference operator '*' and the address-of operator '&' will be directly connected with the type-specifier.

Will

Yes

AV Rule 64

A class interface should be complete and minimal.

Should

NSE

AV Rule 66

A class should be used to model an entity that maintains an invariant.

Should

No

AV Rule 68

Unneeded implicitly generated member functions shall be explicitly disallowed.

Shall

Yes

AV Rule 70

A class will have friends only when a function or object requires access to the private elements of the class, but is unable to be a member of the class for logical or efficiency reasons.

Will

No

AV Rule 71

Calls to an externally visible operation of an object, other than its constructors, shall not be allowed until the object has been fully initialized.

Shall

Yes

AV Rule 72

The invariant for a class should be: - a part of the postcondition of every class constructor, - a part of the precondition of the class destructor (if any), - a part of the precondition and postcondition of every other publicly accessible operation.

Should

No

AV Rule 74

Initialization of nonstatic class members will be performed through the member initialization list rather than through assignment in the body of a constructor.

Will

Yes

AV Rule 76

A copy constructor and an assignment operator shall be declared for classes that contain pointers to data items or nontrivial destructors.

Shall

Yes

AV Rule 77.1

The definition of a member function shall not contain default arguments that produce a signature identical to that of the implicitly-declared copy constructor for the corresponding class/structure.

Shall

Yes

AV Rule 79

All resources acquired by a class shall be released by the class's destructor.

Shall

Yes

AV Rule 81

The assignment operator shall handle self-assignment correctly.

Shall

Yes

AV Rule 83

An assignment operator shall assign all data members and bases that affect the class invariant (a data element representing a cache, for example, would not need to be copied).

Shall

Yes

AV Rule 85

When two operators are opposites (such as == and !=), both will be defined and one will be defined in terms of the other.

Will

Yes

AV Rule 87

Hierarchies should be based on abstract classes.

Should

Yes

AV Rule 88.1

A stateful virtual base shall be explicitly declared in each derived class that accesses it.

Shall

Yes

AV Rule 90

Heavily used interfaces should be minimal, general and abstract.

Should

NSE

AV Rule 92

A subtype (publicly derived classes) will conform to the following guidelines with respect to all classes involved in the polymorphic assignment of different subclass instances to the same variable or parameter during the execution of the system: - Preconditions of derived methods must be at least as weak as the preconditions of the methods they override. - Postconditions of derived methods must be at least as strong as the postconditions of the methods they override.

Will

NSE

AV Rule 94

An inherited nonvirtual function shall not be redefined in a derived class.

Shall

Yes

AV Rule 96

Arrays shall not be treated polymorphically.

Shall

Yes

AV Rule 97.1

Neither operand of an equality operator (== or !=) shall be a pointer to a virtual member function.

Shall

Yes

AV Rule 99

amespaces will not be nested more than two levels deep.

Will

Yes

AV Rule 101

Templates shall be reviewed as follows: 1. with respect to the template in isolation considering assumptions or requirements placed on its arguments. 2. with respect to all functions instantiated by actual arguments.

Shall

NSE

AV Rule 103

Constraint checks should be applied to template arguments.

Should

No

AV Rule 105

A template definition's dependence on its instantiation contexts should be minimized.

Should

No

AV Rule 107

Functions shall always be declared at file scope.

Shall

Yes

AV Rule 109

A function definition should not be placed in a class specification unless the function is intended to be inlined.

Should

Yes

AV Rule 111

A function shall not return a pointer or reference to a non-static local object.

Shall

Yes

AV Rule 113

Functions will have a single exit point.

Will

Yes

AV Rule 115

If a function returns error information, then that error information will be tested.

Will

No

AV Rule 117

Arguments should be passed by reference if NULL values are not possible.

Should

Yes

AV Rule 117.2

An object should be passed as T& if the function may change the value of the object.

Should

Yes

AV Rule 118.1

An object should be passed as const T* if its value should not be modified.

Should

Yes

AV Rule 119

Functions shall not call themselves, either directly or indirectly (i.e. recursion shall not be allowed).

Shall

Yes

AV Rule 121

Only functions with 1 or 2 statements should be considered candidates for inline functions.

Should

Yes

AV Rule 123

The number of accessor and mutator functions should be minimized.

Should

Yes

AV Rule 125

Unnecessary temporary objects should be avoided.

Should

No

AV Rule 127

Code that is not used (commented out) shall be deleted.

Shall

Yes

AV Rule 129

Comments in header files should describe the externally visible behavior of the functions or classes being documented.

Should

NSE

AV Rule 131

One should avoid stating in comments what is better stated in code (i.e. do not simply repeat what is in the code).

Should

NSE

AV Rule 133

Every source file will be documented with an introductory comment that provides information on the file name, its contents, and any program-required information (e.g. legal statements, copyright information, etc).

Will

Yes

AV Rule 135

Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identifier.

Shall

Yes

AV Rule 137

All declarations at file scope should be static where possible.

Should

Yes

AV Rule 139

External objects will not be declared in more than one file.

Will

Yes

AV Rule 141

A class, structure, or enumeration will not be declared in the definition of its type.

Will

Yes

AV Rule 143

Variables will not be introduced until they can be initialized with meaningful values.

Will

Yes

AV Rule 145

In an enumerator list, the '=' construct shall not be used to explicitly initialize members other than the first, unless all items are explicitly initialized.

Shall

Yes

AV Rule 147

The underlying bit representations of floating point numbers shall not be used in any way by the programmer.

Shall

Yes

AV Rule 149

Octal constants (other than zero) shall not be used.

Shall

Yes

AV Rule 151

Numeric values in code will not be used; symbolic values will be used instead.

Will

Yes

AV Rule 152

Multiple variable declarations shall not be allowed on the same line.

Shall

Yes

AV Rule 154

Bit-fields shall have explicitly unsigned integral or enumeration types only.

Shall

Yes

AV Rule 156

All the members of a structure (or class) shall be named and shall only be accessed via their names.

Shall

Yes

AV Rule 158

The operands of a logical && or || shall be parenthesized if the operands contain binary operators.

Shall

Yes

AV Rule 160

An assignment expression shall be used only as the expression in an expression statement.

Shall

Yes

AV Rule 163

Unsigned arithmetic shall not be used.

Shall

Yes

AV Rule 164.1

The left-hand operand of a right-shift operator shall not have a negative value.

Shall

Yes

AV Rule 166

The sizeof operator will not be used on expressions that contain side effects.

Will

Yes

AV Rule 168

The comma operator shall not be used.

Shall

Yes

AV Rule 170

More than 2 levels of pointer indirection shall not be used.

Shall

Yes

AV Rule 173

The address of an object with automatic storage shall not be assigned to an object which persists after the object has ceased to exist.

Shall

Yes

AV Rule 175

A pointer shall not be compared to NULL or be assigned NULL; use plain 0 instead.

Shall

Yes

AV Rule 177

User-defined conversion functions should be avoided.

Should

Yes

AV Rule 179

A pointer to a virtual base class shall not be converted to a pointer to a derived class.

Shall

Yes

AV Rule 181

Redundant explicit casts will not be used.

Will

Yes

AV Rule 183

Every possible measure should be taken to avoid type casting.

Should

Yes

AV Rule 185

C++ style casts (const_cast, reinterpret_cast, and static_cast) shall be used instead of the traditional C-style casts.

Shall

Yes

AV Rule 187

All non-null statements shall potentially have a side-effect.

Shall

Yes

AV Rule 189

The goto statement shall not be used.

Shall

Yes

AV Rule 191

The break statement shall not be used (except to terminate the cases of a switch statement).

Shall

Yes

AV Rule 193

Every non-empty case clause in a switch statement shall be terminated with a break statement.

Shall

Yes

AV Rule 195

A switch expression will not represent a Boolean value.

Will

Yes

AV Rule 197

Floating point variables shall not be used as loop counters.

Shall

Yes

AV Rule 199

The increment expression in a for loop will perform no action other than to change a single loop parameter to the next value for the loop.

Will

Yes

AV Rule 201

Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.

Shall

Yes

AV Rule 203

Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented).

Shall

No

AV Rule 204.1

he value of an expression shall be the same under any order of evaluation that the standard permits.

Shall

Yes

AV Rule 206

Allocation/deallocation from/to the free store (heap) shall not occur after initialization.

Shall

No

AV Rule 208

C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.)

Shall

Yes

AV Rule 210

Algorithms shall not make assumptions concerning how data is represented in memory (e.g. big endian vs. little endian, base class subobject ordering in derived classes, nonstatic data member ordering across access specifiers, etc.

Shall

Yes

AV Rule 211

Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses.

Shall

NSE

AV Rule 213

No dependence shall be placed on C++'s operator precedence Rule s, below arithmetic operators, in expressions.

Shall

Yes

AV Rule 215

Pointer arithmetic will not be used.

Will

Yes

AV Rule 217

Compile-time and link-time errors should be preferred over run-time errors.

Should

No

AV Rule 219

All tests applied to a base class interface shall be applied to all derived class interfaces as well. If the derived class poses stronger postconditions/invariants, then the new postconditions /invariants shall be substituted in the derived class tests.

Shall

NSE

AV Rule 221

Structural coverage of a class within an inheritance hierarchy containing virtual functions shall include testing every possible resolution for each set of identical polymorphic references.

Shall

NSE