// Master template
// 
// CAUTION: DO NOT USE SAME ORDINALITY FOR A STRUCTURE AND A CLASS IN THE SAME PROGRAM
//
// In the following, (B) stands for behavior/output, (D) for debug
// ---------------------------------------------------------------------------------
// // VARIABLES AND FUNCTIONS OF AN OBJECT
// 
// // Accessing public (B) data member by client - 100
// Object.Variable.Public.By Client
// // Accessing protected (D) data member by client - 125
// // Object.Variable.Protected.By Client
// Object.Variable.Protected.Client code does not have access to protected data member of the object
// // Accessing private (D) data member by client - 150
// // Object.Variable.Private.By Client
// Object.Variable.Private.Client code does not have access to private data member of the object
// 
// // All functions public
// // Accessing public (B) data member by dynamic member function - 200
// Object.Variable.Public.By Object Function
// // Accessing protected (B) data member by dynamic member function - 225
// Object.Variable.Protected.By Object Function
// // Accessing private (B) data member by dynamic member function - 250
// Object.Variable.Private.By Object Function
// 
// // Accessing dynamic (D) data member by static member function - 300
// // Object.Variable.Public.By Class Function
// OOP.Object.Variable.The variable is not a static member of the class, and cannot be accessed in a static function
// // Accessing protected (D) data member by static member function
// // Object.Variable.Protected.By Class Function
// // Accessing private (D) data member by static member function
// // Object.Variable.Private.By Class Function
// Object.Variable.Private.Class (static) function does not have access to private data member of the object
// 
// // Accessing dynamic data member with respect to the class - 325
// OOP.Object.Variable.The variable is not a static member of the class, and cannot be accessed with respect to the class
// 
// // All public member functions
// // Accessing public (B) member function by client
// // Object.Function.Public.By Client - Further expanded below
// // Accessing protected (D) member function by client - 400
// // Object.Function.Protected.By Client
// Object.Function.Protected.Client code does not have access to protected member function of the object
// // Accessing private (D) member function by client - 425
// // Object.Function.Private.By Client
// Object.Function.Private.Client code does not have access to private member function of the object
// 
// // Execution of constructor code (B) wrt object - 500
// Object.Constructor.By Client
// // Execution of constructor with one or more parameters - 525
// Object.Initialization.Basic object
// TO DO - RENAME
// // Execution of constructor with incorrect number of parameters - 550
// Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// TO DO - RENAME
// // Execution of constructor with incorrect data types for parameters - 575
// Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

// // Execution of selectors (B) wrt object - 600
// Object.Selector.By Client
// TO DO - RENAME
// // Value returned by the selector is ignored by the caller - 625
// Object.Selector.Value returned by the function is ignored by the caller
// TO DO - RENAME
// // Selector is called before data member is initialized - 650
// Object.Selector.Referencing variable before initializing its value

// // Execution of mutators (B) wrt object - 700
// Object.Mutator.By Client
// TO DO - RENAME
// // Value returned by the mutator is ignored by the caller - 725
// Object.Mutator.Value returned by the function is ignored by the caller
// TO DO - RENAME
// // Mutator is called with incorrect number of parameters - 750
// Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// TO DO - RENAME
// // Mutator is called with incorrect data type for parameters - 775
// Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

// // Execution of destructor code (B) wrt object - 800 
// Object.Destructor.By Client

// // Assigning an object to class instead of another object - 900
// // Object.Assignment.Aggregate.Assigning to class
// Object.Assignment.Aggregate.Object cannot be assigned to a class
// // Aggregate assignment from one object to another - 925
// Object.Assignment.Aggregate.Assigning object to variable
// // Object passed as parameter to a function where it is accessed - 950
// Object.Parameter.Aggregate.Accessed
// // Object passed as parameter to a function where it is modified - 975
// Object.Parameter.Aggregate.Modified

// // ---------------------------------------------------------------------------------
// // STATIC VARIABLE AND FUNCTION IN A CLASS
// 
// // Accessing static public (B) data member by client - 1000
// Class.Variable.Public.Wrt Class
// // Accessing static public (B) data member by client - 1025
// Class.Variable.Public.Wrt Object
// // Accessing static protected (D) data member by client - 1050
// Class.Variable.Protected.By Client
// // Accessing static private (D) data member by client - 1075
// Class.Variable.Private.By Client
// 
// // Accessing static public (B) data member by static member function - 1100
// Class.Variable.Public.By Class Function
// // Accessing static protected (B) data member by static member function - 1125
// Class.Variable.Protected.By Class Function
// // Accessing static private (B) data member by static member function - 1150
// Class.Variable.Private.By Class Function
// 
// // Accessing static public (D) data member by dynamic member function - 1200
// Class.Variable.Public.By Object Function
// // Accessing static protected (D) data member by dynamic member function - 1225
// Class.Variable.Protected.By Object Function
// // Accessing static private (D) data member by dynamic member function - 1250
// Class.Variable.Private.By Object Function
// 
// // Accessing static public (B) member function wrt class name by client - 1300
// Class.Function.Public.Wrt Class
// // Accessing static public (D) member function wrt object by client - 1325
// Class.Function.Public.Wrt Object
// // Accessing static protected (D) member function by client - 1350
// Class.Function.Protected.By Client
// // Accessing static private (D) member function by client - 1375
// Class.Function.Private.By Client
// 
// // ---------------------------------------------------------------------------------
// // COMPOSITION OF CLASSES
// 
// // Called in Composer function, which is in turn called by client
// // Accessing public (B) data member by composing class - 2000
// Object.Variable.Public.By Composer
// // Accessing protected (D) data member by composing class - 2025
// Object.Variable.Protected.By Composer
// // Accessing private (D) data member by composing class - 2050
// Object.Variable.Private.By Composer
// 
// // Called in Composer function, which is in turn called by client
// // Accessing public (B) member function by composing class 
// // Object.Function.Public.By Composer.Function - Expanded below
// // Accessing protected (D) member function by composing class - 2100
// Object.Function.Protected.By Composer
// // Accessing private (D) member function by composing class - 2125
// Object.Function.Private.By Composer
// 
// // Execution of constructor code (B) by composing class constructor - 2200
// Object.Constructor.By Composer

// // Calling constructor with arguments, some of which are used to initialize composed object - 2225
// Object.Initialization.Composed object

// // Execution of selectors (B) by composing class function - 2250
// Object.Selector.By Composer
// // Execution of mutators (B) by composing class function - 2275
// Object.Mutator.By Composer
// // Execution of destructor code (B) by composing class destructor - 2300
// Object.Destructor.By Composer
// 
// // Accessing public (D) data member wrt composing object by client - 2400
// Object.Variable.Public.Wrt Composer
// // Accessing protected (D) data member wrt composing object by client - 2425
// Object.Variable.Protected.Wrt Composer
// // Accessing private (D) data member wrt composing object by client - 2450
// Object.Variable.Private.Wrt Composer
// 
// // Accessing public (D) member function wrt composing object by client - 2500
// Object.Function.Public.Wrt Composer
// // Accessing protected (D) member function wrt composing object by client - 2525
// Object.Function.Protected.Wrt Composer
// // Accessing private (D) member function wrt composing object by client - 2550
// Object.Function.Private.Wrt Composer
// 

