void CgiResponseHandler::SendError(MgException* e)
{
MG_TRY()
STRING shortError = e->GetExceptionMessage();
STRING stackTrace = e->GetStackTrace();
STRING statusMessage = e->GetClassName();
STRING longError = e->GetDetails();
//TODO: Use a string resource for html error text format
printf(MapAgentStrings::StatusHeader, 559, MG_WCHAR_TO_CHAR(statusMessage));
printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, MapAgentStrings::Utf8Text);
printf("\r\n"
"<html>\n<head>\n"
"<title>%s</title>\n"
"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n"
"</head>\n"
"<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n",
MG_WCHAR_TO_CHAR(statusMessage),
MG_WCHAR_TO_CHAR(shortError),
MG_WCHAR_TO_CHAR(stackTrace));
DumpMessage(MG_WCHAR_TO_CHAR(longError));
MG_CATCH(L"CgiResponseHandler.SendError")
}
void c_RestResponse::SendError(MgException* e)
{
MG_TRY()
#ifdef _MG_ENT_2011
STRING shortError = mgException->GetExceptionMessage();
#else
STRING shortError = mgException->GetMessage();
#endif
STRING longError = e->GetDetails();
STRING statusMessage = e->GetClassName();
//TODO: Use a string resource for html error text format
string sResponseHeader;
char tempHeader[4096];
m_HttpData.SetStatusAndReason(559,MG_WCHAR_TO_CHAR(statusMessage));
sprintf(tempHeader, "%s%s", MapAgentStrings::TextHtml, MapAgentStrings::Utf8Text);
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,tempHeader);
WriteContent("\r\n"
"<html>\n<head>\n"
"<title>%s</title>\n"
"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n"
"</head>\n"
"<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n",
MG_WCHAR_TO_CHAR(statusMessage),
MG_WCHAR_TO_CHAR(shortError),
MG_WCHAR_TO_CHAR(longError));
MG_CATCH(L"IsapiResponseHandler.SendError")
}
void CgiResponseHandler::RequestAuth()
{
//TODO: Use string resources for realm and message
printf(MapAgentStrings::UnauthorizedHeader);
printf(MapAgentStrings::WWWAuth, MG_WCHAR_TO_CHAR(MapAgentStrings::ProductName));
string errorMsg = "You must enter a valid login ID and password to access this site\r\n";
printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
printf(MapAgentStrings::ContentLengthHeader, errorMsg.length());
printf("\r\n%s",errorMsg.c_str());
}
void TestProfilingService::TestCase_ProfileRenderMap()
{
try
{
// make a runtime normal map
Ptr<MgMap> map = CreateTestMap();
Ptr<MgSelection> selectionOnMap = CreateSelection(map);
// make a runtime map with watermark
Ptr<MgMap> mapWithWatermark = CreateTestMapWithWatermark();
Ptr<MgSelection> selectionOnMapWithWatermark = CreateSelection(mapWithWatermark);
// make a rendering option
Ptr<MgRenderingOptions> options = new MgRenderingOptions(L"PNG",MgRenderingOptions::RenderSelection| MgRenderingOptions::RenderLayers| MgRenderingOptions::KeepSelection,NULL);
Ptr<MgCoordinate> coordNewCenter = new MgCoordinateXY(-87.733253, 43.746199);
Ptr<MgColor> bgc = new MgColor(255, 255, 255, 255);
// profile rendering normal map
Ptr<MgByteReader> rdr1 = m_svcProfiling->ProfileRenderMap(map, NULL, coordNewCenter, 75000, 1024, 1024, bgc, L"PNG", false);
rdr1->ToFile(L"../UnitTestFiles/ProfileRenderMap_Normal.xml");
// profile rendering normal map with selection
Ptr<MgByteReader> rdr2 = m_svcProfiling->ProfileRenderMap(map, selectionOnMap, coordNewCenter, 75000, 1024, 1024, bgc, L"PNG", false);
rdr2->ToFile(L"../UnitTestFiles/ProfileRenderMap_Selection.xml");
// profile rendering normal map with watermark
Ptr<MgByteReader> rdr3 = m_svcProfiling->ProfileRenderMap(mapWithWatermark, NULL, coordNewCenter, 75000, 1024, 1024, bgc, L"PNG", false);
rdr3->ToFile(L"../UnitTestFiles/ProfileRenderMap_Watermark.xml");
// profile rendering normal map with watermark
Ptr<MgByteReader> rdr4 = m_svcProfiling->ProfileRenderMap(mapWithWatermark, selectionOnMapWithWatermark, coordNewCenter, 75000, 1024, 1024, bgc, L"PNG", false);
rdr4->ToFile(L"../UnitTestFiles/ProfileRenderMap_Watermark_Selection.xml");
}
catch (MgException* e)
{
STRING message = e->GetDetails(TEST_LOCALE);
SAFE_RELEASE(e);
CPPUNIT_FAIL(MG_WCHAR_TO_CHAR(message.c_str()));
}
catch (...)
{
throw;
}
}
void TestProfilingService::TestCase_ProfileRenderDynamicOverlay()
{
try
{
// make a runtime normal map
Ptr<MgMap> map = CreateTestMap();
Ptr<MgSelection> selectionOnMap = CreateSelection(map);
// make a runtime map with watermark
Ptr<MgMap> mapWithWatermark = CreateTestMapWithWatermark();
Ptr<MgSelection> selectionOnMapWithWatermark = CreateSelection(mapWithWatermark);
// make a rendering option
Ptr<MgRenderingOptions> options = new MgRenderingOptions(L"PNG",MgRenderingOptions::RenderSelection| MgRenderingOptions::RenderLayers| MgRenderingOptions::KeepSelection,NULL);
// profile rendering normal map
Ptr<MgByteReader> rdr1 = m_svcProfiling->ProfileRenderDynamicOverlay(map, NULL, options);
rdr1->ToFile(L"../UnitTestFiles/ProfileRenderDynamicOverlay_Normal.xml");
// profile rendering normal map with selection
Ptr<MgByteReader> rdr2 = m_svcProfiling->ProfileRenderDynamicOverlay(map, selectionOnMap, options);
rdr2->ToFile(L"../UnitTestFiles/ProfileRenderDynamicOverlay_Selection.xml");
// profile rendering map with watermark
Ptr<MgByteReader> rdr3 = m_svcProfiling->ProfileRenderDynamicOverlay(mapWithWatermark, NULL, options);
rdr3->ToFile(L"../UnitTestFiles/ProfileRenderDynamicOverlay_Watermark.xml");
// profile rendering map with both watermark and selection
Ptr<MgByteReader> rdr4 = m_svcProfiling->ProfileRenderDynamicOverlay(mapWithWatermark, selectionOnMapWithWatermark, options);
rdr4->ToFile(L"../UnitTestFiles/ProfileRenderDynamicOverlay_Watermark_Selection.xml");
}
catch (MgException* e)
{
STRING message = e->GetDetails(TEST_LOCALE);
SAFE_RELEASE(e);
CPPUNIT_FAIL(MG_WCHAR_TO_CHAR(message.c_str()));
}
catch (...)
{
throw;
}
}
void CgiResponseHandler::SendResponse(MgHttpResponse* response)
{
MG_TRY()
Ptr<MgHttpResult> result = response->GetResult();
STATUS status = result->GetStatusCode();
if (status != 200)
{
STRING statusMessage = result->GetHttpStatusMessage();
if (statusMessage == MapAgentStrings::FailedAuth1 ||
statusMessage == MapAgentStrings::FailedAuth2)
{
RequestAuth();
}
else
{
//TODO: Use a resource for the HTML error message
STRING shortError = result->GetErrorMessage();
STRING longError = result->GetDetailedErrorMessage();
printf(MapAgentStrings::StatusHeader, status, MG_WCHAR_TO_CHAR(statusMessage));
printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, "");
printf("\r\n"
"<html>\n<head>\n"
"<title>%s</title>\n"
"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n"
"</head>\n"
"<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n",
MG_WCHAR_TO_CHAR(statusMessage),
MG_WCHAR_TO_CHAR(shortError),
MG_WCHAR_TO_CHAR(longError));
DumpMessage(MG_WCHAR_TO_CHAR(longError));
}
}
else
{
DumpMessage(MapAgentStrings::StatusOkHeader);
// Status was ok. Send the real result back.
STRING contentType = result->GetResultContentType();
STRING stringVal;
printf(MapAgentStrings::StatusOkHeader);
if (contentType.length() > 0)
{
// If we are returning text, state that it is utf-8.
string charSet = "";
if (contentType.find(L"text") != contentType.npos) //NOXLATE
{
charSet = MapAgentStrings::Utf8Text;
}
printf(MapAgentStrings::ContentTypeHeader, MG_WCHAR_TO_CHAR(contentType), charSet.c_str());
}
else
{
printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
}
Ptr<MgByteReader> outputReader;
Ptr<MgDisposable> resultObj = result->GetResultObject();
MgDisposable* pResultObj = (MgDisposable*)resultObj;
if (NULL != dynamic_cast<MgByteReader*>(pResultObj))
{
outputReader = (MgByteReader*) SAFE_ADDREF(pResultObj);
}
else if (NULL != dynamic_cast<MgStringCollection*>(pResultObj))
{
outputReader = ((MgStringCollection*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgSpatialContextReader*>(pResultObj))
{
outputReader = ((MgSpatialContextReader*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgLongTransactionReader*>(pResultObj))
{
outputReader = ((MgLongTransactionReader*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgHttpPrimitiveValue*>(pResultObj))
{
stringVal = ((MgHttpPrimitiveValue*)pResultObj)->ToString();
}
if (stringVal.length() > 0)
{
string utf8 = MG_WCHAR_TO_CHAR(stringVal);
printf(MapAgentStrings::ContentLengthHeader, utf8.length());
printf("\r\n%s",utf8.c_str());
}
else if (outputReader != NULL)
{
Ptr<MgHttpHeader> respHeader = response->GetHeader();
//Check for chunking hint
if (respHeader->GetHeaderValue(MgHttpResourceStrings::hrhnTransfer_Encoding) == MgHttpResourceStrings::hrhnChunked)
{
CgiReaderStreamer crs(outputReader);
crs.StreamResult();
}
else
{
INT64 outLen = outputReader->GetLength();
printf(MapAgentStrings::ContentLengthHeader,(INT32)outLen);
printf("\r\n");
unsigned char buf[4096];
int nBytes = outputReader->Read(buf,4096);
while (nBytes > 0)
{
fwrite(buf, 1, nBytes, stdout);
nBytes = outputReader->Read(buf,4096);
}
}
}
else
{
printf(MapAgentStrings::ContentLengthHeader, 0);
printf("\r\n");
}
}
MG_CATCH_AND_THROW(L"CgiResponseHandler.SendResponse");
}
int main(int argc, char** argv)
{
#if defined(_WIN32) && defined(_DEBUG)
#if !defined(USING_VLD)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#ifdef _DEBUG
// to debug memory leaks, set a breakpoint here and set iBlock
// to the block allocation you want to break on
long iBlock = -1;
_CrtSetBreakAlloc(iBlock);
#endif
#endif
#endif
ACE_DEBUG((LM_INFO, ACE_TEXT("Initialize Platform.ini\n")));
//Benchmark this
#ifdef WIN32
//Muffle errors due to broken FDO RDBMS provider dlls, they aren't the ones exercised
//under test anyway
SetErrorMode(SEM_FAILCRITICALERRORS);
long lStart = GetTickCount();
#endif
MgdPlatform::Initialize(L"Platform.ini");
#ifdef WIN32
ACE_DEBUG((LM_INFO, ACE_TEXT("Platform Initialization time in %dms\n"), (GetTickCount()-lStart)));
#endif
Ptr<MgCoordinateSystemFactory> csFactory = new MgCoordinateSystemFactory();
Ptr<MgCoordinateSystemCatalog> csCatalog = csFactory->GetCatalog();
STRING dictDir = csCatalog->GetDictionaryDir();
ACE_DEBUG((LM_INFO, ACE_TEXT("MENTOR_DICTIONARY_PATH is: %s\n"), dictDir.c_str()));
CppUnit::TextUi::TestRunner runner;
// Add all of the tests
//NOTE: Leave trace log off, otherwise one of the tests here will fail
#if TEST_LOG_MANAGER == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestLogManager").makeTest());
#endif
#if TEST_RESOURCE_SERVICE == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestResourceService").makeTest());
#endif
#if TEST_RENDERING_SERVICE == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestRenderingService").makeTest());
#endif
#if TEST_FEATURE_SERVICE == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestFeatureService").makeTest());
#endif
#if TEST_MAPPING_SERVICE == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestMappingService").makeTest());
#endif
#if TEST_PROFILING_SERVICE == 1
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestProfilingService").makeTest());
#endif
#if TEST_TILE_SERVICE == 1
//This causes access violations in Visual Leak Detector when run in debug mode. Only uncommment
//to verify functionality, but don't use VLD for memory leak detection. Seek an alternate tool/library
//in this case.
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("TestTileService").makeTest());
#endif
STRING fileName = L"UnitTestResults.xml";
if (fileName.size() > 0)
{
ofstream outfile(MG_WCHAR_TO_CHAR(fileName.c_str()));
if (outfile.is_open())
{
runner.setOutputter(new CppUnit::XmlOutputter(&runner.result(), outfile, "ISO-8859-1"));
runner.run();
outfile.close();
}
}
else
{
runner.setOutputter(new CppUnit::TextOutputter(&runner.result(), std::cout));
runner.run();
}
int nResult = runner.result().testFailuresTotal();
MgdPlatform::Terminate();
return nResult;
}
c_RestResponse_HttpData* c_RestResponse::PrepareHttpData(c_RestRequest* RestRequest)
{
try
{
char tempHeader[4096];
//string sResponseHeader;
Ptr<MgByteReader> outputReader;
Ptr<c_RestResult> result = GetResult();
STATUS status = result->GetStatusCode();
STRING statusMessage = result->GetHttpStatusMessage();
if (status != 200)
{
if (statusMessage == MapAgentStrings::FailedAuth1 ||
statusMessage == MapAgentStrings::FailedAuth2
)
{
RequestAuth(RestRequest);
}
else
{
//TODO: Use a resource for the HTML error message
char content[4096];
STRING shortError = result->GetErrorMessage();
STRING longError = result->GetDetailedErrorMessage();
sprintf(content,"\r\n"
"<html>\n<head>\n"
"<title>%s</title>\n"
"<meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\">\n"
"</head>\n"
"<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n",
MG_WCHAR_TO_CHAR(statusMessage),
MG_WCHAR_TO_CHAR(shortError),
MG_WCHAR_TO_CHAR(longError));
DWORD content_length = strlen(content);
/*
sprintf(tempHeader, MapAgentStrings::StatusHeader, status, MG_WCHAR_TO_CHAR(statusMessage));
sResponseHeader.append(tempHeader);
sprintf(tempHeader, MapAgentStrings::ContentLengthHeader, (int)content_length);
sResponseHeader.append(tempHeader);
sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, "");
sResponseHeader.append(tempHeader);
*/
m_HttpData.SetStatusAndReason(status,MG_WCHAR_TO_CHAR(statusMessage));
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,MapAgentStrings::TextHtml);
sprintf(tempHeader, "%d", (int)content_length);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(content);
}
}
else
{
// Status was ok. Send the real result back.
STRING result_contentType = result->GetResultContentType();
STRING response_contentType = GetContentType();
std::string stringval_utf8;
//sprintf(tempHeader, MapAgentStrings::StatusOkHeader);
//sResponseHeader.append(tempHeader);
m_HttpData.SetStatusAndReason(200,"OK");
if (response_contentType.length() > 0)
{
// If we are returning text, state that it is utf-8.
STRING mime = response_contentType;
if( response_contentType == RestMimeType::JsonP )
{
mime = L"text/plain";
}
else
{
if( response_contentType == RestMimeType::Json )
{
mime = L"text/plain";
}
}
string charSet = "";
if (mime.find(L"text") != mime.npos) //NOXLATE
{
charSet = MapAgentStrings::Utf8Text;
}
//sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MG_WCHAR_TO_CHAR(response_contentType), charSet.c_str());
//sResponseHeader.append(tempHeader);
sprintf(tempHeader, "%s%s", MG_WCHAR_TO_CHAR(mime), charSet.c_str());
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,tempHeader);
}
else
{
//sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
//sResponseHeader.append(tempHeader);
sprintf(tempHeader, "%s%s", MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,tempHeader);
}
Ptr<MgDisposable> resultObj = result->GetResultObject();
MgDisposable* pResultObj = (MgDisposable*)resultObj;
// Test type of response needed
Ptr<c_RestDataReader> restreader = NULL;
MgProxyFeatureReader* proxyfreader = dynamic_cast<MgProxyFeatureReader*>(pResultObj);
if( proxyfreader )
{
restreader = new c_RestDataReader_MgFeatureReader(proxyfreader);
}
else
{
restreader = SAFE_ADDREF(dynamic_cast<c_RestDataReader*>(pResultObj));
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Template)
{
if( response_contentType == RestMimeType::Html )
{
c_FeatureReaderToHtml::ToHtml(restreader,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
if( response_contentType == RestMimeType::Kml )
{
c_FeatureReaderToHtml::ToKml(restreader.p,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
if( response_contentType == RestMimeType::Kmz )
{
outputReader = c_FeatureReaderToHtml::ToKmz(restreader.p,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
c_FeatureReaderToHtml::ToTemplate(false,restreader,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_FeaturesXML)
{
if( restreader.p )
{
c_FeatureReaderToXML::ToXml(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Sitemap)
{
if( restreader.p )
{
c_FeatureReaderToXML::ToSitemapXml(restreader.p,RestRequest,RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_FeaturesJSON)
{
if( restreader.p )
{
c_FeatureReaderToGeoJson::ToGeoJson(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Custom)
{
if( restreader.p )
{
//std::stringstream strs;
c_CfgRepresentation_Custom *customrep = (c_CfgRepresentation_Custom *)RestRequest->m_CfgRepresentation;
Ptr<c_StreamResponse_FReader2Custom> streamout = new c_StreamResponse_FReader2Custom(restreader.p,customrep);
m_HttpData.SetContent(streamout);
return &m_HttpData; // need to go out here - bellow is closing featuer reader - setting hhtp header for content length etc..
///(*(customrep->m_CustomRenderer->m_FuncContent2Stream))(restreader.p,&strs);
//stringval_utf8 = strs.str();
//c_FeatureReaderToGeoJson::ToGeoJson(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( restreader.p )
{
restreader->Close();
}
if (NULL != dynamic_cast<c_RestPrimitiveValue*>(pResultObj))
{
stringval_utf8 = ((c_RestPrimitiveValue*)pResultObj)->ToStringUTF8();;
}
else if (NULL != dynamic_cast<MgByteReader*>(pResultObj))
{
outputReader = (MgByteReader*) SAFE_ADDREF(pResultObj);
}
else if (NULL != dynamic_cast<MgStringCollection*>(pResultObj))
{
outputReader = ((MgStringCollection*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgSqlDataReader*>(pResultObj))
{
outputReader = ((MgSqlDataReader*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgDataReader*>(pResultObj))
{
outputReader = ((MgDataReader*)pResultObj)->ToXml();
}
if (stringval_utf8.length() > 0)
{
if( response_contentType == RestMimeType::JsonP ||
( response_contentType == RestMimeType::Json && (GetJsonpCallbackName().length()>0))
)
{
//utf8 = response->GetJsonpCallbackName() + "( \"" + utf8 + "\" )"; ...
std::string jsonp;
CreateJsonpCallbackString(GetJsonpCallbackName(),stringval_utf8,jsonp);
stringval_utf8 = jsonp;
}
sprintf(tempHeader, "%d", stringval_utf8.length());
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(stringval_utf8);
}
else if (outputReader != NULL)
{
if( response_contentType == RestMimeType::Json || response_contentType == RestMimeType::JsonP )
{
MgXmlJsonConvert convert;
convert.ToJson(outputReader);
if( response_contentType == RestMimeType::JsonP )
{
string json;
// set read back to text from Jason so it can be converted to string with function 'ToStringUtf8'
outputReader->GetByteSource()->SetMimeType(RestMimeType::Text);
outputReader->ToStringUtf8(json);
string jsonp;
CreateJsonpCallbackString(GetJsonpCallbackName(),json,jsonp);
Ptr<MgByteSource> byteSource = new MgByteSource(
(unsigned char*)jsonp.c_str(), (INT32)jsonp.length());
byteSource->SetMimeType(RestMimeType::JsonP);
outputReader.Attach(byteSource->GetReader());
}
}
INT64 outLen = outputReader->GetLength();
sprintf(tempHeader, "%d", (INT32)outLen);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(outputReader);
// Tell IIS to keep the connection open
//DWORD dwState = HSE_STATUS_SUCCESS_AND_KEEP_CONN;
//m_pECB->ServerSupportFunction(m_pECB->ConnID, HSE_REQ_DONE_WITH_SESSION, &dwState, NULL, 0);
}
else
{
sprintf(tempHeader, "%d", 0);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
// Tell IIS to keep the connection open
//DWORD dwState = HSE_STATUS_SUCCESS_AND_KEEP_CONN;
//m_pECB->ServerSupportFunction(m_pECB->ConnID, HSE_REQ_DONE_WITH_SESSION, &dwState, NULL, 0);
}
}
return &m_HttpData;
}
catch (MgException* exc)
{
SendError(exc);
exc->Release();
}
catch (exception& e)
{
Ptr<MgException> mgException = MgSystemException::Create(e, L"c_RestResponse::PrepareHttpData", __LINE__, __WFILE__);
SendError(mgException);
}
catch (...)
{
Ptr<MgException> mgException = new MgUnclassifiedException(L"c_RestResponse::PrepareHttpData", __LINE__, __WFILE__, NULL, L"", NULL);
SendError(mgException);
}
}//end of c_RestResponse::PrepareHttpData
void TestProfilingService::TestStart()
{
ACE_DEBUG((LM_INFO, ACE_TEXT("\nRunning Profiling Service tests.\n")));
try
{
#ifdef _DEBUG
MgFdoConnectionManager* pFdoConnectionManager = MgFdoConnectionManager::GetInstance();
if(pFdoConnectionManager)
{
pFdoConnectionManager->ShowCache();
}
#endif
// set user info
Ptr<MgUserInformation> userInfo = new MgUserInformation(L"Administrator", L"admin");
userInfo->SetLocale(TEST_LOCALE);
MgUserInformation::SetCurrentUserInfo(userInfo);
// publish the map definition
Ptr<MgResourceIdentifier> mapres1 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Sheboygan.MapDefinition");
Ptr<MgByteSource> mdfsrc1 = new MgByteSource(L"../UnitTestFiles/UT_Sheboygan.mdf", false);
Ptr<MgByteReader> mdfrdr1 = mdfsrc1->GetReader();
m_svcResource->SetResource(mapres1, mdfrdr1, NULL);
// publish the layer definitions
Ptr<MgResourceIdentifier> ldfres1 = new MgResourceIdentifier(L"Library://UnitTests/Layers/HydrographicPolygons.LayerDefinition");
Ptr<MgByteSource> ldfsrc1 = new MgByteSource(L"../UnitTestFiles/UT_HydrographicPolygons.ldf", false);
Ptr<MgByteReader> ldfrdr1 = ldfsrc1->GetReader();
m_svcResource->SetResource(ldfres1, ldfrdr1, NULL);
Ptr<MgResourceIdentifier> ldfres2 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Rail.LayerDefinition");
Ptr<MgByteSource> ldfsrc2 = new MgByteSource(L"../UnitTestFiles/UT_Rail.ldf", false);
Ptr<MgByteReader> ldfrdr2 = ldfsrc2->GetReader();
m_svcResource->SetResource(ldfres2, ldfrdr2, NULL);
Ptr<MgResourceIdentifier> ldfres3 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Parcels.LayerDefinition");
Ptr<MgByteSource> ldfsrc3 = new MgByteSource(L"../UnitTestFiles/UT_Parcels.ldf", false);
Ptr<MgByteReader> ldfrdr3 = ldfsrc3->GetReader();
m_svcResource->SetResource(ldfres3, ldfrdr3, NULL);
// publish the feature sources
Ptr<MgResourceIdentifier> fsres1 = new MgResourceIdentifier(L"Library://UnitTests/Data/HydrographicPolygons.FeatureSource");
Ptr<MgByteSource> fssrc1 = new MgByteSource(L"../UnitTestFiles/UT_HydrographicPolygons.fs", false);
Ptr<MgByteReader> fsrdr1 = fssrc1->GetReader();
m_svcResource->SetResource(fsres1, fsrdr1, NULL);
Ptr<MgResourceIdentifier> fsres2 = new MgResourceIdentifier(L"Library://UnitTests/Data/Rail.FeatureSource");
Ptr<MgByteSource> fssrc2 = new MgByteSource(L"../UnitTestFiles/UT_Rail.fs", false);
Ptr<MgByteReader> fsrdr2 = fssrc2->GetReader();
m_svcResource->SetResource(fsres2, fsrdr2, NULL);
Ptr<MgResourceIdentifier> fsres3 = new MgResourceIdentifier(L"Library://UnitTests/Data/Parcels.FeatureSource");
Ptr<MgByteSource> fssrc3 = new MgByteSource(L"../UnitTestFiles/UT_Parcels.fs", false);
Ptr<MgByteReader> fsrdr3 = fssrc3->GetReader();
m_svcResource->SetResource(fsres3, fsrdr3, NULL);
// publish the resource data
Ptr<MgByteSource> dataSource1 = new MgByteSource(L"../UnitTestFiles/UT_HydrographicPolygons.sdf", false);
Ptr<MgByteReader> dataReader1 = dataSource1->GetReader();
m_svcResource->SetResourceData(fsres1, L"UT_HydrographicPolygons.sdf", L"File", dataReader1);
Ptr<MgByteSource> dataSource2 = new MgByteSource(L"../UnitTestFiles/UT_Rail.sdf", false);
Ptr<MgByteReader> dataReader2 = dataSource2->GetReader();
m_svcResource->SetResourceData(fsres2, L"UT_Rail.sdf", L"File", dataReader2);
Ptr<MgByteSource> dataSource3 = new MgByteSource(L"../UnitTestFiles/UT_Parcels.sdf", false);
Ptr<MgByteReader> dataReader3 = dataSource3->GetReader();
m_svcResource->SetResourceData(fsres3, L"UT_Parcels.sdf", L"File", dataReader3);
// publish the print layouts
Ptr<MgResourceIdentifier> plres1 = new MgResourceIdentifier(L"Library://UnitTests/PrintLayouts/AllElements.PrintLayout");
Ptr<MgByteSource> plsrc1 = new MgByteSource(L"../UnitTestFiles/UT_AllElements.pl", false);
Ptr<MgByteReader> plrdr1 = plsrc1->GetReader();
m_svcResource->SetResource(plres1, plrdr1, NULL);
Ptr<MgResourceIdentifier> plres2 = new MgResourceIdentifier(L"Library://UnitTests/PrintLayouts/NoLegend.PrintLayout");
Ptr<MgByteSource> plsrc2 = new MgByteSource(L"../UnitTestFiles/UT_NoLegend.pl", false);
Ptr<MgByteReader> plrdr2 = plsrc2->GetReader();
m_svcResource->SetResource(plres2, plrdr2, NULL);
// publish the symbol library
Ptr<MgResourceIdentifier> slres1 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/SymbolMart.SymbolLibrary");
Ptr<MgByteSource> slsrc1 = new MgByteSource(L"../UnitTestFiles/UT_SymbolMart.sl", false);
Ptr<MgByteReader> slrdr1 = slsrc1->GetReader();
m_svcResource->SetResource(slres1, slrdr1, NULL);
Ptr<MgByteSource> datasrc = new MgByteSource(L"../UnitTestFiles/UT_Symbols.dwf", false);
Ptr<MgByteReader> datardr = datasrc->GetReader();
m_svcResource->SetResourceData(slres1, L"symbols.dwf", L"File", datardr);
//
// publish symbology stuff
//
// the point feature source
Ptr<MgResourceIdentifier> fsres4 = new MgResourceIdentifier(L"Library://UnitTests/Data/Capitals.FeatureSource");
Ptr<MgByteSource> fssrc4 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPoints.fs", false);
Ptr<MgByteReader> fsrdr4 = fssrc4->GetReader();
m_svcResource->SetResource(fsres4, fsrdr4, NULL);
// point sdf file
Ptr<MgByteSource> dataSource4 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPoints.sdf", false);
Ptr<MgByteReader> dataReader4 = dataSource4->GetReader();
m_svcResource->SetResourceData(fsres4, L"UT_SymbologyPoints.sdf", L"File", dataReader4);
// point symbols
Ptr<MgResourceIdentifier> sdres1 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/PointSymbol.SymbolDefinition");
Ptr<MgByteSource> sdsrc1 = new MgByteSource(L"../UnitTestFiles/symbol.sd", false);
Ptr<MgByteReader> sdrdr1 = sdsrc1->GetReader();
m_svcResource->SetResource(sdres1, sdrdr1, NULL);
Ptr<MgResourceIdentifier> sdres2 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/PointSymbolParam.SymbolDefinition");
Ptr<MgByteSource> sdsrc2 = new MgByteSource(L"../UnitTestFiles/symbolp.sd", false);
Ptr<MgByteReader> sdrdr2 = sdsrc2->GetReader();
m_svcResource->SetResource(sdres2, sdrdr2, NULL);
// point ldf
Ptr<MgResourceIdentifier> ldfres4 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Capitals.LayerDefinition");
Ptr<MgByteSource> ldfsrc4 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPoints.ldf", false);
Ptr<MgByteReader> ldfrdr4 = ldfsrc4->GetReader();
m_svcResource->SetResource(ldfres4, ldfrdr4, NULL);
Ptr<MgResourceIdentifier> ldfres5 = new MgResourceIdentifier(L"Library://UnitTests/Layers/CapitalsParam.LayerDefinition");
Ptr<MgByteSource> ldfsrc5 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPointsParam.ldf", false);
Ptr<MgByteReader> ldfrdr5 = ldfsrc5->GetReader();
m_svcResource->SetResource(ldfres5, ldfrdr5, NULL);
// point mdf
Ptr<MgResourceIdentifier> mapres2 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Capitals.MapDefinition");
Ptr<MgByteSource> mdfsrc2 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPoints.mdf", false);
Ptr<MgByteReader> mdfrdr2 = mdfsrc2->GetReader();
m_svcResource->SetResource(mapres2, mdfrdr2, NULL);
Ptr<MgResourceIdentifier> mapres3 = new MgResourceIdentifier(L"Library://UnitTests/Maps/CapitalsParam.MapDefinition");
Ptr<MgByteSource> mdfsrc3 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPointsParam.mdf", false);
Ptr<MgByteReader> mdfrdr3 = mdfsrc3->GetReader();
m_svcResource->SetResource(mapres3, mdfrdr3, NULL);
// the line feature source
Ptr<MgResourceIdentifier> fsres5 = new MgResourceIdentifier(L"Library://UnitTests/Data/Lines.FeatureSource");
Ptr<MgByteSource> fssrc5 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLines.fs", false);
Ptr<MgByteReader> fsrdr5 = fssrc5->GetReader();
m_svcResource->SetResource(fsres5, fsrdr5, NULL);
// line sdf file
Ptr<MgByteSource> dataSource5 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLines.sdf", false);
Ptr<MgByteReader> dataReader5 = dataSource5->GetReader();
m_svcResource->SetResourceData(fsres5, L"UT_SymbologyLines.sdf", L"File", dataReader5);
// line symbols
Ptr<MgResourceIdentifier> sdres3 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/LineSymbol.SymbolDefinition");
Ptr<MgByteSource> sdsrc3 = new MgByteSource(L"../UnitTestFiles/linesymbol.sd", false);
Ptr<MgByteReader> sdrdr3 = sdsrc3->GetReader();
m_svcResource->SetResource(sdres3, sdrdr3, NULL);
Ptr<MgResourceIdentifier> sdres4 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/MTYP1500a.SymbolDefinition");
Ptr<MgByteSource> sdsrc4 = new MgByteSource(L"../UnitTestFiles/MTYP1500a.sd", false);
Ptr<MgByteReader> sdrdr4 = sdsrc4->GetReader();
m_svcResource->SetResource(sdres4, sdrdr4, NULL);
// line ldf
Ptr<MgResourceIdentifier> ldfres6 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Lines.LayerDefinition");
Ptr<MgByteSource> ldfsrc6 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLines.ldf", false);
Ptr<MgByteReader> ldfrdr6 = ldfsrc6->GetReader();
m_svcResource->SetResource(ldfres6, ldfrdr6, NULL);
Ptr<MgResourceIdentifier> ldfres7 = new MgResourceIdentifier(L"Library://UnitTests/Layers/LinesCrossTick.LayerDefinition");
Ptr<MgByteSource> ldfsrc7 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLinesCrossTick.ldf", false);
Ptr<MgByteReader> ldfrdr7 = ldfsrc7->GetReader();
m_svcResource->SetResource(ldfres7, ldfrdr7, NULL);
// line mdf
Ptr<MgResourceIdentifier> mapres4 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Lines.MapDefinition");
Ptr<MgByteSource> mdfsrc4 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLines.mdf", false);
Ptr<MgByteReader> mdfrdr4 = mdfsrc4->GetReader();
m_svcResource->SetResource(mapres4, mdfrdr4, NULL);
Ptr<MgResourceIdentifier> mapres5 = new MgResourceIdentifier(L"Library://UnitTests/Maps/LinesCrossTick.MapDefinition");
Ptr<MgByteSource> mdfsrc5 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyLinesCrossTick.mdf", false);
Ptr<MgByteReader> mdfrdr5 = mdfsrc5->GetReader();
m_svcResource->SetResource(mapres5, mdfrdr5, NULL);
// annotation ldf - this shares the point sdf
Ptr<MgResourceIdentifier> ldfres8 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation1.LayerDefinition");
Ptr<MgByteSource> ldfsrc8 = new MgByteSource(L"../UnitTestFiles/UT_Annotation1.ldf", false);
Ptr<MgByteReader> ldfrdr8 = ldfsrc8->GetReader();
m_svcResource->SetResource(ldfres8, ldfrdr8, NULL);
Ptr<MgResourceIdentifier> ldfres9 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation2.LayerDefinition");
Ptr<MgByteSource> ldfsrc9 = new MgByteSource(L"../UnitTestFiles/UT_Annotation2.ldf", false);
Ptr<MgByteReader> ldfrdr9 = ldfsrc9->GetReader();
m_svcResource->SetResource(ldfres9, ldfrdr9, NULL);
Ptr<MgResourceIdentifier> ldfres10 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation3.LayerDefinition");
Ptr<MgByteSource> ldfsrc10 = new MgByteSource(L"../UnitTestFiles/UT_Annotation3.ldf", false);
Ptr<MgByteReader> ldfrdr10 = ldfsrc10->GetReader();
m_svcResource->SetResource(ldfres10, ldfrdr10, NULL);
// annotation mdf
Ptr<MgResourceIdentifier> mapres8 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation1.MapDefinition");
Ptr<MgByteSource> mdfsrc8 = new MgByteSource(L"../UnitTestFiles/UT_Annotation1.mdf", false);
Ptr<MgByteReader> mdfrdr8 = mdfsrc8->GetReader();
m_svcResource->SetResource(mapres8, mdfrdr8, NULL);
Ptr<MgResourceIdentifier> mapres9 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation2.MapDefinition");
Ptr<MgByteSource> mdfsrc9 = new MgByteSource(L"../UnitTestFiles/UT_Annotation2.mdf", false);
Ptr<MgByteReader> mdfrdr9 = mdfsrc9->GetReader();
m_svcResource->SetResource(mapres9, mdfrdr9, NULL);
Ptr<MgResourceIdentifier> mapres10 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation3.MapDefinition");
Ptr<MgByteSource> mdfsrc10 = new MgByteSource(L"../UnitTestFiles/UT_Annotation3.mdf", false);
Ptr<MgByteReader> mdfrdr10 = mdfsrc10->GetReader();
m_svcResource->SetResource(mapres10, mdfrdr10, NULL);
//symbology - polygons
Ptr<MgResourceIdentifier> mapres11 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_SymbologyPolygons.MapDefinition");
Ptr<MgByteSource> mdfsrc11 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyPolygons.mdf", false);
Ptr<MgByteReader> mdfrdr11 = mdfsrc11->GetReader();
m_svcResource->SetResource(mapres11, mdfrdr11, NULL);
Ptr<MgResourceIdentifier> ldfres11 = new MgResourceIdentifier(L"Library://UnitTests/Layers/SymbologyParcels.LayerDefinition");
Ptr<MgByteSource> ldfsrc11 = new MgByteSource(L"../UnitTestFiles/UT_SymbologyParcels.ldf", false);
Ptr<MgByteReader> ldfrdr11 = ldfsrc11->GetReader();
m_svcResource->SetResource(ldfres11, ldfrdr11, NULL);
Ptr<MgResourceIdentifier> sdres5 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/AreaSymbol.SymbolDefinition");
Ptr<MgByteSource> sdsrc5 = new MgByteSource(L"../UnitTestFiles/areasymbol.sd", false);
Ptr<MgByteReader> sdrdr5 = sdsrc5->GetReader();
m_svcResource->SetResource(sdres5, sdrdr5, NULL);
// For watermark test
// publish the map definition
Ptr<MgResourceIdentifier> mapres12 = new MgResourceIdentifier(L"Library://UnitTests/Maps/SheboyganWithWatermark.MapDefinition");
Ptr<MgByteSource> mdfsrc12 = new MgByteSource(L"../UnitTestFiles/UT_SheboyganWithWatermark.mdf", false);
Ptr<MgByteReader> mdfrdr12 = mdfsrc12->GetReader();
m_svcResource->SetResource(mapres12, mdfrdr12, NULL);
// publish the watermark definition
Ptr<MgResourceIdentifier> wdfres1 = new MgResourceIdentifier(L"Library://UnitTests/Watermarks/PoweredByMapGuide.WatermarkDefinition");
Ptr<MgByteSource> wdfsrc1 = new MgByteSource(L"../UnitTestFiles/UT_PoweredByMapGuide.wdf", false);
Ptr<MgByteReader> wdfrdr1 = wdfsrc1->GetReader();
m_svcResource->SetResource(wdfres1, wdfrdr1, NULL);
}
catch (MgException* e)
{
STRING message = e->GetDetails(TEST_LOCALE);
SAFE_RELEASE(e);
CPPUNIT_FAIL(MG_WCHAR_TO_CHAR(message.c_str()));
}
catch (...)
{
throw;
}
}
void TestProfilingService::TestEnd()
{
try
{
// set user info
Ptr<MgUserInformation> userInfo = new MgUserInformation(L"Administrator", L"admin");
userInfo->SetLocale(TEST_LOCALE);
MgUserInformation::SetCurrentUserInfo(userInfo);
// delete the map definition
Ptr<MgResourceIdentifier> mapres1 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Sheboygan.MapDefinition");
m_svcResource->DeleteResource(mapres1);
// delete the layer definitions
Ptr<MgResourceIdentifier> ldfres1 = new MgResourceIdentifier(L"Library://UnitTests/Layers/HydrographicPolygons.LayerDefinition");
m_svcResource->DeleteResource(ldfres1);
Ptr<MgResourceIdentifier> ldfres2 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Rail.LayerDefinition");
m_svcResource->DeleteResource(ldfres2);
Ptr<MgResourceIdentifier> ldfres3 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Parcels.LayerDefinition");
m_svcResource->DeleteResource(ldfres3);
// delete the feature sources
Ptr<MgResourceIdentifier> fsres1 = new MgResourceIdentifier(L"Library://UnitTests/Data/HydrographicPolygons.FeatureSource");
m_svcResource->DeleteResource(fsres1);
Ptr<MgResourceIdentifier> fsres2 = new MgResourceIdentifier(L"Library://UnitTests/Data/Rail.FeatureSource");
m_svcResource->DeleteResource(fsres2);
Ptr<MgResourceIdentifier> fsres3 = new MgResourceIdentifier(L"Library://UnitTests/Data/Parcels.FeatureSource");
m_svcResource->DeleteResource(fsres3);
// delete the print layouts
Ptr<MgResourceIdentifier> plres1 = new MgResourceIdentifier(L"Library://UnitTests/PrintLayouts/AllElements.PrintLayout");
m_svcResource->DeleteResource(plres1);
Ptr<MgResourceIdentifier> plres2 = new MgResourceIdentifier(L"Library://UnitTests/PrintLayouts/NoLegend.PrintLayout");
m_svcResource->DeleteResource(plres2);
// delete the symbol library
Ptr<MgResourceIdentifier> slres1 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/SymbolMart.SymbolLibrary");
m_svcResource->DeleteResource(slres1);
// delete symbology stuff
Ptr<MgResourceIdentifier> fsres4 = new MgResourceIdentifier(L"Library://UnitTests/Data/Capitals.FeatureSource");
m_svcResource->DeleteResource(fsres4);
Ptr<MgResourceIdentifier> sdres1 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/PointSymbol.SymbolDefinition");
m_svcResource->DeleteResource(sdres1);
Ptr<MgResourceIdentifier> sdres2 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/PointSymbolParam.SymbolDefinition");
m_svcResource->DeleteResource(sdres2);
Ptr<MgResourceIdentifier> ldfres4 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Capitals.LayerDefinition");
m_svcResource->DeleteResource(ldfres4);
Ptr<MgResourceIdentifier> ldfres5 = new MgResourceIdentifier(L"Library://UnitTests/Layers/CapitalsParam.LayerDefinition");
m_svcResource->DeleteResource(ldfres5);
Ptr<MgResourceIdentifier> mapres2 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Capitals.MapDefinition");
m_svcResource->DeleteResource(mapres2);
Ptr<MgResourceIdentifier> mapres3 = new MgResourceIdentifier(L"Library://UnitTests/Maps/CapitalsParam.MapDefinition");
m_svcResource->DeleteResource(mapres3);
Ptr<MgResourceIdentifier> fsres5 = new MgResourceIdentifier(L"Library://UnitTests/Data/Lines.FeatureSource");
m_svcResource->DeleteResource(fsres5);
Ptr<MgResourceIdentifier> sdres3 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/LineSymbol.SymbolDefinition");
m_svcResource->DeleteResource(sdres3);
Ptr<MgResourceIdentifier> sdres4 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/MTYP1500a.SymbolDefinition");
m_svcResource->DeleteResource(sdres4);
Ptr<MgResourceIdentifier> ldfres6 = new MgResourceIdentifier(L"Library://UnitTests/Layers/Lines.LayerDefinition");
m_svcResource->DeleteResource(ldfres6);
Ptr<MgResourceIdentifier> ldfres7 = new MgResourceIdentifier(L"Library://UnitTests/Layers/LinesCrossTick.LayerDefinition");
m_svcResource->DeleteResource(ldfres7);
Ptr<MgResourceIdentifier> mapres4 = new MgResourceIdentifier(L"Library://UnitTests/Maps/Lines.MapDefinition");
m_svcResource->DeleteResource(mapres4);
Ptr<MgResourceIdentifier> mapres5 = new MgResourceIdentifier(L"Library://UnitTests/Maps/LinesCrossTick.MapDefinition");
m_svcResource->DeleteResource(mapres5);
Ptr<MgResourceIdentifier> ldfres8 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation1.LayerDefinition");
m_svcResource->DeleteResource(ldfres8);
Ptr<MgResourceIdentifier> ldfres9 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation2.LayerDefinition");
m_svcResource->DeleteResource(ldfres9);
Ptr<MgResourceIdentifier> ldfres10 = new MgResourceIdentifier(L"Library://UnitTests/Layers/UT_Annotation3.LayerDefinition");
m_svcResource->DeleteResource(ldfres10);
Ptr<MgResourceIdentifier> mapres8 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation1.MapDefinition");
m_svcResource->DeleteResource(mapres8);
Ptr<MgResourceIdentifier> mapres9 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation2.MapDefinition");
m_svcResource->DeleteResource(mapres9);
Ptr<MgResourceIdentifier> mapres10 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_Annotation3.MapDefinition");
m_svcResource->DeleteResource(mapres10);
Ptr<MgResourceIdentifier> mapres11 = new MgResourceIdentifier(L"Library://UnitTests/Maps/UT_SymbologyPolygons.MapDefinition");
m_svcResource->DeleteResource(mapres11);
Ptr<MgResourceIdentifier> ldfres11 = new MgResourceIdentifier(L"Library://UnitTests/Layers/SymbologyParcels.LayerDefinition");
m_svcResource->DeleteResource(ldfres11);
Ptr<MgResourceIdentifier> sdres5 = new MgResourceIdentifier(L"Library://UnitTests/Symbols/AreaSymbol.SymbolDefinition");
m_svcResource->DeleteResource(sdres5);
Ptr<MgResourceIdentifier> mapres12 = new MgResourceIdentifier(L"Library://UnitTests/Maps/SheboyganWithWatermark.MapDefinition");
m_svcResource->DeleteResource(mapres12);
Ptr<MgResourceIdentifier> wdfres1 = new MgResourceIdentifier(L"Library://UnitTests/Watermarks/PoweredByMapGuide.WatermarkDefinition");
m_svcResource->DeleteResource(wdfres1);
#ifdef _DEBUG
MgFdoConnectionManager* pFdoConnectionManager = MgFdoConnectionManager::GetInstance();
if(pFdoConnectionManager)
{
pFdoConnectionManager->ShowCache();
}
#endif
}
catch(MgFileIoException* e)
{
STRING message = e->GetDetails(TEST_LOCALE);
SAFE_RELEASE(e);
ACE_DEBUG((LM_INFO, ACE_TEXT("\nMgFileIoException - Possible file permission error.\nError: %W\n"), message.c_str()));
}
catch (MgException* e)
{
STRING message = e->GetDetails(TEST_LOCALE);
message += e->GetStackTrace(TEST_LOCALE);
SAFE_RELEASE(e);
CPPUNIT_FAIL(MG_WCHAR_TO_CHAR(message.c_str()));
}
catch (...)
{
throw;
}
ACE_DEBUG((LM_INFO, ACE_TEXT("\nProfiling Service tests completed.\n\n")));
}
