myvtm/module/mod_sample/mod_SampleEntity.h

#ifndef __MOD_SAMPLEENTITY_H__
#define __MOD_SAMPLEENTITY_H__

#pragma once

// This code is generated by spgenex tool!

#include "SampleEntity_server_g.h"
#include "SampleFSM.h"
#include "SpTest.h"

using namespace SampleEntity;

class CSampleEntity : public CEntityBase, public ITestCaseSuite<CSampleEntity>
{
public:
	CSampleEntity(){}
	virtual ~CSampleEntity(){}
	virtual const char *GetEntityName() const { return "SampleEntity"; }
	virtual bool IsService() const { return true; }

	virtual bool IsMultiThread() const { return true; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		ErrorCodeEnum ec = Error_Succeed;
		if(m_sampleFsm.Init(this) != 0) {
			ec = Error_InvalidState;
		}

		AddTestCaseEntry(&CSampleEntity::TestTwoWayFuncNormal);
		pTransactionContext->SendAnswer(ec);
	}

	virtual void OnStarted() override
	{
		CSimpleStringA strValue;

		CHECK(Error_NotExist == GetFunction()->GetSysVar("NoExistSysValue", strValue));

		IFFAILBREAK(GetFunction()->GetSysVar("SampleState", strValue));
		CHECK_FALSE(strValue.IsNullOrEmpty());

		/*set sys val*/
		Dbg("Update sysVal...");
		strValue = strValue.Compare("1") == 0 ? "0" : "1";
		IFFAILBREAK(GetFunction()->SetSysVar("SampleState", strValue, true));
		CSimpleStringA strNewValue;
		IFFAILBREAK(GetFunction()->GetSysVar("SampleState", strNewValue));
		CHECK(strValue.Compare(strNewValue) == 0);

		Dbg("Update sysVal again...");
		strValue = strValue.Compare("1") == 0 ? "0" : "1";
		IFFAILBREAK(GetFunction()->SetSysVar("SampleState", strValue));
		IFFAILBREAK(GetFunction()->GetSysVar("SampleState", strNewValue));
		CHECK(strValue.Compare(strNewValue) == 0);

		//depecrate: assert would happen!
		//IFFAILBREAK(GetFunction()->SetSysVar("SampleState", NULL)); //would clear the sys val value.

		Dbg("test some illegal action.");
		CHECK(Error_NotExist == GetFunction()->SetSysVar("NoExistSysValue", "1", true));
		CHECK(Error_NotExist == GetFunction()->SetSysVar("NoExistSysValue", "1"));
		CHECK(Error_Null == GetFunction()->SetSysVar(NULL, "1", true));
		CHECK(Error_Null == GetFunction()->SetSysVar(NULL, "1"));
		CHECK(Error_NoPrivilege == GetFunction()->SetSysVar("PrivilegeState", "1", true));
		CHECK(Error_NoPrivilege == GetFunction()->SetSysVar("PrivilegeState", "1"));

		TestCaseDemo();
	}

	void TestCaseDemo()
	{
		/** simple test way, user declare and implement the test method*/
		AddTestCaseEntry(&CSampleEntity::TestTwoWayFuncWithID);

		/** this is meanless usage way beacause we cannot set req member*/
		AddTestMethodEntry(
			new MethodTestCaseT<SampleService_TwoWayFuncNotOverlap_Req, SampleService_TwoWayFuncNotOverlap_Ans>(
				this,
				&CSampleEntity::TwoWayFuncNotOverlap));

		/** but we can change it like this.*/
		auto methdTest1 = new MethodTestCaseT<SampleService_TwoWayFuncNotOverlap_Req, SampleService_TwoWayFuncNotOverlap_Ans>(
			this,
			&CSampleEntity::TwoWayFuncNotOverlap);

		methdTest1->Req.req_context = "I'am Test";
		AddTestMethodEntry(methdTest1);

		/** but still, we cannot check the Ans member's validity, only one thing what we can do is 
		      just checking the aim furncion returned 'ErrorCodeEnum' type value*/

		 /** last but not lease, we can inherit MethodTestCaseT and override PreTest(to set Req) and PostTest(to check Ans)*/
		struct TwoWayFuncOverlapTestCase :
			public MethodTestCaseT<SampleService_TwoWayFuncOverlap_Req, SampleService_TwoWayFuncOverlap_Ans>
		{
			TwoWayFuncOverlapTestCase(CEntityBase* ent, ToTestFuncProto testFunc) :MethodTestCaseT(ent, testFunc) {}

			void PreTest()
			{
				LOG_FUNCTION();

				Req.req_context = "hello";
			}

			ErrorCodeEnum PostTest()
			{
				LOG_FUNCTION();

				if (Ans.ans_context.Compare("world", true) != 0) {
					LOG_TRACE("Check failed, return except Error_Succeed");
					return Error_Unexpect;
				}

				return Error_Succeed;
			}
		};

		AddTestMethodEntry(new TwoWayFuncOverlapTestCase(this, &CSampleEntity::TwoWayFuncOverlap));
	}

