TL;DR: This chapter discusses the evolution of C++ and ANSI C, a standards-based programming language, and its applications in the rapidly changing environment, as well as some of the techniques used to design and implement these systems.
Abstract: Preface. 1. Introduction. Overview. Syntax Notation. Evolution of C++. Acknowledgements. 2. Lexical Conventions. Tokens. Comments. Identifiers. Keywords. Literals. Implementation Dependencies. 3. Basic Concepts. Declarations and Definitions. Scopes. Program and Linkage. Start and Termination. Storage Classes. Types. Lvalues. Name Spaces. Numerical Limits. 4. Standard Conversions. Integral Promotions. Integral Conversions. Float and Double. Floating and Integral. Arithmetic Conversions. Pointer Conversions. Reference Conversions. Pointers to Members. Arithmetic Conversions. 5. Expressions. Primary Expressions. Postfix Expressions. Unary Operators. Explicit Type Conversion. Pointer-to-Member Operators. Multiplicative Operators. Additive Operators. Shift Operators. Relational Operators. Equality Operators. Bitwise AND Operator. Bitwise Exclusive OR Operator. Bitwise Inclusive OR Operator. Logical AND Operator. Logical OR Operator. Conditional Operator. Assignment Operators. Comma Operator. Constant Expressions. 6. Statements. Labeled Statement. Expression Statement. Compound Statement, or Block. Selection Statements. Iteration Statements. Jump Statements. Declaration Statement. Ambiguity Resolution. 7. Declarations. Specifiers. Enumeration Declarations. Asm Declarations. Linkage Specifications. Linkage Specifications. Type-safe Linkage. Limitations. 8. Declarators. Type Names Meaning of Declarators. Function Definitions. Initializers. Pointers to Members. 9. Classes. Class Names. Class Members. Member Functions. Static Members. Unions. Bit-Fields. Nested Class Declarations. Local Class Declarations. Local Type Names. Interfaces. 10. Derived Classes. Multiple Base Classes. Virtual Functions. Abstract Classes. Summary of Scope Rules. Single Inheritance. Multiple Inheritance. Multiple Inheritance and Casting. Multiple Inheritance and Implicit Conversion. Virtual Base Classes. Virtual Base Classes and Casting. Single Inheritance and Virtual Functions. Multiple Inheritance and Virtual Functions. Instantiation of Virtual Functions. Virtual Base Classes with Virtual Functions. Renaming. 11. Member Access Control. Access Specifiers. Access Specifiers for Base Classes. Access Declarations. Friends. Protected Member Access. Access to Virtual Functions. Multiple Access. General Ideas. Per Class Protection. Access Control. 12. Special Member Functions. Constructors. Temporary Objects. Conversions. Destructors. Free Store. Initialization. Constructors and Destructors. Copying Class Objects. Temporary Elimination. Access Control and Special Functions. Summary of Member, Friend, and Special Functions. 13. Overloading. Declaration Matching. Argument Matching. Address of Overload Function. Overloaded Operators. 14. Templates. Templates. Class Templates. Type Equivalence. Function Templates. Declarations and Definitions. Member Function Templates. Friends. Static Members and Variables. 15. Exception Handling. Exception Handling. Throwing an Exception. Constructors and Destructors. Handling and Exception. Exception Specifications. Special Functions. Exceptions and Access. 16. Preprocessing. Phases of Preprocessing. Trigraph Sequences. Macro Definition and Expansion. File Inclusion. Conditional Compilation. Line Control. Error Directive. Pragmas. Null Directive. Predefined Names. C++ Constructs versus #define. Compatibility. Classic C Preprocessing. 17. Grammar Summary. Keywords. Expressions. Declarations. Declarators. Class. Statements. Preprocessor. Templates. Exception. 18. Compatibility. Extensions. C++ and ANSI C. Anachronisms. ANSI/ISO Resolutions. Index. 0201514591T04062001
TL;DR: This paper convincingly demonstrates that it is possible to improve the effectiveness and efficiency of a mutation analysis system by identifying and removing redundant mutants.
Abstract: Mutation analysis is an unbiased and powerful method for assessing input values and test oracles. However, in comparison to other techniques, such as those that rely on code coverage, it is a computationally-expensive and time-consuming method, especially for large software systems. This high cost is due, in part, to the fact that many mutation operators generate redundant mutants that may both misrepresent the mutation score and increase the runtime of the mutation analysis process. After showing how the conditional operator replacement(COR) mutation operator can be defined in a redundant-free manner, this paper uses four real-world programs, ranging in size from 3,000 to nearly 40,000 lines of code, to show the prevalence of redundant mutants. Focusing on the conditional operator replacement (COR)and relational operator replacement (ROR) mutation operators that create 41% of all mutants in the chosen programs, the case study reveals that the removal of redundant mutants reduces the runtime of mutation analysis by up to 34%. Additional empirical results show that redundant mutants can lead to a mutation score that is misleadingly overestimated by as much as 10%. Overall, this paper convincingly demonstrates that it is possible to improve the effectiveness and efficiency of a mutation analysis system by identifying and removing redundant mutants.
TL;DR: In this paper, a brief description of method-level mutation operators for Java used by muJava is given, where the focus is on modifying expression by replacing, deleting, and inserting primitive operators.
Abstract: This document provides a brief description of method-level mutation operators for Java used by muJava. When designing method-level mutation operators for Java, we followed the selective approach [1]. The selective results found that the traditional operatorso of modifying operands and statements give little effectiveness to mutation testing. Therefore, we only consider mutation operators that modify expression by replacing, deleting, and inserting primitive operators. muJava provides six kinds of primitive operators; (1) arithmetic operator, (2) relational operator, (3) conditional operator, (4) shift operator, (5) logical operator, and (6) assignment. For some of them, muJava provides short-cut operators. This section presents designs of mutation operators for those six kinds of primitive operators. We try to design mutation operators that replace, insert, and delete the primitive operators. We defined total 12 method-level operators in Table 1. The detailed description for the operators are described in the following subsections, according to each primitive operator.
TL;DR: The Rule Engine as discussed by the authors uses Rule Objects that only need to know hoe to understand and apply a very specific type of Rule from a Rule set, which minimizes the need to parse and interpret a complex all-purpose Rule language.
Abstract: A high performance Rule Engine, capable of handling interactions and dependencies within a system. A system, such as a provisioning system for customer care, contains many pieces of interdependent Data. The Rule Engine uses Rule Objects that only need to know hoe to understand and apply a very specific type of Rule from a Rule set. This minimizes the need to parse and interpret a complex all-purpose Rule language. Each Rule Object can be linked together to form a list of Rules emanating from a Business Rule Coordinator Objects. Moreover, each Rule Object is loaded with a operator, such as a conditional operator, at startup, after which the conditional operator does not need to change and the Rule Object hierarchy can be kept active in memory.