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 ); }