RenJuan
/
DRDE
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*

This commit is contained in:
Ren RenJuan 2014-01-17 01:46:48 +00:00
parent 565b85ca23
commit 318ea42bba
41 changed files with 97 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ACTK1_0/Makefile
View File

@ -1,8 +1,8 @@
##################################################
# Makefile for building lib and main test routine#
##################################################
#LOCATION=DEBIAN_7
LOCATION=DEBIAN_6
LOCATION=DEBIAN_7
#LOCATION=DEBIAN_6
#LOCATION=OSX_10_8
SYSTEM = $(shell uname -s)
@ -115,7 +115,7 @@ $(BUILD_OBJ_DIR)/%: $(BUILD_OBJ_DIR)/%.o
# The toolkit raises the c++ "static initialization fiasco" situation.
#
ARTKOBJS= build/XMLGregorianCalendar.o build/XMLParser.o build/XMLWriter.o build/ACSession.o build/DomainAddRem.o build/EnumDomainInfoResponse.o build/log.o build/PostalInfoType.o build/SessionManagerPropertiesImpl.o \
build/RegistrantObjectType.o /
build/RegistrantObjectType.o \
build/AddRemType.o build/DomainCheckResponse.o build/EnumDomainUpdateCommand.o build/LPECheckResponse.o build/Properties.o build/SessionPoolImpl.o \
build/boolean.o build/DomainCreateCommand.o build/EnumType.o build/LPECreateCommand.o build/ProtocolExtensionCommand.o build/SSLException.o \
build/CertificateUserMismatchException.o build/DomainCreateResponse.o build/EPPDateFormatter.o build/LPECreateResponse.o build/ReceiveSE.o build/StandardCommandType.o \

2
ACTK1_0/OTE/LPECheckCommandTest.cpp
View File

@ -1,8 +1,8 @@
#include "common/init.hpp"
#include "common/Test.hpp"
#include "se/CLTRID.hpp"
#include "OTE/LPECheckCommand.hpp"
#include "session/Timer.hpp"
#include "OTE/LPECheckCommand.hpp"
#include <iostream>

2
ACTK1_0/OTE/LPECheckResponse.cpp
View File

