Changeset 3531


Ignore:
Timestamp:
Dec 9, 2011 12:46:06 AM (5 years ago)
Author:
strk
Message:

Allow XML tests not to specify a precision model, defaulting to floating

This allows running some JTS tests w/out touching them

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/3.3/tests/xmltester/XMLTester.cpp

    r3295 r3531  
    419419XMLTester::parseRun(const TiXmlNode* node)
    420420{
     421        using geos::geom::PrecisionModel;
     422
    421423        assert(node);
    422424
     
    426428        const TiXmlElement* el = node->FirstChildElement("precisionModel");
    427429        if ( el ) parsePrecisionModel(el);
    428 
    429         const TiXmlNode* casenode;
    430         for ( casenode = node->FirstChild("case");
    431               casenode;
    432               casenode = casenode->NextSibling("case") )
    433         {
    434                 try {
    435                         parseCase(casenode);
    436                 } catch (const std::exception& exc) {
    437                         std::cerr<<exc.what()<<std::endl;
    438                 }
    439         }
    440 
    441 }
    442 
    443 void
    444 XMLTester::parsePrecisionModel(const TiXmlElement* el)
    445 {
    446         using geos::geom::PrecisionModel;
    447 
    448         //dump_to_stdout(el);
    449 
    450         /* This does not seem to work... */
    451         std::string type;
    452         const char* typeStr = el->Attribute("type");
    453         if ( typeStr ) type = typeStr;
    454 
    455         const char* scaleStr = el->Attribute("scale");
    456 
    457         if ( ! scaleStr ) {
    458                 if ( type == "FLOATING_SINGLE" )
    459                 {
    460                         pm.reset(new PrecisionModel(PrecisionModel::FLOATING_SINGLE));
    461                 }
    462                 else
    463                 {
    464                         pm.reset(new PrecisionModel());
    465                 }
    466         } else {
    467 
    468                 char* stopstring;
    469 
    470                 double scale = std::strtod(scaleStr, &stopstring);
    471                 double offsetX = 0;
    472                 double offsetY = 2;
    473 
    474                 if ( ! el->QueryDoubleAttribute("offsetx", &offsetX) )
    475                 {} // std::cerr << "No offsetx" << std::endl;
    476 
    477                 if ( ! el->QueryDoubleAttribute("offsety", &offsetY) )
    478                 {} // std::cerr << "No offsety" << std::endl;
    479 
    480                 // NOTE: PrecisionModel discards offsets anyway...
    481                 pm.reset(new PrecisionModel(scale, offsetX, offsetY));
    482         }
     430        else pm.reset(new PrecisionModel());
    483431
    484432        if (verbose > 1)
     
    492440        wkbreader.reset(new io::WKBReader(*factory));
    493441        wkbwriter.reset(new io::WKBWriter());
     442
     443        const TiXmlNode* casenode;
     444        for ( casenode = node->FirstChild("case");
     445              casenode;
     446              casenode = casenode->NextSibling("case") )
     447        {
     448                try {
     449                        parseCase(casenode);
     450                } catch (const std::exception& exc) {
     451                        std::cerr<<exc.what()<<std::endl;
     452                }
     453        }
     454
     455}
     456
     457void
     458XMLTester::parsePrecisionModel(const TiXmlElement* el)
     459{
     460        using geos::geom::PrecisionModel;
     461
     462        //dump_to_stdout(el);
     463
     464        /* This does not seem to work... */
     465        std::string type;
     466        const char* typeStr = el->Attribute("type");
     467        if ( typeStr ) type = typeStr;
     468
     469        const char* scaleStr = el->Attribute("scale");
     470
     471        if ( ! scaleStr ) {
     472                if ( type == "FLOATING_SINGLE" )
     473                {
     474                        pm.reset(new PrecisionModel(PrecisionModel::FLOATING_SINGLE));
     475                }
     476                else
     477                {
     478                        pm.reset(new PrecisionModel());
     479                }
     480        } else {
     481
     482                char* stopstring;
     483
     484                double scale = std::strtod(scaleStr, &stopstring);
     485                double offsetX = 0;
     486                double offsetY = 2;
     487
     488                if ( ! el->QueryDoubleAttribute("offsetx", &offsetX) )
     489                {} // std::cerr << "No offsetx" << std::endl;
     490
     491                if ( ! el->QueryDoubleAttribute("offsety", &offsetY) )
     492                {} // std::cerr << "No offsety" << std::endl;
     493
     494                // NOTE: PrecisionModel discards offsets anyway...
     495                pm.reset(new PrecisionModel(scale, offsetX, offsetY));
     496        }
    494497}
    495498
Note: See TracChangeset for help on using the changeset viewer.