int main(void)
{
#ifdef __OS20__
/* The internal partition on OS20 leaks with transient tasks */
internal_partition = system_partition;
#endif
harness_boot();
MME_Init();
MME_RegisterTransport(TRANSPORT_NAME);
MME(RegisterTransformer("com.st.mcdt.mme.test",
SimpleTest_AbortCommand,
SimpleTest_GetTransformerCapability,
SimpleTest_InitTransformer,
SimpleTest_ProcessCommand,
SimpleTest_TermTransformer));
MME(Run());
/* INSbl23335: prove that the remote termination function really was called */
assert(0 == instantiatedCounter);
harness_shutdown();
return 0;
}
void
MET_type_exit()
{
int i;
MME(MET_type_exit);
for (i = 0; i < MET_FIELD_MAX; i++)
MET_TYPE_FREE(MET__type_field[i]);
MET_TYPE_FREE(MET__type_unknown);
MET_TYPE_FREE(MET__type_set);
MET_TYPE_FREE(MET__type_bogus);
MET_TYPE_FREE(MET_type_generic_map);
MET_TYPE_FREE(MET_type_interval);
MET_TYPE_FREE(MET_type_access_marker);
MET_TYPE_FREE(MET_type_access_text);
}
void
MET_type_initialize()
{
int i;
METtype *t,*t1, *t2;
MME(MET_type_initialize);
MET_TYPE_ALLOC(MET__type_unknown);
MET__type_unknown->type = MET_TYPE_TYPE_UNKNOWN;
MET_TYPE_ALLOC(MET__type_set);
MET__type_set->type = MET_TYPE_TYPE_SET;
MET_TYPE_ALLOC(MET__type_bogus);
MET__type_bogus->type = MET_TYPE_TYPE_BOGUS;
MET_TYPE_ALLOC(MET_type_generic_map);
MET_type_generic_map->type = MET_TYPE_TYPE_MAP;
MET_TYPE_NEW_UNKNOWN(MET_type_generic_map->info.map.from);
MET_TYPE_NEW_UNKNOWN(MET_type_generic_map->info.map.to);
for (i = 0; i < MET_FIELD_MAX; i++) {
MET_TYPE_ALLOC(MET__type_field[i]);
MET__type_field[i]->type = MET_TYPE_TYPE_FIELD;
MET__type_field[i]->info.field.type = i;
}
MET_TYPE_NEW_FIELD(t, MET_FIELD_REAL);
MET_TYPE_NEW_SET_OF(MET_type_interval, t);
MET_TYPE_FREE(t);
MET_TYPE_NEW_UNKNOWN(t);
MET_TYPE_NEW_FIELD(t1, MET_FIELD_INTEGER);
MET_TYPE_NEW_PAIR(MET_type_access_marker, t, t1);
MET_TYPE_FREE(t);
MET_TYPE_FREE(t1);
MET_TYPE_NEW_UNKNOWN(t);
MET_TYPE_NEW_FIELD(t1, MET_FIELD_INTEGER);
MET_TYPE_NEW_VECTOR(t2, t1, TYPE_DIMENSION_UNKNOWN, NO);
MET_TYPE_FREE(t1);
MET_TYPE_NEW_PAIR(MET_type_access_text, t, t2);
MET_TYPE_FREE(t);
MET_TYPE_FREE(t2);
}
void ModelManager :: AddModel( Model * m, ModelMode mm ) {
if ( FindModel( m->Name() ) ) {
throw Exception( "Duplicate model name " + ALib::SQuote( m->Name() ));
}
mModels.push_back( MME( m, mm ) );
}
/* TODO:
* Multiple companion CPU tests
*/
int main(void)
{
MME_TransformerInitParams_t initParams = {
sizeof(MME_TransformerInitParams_t),
MME_PRIORITY_NORMAL,
TransformerCallback,
USERDATA,
0,
NULL,
};
MME_TransformerHandle_t transformerHandle;
MME_TransformerHandle_t transformerHandle2;
MME_ERROR error;
/* bring up the API */
harness_boot();
MME(Init());
#ifndef USERMODE
assert(MME_DeregisterTransport(TRANSPORT_NAME)==MME_INVALID_ARGUMENT);
MME(RegisterTransport(TRANSPORT_NAME));
#endif
#if 0
/* Currently a bug in EMBX prevents a transport from being
closed and reopened
*/
printf("Calling MME_DeregisterTransport\n");
error = MME_DeregisterTransport(TRANSPORT_NAME);
printf("MME_DeregisterTransport err %d\n", error);
VERBOSE(printf(MACHINE "MME_InitTransformer(com.st.mcdt.mme.test)"));
/* this should fail - no transports yet */
error = MME_InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle);
assert(error == MME_UNKNOWN_TRANSFORMER);
MME(RegisterTransport(TRANSPORT_NAME));
#endif
/* this should fail - not a valid xformer */
error = MME_InitTransformer("com.st.mcdt.mme.testX", &initParams, &transformerHandle);
assert(error == MME_UNKNOWN_TRANSFORMER);
do {
VERBOSE(printf("Attempting MME_InitTransformer(com.st.mcdt.mme.test)\n"));
/* loop till registered on companion */
error = MME_InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle);
harness_sleep(1);
} while (error == MME_UNKNOWN_TRANSFORMER);
/* And again - two instantiations on the same CPU */
MME(InitTransformer("com.st.mcdt.mme.test", &initParams, &transformerHandle2));
/* tidy up */
MME(TermTransformer(transformerHandle));
error = MME_Term();
assert(error == MME_HANDLES_STILL_OPEN);
MME(TermTransformer(transformerHandle2));
MME(Term());
harness_shutdown();
return 0;
}