// Following are for chained dot operator, where operands are both member function calls
//   Elsewhere, we see chained dot operators, where one operand is a data member
// // Object is returned by a function, which is then accessed - 2600
// Object.Returned.By Composer  // Calling selector/mutator w.r.t object returned by Composer

// // ---------------------------------------------------------------------------------
// // PUBLIC INHERITANCE
// 
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) data member by inheriting class - 3000
// Object.Variable.Public.By Inheritor
// // Accessing protected (B) data member by inheriting class - 3025
// Object.Variable.Protected.By Inheritor
// // Accessing private (D) data member by inheriting class - 3050
// Object.Variable.Private.By Inheritor
// 
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) member function by inheriting class 
// // Object.Function.Public.By Inheritor.Function - Expanded below
// // Accessing protected (B) member function by inheriting class - 3100
// Object.Function.Protected.By Inheritor
// // Accessing private (D) member function by inheriting class - 3125
// Object.Function.Private.By Inheritor
// 
// // Accessing public (B) data member wrt inheriting object by client - 3200
// Object.Variable.Public.Wrt Inheritor
// // Accessing protected (D) data member wrt inheriting object by client - 3225
// Object.Variable.Protected.Wrt Inheritor
// // Accessing private (D) data member wrt inheriting object by client - 3250
// Object.Variable.Private.Wrt Inheritor
// 
// // Accessing public (B) member function wrt inheriting object by client - 3300
// Object.Function.Public.Wrt Inheritor
// // Accessing protected (D) member function wrt inheriting object by client - 3325
// Object.Function.Protected.Wrt Inheritor
// // Accessing private (D) member function wrt inheriting object by client - 3350
// Object.Function.Private.Wrt Inheritor

// // Execution of constructor code (B) when inheriting class's constructor calls it - 3400
// Object.Constructor.Inheritor.Coopted
// // Execution of constructor code (B) when inheriting class's constructor does not call it - 3425
// Object.Constructor.Inheritor.Not Coopted

// // Constructor is called with arguments, some of which are passed to base class - 3450
// Object.Initialization.Inherited object

// // In each problem, call the overridden function wrt BOTH base and derived class object
// // Execution of selectors (B) by inheriting class 
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3500
// Object.Selector.Inheritor.Overridden.Coopted.Polymorphic
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3525
// Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic
// // Execution of selectors (B) by client wrt inheriting object which does not override - 3550
// Object.Selector.Inheritor.Not Overridden
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3575
// Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3600
// Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic
// 
// // In each problem, call the overridden function wrt both base and derived class object
// // Execution of mutators (B) by inheriting class 
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3700
// Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3725
// Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic
// // Execution of mutators (B) by client wrt inheriting object which does not override - 3750
// Object.Mutator.Inheritor.Not Overridden
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3775
// Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3800
// Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic
//
// // Execution of destructor code (B) by inheriting class's destructor - 3850
// Object.Destructor.By Inheritor
// 
// // Assigning base class object to derived class variable - 3900
// Object.Assignment.Aggregate.Assigning base object to derived variable
// // Assigning derived class object to base class variable - 3925
// Object.Assignment.Aggregate.Assigning derived object to base variable
// // Assigning object of one derived class to variable of another derived class - 3950
// Object.Assignment.Aggregate.Assigning derived object to different derived variable

// ---------------------------------------------------------------------------------------
// INVERSE OF INHERITANCE

// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) data member by ancestral class - 4000
// Object.Variable.Public.By Ancestor
// // Accessing protected (B) data member by ancestral class - 4025
// Object.Variable.Protected.By Ancestor
// // Accessing private (D) data member by ancestral class - 4050
// Object.Variable.Private.By Ancestor
// 
// // Called in inheritor function, which is in turn called by client

// // Accessing public (B) member function by ancestral class - 4100
// Object.Function.Public.By Ancestor
// // Accessing protected (B) member function by ancestral class - 4125
// Object.Function.Protected.By Ancestor
// // Accessing private (D) member function by ancestral class - 4150
// Object.Function.Private.By Ancestor
// 

// // Accessing public (B) data member wrt ancestral object by client - 4200
// Object.Variable.Public.Wrt Ancestor
// // Accessing protected (D) data member wrt ancestral object by client - 4225
// Object.Variable.Protected.Wrt Ancestor
// // Accessing private (D) data member wrt ancestral object by client - 4250
// Object.Variable.Private.Wrt Ancestor
// 

// // Accessing public (B) member function wrt ancestral object by client - 4300
// Object.Function.Public.Wrt Ancestor
// // Accessing protected (D) member function wrt ancestral object by client - 4325
// Object.Function.Protected.Wrt Ancestor
// // Accessing private (D) member function wrt ancestral object by client - 4350
// Object.Function.Private.Wrt Ancestor

// Notation:
// <F1.0.0>:
//    <C1>'s constructor (last digit is 0)
//        In client:
//          <C1><O1> = <F1.0.0>();
//        In composing object's constructor:
//          <O1> = <F1.0.0>(); 
//        In inheriting object's constructor:
//          <F1.0.0>();
//    Note: <T0> is used as return type in the definition so that TemplateParser.isFunctionHeader() 
//    will properly identify constructor as a function
// <F1.0.1>:
//    <C1>'s destructor (last digit is 1)
//    Note: <T0> is used as return type in the definition so that TemplateParser.isFunctionHeader() 
//    will properly identify destructor as a function
// <F1.2.0>: 
//    <C1>'s <V2>'s selector (last digit is 0) (Note: <V2> may be inherited from <C1>'s parent!)
//        In client:
//          << <O1>.<F1.2.0>();
//        In inheriting object's selector (assuming <C1> inherited from <C2>):
//          return <F2.2.0>();
//    Note: Selector's name is not logged in SymbolTable
// <F3.2.1>: 
//    <C3>'s <V2>'s mutator (last digit is 1) (Note: <V2> may be inherited from <C1>'s parent!)
//    Note: Mutator's name is not logged in SymbolTable
// Say <C1> is the parent and <C2> inherits from it 
//   <F2> is defined in <C1> and overridden in <C2>
//   In <C2>.<F2>() definition, <F2>(); would be a recursive call.
//   How do we call <C1>'s <F2>()?
//     <*1>.<F2>()?
//     <C*>.<F2>()?
//     <F2*>()?
//     <F*2>()?


