/*test case:test the reaction of the system called with
an activation of a task*/
static void test_isr1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9;
TickType TickType_inst_1, TickType_inst_2;
SCHEDULING_CHECK_INIT(2);
result_inst_1 = GetCounterValue(Software_Counter, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(2,E_OK, result_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(2,0, TickType_inst_1);
SCHEDULING_CHECK_INIT(3);
result_inst_2 = SetRelAlarm(Alarm_ActivateTask, 2, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(4);
result_inst_3 = IncrementCounter(Software_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_3);
SCHEDULING_CHECK_INIT(5);
result_inst_4 = IncrementCounter(Software_Counter);
/* alarm expiration */
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK, result_inst_4);
/* force scheduling */
SCHEDULING_CHECK_INIT(7);
result_inst_5 = SetRelAlarm(Alarm_SetEvent_suspendedtask, 2, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(7,E_OK, result_inst_5);
SCHEDULING_CHECK_INIT(8);
result_inst_6 = IncrementCounter(Software_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK, result_inst_6);
SCHEDULING_CHECK_INIT(9);
result_inst_7 = IncrementCounter(Software_Counter);
/*alarm expires*/
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK, result_inst_7);
/*force rescheduling*/
SCHEDULING_CHECK_INIT(11);
result_inst_8 = GetCounterValue(Software_Counter_By_Alarm, &TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(11,E_OK, result_inst_8);
SCHEDULING_CHECK_AND_EQUAL_INT(11,0, TickType_inst_2);
SCHEDULING_CHECK_INIT(12);
result_inst_9 = SetRelAlarm(Alarm_ActivateTask, 0, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(13,E_OS_VALUE, result_inst_9);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_isr1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9;
TickType TickType_inst_1, TickType_inst_2, TickType_inst_3, TickType_inst_4, TickType_inst_5;
/*s1*/
SCHEDULING_CHECK_INIT(2);
result_inst_1 = GetCounterValue(Software_Counter, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(2,E_OK, result_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(2,0, TickType_inst_1);
SCHEDULING_CHECK_INIT(3);
result_inst_2 = SetRelAlarm(Alarm1, 2, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(4);
result_inst_3 = IncrementCounter(Software_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_3);
SCHEDULING_CHECK_INIT(5);
result_inst_4 = IncrementCounter(Software_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(5,E_OK, result_inst_4);
SCHEDULING_CHECK_INIT(6);
result_inst_5 = GetCounterValue(Software_Counter, &TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(6,E_OK, result_inst_5);
SCHEDULING_CHECK_AND_EQUAL_INT(6,1, TickType_inst_2);
SCHEDULING_CHECK_INIT(7);
result_inst_6 = IncrementCounter(Software_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(7,E_OK, result_inst_6);
SCHEDULING_CHECK_INIT(8);
result_inst_7 = IncrementCounter(Software_Counter);
/*alarm expires*/
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK, result_inst_7);
/*force rescheduling*/
SCHEDULING_CHECK_INIT(11);
result_inst_8 = GetCounterValue(Software_Counter, &TickType_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(11,E_OK, result_inst_8);
SCHEDULING_CHECK_AND_EQUAL_INT(11,2, TickType_inst_3);
SCHEDULING_CHECK_INIT(12);
TickType_inst_4 = 0;
result_inst_9 = GetElapsedCounterValue(Software_Counter, &TickType_inst_4, &TickType_inst_5);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(12,E_OK , result_inst_9);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(12,2 , TickType_inst_4);
SCHEDULING_CHECK_AND_EQUAL_INT(12,2 , TickType_inst_5);
}
LONGLONG CCpuUsage::CPerfCounters::GetCounterValue(PERF_DATA_BLOCK **pPerfData, DWORD dwObjectIndex, DWORD dwCounterIndex, LPCTSTR pInstanceName)
{
QueryPerformanceData(pPerfData, dwObjectIndex, dwCounterIndex);
PPERF_OBJECT_TYPE pPerfObj = NULL;
LONGLONG lnValue = {0};
// Get the first object type.
pPerfObj = FirstObject( *pPerfData );
// Look for the given object index
for( DWORD i=0; i < (*pPerfData)->NumObjectTypes; i++ )
{
if (pPerfObj->ObjectNameTitleIndex == dwObjectIndex)
{
lnValue = GetCounterValue(pPerfObj, dwCounterIndex, pInstanceName);
break;
}
pPerfObj = NextObject( pPerfObj );
}
return lnValue;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6;
TickType TickType_inst_5, TickType_inst_6, TickType_inst_7;
TickType TickType_inst_1 = OSMAXALLOWEDVALUE_Software_Counter + 1;
TickType TickType_inst_2 = OSMAXALLOWEDVALUE_Software_Counter + 1;
TickType TickType_inst_3 = OSMAXALLOWEDVALUE_Software_Counter + 1;
TickType TickType_inst_4 = OSMAXALLOWEDVALUE_Hardware_Counter + 1;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = IncrementCounter(Hardware_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OS_ID, result_inst_1);
SCHEDULING_CHECK_INIT(3);
result_inst_2 = IncrementCounter(INVALID_COUNTER);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OS_ID, result_inst_2);
SCHEDULING_CHECK_INIT(5);
result_inst_3 = GetCounterValue(INVALID_COUNTER, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OS_ID, result_inst_3);
SCHEDULING_CHECK_INIT(7);
result_inst_4 = GetElapsedCounterValue(Software_Counter, &TickType_inst_2, &TickType_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OS_VALUE, result_inst_4);
SCHEDULING_CHECK_INIT(9);
result_inst_5 = GetElapsedCounterValue(Hardware_Counter, &TickType_inst_4, &TickType_inst_5);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_VALUE, result_inst_5);
SCHEDULING_CHECK_INIT(11);
result_inst_6 = GetElapsedCounterValue(INVALID_COUNTER, &TickType_inst_6, &TickType_inst_7);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_ID, result_inst_6);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5;
TickType TickType_inst_1, TickType_inst_2, TickType_inst_3, tick_temp;
TickType alarm_increment = 2;
EventMaskType EventMaskType_inst_1;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = GetCounterValue(Hardware_Counter, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK, result_inst_1);
WaitCounterDeltaValue(Hardware_Counter, 3);
SCHEDULING_CHECK_INIT(2);
result_inst_2 = GetCounterValue(Hardware_Counter, &TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(2, (TickType_inst_1 + 3)%(OSMAXALLOWEDVALUE_Hardware_Counter + 1) , TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(3);
result_inst_3 = SetRelAlarm(Alarm1, alarm_increment, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK, result_inst_3);
WaitActivationOneShotAlarm(Alarm1);
SCHEDULING_CHECK_INIT(4);
tick_temp = TickType_inst_2;
result_inst_4 = GetElapsedCounterValue(Hardware_Counter, &TickType_inst_2, &TickType_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(4,E_OK , result_inst_4);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(4, (tick_temp + alarm_increment)%(OSMAXALLOWEDVALUE_Hardware_Counter + 1) , TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,alarm_increment , TickType_inst_3);
SCHEDULING_CHECK_INIT(5);
result_inst_5 = GetEvent(t1, &EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5,Event1 , EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(5, E_OK , result_inst_5);
}
uint64_t SystemClock::monotonicTime() {
static uint32_t base = 0;
static uint32_t offset = 0;
TickType counter;
GetCounterValue(counter_1_ms, &counter);
Lock::lock();
if (offset > counter) {
base++;
}
offset = counter;
uint64_t time = ((uint64_t) base << 32) | offset;
Lock::unlock();
return time;
}
/** @req 4.1.2/SWS_Os_00392 */
StatusType GetElapsedValue ( CounterType counter_id, TickRefType val, TickRefType elapsed_val)
{
StatusType rv = E_OK;
OsCounterType *cPtr;
TickType currTick = 0;
TickType max;
cPtr = Os_CounterGet(counter_id);
/** @req SWS_Os_00381 */
OS_VALIDATE(IsCounterValid(counter_id),E_OS_ID);
max = Os_CounterGetMaxValue(cPtr);
/** @req SWS_Os_00391 */
OS_VALIDATE( *val <= max,E_OS_VALUE );
#if (OS_APPLICATION_CNT > 1) && (OS_NUM_CORES > 1)
if (Os_ApplGetCore(cPtr->applOwnerId) != GetCoreID()) {
StatusType status = Os_NotifyCore(Os_ApplGetCore(cPtr->applOwnerId),
OSServiceId_GetElapsedValue,
counter_id,
(int32_t)val,
(int32_t)elapsed_val);
return status;
}
#endif
GetCounterValue(counter_id,&currTick);
/** @req OS382 */
*elapsed_val = Os_CounterDiff(currTick,*val,max);
/** @req OS460 */
*val = currTick;
COUNTER_STD_END;
}
//=========================================================================================================
bool GetASICInfo(ASICInfo& rASICInfo)
{
if (nullptr == oglUtils::_oglGetPerfMonitorCountersAMD ||
nullptr == oglUtils::_oglGetPerfMonitorGroupStringAMD ||
nullptr == oglUtils::_oglGetPerfMonitorCounterInfoAMD ||
nullptr == oglUtils::_oglGetPerfMonitorCounterStringAMD ||
nullptr == oglUtils::_oglGenPerfMonitorsAMD ||
nullptr == oglUtils::_oglDeletePerfMonitorsAMD ||
nullptr == oglUtils::_oglSelectPerfMonitorCountersAMD ||
nullptr == oglUtils::_oglBeginPerfMonitorAMD ||
nullptr == oglUtils::_oglEndPerfMonitorAMD ||
nullptr == oglUtils::_oglGetPerfMonitorCounterDataAMD)
{
// No AMD_peformance_monitor support, means no ASIC info
GPA_LogError("One or more of the GL_AMD_performance_monitor functions were not found.");
return false;
}
// Find the ASIC info group (GPIN = GPu INformation)
GLint nASICGroupId = GetGroupID(ASIC_GROUP);
if (nASICGroupId == -1)
{
GPA_LogError("Unable to find the GPIN group.");
return false;
}
// Get the ASIC ID
GLuint nAsicType = 0;
if (!GetCounterValue(nASICGroupId, ASIC_TYPE, nAsicType))
{
GPA_LogError("Unable to get the asic id.");
return false;
}
// query the driver version so that we can correct the asic ID after a driver
// change that happened for 10.2, where support for pre-R6xx hardware was removed
//(legacy driver will support that)
#ifndef GLES
// Since GL ES didn't exist before version 9551, there's no need to check the
// version number. For now, it is assumed the version number will be >9551
const GLubyte* pVersion = oglUtils::_oglGetString(GL_VERSION);
int nVersion = extractVersionNumber(pVersion);
std::stringstream message;
message << "ASIC ID returned from driver is: " << nAsicType << " and GL_VERSION is: " << reinterpret_cast<const char*>(pVersion) << ".";
GPA_LogMessage(message.str().c_str());
#else
int nVersion = INT_MAX;
#endif
if (nVersion < 13452)
{
// pre-GCN devices were removed from the driver starting with version 13452.
// if the driver version is earlier than that we will return an error.
GPA_LogError("OpenGL driver version is too old. Please update your driver.");
return false;
}
// store the Asic Revision ID
rASICInfo.eAsicRev = (ATIAsicID) nAsicType;
// Decode the ASIC Type
if (nAsicType == ATIASIC_ID_TAHITI_P ||
nAsicType == ATIASIC_ID_PITCAIRN_PM ||
nAsicType == ATIASIC_ID_CAPEVERDE_M ||
nAsicType == ATIASIC_ID_OLAND_M ||
nAsicType == ATIASIC_ID_HAINAN_M)
{
GPA_LogMessage("Recognized a GFX6 card.");
rASICInfo.eAsicType = ASIC_Gfx6;
}
else if (nAsicType == ATIASIC_ID_BONAIRE_M ||
nAsicType == ATIASIC_ID_HAWAII_P)
{
GPA_LogMessage("Recognized a GFX7 card.");
rASICInfo.eAsicType = ASIC_Gfx7;
}
else if (nAsicType == ATIASIC_ID_KALINDI ||
nAsicType == ATIASIC_ID_GODAVARI ||
nAsicType == ATIASIC_ID_SPECTRE ||
nAsicType == ATIASIC_ID_SPOOKY)
{
GPA_LogMessage("Recognized an APU with GFX7 graphics.");
rASICInfo.eAsicType = ASIC_Gfx7;
}
else if (nAsicType == ATIASIC_ID_ICELAND_M ||
nAsicType == ATIASIC_ID_TONGA_P ||
nAsicType == ATIASIC_ID_FIJI_P ||
nAsicType == ATIASIC_ID_ELLESMERE ||
nAsicType == ATIASIC_ID_BAFFIN ||
nAsicType == ATIASIC_ID_LEXA ||
nAsicType == ATIASIC_ID_VEGAM)
{
GPA_LogMessage("Recognized a GFX8 card.");
rASICInfo.eAsicType = ASIC_Gfx8;
}
else if (nAsicType == ATIASIC_ID_CARRIZO ||
nAsicType == ATIASIC_ID_STONEY)
{
GPA_LogMessage("Recognized an APU with GFX8 graphics.");
rASICInfo.eAsicType = ASIC_Gfx8;
}
else if (nAsicType == ATIASIC_ID_GFX900 ||
nAsicType == ATIASIC_ID_PLACEHOLDER1 ||
nAsicType == ATIASIC_ID_GFX906)
{
GPA_LogMessage("Recognized a GFX9 card.");
rASICInfo.eAsicType = ASIC_Gfx9;
}
else if (nAsicType == ATIASIC_ID_GFX902 ||
nAsicType == ATIASIC_ID_PLACEHOLDER)
{
GPA_LogMessage("Recognized an APU with GFX9 graphics.");
rASICInfo.eAsicType = ASIC_Gfx9;
}
else
{
std::stringstream errorMessage;
errorMessage << "Unrecognized asic type: " << nAsicType << ".";
GPA_LogError(errorMessage.str().c_str());
assert(0); // Unknown ASIC Type, need to update enums list from UGL driver
rASICInfo.eAsicType = ASIC_UNKNOWN;
return false;
}
// Now, fill in the rest of the ASIC structure
switch (rASICInfo.eAsicType)
{
case ASIC_Gfx6:
case ASIC_Gfx7:
case ASIC_Gfx8:
case ASIC_Gfx9:
if (!GetCounterValue(nASICGroupId, "GPIN_001", rASICInfo.nNumSIMD))
{
GPA_LogError("Unable to query GPIN_001.");
return false;
}
if (!GetCounterValue(nASICGroupId, "GPIN_002", rASICInfo.nNumQuadPipe))
{
GPA_LogError("Unable to query GPIN_002.");
return false;
}
if (!GetCounterValue(nASICGroupId, "GPIN_003", rASICInfo.nNumRB))
{
GPA_LogError("Unable to query GPIN_003.");
return false;
}
if (!GetCounterValue(nASICGroupId, "GPIN_004", rASICInfo.nNumSPI))
{
GPA_LogError("Unable to query GPIN_004.");
return false;
}
break;
default:
break;
}
return true;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
ApplicationType ApplicationType_inst_1, ApplicationType_inst_2;
ISRType ISRType_inst_1;
ObjectAccessType ObjectAccessType_inst_1;
ScheduleTableStatusType ScheduleTableStatusType_inst_1;
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11, result_inst_12;
TickType TickType_inst_1, TickType_inst_2;
SCHEDULING_CHECK_STEP(1);
DisableAllInterrupts();
SCHEDULING_CHECK_INIT(2);
ApplicationType_inst_1 = GetApplicationID();
SCHEDULING_CHECK_AND_EQUAL_INT(3, app1, ApplicationType_inst_1);
SCHEDULING_CHECK_INIT(4);
ISRType_inst_1 = GetISRID();
SCHEDULING_CHECK_AND_EQUAL_INT(5, INVALID_ISR, ISRType_inst_1);
SCHEDULING_CHECK_INIT(6);
ObjectAccessType_inst_1 = CheckObjectAccess(app1, OBJECT_TASK, t1);
SCHEDULING_CHECK_AND_EQUAL_INT(7, ACCESS, ObjectAccessType_inst_1);
SCHEDULING_CHECK_INIT(8);
ApplicationType_inst_2 = CheckObjectOwnership(OBJECT_TASK, t1);
SCHEDULING_CHECK_AND_EQUAL_INT(9, app1, ApplicationType_inst_2);
SCHEDULING_CHECK_INIT(10);
result_inst_1 = StartScheduleTableRel(sched1, 1);
SCHEDULING_CHECK_AND_EQUAL_INT(11, E_OS_DISABLEDINT, result_inst_1);
SCHEDULING_CHECK_INIT(12);
result_inst_2 = StartScheduleTableAbs(sched1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(13, E_OS_DISABLEDINT, result_inst_2);
SCHEDULING_CHECK_INIT(14);
result_inst_3 = StopScheduleTable(sched1);
SCHEDULING_CHECK_AND_EQUAL_INT(15, E_OS_DISABLEDINT, result_inst_3);
SCHEDULING_CHECK_INIT(16);
result_inst_4 = NextScheduleTable(sched1, sched2);
SCHEDULING_CHECK_AND_EQUAL_INT(17, E_OS_DISABLEDINT, result_inst_4);
SCHEDULING_CHECK_INIT(18);
result_inst_5 = StartScheduleTableSynchron(sched1);
SCHEDULING_CHECK_AND_EQUAL_INT(19, E_OS_DISABLEDINT, result_inst_5);
SCHEDULING_CHECK_INIT(20);
result_inst_6 = SyncScheduleTable(sched1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(21, E_OS_DISABLEDINT, result_inst_6);
SCHEDULING_CHECK_INIT(22);
result_inst_7 = GetScheduleTableStatus(sched1, &ScheduleTableStatusType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(23, E_OS_DISABLEDINT, result_inst_7);
SCHEDULING_CHECK_INIT(24);
result_inst_8 = SetScheduleTableAsync(sched1);
SCHEDULING_CHECK_AND_EQUAL_INT(25, E_OS_DISABLEDINT, result_inst_8);
SCHEDULING_CHECK_INIT(26);
result_inst_9 = IncrementCounter(Software_Counter1);
SCHEDULING_CHECK_AND_EQUAL_INT(27, E_OS_DISABLEDINT, result_inst_9);
SCHEDULING_CHECK_INIT(28);
result_inst_10 = GetCounterValue(Software_Counter1, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(29, E_OS_DISABLEDINT, result_inst_10);
SCHEDULING_CHECK_INIT(30);
result_inst_11 = GetElapsedCounterValue(Software_Counter1, &TickType_inst_1, &TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(31, E_OS_DISABLEDINT, result_inst_11);
SCHEDULING_CHECK_INIT(32);
result_inst_12 = TerminateApplication(app1, NO_RESTART);
SCHEDULING_CHECK_AND_EQUAL_INT(33, E_OS_DISABLEDINT, result_inst_12);
SCHEDULING_CHECK_STEP(34);
EnableAllInterrupts();
/*
Missing :
- CallTrustedFunction
- CheckISRMemoryAccess
- CheckTaskMemoryAccess
- GetActiveApplicationMode (OS tests)
Ok but not tested :
- StartOS (OS tests)
- ShutdownOS (OS tests)
*/
}
int StatsTable::GetCounterValue(const std::string& name)
{
return GetCounterValue(name, 0);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_isr1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11;
TickType TickType_inst_1, TickType_inst_2, TickType_inst_3, TickType_inst_4, TickType_inst_6, TickType_inst_8, TickType_inst_9, TickType_inst_10, tick_temp;
TickType TickType_inst_5 = OSMAXALLOWEDVALUE_Software_Counter + 1;
TickType TickType_inst_7 = OSMAXALLOWEDVALUE_Hardware_Counter + 1;
TickType alarm_increment = 2;
EventMaskType EventMaskType_inst_1;
SCHEDULING_CHECK_INIT(2);
result_inst_1 = GetCounterValue(Hardware_Counter, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK, result_inst_1);
WaitCounterDeltaValue(Hardware_Counter, 3);
SCHEDULING_CHECK_INIT(3);
result_inst_2 = GetCounterValue(Hardware_Counter, &TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(3, (TickType_inst_1 + 3)%(OSMAXALLOWEDVALUE_Hardware_Counter + 1) , TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(4);
result_inst_3 = SetRelAlarm(Alarm1, alarm_increment, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_3);
WaitActivationOneShotAlarm(Alarm1);
SCHEDULING_CHECK_INIT(5);
tick_temp = TickType_inst_2;
result_inst_4 = GetElapsedCounterValue(Hardware_Counter, &TickType_inst_2, &TickType_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5,E_OK , result_inst_4);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5,(tick_temp + alarm_increment)%(OSMAXALLOWEDVALUE_Hardware_Counter + 1) , TickType_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(5,alarm_increment , TickType_inst_3);
SCHEDULING_CHECK_INIT(6);
result_inst_5 = GetEvent(t1, &EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(6,Event1 , EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK , result_inst_5);
SCHEDULING_CHECK_INIT(7);
result_inst_6 = IncrementCounter(Hardware_Counter);
SCHEDULING_CHECK_AND_EQUAL_INT(7,E_OS_ID, result_inst_6);
SCHEDULING_CHECK_INIT(8);
result_inst_7 = IncrementCounter(INVALID_COUNTER);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OS_ID, result_inst_7);
SCHEDULING_CHECK_INIT(9);
result_inst_8 = GetCounterValue(INVALID_COUNTER, &TickType_inst_4);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OS_ID, result_inst_8);
SCHEDULING_CHECK_INIT(10);
result_inst_9 = GetElapsedCounterValue(Software_Counter, &TickType_inst_5, &TickType_inst_6);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_VALUE, result_inst_9);
SCHEDULING_CHECK_INIT(11);
result_inst_10 = GetElapsedCounterValue(Hardware_Counter, &TickType_inst_7, &TickType_inst_8);
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OS_VALUE, result_inst_10);
SCHEDULING_CHECK_INIT(12);
result_inst_11 = GetElapsedCounterValue(INVALID_COUNTER, &TickType_inst_9, &TickType_inst_10);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_ID, result_inst_11);
}