	TESTCASE_OVERRIDE_ON_EXAM_AND_IMPLEMENT()

	ErrorCodeEnum CustomTestCase() override
	{
		LOG_FUNCTION();
		/** User add any other test logical*/
		return Error_Succeed;
	}

	ErrorCodeEnum OnewayFuncOverlap(
			SpOnewayCallContext<SampleService_OnewayFuncOverlap_Info>::Pointer ctx)
	{
		ErrorCodeEnum ec = Error_Unexpect;
		// TODO: user should implement the function!
		return ec;
	}

	ErrorCodeEnum OnewayFuncNoOverlap(
			SpOnewayCallContext<SampleService_OnewayFuncNoOverlap_Info>::Pointer ctx)
	{
		ErrorCodeEnum ec = Error_Unexpect;
		// TODO: user should implement the function!
		return ec;
	}

	ErrorCodeEnum OnewayFuncNormal(
			SpOnewayCallContext<SampleService_OnewayFuncNormal_Info>::Pointer ctx)
	{
		ErrorCodeEnum ec = Error_Unexpect;
		// TODO: user should implement the function!
		return ec;
	}

	ErrorCodeEnum TwoWayFuncOverlap(
			SpReqAnsContext<SampleService_TwoWayFuncOverlap_Req, SampleService_TwoWayFuncOverlap_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		ErrorCodeEnum ec = Error_Succeed;
		// TODO: 
		ctx->Ans.ans_context = "World";
		ctx->Answer();
		return ec;
	}

	ErrorCodeEnum TwoWayFuncNotOverlap(
			SpReqAnsContext<SampleService_TwoWayFuncNotOverlap_Req, SampleService_TwoWayFuncNotOverlap_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();

		ErrorCodeEnum ec = Error_Succeed;
		ctx->Answer(Error_Succeed);
		return ec;
	}

	ErrorCodeEnum TwoWayFuncWithID(
			SpReqAnsContext<SampleService_TwoWayFuncWithID_Req, SampleService_TwoWayFuncWithID_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		ErrorCodeEnum ec = Error_Succeed;
		// TODO: 

		//ctx->Answer(Error_Unexpect, Error_Unexpect);

		return ec;
	}

	ErrorCodeEnum TwoWayFuncNormal(
			SpReqAnsContext<SampleService_TwoWayFuncNormal_Req, SampleService_TwoWayFuncNormal_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();

		ErrorCodeEnum ec = Error_Succeed;
		ctx->Answer(Error_Succeed);
		return ec;
	}

	ErrorCodeEnum SubscribeOverlap(
			SpSubscribeContext<SampleService_SubscribeOverlap_Sub, SampleService_SubscribeOverlap_Message_Info>::Pointer ctx)
	{
		ErrorCodeEnum ec = Error_NotImpl;
		// TODO: 
		return ec;
	}

	ErrorCodeEnum SubscribeOverlap_Cancel(
			SpOnewayCallContext<SampleService_SubscribeOverlap_Cancel_Info>::Pointer ctx)
	{
		ErrorCodeEnum ec = Error_NotImpl;
		// TODO: 
		return ec;
	}


///////////////////////////