@ -1,6 +1,6 @@
#include "OTE/LPECheckResponse.hpp"
#include "common/StringUtils.hpp"
#include "se/StandardObjectType.hpp"
#include "OTE/LPECheckResponse.hpp"
const std::string& LPECheckResponse::DOM_CHKDATA_COUNT_EXPR()
{

2
ACTK1_0/OTE/LPECheckResponseTest.cpp
View File

@ -1,10 +1,10 @@
#include "OTE/LPECheckResponse.hpp"
#include "session/TestEnvironment.hpp"
#include "xml/XMLParser.hpp"
#include "xml/XMLDocument.hpp"
#include "common/init.hpp"
#include "common/Test.hpp"
#include "OTE/LPECheckResponse.hpp"
#include <memory>

2
ACTK1_0/OTE/LPECreateCommand.cpp
View File

@ -1,6 +1,6 @@
#include "OTE/LPECreateCommand.hpp"
#include "se/StandardObjectType.hpp"
#include "xml/XMLHelper.hpp"
#include "OTE/LPECreateCommand.hpp"
LPECreateCommand::LPECreateCommand (const std::string& name,

2
ACTK1_0/OTE/LPECreateResponse.cpp
View File

@ -1,7 +1,7 @@
#include "OTE/LPECreateResponse.hpp"
#include "se/StandardObjectType.hpp"
#include "se/EPPDateFormatter.hpp"
#include "common/StringUtils.hpp"
#include "OTE/LPECreateResponse.hpp"
const std::string LPECreateResponse::DOM_CR_DATE_EXPR
(LPECreateResponse::exprReplace

5
ACTK1_0/OTE/OteDomainModifyRegistrantCommand.cpp
View File

@ -1,7 +1,8 @@
#include "OTE/OteDomainModifyRegistrantCommand.hpp"
#include "common/ErrorPkg.hpp"
#include "OTE/OteExtension.hpp"
#include "xml/XMLHelper.hpp"
#include "OTE/OteExtension.hpp"
#include "OTE/OteDomainModifyRegistrantCommand.hpp"
namespace {
OteExtension& oteExtension() {

12
ACTK1_0/OTE/OteDomainTransferRegistrantCommand.cpp
View File

@ -1,12 +1,12 @@
#include "OTE/OteDomainTransferRegistrantCommand.hpp"
#include "se/XMLGregorianCalendar.hpp"
#include "se/CommandType.hpp"
#include "common/ErrorPkg.hpp"
#include "se/Period.hpp"
#include "se/RegistrantTransferCommandType.hpp"
#include "OTE/OteExtension.hpp"
#include "OTE/OteDomainObjectType.hpp"
#include "se/RegistrantTransferCommandType.hpp"
#include "se/CommandType.hpp"
#include "se/Period.hpp"
#include "common/ErrorPkg.hpp"
#include "OTE/OteDomainTransferRegistrantCommand.hpp"
#include "se/EPPDateFormatter.hpp"

4
ACTK1_0/OTE/OteDomainTransferRegistrantResponse.cpp
View File

@ -1,7 +1,7 @@
#include "OTE/OteDomainTransferRegistrantResponse.hpp"
#include "OTE/OteDomainObjectType.hpp"
#include "se/RegistrantTransferCommandType.hpp"
#include "se/EPPDateFormatter.hpp"
#include "OTE/OteDomainObjectType.hpp"
#include "OTE/OteDomainTransferRegistrantResponse.hpp"
namespace {
const RegistrantTransferCommandType rtrnType;

4
ACTK1_0/OTE/OteLPECreateCommand.cpp
View File

@ -1,7 +1,7 @@
#include "OTE/OteLPECreateCommand.hpp"
#include "xml/XMLHelper.hpp"
#include "OTE/OteExtension.hpp"
#include "common/ErrorPkg.hpp"
#include "OTE/OteExtension.hpp"
#include "OTE/OteLPECreateCommand.hpp"
namespace {
Extension& oteExtension() {

2
ACTK1_0/OTE/OteLPECreateCommandTest.cpp
View File

@ -1,9 +1,9 @@
#include "common/init.hpp"
#include "common/Test.hpp"
#include "session/Timer.hpp"
#include "se/CLTRID.hpp"
#include "se/ContactCheckCommand.hpp"
#include "OTE/OteLPECreateCommand.hpp"
#include "se/CLTRID.hpp"
using namespace std;

2
AusRegEPPTK/se/AeDomainTransferRegistrantCommand.cpp
View File

@ -24,7 +24,7 @@ namespace {
AeDomainTransferRegistrantCommand::AeDomainTransferRegistrantCommand (
const std::string& name,
const XMLGregorianCalendar& curExpDate,
constXMLGC::XMLGregorianCalendar& curExpDate,
const std::string& eligibilityType,
int policyReason,
const std::string& registrantName,

2
AusRegEPPTK/se/AeDomainTransferRegistrantResponse.cpp
View File

@ -31,7 +31,7 @@ void AeDomainTransferRegistrantResponse::fromXML(XMLDocument* xmlDoc) throw (Par
name = xmlDoc->getNodeValue(AEDOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue(AEDOM_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(exDateStr));
}

2
AusRegEPPTK/se/ArDomainUnrenewCommand.cpp
View File

@ -27,7 +27,7 @@ namespace {
ArDomainUnrenewCommand::ArDomainUnrenewCommand(
const std::string &name,
const XMLGregorianCalendar& exDate) : ProtocolExtensionCommand(
constXMLGC::XMLGregorianCalendar& exDate) : ProtocolExtensionCommand(
&unrenewCmdType, &ardomType, name, arExtension())
{
std::string exDateStr = EPPDateFormatter::toXSDate(exDate);

2
AusRegEPPTK/se/ArDomainUnrenewResponse.cpp
View File

@ -31,7 +31,7 @@ void ArDomainUnrenewResponse::fromXML(XMLDocument* xmlDoc) throw (ParsingExcepti
name = xmlDoc->getNodeValue(ARDOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue(ARDOM_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(exDateStr));
}

4
AusRegEPPTK/se/ArDomainUnrenewResponseTest.cpp
View File

@ -22,7 +22,7 @@ void doWork()
response1.fromXML(doc.get());
{
ASSERT_EQ(response1.getName(), "example.com");
const XMLGregorianCalendar *exDate = response1.getExpiryDate();
constXMLGC::XMLGregorianCalendar *exDate = response1.getExpiryDate();
string res = EPPDateFormatter::toXSDateTime(*exDate);
ASSERT_EQ(res, "2009-04-03T22:00:00.0Z");
const vector<Result>& results(response1.getResults());
@ -36,7 +36,7 @@ void doWork()
response2.fromXML(doc2.get());
{
ASSERT_EQ(response2.getName(), "example.com");
const XMLGregorianCalendar *exDate = response2.getExpiryDate();
constXMLGC::XMLGregorianCalendar *exDate = response2.getExpiryDate();
ASSERT_NULL(exDate);
const vector<Result>& results(response2.getResults());
ASSERT_EQ(response2.getCLTRID(), "ABC-12345");

2
AusRegEPPTK/se/AuDomainTransferRegistrantCommand.cpp
View File

@ -24,7 +24,7 @@ namespace {
AuDomainTransferRegistrantCommand::AuDomainTransferRegistrantCommand (
const std::string& name,
const XMLGregorianCalendar& curExpDate,
constXMLGC::XMLGregorianCalendar& curExpDate,
const std::string& eligibilityType,
int policyReason,
const std::string& registrantName,

2
AusRegEPPTK/se/AuDomainTransferRegistrantCommandTest.cpp
View File

@ -22,7 +22,7 @@ void doWork()
const string eligibilityName = "Blah";
const string eligibilityID = "1231239523";
const string eligibilityIDType = "OTHER";
auto_ptr<XMLGregorianCalendar> curExpDate(EPPDateFormatter::fromXSDateTime("2014-01-01T01:01:01.0Z"));
auto_ptr<XMLGC::XMLGregorianCalendar> curExpDate(EPPDateFormatter::fromXSDateTime("2014-01-01T01:01:01.0Z"));
{
Timer::setTime("20070101.010101");

2
AusRegEPPTK/se/AuDomainTransferRegistrantResponse.cpp
View File

@ -31,7 +31,7 @@ void AuDomainTransferRegistrantResponse::fromXML(XMLDocument* xmlDoc) throw (Par
name = xmlDoc->getNodeValue(AUDOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue(AUDOM_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(exDateStr));
}

2
AusRegEPPTK/se/AuDomainTransferRegistrantResponseTest.cpp
View File

@ -20,7 +20,7 @@ void doWork()
response.fromXML(doc.get());
{
ASSERT_EQ(response.getName(), "example.com");
const XMLGregorianCalendar *exDate = response.getExpiryDate();
constXMLGC::XMLGregorianCalendar *exDate = response.getExpiryDate();
string res = EPPDateFormatter::toXSDateTime(*exDate);
ASSERT_EQ(res, "2009-04-03T22:00:00.0Z");
const vector<Result>& results(response.getResults());

2
AusRegEPPTK/se/CreateResponse.cpp
View File

@ -35,7 +35,7 @@ void CreateResponse::fromXML(XMLDocument *xmlDoc) throw (ParsingException)
try
{
std::string crDateStr = xmlDoc->getNodeValue(crDateExpr());
crDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(crDateStr));
crDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(crDateStr));
}
catch (IllegalArgException& iae)
{

2
AusRegEPPTK/se/DomainCreateResponse.cpp
View File

@ -35,7 +35,7 @@ void DomainCreateResponse::fromXML (XMLDocument *xmlDoc) throw (ParsingException
{
name = xmlDoc->getNodeValue (DOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue (DOM_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(exDateStr));
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(exDateStr));
}
catch (XPathExpressionException& e)
{

2
AusRegEPPTK/se/DomainInfoResponse.cpp
View File

@ -160,7 +160,7 @@ void DomainInfoResponse::fromXML(XMLDocument *xmlDoc) throw (ParsingException)
name = xmlDoc->getNodeValue(DOM_NAME_EXPR());
pw = xmlDoc->getNodeValue(DOM_PW_EXPR());
registrantID = xmlDoc->getNodeValue (DOM_REGISTRANT_EXPR());
exDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime
(xmlDoc->getNodeValue (DOM_EX_DATE_EXPR())));
delHosts = xmlDoc->getNodeValues(DOM_NS_EXPR());
subHosts = xmlDoc->getNodeValues(DOM_HOST_EXPR());

2
AusRegEPPTK/se/DomainRegistrantTransferCommand.cpp
View File

@ -24,7 +24,7 @@ RegistrantObjectType& registrantObjectType() {
} // anonymous namespace
DomainRegistrantTransferCommand::DomainRegistrantTransferCommand(const std::string& name,
const XMLGregorianCalendar& curExpDate,
constXMLGC::XMLGregorianCalendar& curExpDate,
const std::string& kvListName,
const std::string& explanation,
const Period* period) :

2
AusRegEPPTK/se/DomainRegistrantTransferCommandTest.cpp
View File

@ -16,7 +16,7 @@ const static std::string policyReason = "1";
const static std::string eligibilityName = "Blah";
const static std::string eligibilityIDValue = "1231239523";
const static std::string eligibilityIDType = "Trademark";
const auto_ptr<XMLGregorianCalendar> curExpDate(EPPDateFormatter::fromXSDateTime("2014-01-01T01:01:01.0Z"));
const auto_ptr<XMLGC::XMLGregorianCalendar> curExpDate(EPPDateFormatter::fromXSDateTime("2014-01-01T01:01:01.0Z"));
const static std::string kvListName = "ae";
void addSampleKVItems(DomainRegistrantTransferCommand *command);

2
AusRegEPPTK/se/DomainRegistrantTransferResponse.cpp
View File

@ -31,7 +31,7 @@ void DomainRegistrantTransferResponse::fromXML(XMLDocument* xmlDoc) throw (Parsi
name = xmlDoc->getNodeValue(REGISTRANT_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue(REGISTRANT_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(exDateStr));
}

2
AusRegEPPTK/se/DomainRegistrantTransferResponseTest.cpp
View File

@ -20,7 +20,7 @@ void doWork()
response.fromXML(doc.get());
{
ASSERT_EQ(response.getName(), "example.com");
const XMLGregorianCalendar *exDate = response.getExpiryDate();
constXMLGC::XMLGregorianCalendar *exDate = response.getExpiryDate();
string res = EPPDateFormatter::toXSDateTime(*exDate);
ASSERT_EQ(res, "2009-04-03T22:00:00.0Z");
const vector<Result>& results(response.getResults());

6
AusRegEPPTK/se/DomainRenewCommand.cpp
View File

@ -6,7 +6,7 @@
#include "se/EPPDateFormatter.hpp"
DomainRenewCommand::DomainRenewCommand (const std::string &name,
const XMLGregorianCalendar &exDate)
constXMLGC::XMLGregorianCalendar &exDate)
: ObjectCommand(StandardCommandType::RENEW(),
StandardObjectType::DOMAIN(),
name)
@ -16,7 +16,7 @@ DomainRenewCommand::DomainRenewCommand (const std::string &name,
DomainRenewCommand::DomainRenewCommand (const std::string &name,
const XMLGregorianCalendar &exDate,
constXMLGC::XMLGregorianCalendar &exDate,
const Period &period)
: ObjectCommand(StandardCommandType::RENEW(),
StandardObjectType::DOMAIN(),
@ -29,7 +29,7 @@ DomainRenewCommand::DomainRenewCommand (const std::string &name,
void DomainRenewCommand::Init (const std::string &name,
const XMLGregorianCalendar &exDate)
constXMLGC::XMLGregorianCalendar &exDate)
{
XMLHelper::setTextContent
(xmlWriter->appendChild (objElement, "curExpDate"),

2
AusRegEPPTK/se/DomainRenewResponse.cpp
View File

@ -26,7 +26,7 @@ void DomainRenewResponse::fromXML (XMLDocument *xmlDoc) throw (ParsingException)
{
name = xmlDoc->getNodeValue (DOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue (DOM_EX_DATE_EXPR);
exDate = std::auto_ptr<XMLGregorianCalendar>(
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(exDateStr));
}
catch (XPathExpressionException& e)

2
AusRegEPPTK/se/DomainTransferResponse.cpp
View File

@ -48,7 +48,7 @@ void DomainTransferResponse::fromXML (XMLDocument *xmlDoc) throw (ParsingExcepti
name = xmlDoc->getNodeValue(DOM_NAME_EXPR);
std::string exDateStr = xmlDoc->getNodeValue(DOM_EXDATE_EXPR);
if (exDateStr.length() > 0)
exDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(exDateStr));
exDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(exDateStr));
}
catch (XPathExpressionException& e)
{

2
AusRegEPPTK/se/DomainUpdateCommandTest.cpp
View File

@ -86,7 +86,7 @@ void testSyncExpiryDateExtension(void)
CLTRID::setClID("JTKUTEST");
DomainUpdateCommand cmd("jtkutest.com.au");
XMLGregorianCalendar *newExpiryDate = EPPDateFormatter::fromXSDateTime("2005-04-03T22:00:00.0Z");
XMLGC::XMLGregorianCalendar *newExpiryDate = EPPDateFormatter::fromXSDateTime("2005-04-03T22:00:00.0Z");
DomainUpdateSyncCommandExtension extension(newExpiryDate);
cmd.appendExtension(extension);

6
AusRegEPPTK/se/EPPDateFormatter.cpp
View File

@ -2,12 +2,12 @@
#include "se/XMLGregorianCalendar.hpp"
#include <sstream>
std::string EPPDateFormatter::toXSDateTime(const XMLGregorianCalendar& date)
std::string EPPDateFormatter::toXSDateTime(constXMLGC::XMLGregorianCalendar& date)
{
return date.toXMLFormat();
}
std::string EPPDateFormatter::toXSDate(const XMLGregorianCalendar& date)
std::string EPPDateFormatter::toXSDate(constXMLGC::XMLGregorianCalendar& date)
{
return date.format("%Y-%M-%D");
}
@ -16,7 +16,7 @@ XMLGregorianCalendar* EPPDateFormatter::fromXSDateTime(const std::string &dateTi
{
try
{
return new XMLGregorianCalendar(dateTime);
return newXMLGC::XMLGregorianCalendar(dateTime);
}
catch (MalformedDateException& e)
{

2
AusRegEPPTK/se/Greeting.cpp
View File

@ -55,7 +55,7 @@ void Greeting::fromXML(XMLDocument *xmlDoc) throw (ParsingException)
// debugLogger->info (xmlDoc->toString());
svID = xmlDoc->getNodeValue (SVID_EXPR);
std::string svDateText = xmlDoc->getNodeValue (SVDATE_EXPR);
svDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(svDateText));
svDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(svDateText));
versions = xmlDoc->getNodeValues(VERSIONS_EXPR);
langs = xmlDoc->getNodeValues(LANGS_EXPR);
objURIs = xmlDoc->getNodeValues(OBJ_URIS_EXPR);

4
AusRegEPPTK/se/HostInfoResponseTest.cpp
View File

@ -38,11 +38,11 @@ void doWork()
{
ASSERT_EQ("NS1_EXAMPLE1-REP", response.getROID());
auto_ptr<XMLGregorianCalendar> dt(
auto_ptr<XMLGC::XMLGregorianCalendar> dt(
EPPDateFormatter::fromXSDateTime("1999-04-03T22:00:00.0Z"));
ASSERT_EQ(EPPDateFormatter::toXSDateTime(*dt), "1999-04-03T22:00:00.0Z");
auto_ptr<XMLGregorianCalendar> dt2(
auto_ptr<XMLGC::XMLGregorianCalendar> dt2(
EPPDateFormatter::fromXSDateTime("1999-04-03T22:00:00.0Z"));
ASSERT_EQ(EPPDateFormatter::toXSDateTime(*dt2), "1999-04-03T22:00:00.0Z");

6
AusRegEPPTK/se/InfoResponse.cpp
View File

@ -96,9 +96,9 @@ void InfoResponse::fromXML (XMLDocument *xmlDoc) throw (ParsingException)
std::string upDateStr = xmlDoc->getNodeValue(upDateExpr());
std::string trDateStr = xmlDoc->getNodeValue(trDateExpr());
crDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(crDateStr));
upDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(upDateStr));
trDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(trDateStr));
crDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(crDateStr));
upDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(upDateStr));
trDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(trDateStr));
int statusCount = xmlDoc->getNodeCount (statusCountExpr());
statuses.clear();

2
AusRegEPPTK/se/NotificationResponse.cpp
View File

@ -86,7 +86,7 @@ void NotificationResponse::fromXML(XMLDocument *xmlDoc) throw (ParsingException)
padateStr = xmlDoc->getNodeValue(padateExpr());
result = (resultStr == "1");
paDate = std::auto_ptr<XMLGregorianCalendar>(
paDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(
EPPDateFormatter::fromXSDateTime(padateStr));
}
catch (XPathExpressionException& e)

4
AusRegEPPTK/se/PollResponseTest.cpp
View File

@ -44,7 +44,7 @@ void testContactTransferApprovePoll()
results[0].getResultMessage());
ASSERT_EQ("ABC-12345", response.getCLTRID());
const XMLGregorianCalendar *qDate1 = response.getMessageEnqueueDate();
constXMLGC::XMLGregorianCalendar *qDate1 = response.getMessageEnqueueDate();
std::string res = EPPDateFormatter::toXSDateTime(*qDate1);
ASSERT_EQ(res, "2000-06-08T22:00:00.0Z");
@ -76,7 +76,7 @@ void testDomainTransferApprovePoll()
results[0].getResultMessage());
ASSERT_EQ("ABC-12345", response.getCLTRID());
const XMLGregorianCalendar *qDate1 = response.getMessageEnqueueDate();
constXMLGC::XMLGregorianCalendar *qDate1 = response.getMessageEnqueueDate();
std::string res = EPPDateFormatter::toXSDateTime(*qDate1);
ASSERT_EQ(res, "2000-06-08T22:00:00.0Z");

2
AusRegEPPTK/se/Response.cpp
View File

@ -124,7 +124,7 @@ void Response::fromXML (XMLDocument *xmlDoc) throw (ParsingException)
std::string msgQqDate = xmlDoc->getNodeValue(MSGQ_QDATE_EXPR());
if (msgQqDate != "")
qDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(msgQqDate));
qDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(msgQqDate));
msg = xmlDoc->getNodeValue(MSGQ_MSG_EXPR());
msgLang = xmlDoc->getNodeValue (MSGQ_MSG_LANG_EXPR());

4
AusRegEPPTK/se/TransferResponse.cpp
View File

@ -60,12 +60,12 @@ void TransferResponse::fromXML (XMLDocument *xmlDoc) throw (ParsingException)
reID = xmlDoc->getNodeValue (reIDExpr());
string reDateStr = xmlDoc->getNodeValue(reDateExpr());
if (reDateStr.length() > 0)
reDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(reDateStr));
reDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(reDateStr));
acID = xmlDoc->getNodeValue(acIDExpr());
string acDateStr = xmlDoc->getNodeValue (acDateExpr());
if (acDateStr.length() > 0)
acDate = std::auto_ptr<XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(acDateStr));
acDate = std::auto_ptr<XMLGC::XMLGregorianCalendar>(EPPDateFormatter::fromXSDateTime(acDateStr));
}
catch (XPathExpressionException& e)
{

50
AusRegEPPTK/se/XMLGregorianCalendar.cpp
View File

@ -9,7 +9,7 @@
using namespace std;
const char * XMLGregorianCalendar::FIELD_NAME[] =
const char *XMLGC::XMLGregorianCalendar::FIELD_NAME[] =
{ "Year",
"Month",
"Day",
@ -19,7 +19,7 @@ const char * XMLGregorianCalendar::FIELD_NAME[] =
"Millisecond",
"Timezone" };
const int XMLGregorianCalendar::daysInMonth[] =
const intXMLGC::XMLGregorianCalendar::daysInMonth[] =
{ 0, // XML Schema months start at 1.
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
@ -68,7 +68,7 @@ class Parser
public:
Parser (const string &format,
const string &value,
XMLGregorianCalendar *calendar)
XMLGC::XMLGregorianCalendar *calendar)
: calendar(calendar), format(format), value(value), flen(format.length()),
vlen(value.length()), fidx(0), vidx(0)
{ }
@ -148,7 +148,7 @@ public:
// End parse()
private:
XMLGregorianCalendar *calendar;
XMLGC::XMLGregorianCalendar *calendar;
string format, value;
int flen, vlen;
@ -348,7 +348,7 @@ XMLGregorianCalendar::XMLGregorianCalendar(const string &lexicalRepresentation)
if (!isValid()) throw MalformedDateException("common.date.format");
}
bool XMLGregorianCalendar::isValid() const
boolXMLGC::XMLGregorianCalendar::isValid() const
{
if (year == 0)
return false;
@ -373,7 +373,7 @@ bool XMLGregorianCalendar::isValid() const
return true;
}
void XMLGregorianCalendar::setMonth (int month)
void XMLGC::XMLGregorianCalendar::setMonth (int month)
{
if ((month < JANUARY || DECEMBER < month) && month != FIELD_UNDEFINED)
invalidFieldValue (MONTH, month);
@ -381,7 +381,7 @@ void XMLGregorianCalendar::setMonth (int month)
this->month = month;
}
void XMLGregorianCalendar::setDay (int day)
void XMLGC::XMLGregorianCalendar::setDay (int day)
{
if ((day < 1 || 31 < day) && day != FIELD_UNDEFINED)
invalidFieldValue (DAY, day);
@ -389,7 +389,7 @@ void XMLGregorianCalendar::setDay (int day)
this->day = day;
}
void XMLGregorianCalendar::setTimezone (int offset)
void XMLGC::XMLGregorianCalendar::setTimezone (int offset)
{
if ((offset < -14*60 || 14*60 < offset) && offset != FIELD_UNDEFINED)
invalidFieldValue (TIMEZONE, offset);
@ -397,7 +397,7 @@ void XMLGregorianCalendar::setTimezone (int offset)
this->timezone = offset;
}
void XMLGregorianCalendar::setTime (int hour,
void XMLGC::XMLGregorianCalendar::setTime (int hour,
int minute,
int second,
long double fractional)
@ -419,7 +419,7 @@ void XMLGregorianCalendar::setTime (int hour,
testHour();
}
void XMLGregorianCalendar::testHour()
void XMLGC::XMLGregorianCalendar::testHour()
{
if (hour == 24 && (getMinute() != 0 ||
getSecond() != 0))
@ -427,7 +427,7 @@ void XMLGregorianCalendar::testHour()
}
void XMLGregorianCalendar::setHour (int hour, bool validate)
void XMLGC::XMLGregorianCalendar::setHour (int hour, bool validate)
{
if ((hour < 0 || hour > 24) && hour != FIELD_UNDEFINED)
invalidFieldValue (HOUR, hour);
@ -438,7 +438,7 @@ void XMLGregorianCalendar::setHour (int hour, bool validate)
testHour();
}
void XMLGregorianCalendar::setMinute (int minute)
void XMLGC::XMLGregorianCalendar::setMinute (int minute)
{
if ((minute < 0 || 59 < minute) && minute != FIELD_UNDEFINED)
invalidFieldValue (MINUTE, minute);
@ -446,7 +446,7 @@ void XMLGregorianCalendar::setMinute (int minute)
this->minute = minute;
}
void XMLGregorianCalendar::setSecond (int second)
void XMLGC::XMLGregorianCalendar::setSecond (int second)
{
if ((second < 0 || 60 < second) && // leap second allows for 60
second != FIELD_UNDEFINED)
@ -457,7 +457,7 @@ void XMLGregorianCalendar::setSecond (int second)
this->second = second;
}
void XMLGregorianCalendar::setFractionalSecond(long double fractional)
void XMLGC::XMLGregorianCalendar::setFractionalSecond(long double fractional)
{
if (fractional < 0.0 || fractional >= 1.0)
throw IllegalArgException ("Invalid fractional seconds");
@ -470,12 +470,12 @@ QName getXMLSchemaType(int year, int month, int day, int hour, int minute, int s
throw (IllegalStateException)
{
unsigned int mask =
(year != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x20 : 0) |
(month != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x10 : 0) |
(day != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x08 : 0) |
(hour != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x04 : 0) |
(minute != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x02 : 0) |
(second != XMLGregorianCalendar::FIELD_UNDEFINED ? 0x01 : 0);
(year !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x20 : 0) |
(month !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x10 : 0) |
(day !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x08 : 0) |
(hour !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x04 : 0) |
(minute !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x02 : 0) |
(second !=XMLGC::XMLGregorianCalendar::FIELD_UNDEFINED ? 0x01 : 0);
switch (mask)
{
@ -517,7 +517,7 @@ QName getXMLSchemaType(int year, int month, int day, int hour, int minute, int s
// End switch
}
string XMLGregorianCalendar::toXMLFormat() const
stringXMLGC::XMLGregorianCalendar::toXMLFormat() const
{
string formatString;
@ -563,7 +563,7 @@ string XMLGregorianCalendar::toXMLFormat() const
return format (formatString);
}
string XMLGregorianCalendar::format (const string &format) const
stringXMLGC::XMLGregorianCalendar::format (const string &format) const
{
string buf;
@ -646,7 +646,7 @@ string XMLGregorianCalendar::format (const string &format) const
}
long double XMLGregorianCalendar::getSeconds() const
long doubleXMLGC::XMLGregorianCalendar::getSeconds() const
{
if (second == FIELD_UNDEFINED)
return 0.0L;
@ -655,7 +655,7 @@ long double XMLGregorianCalendar::getSeconds() const
}
int XMLGregorianCalendar::maximumDayInMonthFor (long long year, int month)
intXMLGC::XMLGregorianCalendar::maximumDayInMonthFor (long long year, int month)
{
if (month != FEBRUARY)
return daysInMonth[month];
@ -670,7 +670,7 @@ int XMLGregorianCalendar::maximumDayInMonthFor (long long year, int month)
}
}
void XMLGregorianCalendar::invalidFieldValue (int field, int value)
void XMLGC::XMLGregorianCalendar::invalidFieldValue (int field, int value)
throw (IllegalArgException)
{
throw IllegalArgException(

22
AusRegEPPTK/se/XMLGregorianCalendarTest.cpp
View File

@ -13,27 +13,27 @@ using namespace std;
void testNoFractionalSecondSet()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
ASSERT_EQ(calendar.getFractionalSecond(), 0);
}
void testSetZeroFractionalSecond()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setFractionalSecond(0.0);
ASSERT_EQ(calendar.getFractionalSecond(), 0);
}
void testSetNonZeroFractionalSecond()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setFractionalSecond(0.123);
ASSERT_EQ(calendar.getFractionalSecond(), 0.123);
}
void testSetNegativeFractionalSecond()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
try
{
@ -48,7 +48,7 @@ void testSetNegativeFractionalSecond()
void testSetFractionalSecondToWholeSecond()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
try
{
@ -69,7 +69,7 @@ void testSetFractionalSecondToWholeSecond()
*/
void testValidYearSet()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setDay(1);
calendar.setMonth(3);
calendar.setYear(2010);
@ -78,7 +78,7 @@ void testValidYearSet()
void testInvalidNoYearSet()
{
XMLGregorianCalendar calendar("2015-04-08T04:23:29.0Z");
XMLGC::XMLGregorianCalendar calendar("2015-04-08T04:23:29.0Z");
ASSERT_EQ(calendar.isValid(), true);
calendar.setYear(0);
ASSERT_EQ(calendar.isValid(), false);
@ -86,7 +86,7 @@ void testInvalidNoYearSet()
void testInvalidNonLeapYear()
{
XMLGregorianCalendar calendar("2009-02-08T04:23:29.0Z");
XMLGC::XMLGregorianCalendar calendar("2009-02-08T04:23:29.0Z");
ASSERT_EQ(calendar.isValid(), true);
calendar.setDay(29);
ASSERT_EQ(calendar.isValid(), false);
@ -94,7 +94,7 @@ void testInvalidNonLeapYear()
void testFormatYear()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setYear(2015);
ASSERT_EQ(calendar.format("%Y"), "2015");
}
@ -106,14 +106,14 @@ void testFormatYear()
void testValidNegativeYear()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setYear(-2102);
ASSERT_EQ(calendar.isValid(), true);
}
void testFormatNegativeYear()
{
XMLGregorianCalendar calendar;
XMLGC::XMLGregorianCalendar calendar;
calendar.setYear(-2015);
ASSERT_EQ(calendar.format("%Y"), "-2015");
}