// Master template
// 
// 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 public (D) data member by static member function - 300
// // Object.Variable.Public.By Class Function
// Object.Variable.Public.Class (static) function does not have access to public data member of the object
// // Accessing protected (D) data member by static member function - 325
// // Object.Variable.Protected.By Class Function
// // Accessing private (D) data member by static member function - 350
// // Object.Variable.Private.By Class Function
// Object.Variable.Private.Class (static) function does not have access to private data member of the object
// 
// // 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


// ---------------------------------------------------------------------------------
// 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
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> = <C1>.<F+>();
  <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.Client code does not have access to protected data member of the object

# 125
Object.Variable.Protected.Client code does not have access to protected data member of the object
>
{<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> = <C1>.<F+>();
  <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.Client code does not have access to private data member of the object

# 150
Object.Variable.Private.Client code does not have access to private data member of the object
>
{<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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

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

# 250
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> = <C1>.<F+>();
  <O1>.<F1>();
  << <V1>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) data member by static member function - 300
// Object.Variable.Public.By Class Function
// Object.Variable.Public.Class (static) function does not have access to public data member of the object

# 300
Object.Variable.Public.Class (static) function does not have access to public data member of the object
>
{<C1>{
public:
   static <T0><F1>(<T1#signed#><V2>){<V1> = <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <C1>.<F1>(<R1#0<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member by static member function - 325
// Object.Variable.Protected.By Class Function
// Object.Variable.Protected.Class (static) function does not have access to protected data member of the object

# 325
Object.Variable.Protected.Class (static) function does not have access to protected data member of the object
>
{<C1>{
public:
   static <T0><F1>(){<T1#signed#><V2>;>> <V1>;>> <V2>;<< <V2> - 10;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <C1>.<F1>();
}}
>
Input: "<R1#0<=R1<=8;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by static member function - 350
// Object.Variable.Private.By Class Function
// Object.Variable.Private.Class (static) function does not have access to private data member of the object

# 350
Object.Variable.Private.Class (static) function does not have access to private data member of the object
>
{<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> = <C1>.<F+>();
  <C1>.<F1>(<R2#R2 = R1 * 10;#>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // 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

# 400
Object.Function.Protected.Client code does not have access to protected member function of the object
>
{<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> = <C1>.<F+>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // 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

# 425
Object.Function.Private.Client code does not have access to private member function of the object
>
{<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> = <C1>.<F+>();
  <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

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

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

# 500
Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <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
Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;<< <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 526
Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V2>){<< <V2>;<V1> = <V2> * 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>;
  >> <V3>;
  <C1><O1> = <C1>.<F+>( <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
Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R2#11<=R2<=19;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 551
Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F+>(<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> = <C1>.<F+>( <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
Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F+>(<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> = <C1>.<F+>( <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
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><F+>(<T1#signed#><V2>){<V1> = <V2> * 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#float#><V3> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <C1>.<F+>( <V3> );
}}
>
Type: debug_output
Hardness: 10 

# 576
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><F+>(<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> = <C1>.<F+>( <V4>, <V5> );
}}
>
Type: debug_output
Hardness: 10 

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

# 600
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 626
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> = <C1>.<F+>();
  <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

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

# 651
Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#float#><F1.1.0>(){<T1><V2> = <R1#float;1<=R1<=9;#>;<< <V2>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <T1><V3>;
  <V3> = <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

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

# 700
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<F1.1.1>();
}}
>
Type: debug_output
Hardness: 10 

# 751
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> = <C1>.<F+>();
  <O1>.<F1.1.1>( <V2>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 752
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 776
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> = <C1>.<F+>();
  <O1>.<F1.1.1>( <V5>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

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

# 800
Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F->(){<< <R1#1<=R1<=9;#>;<< <R3#R3 = R1 * 2;#>;}
protected: 
private:
   <T1#signed#><V1>;
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <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
Object.Assignment.Aggregate.Object cannot be assigned to a class
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1> = <C1>.<F+>();
  << <R2#R2 = R1 * 10;#>;
}}
>
Type: debug_output
Hardness: 10 

# 901
Object.Assignment.Aggregate.Assigning to class
>
{<C1>{
public:
   <T0><F+>(){>> <V1>;<V1> = <V1> * 10;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1> = <C1>.<F+>();
  <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
Object.Assignment.Aggregate.Assigning object to variable
?
Object.{Constructor.By Client,Variable.Public.By Object Function,Selector.By Client}
>
{<C1>{
public:
   <T0><F+>(){>> <V1>;<< <V1>;}
   <T1#signed#><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <C1><O2> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 960
Object.Parameter.Aggregate.Accessed
?
Object.{Constructor.By Client,Selector.By Client,Mutator.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F+>(){<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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 985
Object.Parameter.Aggregate.Modified
?
Object.{Constructor.By Client,Selector.By Client,Mutator.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F+>(){<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> = <C1>.<F+>();
  <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
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
Class.Variable.Public.Wrt Object
>
{<C1>{
public:
   <T0><F1>(){>> <V2>;<< <V2>;}
   static <T1#signed#> <V1>;
protected: 
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  >> <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
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
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> = <C1>.<F+>();
  << <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  << <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
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> = <C1>.<F+>();
  << <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
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> = <C1>.<F+>();
  << <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
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T0><F1>(){<T1#signed#><V2> = <R1#1<=R1<=9;#>;<V2> = <V2> * 10;<< <V2>;}
   <T0><F+>(){<V1> = <R2#11<=R2<=19;#>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

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

# 1325
Class.Function.Public.Wrt Object
>
{<C1>{
public:
   static <T0><F1>(<T1#signed#><V3>){<T1><V2> = <V3>;<V2> = <V2> + 10;<< <V2>;}
   <T0><F+>(){<V1> = <R2#11<=R2<=19;#>; <V1> = <V1> - 10; << <V1>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <C1>.<F+>();
  <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
Class.Function.Protected.By Client
>
{<C1>{
public:
   <T0><F+>(){<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> = <C1>.<F+>();
  <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
Class.Function.Private.By Client
>
{<C1>{
public:
   <T0><F+>(){<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> = <C1>.<F+>();
  <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
Object.Variable.Public.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();} 
   <T0><F2>(){>> <O1>.<V1>;<O1>.<V1>++;<< <O1>.<V1>;} 
   <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>();
  <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
Object.Variable.Protected.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>();
  <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
Object.Variable.Private.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <C2>.<F+>();
  <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
Object.Function.Protected.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>();
  <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
Object.Function.Private.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <C2>.<F+>();
  <O2>.<F2>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

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

# 2200
Object.Constructor.By Composer
?
Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F+>(){<T1#signed#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
private: 
  <C1><O1>;
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O2> = <C2>.<F+>();
  << <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
Object.Initialization.Composed object
?
Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public:
   <T0><F+>(<T1><V4>,<T1><V5>){<O1>=<C1>.<F+>(<V4>);<V3> = <V5>;<< <V3>;}
protected: 
private:
   <T1><V3>;
   <C1><O1>;
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>( <R1#1<=R1<=4;#>, <R2#5<=R2<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 2226
Object.Initialization.Composed object
?
Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F+>(<T1><V4>,<T1><V5>){<V3> = <V5>;<O1>=<C1>.<F+>(<V4>);<< <V3>;}
protected: 
   <T1><V3>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <T1><V6>;
  >> <V6>;
  <T1><V7>;
  >> <V7>;
  <C2><O2> = <C2>.<F+>( <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
Object.Selector.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();}
  <T0><F1>(){<T1><V2> = <O1>.<F1.1.0>();<< <V2>;} 
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <O2>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

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

# 2275
Object.Mutator.By Composer
?
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><F+>(){<O1> = <C1>.<F+>();}
  <T0><F1>( <T1><V5> ){<O1>.<F1.1.1>( <V5> );<V5> = <V5> + 10;<< <V5>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <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
Object.Destructor.By Composer
?
Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F->(){<T1#signed#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();}
  <T0><F->(){<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  {  <C2><O2> = <C2>.<F+>(); 
     <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
Object.Variable.Public.Wrt Composer
?
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><F+>(){<O1> = <C1>.<F+>();}
  <T1><F2.2.0>(){<V2> = <R1#1<=R1<=9;#>;<< <V2> / 2;return <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <O2>.<O1>.<V1> = <R2#11<=R2<=19;#>;
  << <O2>.<O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 


# 2401
Object.Variable.Public.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><F1.1.0>(){>> <V1>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();}
  <T1><F1>(){<V2> = <O1>.<F1.1.0>();<V2> = <V2> * <V2>;<< <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <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
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><F+>(){<O1> = <C1>.<F+>();}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <T1><V4> = <R2#11<=R2<=19;#>;
  <O2>.<O1>.<V1> = <V4>;
  << <V4>;
}}
>
Type: debug_output
Hardness: 10 

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

# 2501
Object.Function.Public.Wrt Composer
>
{<C1>{
public:
  <T0><F1>(){<T1#signed#><V1>; >> <V1>;<< <V1>;<< <V1> * 10;}
protected: 
private:
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();}
  <T0><F2>(){<O1>.<F1>();<O1>.<F1>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <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
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><F+>(){<O1> = <C1>.<F+>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2> = <O1>.<F1>();if( <V2> > 5 ) << <V2> - 1;else << <V2> + 1;}
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  << <O2>.<O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

# 2526
Object.Function.Protected.Wrt Composer
>
{<C1>{
public:
protected: 
  <T0><F1>(){ do{ >> <V1>; }while( <V1> % 2 == 0 ); << <V1>;}
private:
  <T1#signed#><V1>;
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2>; do{ >> <V2>; }while( <V2> < 10 ); << <V2>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <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
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><F+>(){<O1> = <C1>.<F+>();}
  <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> = <C2>.<F+>(); 
  <O2>.<O1>.<F1>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 2551
Object.Function.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signed#><V1>;
protected: 
private:
  <T0><F1>(){do{ >> <V1>;} while( <V1> < 10 ); << <V1>;}
}
<C2>{
public: 
  <T0><F+>(){<O1> = <C1>.<F+>();}
  <C1><O1>;
protected:
  <T1><F2>( <T1><V2> ){<T1><V3>; do{ >> <V3>;} while( <V3> < <V2> );return <V3>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>(); 
  <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
Object.Returned.By Composer
?
Object.{Constructor.By Client,Selector.By Client,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=4;#>;}
   <T1#signed#><F1.1.0>(){ return <V1>; }
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F+>(){<O1>=<C1>.<F+>();<V2> = <R2#5<=R2<=9;#>;}
   <C1><F1>(){ return <O1>; }
protected: 
   <T1><V2>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <C2><O2> = <C2>.<F+>();
  << <O2>.<F1>().<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 


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

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

# 3025
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> = <C2>.<F+>();
  <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
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> = <C2>.<F+>();
  <O1>.<F2>();}
}
>
Type: debug_output
Hardness: 10 

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

# 3100
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> = <C2>.<F+>();
  <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
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> = <C2>.<F+>();
  <O1>.<F2>();}
}
>
Type: debug_output
Hardness: 10 

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

# 3200
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> = <C2>.<F+>();
  <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
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> = <C2>.<F+>();
  <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
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> = <C2>.<F+>();
  >> <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
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> = <C2>.<F+>();
  <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
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> = <C2>.<F+>();
  << <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
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> = <C2>.<F+>();
  <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
Object.Constructor.Inheritor.Coopted
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C1>.<F+>();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <C2>.<F+>();
  <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
Object.Constructor.Inheritor.Not Coopted
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;<< <V1> - 1;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<V2> = <R2#1<=R2<=5;#>;<< <V2>;<< <V2> + 1;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O1> = <C2>.<F+>();
  << <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
Object.Initialization.Inherited object
?
Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V4>){<V1> = <V4>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(<T1><V5>, <T1><V6>){<C1>.<F+>(<V5>);<V2> = <V6>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R1#1<=R1<=4;#>;
  <T1><V7> = <R2#5<=R2<=9;#>;
  <C2><O1> = <C2>.<F+>( <V3>, <V7> );
}
>
Type: debug_output
Hardness: 10 

# 3451
Object.Initialization.Inherited object
?
Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F+>(<T1#signed#><V4>){<V1> = <V4>;<V4> = <V4> + 1;<< <V4>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F+>(<T1><V5>, <T1><V6>){<C1>.<F+>(<V5>);<V2> = <V6>;<V6> = <V6> - 1;<< <V6>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <T1><V3>;
  >> <V3>;
  <T1><V7>;
  >> <V7>;
  <C2><O1> = <C2>.<F+>( <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
Object.Selector.Inheritor.Overridden.Coopted.Polymorphic
?
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> = <C1>.<F+>();
  <T1><V3> = <O1>.<F1.1.0>();
  << <V3>;
  <C1><O2> = <C2>.<F+>();
  <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
Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic
?
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> = <C1>.<F+>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <C2>.<F+>();
  <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
Object.Selector.Inheritor.Not Overridden
?
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> = <C2>.<F+>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <C1>.<F+>();
  <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
Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic
?
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> = <C2>.<F+>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <C1>.<F+>();
  << <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
Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
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> = <C2>.<F+>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <C1>.<F+>();
  << <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
Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic
?
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> = <C1>.<F+>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <C2>.<F+>();
  <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
Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic
?
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> = <C2>.<F+>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <C1>.<F+>();
  <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
Object.Mutator.Inheritor.Not Overridden
?
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> = <C2>.<F+>();
  <T1><V4> = <R1#1<=R1<=5;#>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <C1>.<F+>();
  <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
Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic
?
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> = <C1>.<F+>();
  >> <V4>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <C2>.<F+>();
  >> <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
Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
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> = <C1>.<F+>();
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <C2>.<F+>();
  <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
Object.Destructor.By Inheritor
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F->(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F->(){<C1>.<F->();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <C2>.<F+>();
  <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
Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C2><O1> = <C1>.<F+>();
}
>
Type: debug_output
Hardness: 10 

# 3901
Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F+>(){>> <V1>;<< <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C2><O1> = <C1>.<F+>();
}
>
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
Object.Assignment.Aggregate.Assigning derived object to base variable
?
Object.{Variable.Protected.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
   <T1#signed#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <C2>.<F+>();
}
>
Type: debug_output
Hardness: 10 

# 3926
Object.Assignment.Aggregate.Assigning derived object to base variable
?
Object.{Variable.Private.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F+>(){>> <V1>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();>> <V2>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <C2>.<F+>();
}
>
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
Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F+>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signed#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();<V3> = R3#11<=R3<=14;#>;<< <V3>;}
   <T1><V3>;
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <C3>.<F+>();
}
>
Type: debug_output
Hardness: 10 

# 3951
Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F+>(){>> <V1>;<< <V1>;}
   <T1#signed#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F+>(){<C*>.<F+>();>> <V3>;<< <V3>;}
protected: 
private: 
   <T1><V3>;
}
<T0><F0>(){
  <C3><O1> = <C2>.<F+>();
}
>
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
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> = <C1>.<F+>();
  <O1>.<F1>();}
}
>
Type: debug_output
Hardness: 10 

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

# 4025
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <O1>.<F1>();}
}
>
Type: debug_output
Hardness: 10 

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

# 4150
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  >> <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  <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
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> = <C1>.<F+>();
  << <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 

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