	void TestTwoWayFuncNormal(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		SpReqAnsContext< SampleService_TwoWayFuncNormal_Req, SampleService_TwoWayFuncNormal_Ans>::Pointer ctx =
			new SpReqAnsContext< SampleService_TwoWayFuncNormal_Req, SampleService_TwoWayFuncNormal_Ans>(pTransactionContext);

		/** Set ctx->Req*/

		/*The aim function you would like test.*/
		if (Error_Succeed == TwoWayFuncNormal(ctx)) 
		{
			/** Check ctx->Ans*/

			/** Overwite the Result using pTransactionContext->SendAnswer()*/
		}
	}

	void TestTwoWayFuncWithID(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		SpReqAnsContext< SampleService_TwoWayFuncWithID_Req, SampleService_TwoWayFuncWithID_Ans>::Pointer ctx =
			new SpReqAnsContext< SampleService_TwoWayFuncWithID_Req, SampleService_TwoWayFuncWithID_Ans>(pTransactionContext);

		TwoWayFuncWithID(ctx);
	}

	//TESTCASE_DECLARE_BEGIN(SampleService, TwoWayFuncOverlap);
	//ctx->Req.req_context = "hello";
	//TESTCASE_DECLARE_INVOKE(TwoWayFuncOverlap);
	//TESTCASE_DECLARE_END(TwoWayFuncOverlap);


private:
	CSampleFSM m_sampleFsm;
};

class CSampleServiceSession : public SampleService_ServerSessionBase
{
public:
	CSampleServiceSession(CSampleEntity *pEntity) : m_pEntity(pEntity) {}
	virtual ~CSampleServiceSession() {}

	virtual void Handle_OnewayFuncOverlap(
			SpOnewayCallContext<SampleService_OnewayFuncOverlap_Info>::Pointer ctx)
	{
		auto rc = m_pEntity->OnewayFuncOverlap(ctx);
	}

	virtual void Handle_OnewayFuncNoOverlap(
			SpOnewayCallContext<SampleService_OnewayFuncNoOverlap_Info>::Pointer ctx)
	{
		auto rc = m_pEntity->OnewayFuncNoOverlap(ctx);
	}

	virtual void Handle_OnewayFuncNormal(
			SpOnewayCallContext<SampleService_OnewayFuncNormal_Info>::Pointer ctx)
	{
		auto rc = m_pEntity->OnewayFuncNormal(ctx);
	}

	virtual void Handle_TwoWayFuncOverlap(
			SpReqAnsContext<SampleService_TwoWayFuncOverlap_Req, SampleService_TwoWayFuncOverlap_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->TwoWayFuncOverlap(ctx);
		ctx->Answer(rc);
	}

	virtual void Handle_TwoWayFuncNotOverlap(
			SpReqAnsContext<SampleService_TwoWayFuncNotOverlap_Req, SampleService_TwoWayFuncNotOverlap_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->TwoWayFuncNotOverlap(ctx);
		ctx->Answer(rc);
	}

	virtual void Handle_TwoWayFuncWithID(
			SpReqAnsContext<SampleService_TwoWayFuncWithID_Req, SampleService_TwoWayFuncWithID_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->TwoWayFuncWithID(ctx);
		ctx->Answer(rc);
	}

	virtual void Handle_TwoWayFuncNormal(
			SpReqAnsContext<SampleService_TwoWayFuncNormal_Req, SampleService_TwoWayFuncNormal_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->TwoWayFuncNormal(ctx);
		ctx->Answer(rc);
	}

	virtual void Handle_SubscribeOverlap(
			SpSubscribeContext<SampleService_SubscribeOverlap_Sub, SampleService_SubscribeOverlap_Message_Info>::Pointer ctx)
	{
		auto rc = m_pEntity->SubscribeOverlap(ctx);
	}

	virtual void Handle_SubscribeOverlap_Cancel(
			SpOnewayCallContext<SampleService_SubscribeOverlap_Cancel_Info>::Pointer ctx)
	{
		auto rc = m_pEntity->SubscribeOverlap_Cancel(ctx);
	}

private:
	CSampleEntity *m_pEntity;
};


///////////////////////////


#endif // __MOD_SAMPLEENTITY_H__