void object::test<9>()
{
// Test some name=value handling stuff *with* sorting active.
CPLStringList oNVL;
oNVL.Sort();
oNVL.AddNameValue( "KEY1", "VALUE1" );
oNVL.AddNameValue( "2KEY", "VALUE2" );
ensure_equals( "91", oNVL.Count(), 2 );
ensure( "92", EQUAL(oNVL.FetchNameValue("KEY1"),"VALUE1") );
ensure( "93", EQUAL(oNVL.FetchNameValue("2KEY"),"VALUE2") );
ensure( "94", oNVL.FetchNameValue("MISSING") == NULL );
oNVL.AddNameValue( "KEY1", "VALUE3" );
ensure_equals( "95", oNVL.Count(), 3 );
ensure( "96", EQUAL(oNVL.FetchNameValue("KEY1"),"VALUE1") );
ensure( "97", EQUAL(oNVL.FetchNameValueDef("MISSING","X"),"X") );
oNVL.SetNameValue( "2KEY", "VALUE4" );
ensure( "98", EQUAL(oNVL.FetchNameValue("2KEY"),"VALUE4") );
ensure_equals( "99", oNVL.Count(), 3 );
// make sure deletion works.
oNVL.SetNameValue( "2KEY", NULL );
ensure( "9a", oNVL.FetchNameValue("2KEY") == NULL );
ensure_equals( "9b", oNVL.Count(), 2 );
// Test insertion logic pretty carefully.
oNVL.Clear();
ensure( "9c", oNVL.IsSorted() == TRUE );
oNVL.SetNameValue( "B", "BB" );
oNVL.SetNameValue( "A", "AA" );
oNVL.SetNameValue( "D", "DD" );
oNVL.SetNameValue( "C", "CC" );
// items should be in sorted order.
ensure( "9c1", EQUAL(oNVL[0],"A=AA") );
ensure( "9c2", EQUAL(oNVL[1],"B=BB") );
ensure( "9c3", EQUAL(oNVL[2],"C=CC") );
ensure( "9c4", EQUAL(oNVL[3],"D=DD") );
ensure( "9d", EQUAL(oNVL.FetchNameValue("A"),"AA") );
ensure( "9e", EQUAL(oNVL.FetchNameValue("B"),"BB") );
ensure( "9f", EQUAL(oNVL.FetchNameValue("C"),"CC") );
ensure( "9g", EQUAL(oNVL.FetchNameValue("D"),"DD") );
}
static CPLStringList ParseSimpleJson(const char *pszJson)
{
/* -------------------------------------------------------------------- */
/* We are expecting simple documents like the following with no */
/* heirarchy or complex structure. */
/* -------------------------------------------------------------------- */
/*
{
"access_token":"1/fFBGRNJru1FQd44AzqT3Zg",
"expires_in":3920,
"token_type":"Bearer"
}
*/
CPLStringList oWords(
CSLTokenizeString2(pszJson, " \n\t,:{}", CSLT_HONOURSTRINGS ));
CPLStringList oNameValue;
for( int i=0; i < oWords.size(); i += 2 )
{
oNameValue.SetNameValue( oWords[i], oWords[i+1] );
}
return oNameValue;
}
/**
* @details This method is the heart of the tiler. A `TileCoordinate` is used
* to obtain the geospatial extent associated with that tile as related to the
* underlying GDAL dataset. This mapping may require a reprojection if the
* underlying dataset is not in the tile projection system. This information
* is then encapsulated as a GDAL virtual raster (VRT) dataset and returned to
* the caller.
*
* It is the caller's responsibility to call `GDALClose()` on the returned
* dataset.
*/
GDALTile *
GDALTiler::createRasterTile(double (&adfGeoTransform)[6]) const {
if (poDataset == NULL) {
throw CTBException("No GDAL dataset is set");
}
// The source and sink datasets
GDALDatasetH hSrcDS = (GDALDatasetH) dataset();
GDALDatasetH hDstDS;
// The transformation option list
CPLStringList transformOptions;
// The source, sink and grid srs
const char *pszSrcWKT = GDALGetProjectionRef(hSrcDS),
*pszGridWKT = pszSrcWKT;
if (!strlen(pszSrcWKT))
throw CTBException("The source dataset no longer has a spatial reference system assigned");
// Populate the SRS WKT strings if we need to reproject
if (requiresReprojection()) {
pszGridWKT = crsWKT.c_str();
transformOptions.SetNameValue("SRC_SRS", pszSrcWKT);
transformOptions.SetNameValue("DST_SRS", pszGridWKT);
}
// Set the warp options
GDALWarpOptions *psWarpOptions = GDALCreateWarpOptions();
psWarpOptions->eResampleAlg = options.resampleAlg;
psWarpOptions->dfWarpMemoryLimit = options.warpMemoryLimit;
psWarpOptions->hSrcDS = hSrcDS;
psWarpOptions->nBandCount = poDataset->GetRasterCount();
psWarpOptions->panSrcBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panDstBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
for (short unsigned int i = 0; i < psWarpOptions->nBandCount; ++i) {
psWarpOptions->panDstBands[i] = psWarpOptions->panSrcBands[i] = i + 1;
}
// Create the image to image transformer
void *transformerArg = GDALCreateGenImgProjTransformer2(hSrcDS, NULL, transformOptions.List());
if(transformerArg == NULL) {
GDALDestroyWarpOptions(psWarpOptions);
throw CTBException("Could not create image to image transformer");
}
// Try and get an overview from the source dataset that corresponds more
// closely to the resolution of this tile.
GDALDatasetH hWrkSrcDS = getOverviewDataset(hSrcDS, GDALGenImgProjTransform, transformerArg);
if (hWrkSrcDS == NULL) {
hWrkSrcDS = psWarpOptions->hSrcDS = hSrcDS;
} else {
// We need to recreate the transform when operating on an overview.
GDALDestroyGenImgProjTransformer( transformerArg );
transformerArg = GDALCreateGenImgProjTransformer2( hWrkSrcDS, NULL, transformOptions.List() );
if(transformerArg == NULL) {
GDALDestroyWarpOptions(psWarpOptions);
throw CTBException("Could not create overview image to image transformer");
}
}
// Specify the destination geotransform
GDALSetGenImgProjTransformerDstGeoTransform(transformerArg, adfGeoTransform );
// Decide if we are doing an approximate or exact transformation
if (options.errorThreshold) {
// approximate: wrap the transformer with a linear approximator
psWarpOptions->pTransformerArg =
GDALCreateApproxTransformer(GDALGenImgProjTransform, transformerArg, options.errorThreshold);
if (psWarpOptions->pTransformerArg == NULL) {
GDALDestroyWarpOptions(psWarpOptions);
GDALDestroyGenImgProjTransformer(transformerArg);
throw CTBException("Could not create linear approximator");
}
psWarpOptions->pfnTransformer = GDALApproxTransform;
} else {
// exact: no wrapping required
psWarpOptions->pTransformerArg = transformerArg;
psWarpOptions->pfnTransformer = GDALGenImgProjTransform;
}
// Specify a multi threaded warp operation using all CPU cores
CPLStringList warpOptions(psWarpOptions->papszWarpOptions, false);
warpOptions.SetNameValue("NUM_THREADS", "ALL_CPUS");
psWarpOptions->papszWarpOptions = warpOptions.StealList();
// The raster tile is represented as a VRT dataset
hDstDS = GDALCreateWarpedVRT(hWrkSrcDS, mGrid.tileSize(), mGrid.tileSize(), adfGeoTransform, psWarpOptions);
bool isApproxTransform = (psWarpOptions->pfnTransformer == GDALApproxTransform);
GDALDestroyWarpOptions( psWarpOptions );
if (hDstDS == NULL) {
GDALDestroyGenImgProjTransformer(transformerArg);
throw CTBException("Could not create warped VRT");
}
// Set the projection information on the dataset. This will always be the grid
// SRS.
if (GDALSetProjection( hDstDS, pszGridWKT ) != CE_None) {
GDALClose(hDstDS);
if (transformerArg != NULL) {
GDALDestroyGenImgProjTransformer(transformerArg);
}
throw CTBException("Could not set projection on VRT");
}
// If uncommenting the following line for debug purposes, you must also `#include "vrtdataset.h"`
//std::cout << "VRT: " << CPLSerializeXMLTree(((VRTWarpedDataset *) hDstDS)->SerializeToXML(NULL)) << std::endl;
// Create the tile, passing it the base image transformer to manage if this is
// an approximate transform
return new GDALTile((GDALDataset *) hDstDS,
isApproxTransform
? transformerArg : NULL);
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.5.
// Note to developers: if we use newer API, please change the requirement.
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr,
"At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
const char *pszSrcFilename = nullptr;
const char *pszDstFilename = nullptr;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = nullptr;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = nullptr;
int bInverse = FALSE;
CPLStringList aosTO;
int bOutputXY = FALSE;
double dfX = 0.0;
double dfY = 0.0;
double dfZ = 0.0;
double dfT = 0.0;
bool bCoordOnCommandLine = false;
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc && argv[i] != nullptr; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and "
"is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy(argv);
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
else if( EQUAL(argv[i],"-t_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("DST_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("SRC_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-ct") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszCT = argv[++i];
aosTO.SetNameValue("COORDINATE_OPERATION", pszCT );
}
else if( EQUAL(argv[i],"-order") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nOrder = atoi(argv[++i]);
aosTO.SetNameValue("MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
aosTO.SetNameValue("METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
aosTO.SetNameValue("METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
aosTO.SetNameValue("METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
aosTO.AddString( argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
char* endptr = nullptr;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = static_cast<GDAL_GCP *>(
CPLRealloc(pasGCPs, sizeof(GDAL_GCP) * nGCPCount));
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = CPLAtof(argv[++i]);
if( argv[i+1] != nullptr &&
(CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
// Check that last argument is really a number and not a
// filename looking like a number (see ticket #863).
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = CPLAtof(argv[++i]);
}
/* should set id and info? */
}
else if( EQUAL(argv[i],"-output_xy") )
{
bOutputXY = TRUE;
}
else if( EQUAL(argv[i],"-coord") && i + 2 < argc)
{
bCoordOnCommandLine = true;
dfX = CPLAtof(argv[++i]);
dfY = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfZ = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfT = CPLAtof(argv[++i]);
}
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else if( pszSrcFilename == nullptr )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == nullptr )
{
pszDstFilename = argv[i];
}
else
{
Usage("Too many command options.");
}
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = nullptr;
if( pszSrcFilename != nullptr )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == nullptr )
exit( 1 );
}
GDALDatasetH hDstDS = nullptr;
if( pszDstFilename != nullptr )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == nullptr )
exit( 1 );
}
if( hSrcDS != nullptr && nGCPCount > 0 )
{
fprintf(stderr,
"Command line GCPs and input file specified, "
"specify one or the other.\n");
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
if( hTransformArg == nullptr )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
double dfLastT = 0.0;
while( bCoordOnCommandLine || !feof(stdin) )
{
if( !bCoordOnCommandLine )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == nullptr )
break;
char **papszTokens = CSLTokenizeString(szLine);
const int nCount = CSLCount(papszTokens);
if( nCount < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = CPLAtof(papszTokens[0]);
dfY = CPLAtof(papszTokens[1]);
if( nCount >= 3 )
dfZ = CPLAtof(papszTokens[2]);
else
dfZ = 0.0;
if( nCount == 4 )
dfT = CPLAtof(papszTokens[3]);
else
dfT = 0.0;
CSLDestroy(papszTokens);
}
if( dfT != dfLastT && nGCPCount == 0 )
{
if( dfT != 0.0 )
{
aosTO.SetNameValue("COORDINATE_EPOCH", CPLSPrintf("%g", dfT));
}
else
{
aosTO.SetNameValue("COORDINATE_EPOCH", nullptr);
}
GDALDestroyGenImgProjTransformer(hTransformArg);
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
int bSuccess = TRUE;
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
if( bOutputXY )
CPLprintf( "%.15g %.15g\n", dfX, dfY );
else
CPLprintf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
if( bCoordOnCommandLine )
break;
dfLastT = dfT;
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
int GDALMultiDomainMetadata::XMLInit( CPLXMLNode *psTree, CPL_UNUSED int bMerge )
{
CPLXMLNode *psMetadata;
/* ==================================================================== */
/* Process all <Metadata> elements, each for one domain. */
/* ==================================================================== */
for( psMetadata = psTree->psChild;
psMetadata != NULL; psMetadata = psMetadata->psNext )
{
CPLXMLNode *psMDI;
const char *pszDomain, *pszFormat;
if( psMetadata->eType != CXT_Element
|| !EQUAL(psMetadata->pszValue,"Metadata") )
continue;
pszDomain = CPLGetXMLValue( psMetadata, "domain", "" );
pszFormat = CPLGetXMLValue( psMetadata, "format", "" );
// Make sure we have a CPLStringList for this domain,
// without wiping out an existing one.
if( GetMetadata( pszDomain ) == NULL )
SetMetadata( NULL, pszDomain );
int iDomain = CSLFindString( papszDomainList, pszDomain );
CPLAssert( iDomain != -1 );
CPLStringList *poMDList = papoMetadataLists[iDomain];
/* -------------------------------------------------------------------- */
/* XML format subdocuments. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszFormat,"xml") )
{
CPLXMLNode *psSubDoc;
/* find first non-attribute child of current element */
psSubDoc = psMetadata->psChild;
while( psSubDoc != NULL && psSubDoc->eType == CXT_Attribute )
psSubDoc = psSubDoc->psNext;
char *pszDoc = CPLSerializeXMLTree( psSubDoc );
poMDList->Clear();
poMDList->AddStringDirectly( pszDoc );
}
/* -------------------------------------------------------------------- */
/* Name value format. */
/* <MDI key="...">value_Text</MDI> */
/* -------------------------------------------------------------------- */
else
{
for( psMDI = psMetadata->psChild; psMDI != NULL;
psMDI = psMDI->psNext )
{
if( !EQUAL(psMDI->pszValue,"MDI")
|| psMDI->eType != CXT_Element
|| psMDI->psChild == NULL
|| psMDI->psChild->psNext == NULL
|| psMDI->psChild->eType != CXT_Attribute
|| psMDI->psChild->psChild == NULL )
continue;
char* pszName = psMDI->psChild->psChild->pszValue;
char* pszValue = psMDI->psChild->psNext->pszValue;
if( pszName != NULL && pszValue != NULL )
poMDList->SetNameValue( pszName, pszValue );
}
}
}
return CSLCount(papszDomainList) != 0;
}
void object::test<8>()
{
// Test some name=value handling stuff.
CPLStringList oNVL;
oNVL.AddNameValue( "KEY1", "VALUE1" );
oNVL.AddNameValue( "2KEY", "VALUE2" );
ensure_equals( oNVL.Count(), 2 );
ensure( EQUAL(oNVL.FetchNameValue("2KEY"),"VALUE2") );
ensure( oNVL.FetchNameValue("MISSING") == NULL );
oNVL.AddNameValue( "KEY1", "VALUE3" );
ensure( EQUAL(oNVL.FetchNameValue("KEY1"),"VALUE1") );
ensure( EQUAL(oNVL[2],"KEY1=VALUE3") );
ensure( EQUAL(oNVL.FetchNameValueDef("MISSING","X"),"X") );
oNVL.SetNameValue( "2KEY", "VALUE4" );
ensure( EQUAL(oNVL.FetchNameValue("2KEY"),"VALUE4") );
ensure_equals( oNVL.Count(), 3 );
// make sure deletion works.
oNVL.SetNameValue( "2KEY", NULL );
ensure( oNVL.FetchNameValue("2KEY") == NULL );
ensure_equals( oNVL.Count(), 2 );
// Test boolean support.
ensure_equals( "b1", oNVL.FetchBoolean( "BOOL", TRUE ), TRUE );
ensure_equals( "b2", oNVL.FetchBoolean( "BOOL", FALSE ), FALSE );
oNVL.SetNameValue( "BOOL", "YES" );
ensure_equals( "b3", oNVL.FetchBoolean( "BOOL", TRUE ), TRUE );
ensure_equals( "b4", oNVL.FetchBoolean( "BOOL", FALSE ), TRUE );
oNVL.SetNameValue( "BOOL", "1" );
ensure_equals( "b5", oNVL.FetchBoolean( "BOOL", FALSE ), TRUE );
oNVL.SetNameValue( "BOOL", "0" );
ensure_equals( "b6", oNVL.FetchBoolean( "BOOL", TRUE ), FALSE );
oNVL.SetNameValue( "BOOL", "FALSE" );
ensure_equals( "b7", oNVL.FetchBoolean( "BOOL", TRUE ), FALSE );
oNVL.SetNameValue( "BOOL", "ON" );
ensure_equals( "b8", oNVL.FetchBoolean( "BOOL", FALSE ), TRUE );
// Test assignmenet operator.
CPLStringList oCopy;
{
CPLStringList oTemp;
oTemp.AddString("test");
oCopy = oTemp;
}
ensure( "c1", EQUAL(oCopy[0],"test") );
oCopy = oCopy;
ensure( "c2", EQUAL(oCopy[0],"test") );
// Test copy constructor.
CPLStringList oCopy2(oCopy);
oCopy.Clear();
ensure( "c3", EQUAL(oCopy2[0],"test") );
// Test sorting
CPLStringList oTestSort;
oTestSort.AddNameValue("Z", "1");
oTestSort.AddNameValue("L", "2");
oTestSort.AddNameValue("T", "3");
oTestSort.AddNameValue("A", "4");
oTestSort.Sort();
ensure( "c4", EQUAL(oTestSort[0],"A=4") );
ensure( "c5", EQUAL(oTestSort[1],"L=2") );
ensure( "c6", EQUAL(oTestSort[2],"T=3") );
ensure( "c7", EQUAL(oTestSort[3],"Z=1") );
ensure_equals( "c8", oTestSort[4], (const char*)NULL );
// Test FetchNameValue() in a sorted list
ensure( "c9", EQUAL(oTestSort.FetchNameValue("A"),"4") );
ensure( "c10", EQUAL(oTestSort.FetchNameValue("L"),"2") );
ensure( "c11", EQUAL(oTestSort.FetchNameValue("T"),"3") );
ensure( "c12", EQUAL(oTestSort.FetchNameValue("Z"),"1") );
// Test AddNameValue() in a sorted list
oTestSort.AddNameValue("B", "5");
ensure( "c13", EQUAL(oTestSort[0],"A=4") );
ensure( "c14", EQUAL(oTestSort[1],"B=5") );
ensure( "c15", EQUAL(oTestSort[2],"L=2") );
ensure( "c16", EQUAL(oTestSort[3],"T=3") );
ensure( "c17", EQUAL(oTestSort[4],"Z=1") );
ensure_equals( "c18", oTestSort[5], (const char*)NULL );
// Test SetNameValue() of an existing item in a sorted list
oTestSort.SetNameValue("Z", "6");
ensure( "c19", EQUAL(oTestSort[4],"Z=6") );
// Test SetNameValue() of a non-existing item in a sorted list
oTestSort.SetNameValue("W", "7");
ensure( "c20", EQUAL(oTestSort[0],"A=4") );
ensure( "c21", EQUAL(oTestSort[1],"B=5") );
ensure( "c22", EQUAL(oTestSort[2],"L=2") );
ensure( "c23", EQUAL(oTestSort[3],"T=3") );
ensure( "c24", EQUAL(oTestSort[4],"W=7") );
ensure( "c25", EQUAL(oTestSort[5],"Z=6") );
ensure_equals( "c26", oTestSort[6], (const char*)NULL );
}