// ---------------------------------------------------------------------------------
// Each problem tests wrt some client code that accesses the data member of member function in question
// In the following, (B) stands for behavior/output, (D) for debug

// =================================================================================
// // VARIABLES AND FUNCTIONS OF AN OBJECT
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by client - 100
// Object.Variable.Public.By Client

# 100
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signed#><V1>;
   <T1><F2>(){return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;}
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member by client - 125
// Object.Variable.Protected.By Client
// Object.Variable.Protected.The variable is protected in the class and cannot be accessed
// Old: Client code does not have access to protected data member of the object

# 125
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signed#><F2>(){return <V1> - 10;}
   <T0><F1>(<T1><V2>){if(<V2> > 0) <V1>=<V2> + 10; else <V1> = 10;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  <T1><V2> = <R1>;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by client - 150
// Object.Variable.Private.By Client
// Object.Variable.Private.The variable is private in the class and cannot be accessed
// Old: Client code does not have access to private data member of the object

# 150
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signed#><F2>(){return <V1> / 2;}
   <T0><F1>(<T1><V2>){<V1>=<V2> * 10;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V2> =  <R1#0<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // All functions public
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by dynamic member function - 200
// Object.Variable.Public.By Object Function

# 200
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signed#><F2>(){return <V1>;}
   <T0><F1>(<T1><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = 1;}}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  << <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by dynamic member function - 225
// Object.Variable.Protected.By Object Function

# 225
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T1#signed#><F2>(){return <V1>;}
   <T0><F1>(){<V1> = <R1#0<=R1<=9;#>; << <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (B) data member by dynamic member function - 250
// Object.Variable.Private.By Object Function

# 250
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signed#><F2>(){return <V1>;}
   <T0><F1>(){<V1> = <R1#0<=R1<=9;#>; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V1> = <R2#10<=R2<=19;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
  << <V1>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) data member by static member function - 300
// // Accessing protected (D) data member by static member function 
// // Accessing private (D) data member by static member function  

// Object.Variable.Public.By Class Function
// Object.Variable.Protected.By Class Function
// Object.Variable.Private.By Class Function

// Object.Variable.Public.Class (static) function does not have access to public data member of the object
// Object.Variable.Protected.Class (static) function does not have access to protected data member of the object
// Object.Variable.Private.Class (static) function does not have access to private data member of the object

# 300
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(<T1#signed#><V2>){<V1> = <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <O1>.<F1.0.0>();
  <C1>.<F1>(<R1#0<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

# 301
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(){<T1#signed#><V2>;>> <V1>;>> <V2>;<< <V2> - 10;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#0<=R1<=8;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

# 302
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(<T1#signed#><V3>){<T1><V2>;<V2> = <V3>;<V1> = <R1#0<=R1<=9;#>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>(<R2#R2 = R1 * 10;#>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing dynamic data member with respect to the class - 325

# 325
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
//    <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
   <T0><F1.0.0>(){<T1><V2> = <R1#1<=R1<=9;#>;<< <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<V1> = 0;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function by client - 400
// Object.Function.Protected.By Client
// Object.Function.Protected.The function is protected in the class and cannot be called
// Old: Client code does not have access to protected member function of the object

# 400
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T1#signed#><F2>(){<T1><V2> = <R2#10<=R2<=19;#>; return <V2>;}
protected: 
   <T0><F1>(){<T1><V1> = <R1#0<=R1<=9;#>; << <V1>;}
private:
}
<T0><F0>(){
  <T1><V1> = <R3#20<=R3<=29;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by client - 425
// Object.Function.Private.By Client
// Object.Function.Private.The function is private in the class and cannot be called
// Old: Client code does not have access to private member function of the object

# 425
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
protected: 
   <T0><F1>(){<T1#signed#><V1> = <R1#0<=R1<=9;#>; << <V1>;}
private:
   <T1><F2>(){<T1><V2> = <R2#10<=R2<=19;#>; return <V2>;}
}
<T0><F0>(){
  <T1><V2> = <R3#20<=R3<=29;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

// =================================================================================

// // All public member functions
// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) wrt object - 500
// Object.Constructor.By Client

# 500
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2#R2 = R1 * 10;#>;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor with one or more parameters - 525
// Object.Initialization.Basic object

# 525
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;<< <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 526
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){<< <V2>;<V1> = <V2> * 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3> = 0;  
  >> <V3>;
  <C1><O1> = <F1.0.0>( <V3> );
}}
>
Input: "<R1#1<=R1<=9;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor with incorrect number of parameters - 550
// Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// 0-1, 1-2, 2-1

# 550
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 551
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){if( <V2> % 2 == 0 ){<V1> = <V2> * 10;} else {<V1> = <V2> + 10;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>;   >> <V3>;
  <T1><V4>;   >> <V4>;  
  <C1><O1> = <F1.0.0>( <V3>, <V4> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 552
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>, <T1><V3>){if( <V2> < <V3> ){<V1> = <V2>;} else {<V1> = <V3>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>( <V4> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor with incorrect data types for parameters - 575
// Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

# 575
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){<V1> = <V2> * 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#float#><V3> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>( <V3> );
}}
>
Type: debug_output
Hardness: 10 

# 576
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>, <T1><V3>){if( <V2> < <V3> ){<V1> = <V2> * 2;} else {<V1> = <V2> / 2;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=9;#>;
  <T2#float#><V5> = <R2#float;1<=R2<=9;#>;
  <C1><O1> = <F1.0.0>( <V4>, <V5> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) wrt object - 600
// Object.Selector.By Client

# 600
OOP.Object.Selector.By Client
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2>;
  <V2> = <O1>.<F1.1.0>();
  <V2> = <V2> * 10;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Value returned by the selector is ignored by the caller - 625
// Object.Selector.Value returned by the function is ignored by the caller

# 625
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 626
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#float#><F1.1.0>(){<V1> = <R1#float;1<=R1<=9;#>;if( <V1> < 5.0 ){ << <V1>;} else { << <V1> - 5.0;} return <V1> * 2;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Selector is called before data member is initialized - 650
// Object.Selector.Referencing variable before initializing its value
// Java compiler initializes value to zero anyway - do not use for Java

# 650
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) wrt object - 700
// Object.Mutator.By Client

# 700
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>){<V1> = <V3>; <V1> = <V1> * 10; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Value returned by the mutator is ignored by the caller - 725
// Object.Mutator.Value returned by the function is ignored by the caller

# 725
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#signed#><V3>){if(<V3> >= 0){<V1> = <V3>; << <V1>; return true;} else {<V1> = <V3> * -1; << <V1>;return false;}}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#-9<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Mutator is called with incorrect number of parameters - 750
// Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// 1-0, 2-1, 1-2

# 750
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>){<V1> = <V3>; <V1> = <V1> * 10; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>();
}}
>
Type: debug_output
Hardness: 10 

# 751
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>){if( <V3> > 0 ) {<V1> = <V3>;} else {<V1> = <V3> * -1;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 752
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>, <T1><V4>){if( <V3> > <V4> ) {<V1> = <V3> - <V4>;} else {<V1> = <V4> - <V3>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Mutator is called with incorrect data type for parameters - 775
// Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

# 775
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>){<V1> = <V3> * <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#float#> <V2> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 776
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V3>, <T1><V4>){if( <V3> > <V4> ) {<V1> = <V3> - <V4>;} else {<V1> = <V4> - <V3>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#float#><V5> = <R2#float;1<=R2<=9;#>;
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V5>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) wrt object - 800
// Object.Destructor.By Client

# 800
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F1.0.1>(){<< <R1#1<=R1<=9;#>;<< <R3#R3 = R1 * 2;#>;}
protected: 
private:
   <T1#signed#><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2#R2 = R1 * 10;#>;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Assigning an object to class instead of another object - 900
// Object.Assignment.Aggregate.Assigning to class
// Object.Assignment.Aggregate.Object cannot be assigned to a class

# 900
OOP.Object.Assignment.Aggregate.Object cannot be assigned to a class
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1> = <F1.0.0>();
  << <R2#R2 = R1 * 10;#>;
}}
>
Type: debug_output
Hardness: 10 

# 901
OOP.Object.Assignment.Aggregate.Object cannot be assigned to a class
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<V1> = <V1> * 10;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1> = <F1.0.0>();
  <T1><V2>;   >> <V2>;
  <V2> = <V2> * <V2>;
  << <V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Aggregate assignment from one object to another - 925
// Object.Assignment.Aggregate.Assigning object to variable

# 925
OOP.Object.Assignment.Aggregate.Assigning object to variable
?
Object.{Constructor.By Client,Variable.Public.By Object Function,Selector.By Client}
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
   <T1#signed#><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1><O2> = <F1.0.0>();
  <O1> = <O2>;
  << <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Object passed as parameter to a function where it is accessed - 950
// Object.Parameter.Aggregate.Accessed

# 950
OOP.Object.Parameter.Aggregate.Accessed
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  << <O2>.<V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 960
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Constructor.By Client,Selector.By Client,Mutator.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T1#signed#><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(){>> <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  << <O2>.<F1.1.0>();
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>();
  <F1>( <O1> );
  << <O1>.<F1.1.0>();
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 20 

// ---------------------------------------------------------------------------------
// // Object passed as parameter to a function where it is modified - 975
// Object.Parameter.Aggregate.Modified

# 975
OOP.Object.Parameter.Aggregate.Modified
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <O2>.<V1> = <R2#11<=R2<=19;#>;
  << <O2>.<V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 985
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Constructor.By Client,Selector.By Client,Mutator.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T1#signed#><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(){>> <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <O2>.<F1.1.1>();
  << <O2>.<F1.1.0>();
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <F1>( <O1> );
  << <O1>.<F1.1.0>();
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 20 

// =================================================================================
// // STATIC VARIABLE AND FUNCTION IN A CLASS
// ---------------------------------------------------------------------------------
// // Accessing static public (B) data member by client - 1000
// Class.Variable.Public.Wrt Class

# 1000
OOP.Class.Variable.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signed#> <V1>;
   <T0><F1>(){>> <V2>;<< <V2>;}
protected: 
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1>.<V1> = <R3#11<=R3<=19;#>;
  << <C1>.<V1>;
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) data member by client - 1025
// Class.Variable.Public.Wrt Object

# 1025
OOP.Class.Variable.Public.Wrt Object
>
{<C1>{
public:
   <T0><F1>(){>> <V2>;<< <V2>;}
   static <T1#signed#> <V1>;
protected: 
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();   >> <O1>.<V1>;
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) data member by client - 1050
// Class.Variable.Protected.By Client

# 1050
OOP.Class.Variable.Protected.By Client
>
{<C1>{
public:
   <T0><F1>(<T1#signed#><V3>){<V2> = <V3>;<< <V2>;}
protected: 
   static <T1> <V1>;
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<V1> = <R2#5<=R2<=9;#>;
  <O1>.<F1>(<R1#0<=R1<=4;#>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) data member by client - 1075
// Class.Variable.Private.By Client

# 1075
OOP.Class.Variable.Private.By Client
>
{<C1>{
public:
   <T0><F1>(){>> <V2>;<< <V2> + 1;>> <V2>;<< <V2> - 1;}
protected: 
private:
   <T1><V2>;
   static <T1> <V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();   >> <C1>.<V1>;
  <O1>.<F1>();
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) data member by static member function - 1100
// Class.Variable.Public.By Class Function

# 1100
OOP.Class.Variable.Public.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signed#><F1>(){<V1> = <R1#1<=R1<=9;#>;return <V1>;}
   static <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  << <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (B) data member by static member function - 1125
// Class.Variable.Protected.By Class Function

# 1125
OOP.Class.Variable.Protected.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signed#><F1>(){>> <V1>;<< <V1>;>> <V1>;return <V1>;}
protected: 
   static <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (B) data member by static member function - 1150
// Class.Variable.Private.By Class Function

# 1150
OOP.Class.Variable.Private.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T0><F1>(){>> <V1>;<V1> = <V1> * 10;<< <V1>;}
protected: 
private:
   static <T1#signed#><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=9;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (D) data member by dynamic member function - 1200
// Class.Variable.Public.By Object Function

# 1200
OOP.Class.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1>(){<V1> = <R1#1<=R1<=9;#>;<V1> = <V1> * 10;return <V1>;}
   static <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) data member by dynamic member function - 1225
// Class.Variable.Protected.By Object Function

# 1225
OOP.Class.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1>(){>> <V1>;<V1> = <V1> + 10;return <V1>;}
protected: 
   static <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) data member by dynamic member function - 1250
// Class.Variable.Private.By Object Function

# 1250
OOP.Class.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1>(){>> <V1>;<V1> = <V1> + 1;return <V1>;}
protected: 
private:
   static <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
  << <O1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) member function wrt class name by client - 1300
// Class.Function.Public.Wrt Class

# 1300
OOP.Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T0><F1>(){<T1#signed#><V2> = <R1#1<=R1<=9;#>;<V2> = <V2> * 10;<< <V2>;}
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (D) member function wrt object by client - 1325
// Class.Function.Public.Wrt Object

# 1325
OOP.Class.Function.Public.Wrt Object
>
{<C1>{
public:
   static <T0><F1>(<T1#signed#><V3>){<T1><V2> = <V3>;<V2> = <V2> + 10;<< <V2>;}
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>; <V1> = <V1> - 10; << <V1>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) member function by client - 1350
// Class.Function.Protected.By Client

# 1350
OOP.Class.Function.Protected.By Client
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;} 
protected: 
   static <T0><F1>(){<T1#signed#><V2>;>> <V2>;<V2> = <V2> * 10;<< <V2>;>> <V2>;<V2> = <V2> + 10;<< <V2>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) member function by client - 1375
// Class.Function.Private.By Client

# 1375
OOP.Class.Function.Private.By Client
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;} 
protected: 
   <T1#signed#><V1>;
private:
   static <T0><F1>(<T1><V3>){<T1><V2>;>> <V2>;<V2> = <V2> + <V3>;<< <V2>;>> <V2>;<V2> = <V2> - <V3>;<< <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>( <R1#1<=R1<=5;#> );
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // COMPOSITION OF CLASSES
// // Called in Composer function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by composing class - 2000
// Object.Variable.Public.By Composer
// ***Technically synonymous with***  Object.Variable.Public.By Client

# 2000
OOP.Object.Variable.Public.By Composer
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signed#><V1>;
protected: 
   <T1><F1>(){<V1>=<R4#0<=R4<=9;#>;return <V1>;}
private:
}
<C2>{
public:
   <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
   <T0><F2>(){>> <O1>.<V1>;<O1>.<V1>++;<< <O1>.<V1>;} 
   <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Input: "<R1#0<=R1<=8;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member by composing class - 2025
// Object.Variable.Protected.By Composer
// ***Technically synonymous with***  Object.Variable.Protected.By Client

# 2025
OOP.Object.Variable.Protected.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1>(){<V1>=<R1#0<=R1<=9;#>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F2>(){<T1><V2> = <R2#10<=R2<=19;#>;<O1>.<V1>=<V2>;<< <V2>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by composing class - 2050
// Object.Variable.Private.By Composer
// ***Technically synonymous with***  Object.Variable.Private.By Client

# 2050
OOP.Object.Variable.Private.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1>(<T1><V4>){<V1>=<V4>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F2>(<T1><V3>){<O1>.<V1> = <V3>;<< <V3>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>(<V2>);
}}
>
Type: debug_output
Hardness: 10 

// // Called in Composer function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function by composing class - 2100
// Object.Function.Protected.By Composer
// ***Technically synonymous with***  Object.Function.Protected.By Client

# 2100
OOP.Object.Function.Protected.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
protected: 
   <T0><F1>(){>> <V1>;<V1> = <V1> + 10;<< <V1>;}
   <T1#signed#><V1>;
private:
}
<C2>{
public: 
  <T0><F2>(){<T1><V2>;<O1>.<F1>(); >> <V2>; << <V2>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by composing class - 2125
// Object.Function.Private.By Composer
// ***Technically synonymous with***  Object.Function.Private.By Client

# 2125
OOP.Object.Function.Private.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signed#><V4>){<V1> = <V4>;<< <V1>;}
   <T1><V1>;
}
<C2>{
public: 
  <T0><F2>(<T1><V3>){<O1>.<F1>(<V3>); << <V3>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) by composing class constructor - 2200
// Object.Constructor.By Composer

# 2200
OOP.Object.Constructor.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signed#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
private: 
  <C1><O1>;
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O2> = <F2.0.0>();
  << <V3>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Calling constructor with arguments, some of which are used to initialize composed object - 2225
// Object.Initialization.Composed object

# 2225
OOP.Object.Initialization.Composed object
?
OOP.Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public:
   <T0><F2.0.0>(<T1><V4>,<T1><V5>){<O1>=<F1.0.0>(<V4>);<V3> = <V5>;<< <V3>;}
protected: 
private:
   <T1><V3>;
   <C1><O1>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>( <R1#1<=R1<=4;#>, <R2#5<=R2<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 2226
OOP.Object.Initialization.Composed object
?
OOP.Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F2.0.0>(<T1><V4>,<T1><V5>){<V3> = <V5>;<O1>=<F1.0.0>(<V4>);<< <V3>;}
protected: 
   <T1><V3>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <T1><V6>;   >> <V6>;
  <T1><V7>;   >> <V7>;
  <C2><O2> = <F2.0.0>( <V6>, <V7> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by composing class function - 2250
// Object.Selector.By Composer

# 2250
OOP.Object.Selector.By Composer
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>; <V1> = <V1> + 1; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F1>(){<T1><V2> = <O1>.<F1.1.0>();<< <V2>;} 
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by composing class function - 2275
// Object.Mutator.By Composer

# 2275
OOP.Object.Mutator.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>( <T1#signed#><V4> ){<V1> = <V4>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F1>( <T1><V5> ){<O1>.<F1.1.1>( <V5> );<V5> = <V5> + 10;<< <V5>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <T1><V3> = <R1#1<=R1<=9;#>;
  <O2>.<F1>( <V3> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) by composing class destructor - 2300
// Object.Destructor.By Composer

# 2300
OOP.Object.Destructor.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1.0.1>(){<T1#signed#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2.0.1>(){<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  {  <C2><O2> = <F2.0.0>(); 
     <V3> = <V3> - 10; }
  <V3> = <V3> + 1;    
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) data member wrt composing object by client - 2400
// Object.Variable.Public.Wrt Composer

# 2400
OOP.Object.Variable.Public.Wrt Composer
?
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T0><F1.1.1>( <T1#signed#><V3> ){<V1> = <V3> % 2;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T1><F2.2.0>(){<V2> = <R1#1<=R1<=9;#>;<< <V2> / 2;return <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<V1> = <R2#11<=R2<=19;#>;
  << <O2>.<O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 


# 2401
OOP.Object.Variable.Public.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){>> <V1>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T1><F1>(){<V2> = <O1>.<F1.1.0>();<V2> = <V2> * <V2>;<< <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<V1> = <R1#11<=R1<=19;#>;
  << <O2>.<F1>();
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#1<=R3<=5;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt composing object by client - 2425
// Object.Variable.Protected.Wrt Composer

# 2425
OOP.Object.Variable.Protected.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<V1> = <V1> * 2;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
   <T0><F2.2.1>( <T1><V3> ){<V2> = <V3> / 2;<V2> = <V2> * 10;<< <V2>;}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <T1><V4> = <R2#11<=R2<=19;#>;
  <O2>.<O1>.<V1> = <V4>;
  << <V4>;
}}
>
Type: debug_output
Hardness: 10 

# 2426
OOP.Object.Variable.Protected.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){>> <V1>;<V1> = <V1> * 2;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F1>( <T1><V2> ){<< <V2>; << <O1>.<F1.1.0>(); << <V2> + <O1>.<F1.1.0>();}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();    >> <O2>.<V1>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#1<=R3<=5;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt composing object by client - 2450
// Object.Variable.Private.Wrt Composer

# 2450
OOP.Object.Variable.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F1>(){<T1><V2> = <O1>.<F1.1.0>();<V2> = <V2> * 10;<< <V2>;}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <T1><V4>;
  <C2><O2> = <F2.0.0>();    >> <O2>.<O1>.<V1>;   >> <V4>;
  << <V4>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#R3 = R2 * 10;#>\n<R4#R4 = R2 + 10;#>"
>
Type: debug_output
Hardness: 10 

# 2451
OOP.Object.Variable.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){>> <V1>;<V1> = <V1> * 10;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F1>(){<< <O1>.<F1.1.0>();<< <O1>.<F1.1.0>();}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();    >> <O2>.<V1>;
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#R3 = R1 + 1;#>\n<R4#R4 = R2 + 1;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) member function wrt composing object by client - 2500
// Object.Function.Public.Wrt Composer

# 2500
OOP.Object.Function.Public.Wrt Composer
?
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T0><F1>(){<T1#signed#><V1> = <R1#1<=R1<=5;#>; << <V1>; << <V1> + 1;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2>(){<V2> = <R2#6<=R2<=9;#>;<< <V2>;<< <V2> - 1;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

# 2501
OOP.Object.Function.Public.Wrt Composer
>
{<C1>{
public:
  <T0><F1>(){<T1#signed#><V1>; >> <V1>;<< <V1>;<< <V1> * 10;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2>(){<O1>.<F1>();<O1>.<F1>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#1<=R3<=9;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt composing object by client - 2525
// Object.Function.Protected.Wrt Composer

# 2525
OOP.Object.Function.Protected.Wrt Composer
>
{<C1>{
public:
protected: 
   <T1#signed#><F1>(){<T1><V1> = <R1#1<=R1<=9;#>; if( <V1> % 2 == 0 ) << <V1>; else << <V1> - 1;}
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2> = <O1>.<F1>();if( <V2> > 5 ) << <V2> - 1;else << <V2> + 1;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  << <O2>.<O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

# 2526
OOP.Object.Function.Protected.Wrt Composer
>
{<C1>{
public:
protected: 
  <T0><F1>(){ do{ >> <V1>; }while( <V1> % 2 == 0 ); << <V1>;}
private:
  <T1#signed#><V1>;
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2>; do{ >> <V2>; }while( <V2> < 10 ); << <V2>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt composing object by client - 2550
// Object.Function.Private.Wrt Composer
// 

# 2550
OOP.Object.Function.Private.Wrt Composer
>
{<C1>{
public:
   <T1#signed#><V1>;
protected: 
private:
  <T0><F1>( <T1><V2> ){if( <V2> >= 0 ) {<V1> = <V2>;} else <V1> = 0;<< <V1>;}
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>( <T1><V4> ){ <V3> = <V4>; if( <V4> <= 5 ){ <V4> = <V4> * 2;} <V1> = <V4>; << <V3>;}
private: 
  <T1><V3>
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<F1>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 2551
OOP.Object.Function.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><V1>;
protected: 
private:
  <T0><F1>(){do{ >> <V1>;} while( <V1> < 10 ); << <V1>;}
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T1><F2>( <T1><V2> ){<T1><V3>; do{ >> <V3>;} while( <V3> < <V2> );return <V3>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Object is returned by a function, which is then accessed - 2600
// Object.Returned.By Composer  // Calling selector/mutator w.r.t object returned by Composer
// This learning objective is about chaining dot operator more than anything else..

# 2600
OOP.Object.Returned.By Composer
?
OOP.Object.{Constructor.By Client,Selector.By Client,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T1#signed#><F1.1.0>(){ return <V1>; }
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F2.0.0>(){<O1>=<F1.0.0>();<V2> = <R2#5<=R2<=9;#>;}
   <C1><F1>(){ return <O1>; }
protected: 
   <T1><V2>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  << <O2>.<F1>().<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 


# 2601
OOP.Object.Returned.By Composer
?
OOP.Object.{Constructor.By Client,Mutator.By Client,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T0><F1.1.1>(<T1><V3>){<V1> = <V3>; << <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2>{
public:
   <T0><F2.0.0>(){<O1>=<F1.0.0>();<V2> = <R2#5<=R2<=9;#>;}
   <C1><F1>(){ return <O1>; }
protected: 
private:
   <T1><V2>;
   <C1><O1>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F1>().<F1.1.1>( <R3#11<=R3<=14;#> );
}}
>
Type: debug_output
Hardness: 10 



// =================================================================================
// // PUBLIC INHERITANCE
// // ---------------------------------------------------------------------------------
// // Called in inheritor function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by inheriting class - 3000
// Object.Variable.Public.By Inheritor

# 3000
OOP.Object.Variable.Public.By Inheritor
>
{<C1>{
public:
   <T1#signed#><F1>(){<V1>=<R1#0<=R1<=5;#>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<V1>=<R2#6<=R2<=9;#>;<< <V1>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by inheriting class - 3025
// Object.Variable.Protected.By Inheritor

# 3025
OOP.Object.Variable.Protected.By Inheritor
>
{<C1>{
public:
   <T1#signed#><F1>(){<V1>=<R4#0<=R4<=9;#>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){>> <V1>;<V1> = <V1> + 1;<< <V1>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by inheriting class - 3050
// Object.Variable.Private.By Inheritor

# 3050
OOP.Object.Variable.Private.By Inheritor
>
{<C1>{
public:
   <T1#signed#><F1>(){<V1>=<R1#0<=R1<=5;#>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;<V1> = <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) member function by inheriting class - 3100
// Object.Function.Protected.By Inheritor

# 3100
OOP.Object.Function.Protected.By Inheritor
>
{<C1>{
public:
protected: 
   <T0><F1>(){<T1#signed#><V1>;>> <V1>;<< <V1>;}
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V3>){<< <V3>;<F1>();}
protected: 
private: 
}
<T0><F0>(){
  <T1><V2> = <R4#1<=R4<=9;#>;
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>( <V2> );}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by inheriting class - 3125
// Object.Function.Private.By Inheritor

# 3125
OOP.Object.Function.Private.By Inheritor
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signed#><V1>){<V1> = <V1> * 2;<< <V1>;}
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2> = <R1#0<=R1<=9;#>;<< <V2>;<F1>(<V2>);}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) data member wrt inheriting object by client - 3200
// Object.Variable.Public.Wrt Inheritor

# 3200
OOP.Object.Variable.Public.Wrt Inheritor
>
{<C1>{
public:
   <T1#signed#><F1>(){<T1><V3>;>> <V3>;<< <V3>;return <V3>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<< <V2>;<V2> = <V2> + 1;<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V3> = <R4#11<=R4<=19;#>;
  <C2><O1> = <F2.0.0>();
  <O1>.<V1> = <V3>;
  << <V3>;}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt inheriting object by client - 3225
// Object.Variable.Protected.Wrt Inheritor

# 3225
OOP.Object.Variable.Protected.Wrt Inheritor
>
{<C1>{
public:
   <T1#signed#><F1>(){>> <V1>;<< <V1>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<V1> = <V2>;<V2> = <V2> / 10;<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<V1> = <R1>;
  <O1>.<F2>(<R3>);}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt inheriting object by client - 3250
// Object.Variable.Private.Wrt Inheritor

# 3250
OOP.Object.Variable.Private.Wrt Inheritor
>
{<C1>{
public:
   <T0><F1>(<T1#signed#><V3>){if(<V3> > 0) <V1> = <V3>; else <V1> = 0;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
  <T1><F2>(){<T1><V2>;>> <V2>;return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();   >> <O1>.<V1>;
  << <O1>.<F2>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 + 1;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) member function wrt inheriting object by client - 3300
// Object.Function.Public.Wrt Inheritor

# 3300
OOP.Object.Function.Public.Wrt Inheritor
>
{<C1>{
public:
   <T0><F1>(){<T1#signed#><V1> = <R3>; << <V1>;}
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T1><F2>(){<T1><V2>;>> <V2>;return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V3> = <R2>;
  <C2><O1> = <F2.0.0>();
  <O1>.<F1>();
  << <V3>;}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 * 2;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt inheriting object by client - 3325
// Object.Function.Protected.Wrt Inheritor

# 3325
OOP.Object.Function.Protected.Wrt Inheritor
>
{<C1>{
public:
protected: 
   <T1#signed#><F1>(){<T1><V1>;>> <V1>; return <V1>;}
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2>;<V2> = <F1>() + <F1>();<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  << <O1>.<F1>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 * 2;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt inheriting object by client - 3350
// Object.Function.Private.Wrt Inheritor

# 3350
OOP.Object.Function.Private.Wrt Inheritor
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signed#><V1>){<< <V1> - 1; << <V1>; << <V1> + 1;}
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<< <V2> / 2; << <V2> % 2;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F1>( <R1#1<=R1<=8;#> );
  <O1>.<F2>( <R1> );}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) when inheriting class's constructor calls it - 3400
// Object.Constructor.Inheritor.Coopted

# 3400
OOP.Object.Constructor.Inheritor.Coopted
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V3> = <R3#11<=R3<=19;#>;
  << <V3>;
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) when inheriting class's constructor does not call it - 3425
// Object.Constructor.Inheritor.Not Coopted

# 3425
OOP.Object.Constructor.Inheritor.Not Coopted
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;<< <V1> - 1;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<V2> = <R2#1<=R2<=5;#>;<< <V2>;<< <V2> + 1;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O1> = <F2.0.0>();
  << <V3>;
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Constructor is called with arguments, some of which are passed to base class - 3450
// Object.Initialization.Inherited object

# 3450
OOP.Object.Initialization.Inherited object
?
OOP.Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V4>){<V1> = <V4>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(<T1><V5>, <T1><V6>){<F1.0.0>(<V5>);<V2> = <V6>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R1#1<=R1<=4;#>;
  <T1><V7> = <R2#5<=R2<=9;#>;
  <C2><O1> = <F2.0.0>( <V3>, <V7> );
}
>
Type: debug_output
Hardness: 10 

# 3451
OOP.Object.Initialization.Inherited object
?
OOP.Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signed#><V4>){<V1> = <V4>;<V4> = <V4> + 1;<< <V4>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(<T1><V5>, <T1><V6>){<F1.0.0>(<V5>);<V2> = <V6>;<V6> = <V6> - 1;<< <V6>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <T1><V3>;   >> <V3>;
  <T1><V7>;   >> <V7>;
  <C2><O1> = <F2.0.0>( <V3>, <V7> );
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // In each problem, call the overridden function wrt BOTH base and derived class object
// // Execution of selectors (B) by inheriting class 
// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3500
// Object.Selector.Inheritor.Overridden.Coopted.Polymorphic

# 3500
OOP.Object.Selector.Inheritor.Overridden.Coopted.Polymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<T1><V2> = <C*>.<F1.1.0>();<V2> = <V2> * 10;<< <V2>;return <V2>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <O1>.<F1.1.0>();
  << <V3>;
  <C1><O2> = <F2.0.0>();
  <V3> = <O2>.<F1.1.0>();
  << <V3>;
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3525
// Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic

# 3525
OOP.Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic
?
OOP.Object.{Variable.Public.{By Inheritor,By Object Function},Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<V1> = <R2#6<=R2<=9;#>;<< <V1>;return <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <F2.0.0>();
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which does not override - 3550
// Object.Selector.Inheritor.Not Overridden

# 3550
OOP.Object.Selector.Inheritor.Not Overridden
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   virtual <T1#signed#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1>(<T1><V3>){<V1> = <V3> + <R2#6<=R2<=9;#>;<< <V1>;return <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <F1.0.0>();
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3575
// Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic

# 3575
OOP.Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T1#signed#><F1.1.0>(){>> <V1>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<T1><V2> = <C*>.<F1.1.0>();>> <V3>;<< <V3>;  return <V3> - <V2>;}
   <T1><V3>;
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <F1.0.0>();
  << <O2>.<F1.1.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3600
// Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic

# 3600
OOP.Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T1#signed#><F1.1.0>(){>> <V1>; if( <V1> < <R2> ){ <V1> = <V1> + 1; } << <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){>> <V2>; if( <V2> > <R1> ){ <V2> = <V2> - 1; } << <V2>;return <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <F1.0.0>();
  << <O2>.<F1.1.0>();
}
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // In each problem, call the overridden function wrt both base and derived class object
// // Execution of mutators (B) by inheriting class 
// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3700
// Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic

# 3700
OOP.Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<C*>.<F1.1.1>(<V3>);<V3> = <V3> * 10; << <V3>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <F2.0.0>();
  <O2>.<F1.1.1>( <R2#6<=R2<=9;#> );
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3725
// Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic

# 3725
OOP.Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic
?
OOP.Object.{Variable.Public.{By Object Function,By Inheritor},Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signed#><V2>){<V1> = <V2> + 1;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<V1> = <V3> - 1; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <F1.0.0>();
  <O2>.<F1.1.1>( <R2#6<=R2<=9;#> );
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which does not override - 3750
// Object.Mutator.Inheritor.Not Overridden

# 3750
OOP.Object.Mutator.Inheritor.Not Overridden
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signed#><V2>){<V1> = <V2> + 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1>(<T1><V3>,<T1><V4>){<V1> = <V3> + <V4>; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V4> = <R1#1<=R1<=5;#>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F1.0.0>();
  <V4> = <R2#6<=R2<=9;#>;
  <O2>.<F1.1.1>( <V4> );
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3775
// Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic

# 3775
OOP.Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V2>){<V2> = <V2> * 10;<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<V3> = <V3> + 10;<C*>.<F1.1.1>(<V3>);<< <V3>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V4>;
  <C1><O1> = <F1.0.0>();   >> <V4>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F2.0.0>();   >> <V4>;
  <O2>.<F1.1.1>( <V4> );
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3800
// Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic

# 3800
OOP.Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signed#><V2>){<V1> = <V2> + 1;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<< <V3>; <V1> = <V3> - 1; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <T1><V4>;   >> <V4>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F2.0.0>();
  <O2>.<F1.1.1>( <V4> );
}
>
Input: "<R1#1<=R1<=8;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 


// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) when inheriting class's destructor calls it - 3850
// Object.Destructor.By Inheritor

# 3850
OOP.Object.Destructor.By Inheritor
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.1>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.1>(){<F1.0.1>();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V3> = <R3#11<=R3<=19;#>;
  << <V3>;
}
>
Type: debug_output
Hardness: 10 
// ---------------------------------------------------------------------------------
// // Assigning base class object to derived class variable - 3900
// Object.Assignment.Aggregate.Assigning base object to derived variable

# 3900
OOP.Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C2><O1> = <F1.0.0>();
}
>
Type: debug_output
Hardness: 10 

# 3901
OOP.Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C2><O1> = <F1.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Assigning derived class object to base class variable - 3925
// Object.Assignment.Aggregate.Assigning derived object to base variable

# 3925
OOP.Object.Assignment.Aggregate.Assigning derived object to base variable
?
OOP.Object.{Variable.Protected.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
}
>
Type: debug_output
Hardness: 10 

# 3926
OOP.Object.Assignment.Aggregate.Assigning derived object to base variable
?
OOP.Object.{Variable.Private.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Assigning object of one derived class to variable of another derived class - 3950
// Object.Assignment.Aggregate.Assigning derived object to different derived variable


# 3950
OOP.Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F3.0.0>(){<F1.0.0>();<V3> = R3#11<=R3<=14;#>;<< <V3>;}
   <T1><V3>;
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <C3>.<F3.0.0>();
}
>
Type: debug_output
Hardness: 10 

# 3951
OOP.Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F3.0.0>(){<F1.0.0>();>> <V3>;<< <V3>;}
protected: 
private: 
   <T1><V3>;
}
<T0><F0>(){
  <C3><O1> = <F2.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // Called in ancestor function, which is in turn called by client
// // Accessing public (B) data member by ancestral class - 4000
// Object.Variable.Public.By Ancestor

# 4000
OOP.Object.Variable.Public.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1>=<R1#1<=R1<=4;#>;<< <V1>; <V2>=<R2#5<=R2<=9;#>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
protected: 
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by ancestral class - 4025
// Object.Variable.Protected.By Ancestor

# 4025
OOP.Object.Variable.Protected.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; >> <V2>; << <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by ancestral class - 4050
// Object.Variable.Private.By Ancestor

# 4050
OOP.Object.Variable.Private.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V2> = <V1>; << <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2>(){>> <V2>;<T1><V3>; >> <V3>;<< <V3> - <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) member function by ancestral class - 4100
// Object.Function.Public.By Ancestor

# 4100
OOP.Object.Function.Public.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>;<< <V1>; <F2>();}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; << <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) member function by ancestral class - 4125
// Object.Function.Protected.By Ancestor

# 4125
OOP.Object.Function.Protected.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;<V1> = <V1> * 10; <F2.2.1>(<V1>);}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2.2.1>(<T1><V3>){<V2> = <V3>; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by ancestral class - 4150
// Object.Function.Private.By Ancestor

# 4150
OOP.Object.Function.Private.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; << <F2.2.0>(); << <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
protected: 
private: 
   <T1><F2.2.0>(){>> <V2>;<< <V2>;return <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) data member wrt ancestral object by client - 4200
// Object.Variable.Public.Wrt Ancestor

# 4200
OOP.Object.Variable.Public.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1>=<R1#1<=R1<=4;#>;<< <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
   <T1><F2.2.0>(){return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <R2#5<=R2<=9;#>;
  <O1>.<V2> = <V3>;
  << <V3>;}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt ancestral object by client - 4225
// Object.Variable.Protected.Wrt Ancestor

# 4225
OOP.Object.Variable.Protected.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V1> = <V1> + 1; << <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; <V2> = <V2> - 1; << <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();   >> <O1>.<V2>;
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt ancestral object by client - 4250
// Object.Variable.Private.Wrt Ancestor

# 4250
OOP.Object.Variable.Private.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V1> = <V1> * 10; << <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2>(){>> <V2>; <V2> = <V2> * 2; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
  <O1>.<V2> = <R4#16<=R4<=19;#>;}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) member function wrt ancestral object by client - 4300
// Object.Function.Public.Wrt Ancestor

# 4300
OOP.Object.Function.Public.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R4#16<=R4<=19;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; << <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt ancestral object by client - 4325
// Object.Function.Protected.Wrt Ancestor

# 4325
OOP.Object.Function.Protected.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2.2.1>(<T1><V3>){<V2> = <V3>; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V4> = <R2#6<=R2<=9;#>;
  <O1>.<F2.2.1>(<V4>);}
}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt ancestral object by client - 4350
// Object.Function.Private.Wrt Ancestor

# 4350
OOP.Object.Function.Private.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<T1#signed#><V3>; >> <V1>; >> <V3>; if( <V1> < <V3> ){ << <V1>; }else << <V3>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T1><V2>;
private: 
   <T1><F2.2.0>(){>> <V2>;<< <V2>;return <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2.2.0>(); }
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------

// Used solely for testing code 
# 9000
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = 29; << <V1>;}
   <T1#signed#><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(<T1><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = 1;}}
   static <T0><F4>(<T1><V2>){<< <V2>;}
   <T0><F1.0.1>(){<< <V1>;}

   <T1><V1>;
   static <T1><V3>;
protected: 
//   <T1><V4>[5];
private:
   <T1><V5>;
}
<C2>{
public:
   <T1><F3>(){return <V6>;}
   <T0><F2.0.0>(){<V6> = 51; << <V6>;}
   <T1><V6>;
private:
   <C1><O2>;
}
<C3>{
public:
   <C1><O4>;
   <T0><F3.0.0>(){<T1><V6> = 51; << <V6>;}
}
<T0><F0>(){
  <C1><O1> = <O1>.<F1.0.0>();
  <T1><V7>=13;   >> <V7>;
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  << <O1>.<F1.1.0>();
  <C2><O3> = <O3>.<F2.0.0>();
// Following statement leads to stack overflow - why?
//  >> <O3>.<O2>.<V1>;  
  <O3>.<V6> = <R2#0<=R2<=9;#>;
  << <O3>.<F3>();
  <C3><O5> = <O5>.<F3.0.0>();
}}
>
Input: "<R3#0<=R3<=8;#>\n<R4#R4 = R3 + 10;#>\n<R5#R5 = R3 * 10;#>"
>
Type: debug_output
Hardness: 10