View difference between Paste ID: N8DKbc9j and Kba8Fn13

 #include <cstdlib>
 #include <iostream>
 
-#include "gtest/gtest.h"
+
-#include "gmock/gmock.h"
+
 using namespace std;
 
 enum State
 {
 	Off,
 	Stopped,
 	Walking,
 	Running,
 	Error
 };
 
 /** The interface of the different states */
 
 class state_interface					/* Abstract Class */
 {
 	public:
 	virtual State turnOn () = 0;
 	virtual State turnOff () = 0;
 	virtual State speedUp () = 0;
 	virtual State speedDown () = 0;
 };
 
 /** The different states */
 class off_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Off --[turnOn]--> Stopped \n";
 		return Stopped;
 	};
 	State turnOff () {
 		cout << "Off --[turnOff]--> Off \n";
 		return Off;
 	};
 	State speedUp () {
 		cout << "Off --[speedUp]--> Error \n";
 		return Error;
 	};
 	State speedDown () {
 		cout << "Off --[speedDown]--> Error \n";
 		return Error;
 	};
 };
 
 class stopped_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Stopped --[turnOn]--> Error \n";
 		return Stopped;
 	};
 	State turnOff () {
 		cout << "Stopped --[turnOff]--> Off \n";
 		return Off;
 	};
 	State speedUp () {
 		cout << "Stopped --[speedUp]--> Walking \n";
 		return Walking;
 	};
 	State speedDown () {
 		cout << "Stopped --[speedDown]--> Error \n";
 		return Error;
 	};
 };
 
 class walking_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Walking --[turnOn]--> Walking \n";
 		return Walking;
 	};
 	State turnOff () {
 		cout << "Walking --[turnOff]--> Off \n";
 		return Off;
 	};
 	State speedUp () {
 		cout << "Walking --[speedUp]--> Running \n";
 		return Running;
 	};
 	State speedDown () {
 		cout << "Walking --[speedDown]--> Stopped \n";
 		return Stopped;
 	};
 };
 
 class running_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Running --[turnOn]--> Running \n";
 		return Running;
 	};
 	State turnOff () {
 		cout << "Running --[turnOff]--> Off \n";
 		return Off;
 	};
 	State speedUp () {
 		cout << "Running --[speedUp]--> Error \n";
 		return Error;
 	};
 	State speedDown () {
 		cout << "Running --[speedDown]--> Walking \n";
 		return Walking;
 	};
 };
 
 class error_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Error --[turnOn]--> Error \n";
 		return Error;
 	};
 	State turnOff () {
 		cout << "Error --[turnOff]--> Off \n";
 		return Off;
 	};
 	State speedUp () {
 		cout << "Error --[speedUp]--> Error \n";
 		return Error;
 	};
 	State speedDown () {
 		cout << "Error --[speedDown]--> Error \n";
 		return Error;
 	};
 };
 
 
 class FSM						/* Singleton */
 {
 	private:
 	state_interface * current;
 	state_interface * states [STATE_AMOUNT];
 	public:
 	FSM()
 	{
 		states[Off] = new (off_State);
 		states[Stopped] = new (stopped_State);
 		states[Walking] = new (walking_State);
 		states[Running] = new (running_State);
 		states[Error] = new (error_State);
 		current = states[Off];
 	};
 
 	void live ()
 	{
 		int input = 0;
-	void cleanUp ()
+
 		while (input != 4)
-		int i;
+
 			cout << "Input stimulus: 0_On, 1_Off, 2_SpUp, 3_SpDn, 4_Exit \n";
-		for (i=0; i<STATE_AMOUNT; i++)
+
 
-			delete (states[i]);
+
-			states[i] = 0;
+
 				State new_state;
-		current = 0;
+
 					new_state = current -> turnOn();
 					current = states[new_state];
 					break;
 				case(1):
 					new_state = current -> turnOff();
 					current = states[new_state];
 					break;
 				case(2):
 					new_state = current -> speedUp();
 					current = states[new_state];
 					break;
 				case(3):
 					new_state = current -> speedDown();
 					current = states[new_state];
 					break;
 				default:
 					break;
 			}
 
 		}
 	};
         ~FSM(){
                 int i;
 
                 for (i=0; i<STATE_AMOUNT; i++) {
                         delete (states[i]);
                         states[i] = 0;
                 }
                 current = 0;
         };
-				case(4):
+
-					cleanUp ();
+
 
 int main (void)
 {
 	FSM the_machine;
 
 	the_machine.live();
 
 	return 0;
 }