Miroirs/arabica
1
0
Fork 0
mirror of https://github.com/jezhiggins/arabica synced 2025-02-06 20:46:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

parameterised QualifiedName

Browse source
This commit is contained in:
jez 2009-02-23 08:38:50 +00:00
parent 32bc0e6597
commit 31b8d99a83
3 changed files with 64 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
include/XML/QName.hpp
View file

@ -1,20 +1,25 @@
#ifndef ARABICA_XML_QNAME_HPP #ifndef ARABICA_XML_QNAME_HPP
#define ARABICA_XML_QNAME_HPP #define ARABICA_XML_QNAME_HPP
#include <SAX/ArabicaConfig.hpp>
#include <Arabica/StringAdaptor.hpp>
template<class string_type, class string_adaptor = Arabica::default_string_adaptor<string_type> >
class QualifiedName class QualifiedName
{ {
typedef string_adaptor SA;
public: public:
QualifiedName(const std::string& localName) : QualifiedName(const string_type& localName) :
prefix_(), prefix_(),
localName_(localName), localName_(localName),
namespaceUri_() namespaceUri_()
{ {
} // QualifiedName } // QualifiedName
QualifiedName(const std::string& prefix, QualifiedName(const string_type& prefix,
const std::string& localName, const string_type& localName,
const std::string& namespaceUri) : const string_type& namespaceUri) :
prefix_(prefix), prefix_(prefix),
localName_(localName), localName_(localName),
namespaceUri_(namespaceUri) namespaceUri_(namespaceUri)
@ -48,24 +53,30 @@ public:
return !(operator==(rhs)); return !(operator==(rhs));
} // operator!= } // operator!=
std::string clarkName() const string_type clarkName() const
{ {
if(namespaceUri_.length() == 0) if(SA::empty(namespaceUri_))
return localName_; return localName_;
return "{" + namespaceUri_ + "}" + localName_;
string_type cn;
SA::append(cn, SA::construct_from_utf8("{"));
SA::append(cn, namespaceUri_);
SA::append(cn, SA::construct_from_utf8("}"));
SA::append(cn, localName_);
return cn;
} // clarkName } // clarkName
bool has_prefix() const { return !prefix_.empty(); } bool has_prefix() const { return !SA::empty(prefix_); }
void set_prefix(const std::string& prefix) { prefix_ = prefix; } void set_prefix(const string_type& prefix) { prefix_ = prefix; }
const std::string& prefix() const { return prefix_; } const string_type& prefix() const { return prefix_; }
const std::string& namespaceUri() const { return namespaceUri_; } const string_type& namespaceUri() const { return namespaceUri_; }
const std::string& localName() const { return localName_; } const string_type& localName() const { return localName_; }
private: private:
std::string prefix_; string_type prefix_;
std::string localName_; string_type localName_;
std::string namespaceUri_; string_type namespaceUri_;
QualifiedName(); QualifiedName();
}; // class QualifiedName }; // class QualifiedName

68
tests/Utils/test_qname.hpp
View file

@ -5,8 +5,11 @@
using namespace Arabica::XML; using namespace Arabica::XML;
template<class string_type, class string_adaptor>
class QualifiedNameTest : public TestCase class QualifiedNameTest : public TestCase
{ {
typedef string_adaptor SA;
typedef QualifiedName<string_type, string_adaptor> QN;
public: public:
QualifiedNameTest(const std::string& name) : QualifiedNameTest(const std::string& name) :
TestCase(name) TestCase(name)
@ -15,8 +18,8 @@ public:
void testNcNameEquality() void testNcNameEquality()
{ {
QualifiedName q1("foo"); QN q1(SA::construct_from_utf8("foo"));
QualifiedName q2("foo"); QN q2(SA::construct_from_utf8("foo"));
assertTrue(q1 == q2); assertTrue(q1 == q2);
assertTrue(!(q1 != q2)); assertTrue(!(q1 != q2));
@ -24,8 +27,8 @@ public:
void testNcNameCopy() void testNcNameCopy()
{ {
QualifiedName q1("foo"); QN q1(SA::construct_from_utf8("foo"));
QualifiedName q2(q1); QN q2(q1);
assertTrue(q1 == q2); assertTrue(q1 == q2);
assertTrue(!(q1 != q2)); assertTrue(!(q1 != q2));
@ -33,8 +36,8 @@ public:
void testNcNameAssignment() void testNcNameAssignment()
{ {
QualifiedName q1("foo"); QN q1(SA::construct_from_utf8("foo"));
QualifiedName q2("bar"); QN q2(SA::construct_from_utf8("bar"));
assertFalse(q1 == q2); assertFalse(q1 == q2);
@ -45,37 +48,37 @@ public:
void testNcClarkName() void testNcClarkName()
{ {
QualifiedName q("bar"); QN q(SA::construct_from_utf8("bar"));
assertEquals("bar", q.clarkName()); assertTrue(SA::construct_from_utf8("bar") == q.clarkName());
} // testNcClarkName } // testNcClarkName
void testEquality() void testEquality()
{ {
QualifiedName q1("foo", "bar", "http://test/"); QN q1(SA::construct_from_utf8("foo"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
QualifiedName q2("foo", "bar", "http://test/"); QN q2(SA::construct_from_utf8("foo"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
assertTrue(q1 == q2); assertTrue(q1 == q2);
assertTrue(!(q1 != q2)); assertTrue(!(q1 != q2));
// prefix is not significant // prefix is not significant
QualifiedName q3("baz", "bar", "http://test/"); QN q3(SA::construct_from_utf8("baz"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
assertTrue(q1 == q3); assertTrue(q1 == q3);
assertTrue(!(q1 != q3)); assertTrue(!(q1 != q3));
} // testEquality } // testEquality
void testCopy() void testCopy()
{ {
QualifiedName q1("foo", "bar", "http://test/"); QN q1(SA::construct_from_utf8("foo"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
QualifiedName q2(q1); QN q2(q1);
assertTrue(q1 == q2); assertTrue(q1 == q2);
} // testCopy } // testCopy
void testAssignment() void testAssignment()
{ {
QualifiedName q1("foo", "bar", "http://test/"); QN q1(SA::construct_from_utf8("foo"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
QualifiedName q2("foo", "parp", "http://tst/"); QN q2(SA::construct_from_utf8("foo"), SA::construct_from_utf8("parp"), SA::construct_from_utf8("http://tst/"));
assertTrue(q1 != q2); assertTrue(q1 != q2);
@ -86,36 +89,39 @@ public:
void testClarkName() void testClarkName()
{ {
QualifiedName q("foo", "bar", "http://test/"); QN q(SA::construct_from_utf8("foo"), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
assertEquals("{http://test/}bar", q.clarkName()); assertTrue(SA::construct_from_utf8("{http://test/}bar") == q.clarkName());
} // testClarkName } // testClarkName
void testPrefix() void testPrefix()
{ {
QualifiedName q("", "bar", "http://test/"); QN q(SA::construct_from_utf8(""), SA::construct_from_utf8("bar"), SA::construct_from_utf8("http://test/"));
assertFalse(q.has_prefix()); assertFalse(q.has_prefix());
assertEquals("bar", q.localName()); assertTrue(SA::construct_from_utf8("bar") == q.localName());
assertEquals("http://test/", q.namespaceUri()); assertTrue(SA::construct_from_utf8("http://test/") == q.namespaceUri());
q.set_prefix("t"); q.set_prefix(SA::construct_from_utf8("t"));
assertTrue(q.has_prefix()); assertTrue(q.has_prefix());
assertEquals("t", q.prefix()); assertTrue(SA::construct_from_utf8("t") == q.prefix());
} // testPrefix } // testPrefix
}; // class QualifiedNameTest }; // class QualifiedNameTest
template<class string_type, class string_adaptor>
TestSuite* QualifiedNameTest_suite() TestSuite* QualifiedNameTest_suite()
{ {
typedef QualifiedNameTest<string_type, string_adaptor> QNT;
TestSuite* suiteOfTests = new TestSuite(); TestSuite* suiteOfTests = new TestSuite();
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testNcNameEquality", &QualifiedNameTest::testNcNameEquality)); suiteOfTests->addTest(new TestCaller<QNT>("testNcNameEquality", &QNT::testNcNameEquality));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testNcNameCopy", &QualifiedNameTest::testNcNameCopy)); suiteOfTests->addTest(new TestCaller<QNT>("testNcNameCopy", &QNT::testNcNameCopy));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testNcNameAssignment", &QualifiedNameTest::testNcNameAssignment)); suiteOfTests->addTest(new TestCaller<QNT>("testNcNameAssignment", &QNT::testNcNameAssignment));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testNcClarkName", &QualifiedNameTest::testNcClarkName)); suiteOfTests->addTest(new TestCaller<QNT>("testNcClarkName", &QNT::testNcClarkName));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testEquality", &QualifiedNameTest::testEquality)); suiteOfTests->addTest(new TestCaller<QNT>("testEquality", &QNT::testEquality));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testCopy", &QualifiedNameTest::testCopy)); suiteOfTests->addTest(new TestCaller<QNT>("testCopy", &QNT::testCopy));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testAssignment", &QualifiedNameTest::testAssignment)); suiteOfTests->addTest(new TestCaller<QNT>("testAssignment", &QNT::testAssignment));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testClarkName", &QualifiedNameTest::testClarkName)); suiteOfTests->addTest(new TestCaller<QNT>("testClarkName", &QNT::testClarkName));
suiteOfTests->addTest(new TestCaller<QualifiedNameTest>("testPrefix", &QualifiedNameTest::testPrefix)); suiteOfTests->addTest(new TestCaller<QNT>("testPrefix", &QNT::testPrefix));
return suiteOfTests; return suiteOfTests;
} // QualifiedNameTest_suite } // QualifiedNameTest_suite

2
tests/Utils/util_test_suite.hpp
View file

@ -20,7 +20,7 @@ bool Util_test_suite(int argc, const char** argv)
runner.addTest("Base64Test", Base64Test_suite()); runner.addTest("Base64Test", Base64Test_suite());
runner.addTest("URITest", URITest_suite()); runner.addTest("URITest", URITest_suite());
runner.addTest("XMLString", XMLStringTest_suite()); runner.addTest("XMLString", XMLStringTest_suite());
runner.addTest("QualifiedName", QualifiedNameTest_suite()); runner.addTest("QualifiedName", QualifiedNameTest_suite<string_type, string_adaptor>());
return runner.run(argc, argv); return runner.run(argc, argv);
} // main } // main