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

s/XPathExpressionPtr/XPathExpression/g

Browse source
This commit is contained in:
jez 2007-10-25 20:42:00 +00:00
parent 240c97814c
commit af3ebfde60
17 changed files with 406 additions and 314 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

104
include/XPath/impl/xpath_expression.hpp
View file

@ -50,27 +50,119 @@ private:
XPathExpression_impl& operator=(const XPathExpression_impl&); XPathExpression_impl& operator=(const XPathExpression_impl&);
}; // class XPathExpression_impl }; // class XPathExpression_impl
template<class string_type, class string_adaptor> class XPathExpressionPtr;
template<class string_type, class string_adaptor = Arabica::default_string_adaptor<string_type> > template<class string_type, class string_adaptor = Arabica::default_string_adaptor<string_type> >
class XPathExpressionPtr class XPathExpression
{ {
public: public:
XPathExpressionPtr() : ptr_() { } XPathExpression() : ptr_() { }
explicit XPathExpressionPtr(XPathExpression_impl<string_type, string_adaptor>* xp) : ptr_(xp) { } explicit XPathExpression(XPathExpression_impl<string_type, string_adaptor>* xp) : ptr_(xp) { }
XPathExpressionPtr(const XPathExpressionPtr& rhs) : ptr_(rhs.ptr_) { } XPathExpression(const XPathExpression& rhs) : ptr_(rhs.ptr_) { }
XPathExpressionPtr& operator=(const XPathExpressionPtr& rhs) XPathExpression& operator=(const XPathExpression& rhs)
{ {
ptr_ = rhs.ptr_; ptr_ = rhs.ptr_;
return *this; return *this;
} // operator= } // operator=
const XPathExpression_impl<string_type, string_adaptor>* get() const { return ptr_.get(); } const XPathExpression_impl<string_type, string_adaptor>* get() const { return ptr_.get(); }
const XPathExpression_impl<string_type, string_adaptor>* operator->() const { return ptr_.get(); }
operator bool() const { return ptr_.get(); } operator bool() const { return ptr_.get(); }
XPathValue<string_type, string_adaptor> evaluate(const DOM::Node<string_type, string_adaptor>& context) const
{
return ptr_->evaluate(context);
} // evaluate
bool evaluateAsBool(const DOM::Node<string_type, string_adaptor>& context) const
{
return ptr_->evaluateAsBool(context);
} // evaluateAsBool
double evaluateAsNumber(const DOM::Node<string_type, string_adaptor>& context) const
{
return ptr_->evaluateAsNumber(context);
} // evaluateAsNumber
string_type evaluateAsString(const DOM::Node<string_type, string_adaptor>& context) const
{
return ptr_->evaluateAsString(context);
} // evaluateAsString
NodeSet<string_type, string_adaptor> evaluateAsNodeSet(const DOM::Node<string_type, string_adaptor>& context) const
{
return ptr_->evaluate(context).asNodeSet();
} // evaluateAsNodeSet
XPathValue<string_type, string_adaptor> evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const
{
return ptr_->evaluate(context, executionContext);
} // evaluate
bool evaluateAsBool(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const
{
return ptr_->evaluateAsBool(context, executionContext);
} // evaluateAsBool
double evaluateAsNumber(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const
{
return ptr_->evaluateAsNumber(context, executionContext);
} // evaluateAsNumber
string_type evaluateAsString(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const
{
return ptr_->evaluateAsString(context, executionContext);
} // evaluateAsString
NodeSet<string_type, string_adaptor> evaluateAsNodeSet(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const
{
return ptr_->evaluate(context, executionContext).asNodeSet();
} // evaluateAsNodeSet
private: private:
typedef boost::shared_ptr<const XPathExpression_impl<string_type, string_adaptor> > ExpressionPtr; typedef boost::shared_ptr<const XPathExpression_impl<string_type, string_adaptor> > ExpressionPtr;
ExpressionPtr ptr_; ExpressionPtr ptr_;
explicit XPathExpression(ExpressionPtr ptr) : ptr_(ptr) { }
friend class XPathExpressionPtr<string_type, string_adaptor>;
}; // class XPathExpression
template<class string_type, class string_adaptor = Arabica::default_string_adaptor<string_type> >
class XPathExpressionPtr
{
public:
explicit XPathExpressionPtr() : ptr_() { }
explicit XPathExpressionPtr(const XPathExpression_impl<string_type, string_adaptor>* v) : ptr_(v) { }
XPathExpressionPtr(const XPathExpression<string_type, string_adaptor>& rhs) : ptr_(rhs.ptr_) { }
XPathExpressionPtr(const XPathExpressionPtr& rhs) : ptr_(rhs.ptr_) { }
XPathExpressionPtr& operator=(const XPathExpression<string_type, string_adaptor>& rhs)
{
ptr_ = rhs.ptr_;
return *this;
} // operator=
XPathExpressionPtr& operator=(const XPathExpressionPtr& rhs)
{
ptr_ = rhs.ptr_;
return *this;
} // operator=
const XPathExpression_impl<string_type, string_adaptor>* operator->() const { return ptr_.get(); }
operator bool() const { return ptr_.get(); }
operator XPathExpression<string_type, string_adaptor>() const { return XPathExpression<string_type, string_adaptor>(ptr_); }
private:
bool operator==(const XPathExpressionPtr&) const;
typedef boost::shared_ptr<const XPathExpression_impl<string_type, string_adaptor> > ExpressionPtr;
ExpressionPtr ptr_;
}; // class XPathExpressionPtr }; // class XPathExpressionPtr
namespace impl namespace impl

64
include/XPath/impl/xpath_function.hpp
View file

@ -18,7 +18,7 @@ template<class string_type, class string_adaptor = Arabica::default_string_adapt
class XPathFunction class XPathFunction
{ {
protected: protected:
XPathFunction(int minArgs, int maxArgs, const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction(int minArgs, int maxArgs, const std::vector<XPathExpression<string_type, string_adaptor> >& args) :
args_(args) args_(args)
{ {
if(((minArgs != -1) && (static_cast<int>(args.size()) < minArgs)) || if(((minArgs != -1) && (static_cast<int>(args.size()) < minArgs)) ||
@ -39,39 +39,39 @@ protected:
const DOM::Node<string_type, string_adaptor>& context, const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return args_[index]->evaluate(context, executionContext); return args_[index].evaluate(context, executionContext);
} // argAsBool } // argAsBool
bool argAsBool(size_t index, bool argAsBool(size_t index,
const DOM::Node<string_type, string_adaptor>& context, const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return args_[index]->evaluate(context, executionContext).asBool(); return args_[index].evaluate(context, executionContext).asBool();
} // argAsBool } // argAsBool
double argAsNumber(size_t index, double argAsNumber(size_t index,
const DOM::Node<string_type, string_adaptor>& context, const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return args_[index]->evaluate(context, executionContext).asNumber(); return args_[index].evaluate(context, executionContext).asNumber();
} // argAsNumber } // argAsNumber
string_type argAsString(size_t index, string_type argAsString(size_t index,
const DOM::Node<string_type, string_adaptor>& context, const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return args_[index]->evaluate(context, executionContext).asString(); return args_[index].evaluate(context, executionContext).asString();
} // argAsString } // argAsString
NodeSet<string_type, string_adaptor> argAsNodeSet(size_t index, NodeSet<string_type, string_adaptor> argAsNodeSet(size_t index,
const DOM::Node<string_type, string_adaptor>& context, const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return args_[index]->evaluate(context, executionContext).asNodeSet(); return args_[index].evaluate(context, executionContext).asNodeSet();
} // argAsNodeSet } // argAsNodeSet
private: private:
const std::vector<XPathExpressionPtr<string_type, string_adaptor> > args_; const std::vector<XPathExpression<string_type, string_adaptor> > args_;
}; // class XPathFunction }; // class XPathFunction
namespace impl namespace impl
@ -83,7 +83,7 @@ template<class string_type, class string_adaptor>
class LastFn : public XPathFunction<string_type, string_adaptor> class LastFn : public XPathFunction<string_type, string_adaptor>
{ {
public: public:
LastFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { } LastFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -97,7 +97,7 @@ template<class string_type, class string_adaptor>
class PositionFn : public XPathFunction<string_type, string_adaptor> class PositionFn : public XPathFunction<string_type, string_adaptor>
{ {
public: public:
PositionFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { } PositionFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -112,7 +112,7 @@ class CountFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
CountFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } CountFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -128,7 +128,7 @@ class LocalNameFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
LocalNameFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } LocalNameFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -163,7 +163,7 @@ class NamespaceURIFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
NamespaceURIFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } NamespaceURIFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -197,7 +197,7 @@ class NameFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
NameFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } NameFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -236,7 +236,7 @@ class StringFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
StringFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } StringFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -251,7 +251,7 @@ class ConcatFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
ConcatFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, -1, args) { } ConcatFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, -1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -269,7 +269,7 @@ class StartsWithFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
StartsWithFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { } StartsWithFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -297,7 +297,7 @@ class ContainsFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
ContainsFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { } ContainsFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -313,7 +313,7 @@ class SubstringBeforeFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
SubstringBeforeFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { } SubstringBeforeFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -334,7 +334,7 @@ class SubstringAfterFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
SubstringAfterFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { } SubstringAfterFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 2, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -356,7 +356,7 @@ class SubstringFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
SubstringFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 3, args) { } SubstringFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(2, 3, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -386,7 +386,7 @@ class StringLengthFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
StringLengthFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } StringLengthFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -402,7 +402,7 @@ class NormalizeSpaceFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
NormalizeSpaceFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } NormalizeSpaceFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -419,7 +419,7 @@ class TranslateFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
TranslateFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(3, 3, args) { } TranslateFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(3, 3, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -453,7 +453,7 @@ class BooleanFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
BooleanFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } BooleanFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -468,7 +468,7 @@ class NotFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
NotFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } NotFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -482,7 +482,7 @@ template<class string_type, class string_adaptor>
class TrueFn : public XPathFunction<string_type, string_adaptor> class TrueFn : public XPathFunction<string_type, string_adaptor>
{ {
public: public:
TrueFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { } TrueFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -496,7 +496,7 @@ template<class string_type, class string_adaptor>
class FalseFn : public XPathFunction<string_type, string_adaptor> class FalseFn : public XPathFunction<string_type, string_adaptor>
{ {
public: public:
FalseFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { } FalseFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 0, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -516,7 +516,7 @@ class NumberFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
NumberFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { } NumberFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(0, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -533,7 +533,7 @@ class SumFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
SumFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } SumFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -552,7 +552,7 @@ class FloorFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
FloorFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } FloorFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -567,7 +567,7 @@ class CeilingFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
CeilingFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } CeilingFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
@ -582,7 +582,7 @@ class RoundFn : public XPathFunction<string_type, string_adaptor>
{ {
typedef XPathFunction<string_type, string_adaptor> baseT; typedef XPathFunction<string_type, string_adaptor> baseT;
public: public:
RoundFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { } RoundFn(const std::vector<XPathExpression<string_type, string_adaptor> >& args) : XPathFunction<string_type, string_adaptor>(1, 1, args) { }
virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context, virtual XPathValue_impl<string_type, string_adaptor>* evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const

6
include/XPath/impl/xpath_function_holder.hpp
View file

@ -13,7 +13,7 @@ namespace impl
{ {
template<class function_type, class string_type, class string_adaptor> template<class function_type, class string_type, class string_adaptor>
XPathFunction<string_type, string_adaptor>* CreateFn(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& argExprs) { return new function_type(argExprs); } XPathFunction<string_type, string_adaptor>* CreateFn(const std::vector<XPathExpression<string_type, string_adaptor> >& argExprs) { return new function_type(argExprs); }
template<class string_type, class string_adaptor> template<class string_type, class string_adaptor>
class FunctionHolder : public XPathExpression_impl<string_type, string_adaptor> class FunctionHolder : public XPathExpression_impl<string_type, string_adaptor>
@ -37,7 +37,7 @@ public:
static FunctionHolder* createFunction(const string_type& namespace_uri, static FunctionHolder* createFunction(const string_type& namespace_uri,
const string_type& name, const string_type& name,
const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& argExprs, const std::vector<XPathExpression<string_type, string_adaptor> >& argExprs,
const CompilationContext<string_type, string_adaptor>& context) const CompilationContext<string_type, string_adaptor>& context)
{ {
if(string_adaptor::empty(namespace_uri)) if(string_adaptor::empty(namespace_uri))
@ -66,7 +66,7 @@ public:
private: private:
XPathFunction<string_type, string_adaptor>* func_; XPathFunction<string_type, string_adaptor>* func_;
typedef XPathFunction<string_type, string_adaptor>* (*CreateFnPtr)(const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& argExprs); typedef XPathFunction<string_type, string_adaptor>* (*CreateFnPtr)(const std::vector<XPathExpression<string_type, string_adaptor> >& argExprs);
struct NamedFunction { const char* name; CreateFnPtr creator; }; struct NamedFunction { const char* name; CreateFnPtr creator; };

6
include/XPath/impl/xpath_function_resolver.hpp
View file

@ -7,7 +7,7 @@ namespace XPath
{ {
template<class string_type, class string_adaptor> class XPathFunction; template<class string_type, class string_adaptor> class XPathFunction;
template<class string_type, class string_adaptor> class XPathExpressionPtr; template<class string_type, class string_adaptor> class XPathExpression;
class UndefinedFunctionException : public std::runtime_error class UndefinedFunctionException : public std::runtime_error
{ {
@ -25,7 +25,7 @@ public:
virtual XPathFunction<string_type, string_adaptor>* virtual XPathFunction<string_type, string_adaptor>*
resolveFunction(const string_type& namespace_uri, resolveFunction(const string_type& namespace_uri,
const string_type& name, const string_type& name,
const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& argExprs) const = 0; const std::vector<XPathExpression<string_type, string_adaptor> >& argExprs) const = 0;
}; // class FunctionResolver }; // class FunctionResolver
template<class string_type, class string_adaptor> template<class string_type, class string_adaptor>
@ -45,7 +45,7 @@ public:
virtual XPathFunction<string_type, string_adaptor>* virtual XPathFunction<string_type, string_adaptor>*
resolveFunction(const string_type& namespace_uri, resolveFunction(const string_type& namespace_uri,
const string_type& name, const string_type& name,
const std::vector<XPathExpressionPtr<string_type, string_adaptor> >& argExprs) const const std::vector<XPathExpression<string_type, string_adaptor> >& argExprs) const
{ {
string_type error; string_type error;
if(!string_adaptor::empty(namespace_uri)) if(!string_adaptor::empty(namespace_uri))

4
include/XPath/impl/xpath_match.hpp
View file

@ -25,13 +25,13 @@ public:
bool evaluate(const DOM::Node<string_type, string_adaptor>& context, bool evaluate(const DOM::Node<string_type, string_adaptor>& context,
const ExecutionContext<string_type, string_adaptor>& executionContext) const const ExecutionContext<string_type, string_adaptor>& executionContext) const
{ {
return match_->evaluateAsBool(context, executionContext); return match_.evaluateAsBool(context, executionContext);
} // evaluate } // evaluate
void override_priority(double p) { priority_ = p; } void override_priority(double p) { priority_ = p; }
private: private:
XPathExpressionPtr<string_type, string_adaptor> match_; XPathExpression<string_type, string_adaptor> match_;
double priority_; double priority_;
}; // MatchExpr }; // MatchExpr

24
include/XPath/impl/xpath_parser.hpp
View file

@ -64,24 +64,24 @@ public:
{ {
} // ~XPath } // ~XPath
XPathExpressionPtr<string_type, string_adaptor> compile(const string_type& xpath) const XPathExpression<string_type, string_adaptor> compile(const string_type& xpath) const
{ {
return do_compile(xpath, &XPath::parse_xpath, expression_factory()); return do_compile(xpath, &XPath::parse_xpath, expression_factory());
} // compile } // compile
XPathExpressionPtr<string_type, string_adaptor> compile_expr(const string_type& xpath) const XPathExpression<string_type, string_adaptor> compile_expr(const string_type& xpath) const
{ {
return do_compile(xpath, &XPath::parse_xpath_expr, expression_factory()); return do_compile(xpath, &XPath::parse_xpath_expr, expression_factory());
} // compile_expr } // compile_expr
XPathExpressionPtr<string_type, string_adaptor> compile_attribute_value_template(const string_type& xpath) const XPathExpression<string_type, string_adaptor> compile_attribute_value_template(const string_type& xpath) const
{ {
return do_compile(xpath, &XPath::parse_xpath_attribute_value_template, attribute_value_factory()); return do_compile(xpath, &XPath::parse_xpath_attribute_value_template, attribute_value_factory());
} // compile_attribute_value_template } // compile_attribute_value_template
std::vector<MatchExpr<string_type, string_adaptor> > compile_match(const string_type& xpath) const std::vector<MatchExpr<string_type, string_adaptor> > compile_match(const string_type& xpath) const
{ {
XPathExpressionPtr<string_type, string_adaptor> wrapper = do_compile(xpath, &XPath::parse_xpath_match, match_factory()); XPathExpression<string_type, string_adaptor> wrapper = do_compile(xpath, &XPath::parse_xpath_match, match_factory());
return (static_cast<const impl::MatchExpressionWrapper<string_type, string_adaptor>*>(wrapper.get()))->matches(); return (static_cast<const impl::MatchExpressionWrapper<string_type, string_adaptor>*>(wrapper.get()))->matches();
} // compile_match } // compile_match
@ -89,14 +89,14 @@ public:
{ {
ExecutionContext<string_type, string_adaptor> executionContext; ExecutionContext<string_type, string_adaptor> executionContext;
executionContext.setVariableResolver(getVariableResolver()); executionContext.setVariableResolver(getVariableResolver());
return compile(xpath)->evaluate(context, executionContext); return compile(xpath).evaluate(context, executionContext);
} // evaluate } // evaluate
XPathValue<string_type, string_adaptor> evaluate_expr(const string_type& xpath, const DOM::Node<string_type, string_adaptor>& context) const XPathValue<string_type, string_adaptor> evaluate_expr(const string_type& xpath, const DOM::Node<string_type, string_adaptor>& context) const
{ {
ExecutionContext<string_type, string_adaptor> executionContext; ExecutionContext<string_type, string_adaptor> executionContext;
executionContext.setVariableResolver(getVariableResolver()); executionContext.setVariableResolver(getVariableResolver());
return compile_expr(xpath)->evaluate(context, executionContext); return compile_expr(xpath).evaluate(context, executionContext);
} // evaluate_expr } // evaluate_expr
void setNamespaceContext(const NamespaceContext<string_type, string_adaptor>& namespaceContext) { namespaceContext_.set(namespaceContext); } void setNamespaceContext(const NamespaceContext<string_type, string_adaptor>& namespaceContext) { namespaceContext_.set(namespaceContext); }
@ -120,7 +120,7 @@ private:
impl::CompilationContext<string_type, string_adaptor>& context); impl::CompilationContext<string_type, string_adaptor>& context);
typedef typename impl::types<string_adaptor>::tree_info_t(XPath::*parserFn)(const string_type& str) const; typedef typename impl::types<string_adaptor>::tree_info_t(XPath::*parserFn)(const string_type& str) const;
XPathExpressionPtr<string_type, string_adaptor> do_compile(const string_type& xpath, XPathExpression<string_type, string_adaptor> do_compile(const string_type& xpath,
parserFn parser, parserFn parser,
const std::map<int, compileFn>& factory) const const std::map<int, compileFn>& factory) const
{ {
@ -132,7 +132,7 @@ private:
impl::CompilationContext<string_type, string_adaptor> context(*this, getNamespaceContext(), getFunctionResolver()); impl::CompilationContext<string_type, string_adaptor> context(*this, getNamespaceContext(), getFunctionResolver());
//XPath::dump(ast.trees.begin(), 0); //XPath::dump(ast.trees.begin(), 0);
return XPathExpressionPtr<string_type, string_adaptor>(compile_with_factory(ast.trees.begin(), return XPathExpression<string_type, string_adaptor>(compile_with_factory(ast.trees.begin(),
ast.trees.end(), ast.trees.end(),
context, context,
factory)); factory));
@ -573,10 +573,10 @@ XPathExpression_impl<string_type, string_adaptor>* XPath<string_type, string_ada
++c; ++c;
impl::skipWhitespace<string_adaptor>(c); impl::skipWhitespace<string_adaptor>(c);
std::vector<XPathExpressionPtr<string_type, string_adaptor> > args; std::vector<XPathExpression<string_type, string_adaptor> > args;
while(impl::getNodeId<string_adaptor>(c) != impl::RightBracket_id) while(impl::getNodeId<string_adaptor>(c) != impl::RightBracket_id)
{ {
XPathExpressionPtr<string_type, string_adaptor> arg(XPath<string_type, string_adaptor>::compile_expression(c++, i->children.end(), context)); XPathExpression<string_type, string_adaptor> arg(XPath<string_type, string_adaptor>::compile_expression(c++, i->children.end(), context));
args.push_back(arg); args.push_back(arg);
impl::skipWhitespace<string_adaptor>(c); impl::skipWhitespace<string_adaptor>(c);
@ -962,10 +962,10 @@ impl::StepList<string_type, string_adaptor> XPath<string_type, string_adaptor>::
template<class string_type, class string_adaptor> template<class string_type, class string_adaptor>
XPathExpression_impl<string_type, string_adaptor>* XPath<string_type, string_adaptor>::createAttributeValue(typename impl::types<string_adaptor>::node_iter_t const& i, typename impl::types<string_adaptor>::node_iter_t const& ie, impl::CompilationContext<string_type, string_adaptor>& context) XPathExpression_impl<string_type, string_adaptor>* XPath<string_type, string_adaptor>::createAttributeValue(typename impl::types<string_adaptor>::node_iter_t const& i, typename impl::types<string_adaptor>::node_iter_t const& ie, impl::CompilationContext<string_type, string_adaptor>& context)
{ {
std::vector<XPathExpressionPtr<string_type, string_adaptor> > args; std::vector<XPathExpression<string_type, string_adaptor> > args;
for(typename impl::types<string_adaptor>::node_iter_t a = i->children.begin(), e = i->children.end(); a != e; ++a) for(typename impl::types<string_adaptor>::node_iter_t a = i->children.begin(), e = i->children.end(); a != e; ++a)
{ {
XPathExpressionPtr<string_type, string_adaptor> arg(XPath<string_type, string_adaptor>::compile_attribute_value(a, e, context)); XPathExpression<string_type, string_adaptor> arg(XPath<string_type, string_adaptor>::compile_attribute_value(a, e, context));
args.push_back(arg); args.push_back(arg);
} // while ... } // while ...
// maybe trailing whitespace ... // maybe trailing whitespace ...

6
include/XSLT/impl/xslt_functions.hpp
View file

@ -15,7 +15,7 @@ class CurrentFunction : public Arabica::XPath::XPathFunction<std::string>
typedef Arabica::XPath::XPathFunction<std::string> baseT; typedef Arabica::XPath::XPathFunction<std::string> baseT;
public: public:
CurrentFunction(const std::vector<Arabica::XPath::XPathExpressionPtr<std::string> >& args) : CurrentFunction(const std::vector<Arabica::XPath::XPathExpression<std::string> >& args) :
Arabica::XPath::XPathFunction<std::string>(0, 0, args) { } Arabica::XPath::XPathFunction<std::string>(0, 0, args) { }
virtual Arabica::XPath::XPathValue_impl<std::string>* evaluate(const DOM::Node<std::string>& context, virtual Arabica::XPath::XPathValue_impl<std::string>* evaluate(const DOM::Node<std::string>& context,
@ -34,7 +34,7 @@ class DocumentFunction : public Arabica::XPath::XPathFunction<std::string>
public: public:
DocumentFunction(const std::string& currentBase, DocumentFunction(const std::string& currentBase,
const std::vector<Arabica::XPath::XPathExpressionPtr<std::string> >& args) : const std::vector<Arabica::XPath::XPathExpression<std::string> >& args) :
Arabica::XPath::XPathFunction<std::string>(1, 2, args), Arabica::XPath::XPathFunction<std::string>(1, 2, args),
baseURI_(currentBase) baseURI_(currentBase)
{ } { }
@ -81,7 +81,7 @@ class SystemPropertyFunction : public Arabica::XPath::XPathFunction<std::string>
typedef Arabica::XPath::XPathFunction<std::string> baseT; typedef Arabica::XPath::XPathFunction<std::string> baseT;
public: public:
SystemPropertyFunction (const std::vector<Arabica::XPath::XPathExpressionPtr<std::string> >& args) : SystemPropertyFunction (const std::vector<Arabica::XPath::XPathExpression<std::string> >& args) :
Arabica::XPath::XPathFunction<std::string>(1, 1, args) { } Arabica::XPath::XPathFunction<std::string>(1, 1, args) { }
virtual Arabica::XPath::XPathValue_impl<std::string>* evaluate(const DOM::Node<std::string>& context, virtual Arabica::XPath::XPathValue_impl<std::string>* evaluate(const DOM::Node<std::string>& context,

2
include/XSLT/impl/xslt_stylesheet_compiler.hpp
View file

@ -199,7 +199,7 @@ private:
virtual Arabica::XPath::XPathFunction<std::string>* resolveFunction( virtual Arabica::XPath::XPathFunction<std::string>* resolveFunction(
const std::string& namespace_uri, const std::string& namespace_uri,
const std::string& name, const std::string& name,
const std::vector<Arabica::XPath::XPathExpressionPtr<std::string> >& argExprs) const const std::vector<Arabica::XPath::XPathExpression<std::string> >& argExprs) const
{ {
if(!namespace_uri.empty()) if(!namespace_uri.empty())
return 0; return 0;

58
tests/XPath/arithmetic_test.hpp
View file

@ -25,10 +25,10 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(1); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(1);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> add(new impl::PlusOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> add(new impl::PlusOperator<string_type, string_adaptor>(p1, p2));
add->evaluate(dummy_); add.evaluate(dummy_);
assertEquals(3.0, add->evaluateAsNumber(dummy_), 0.0); assertEquals(3.0, add.evaluateAsNumber(dummy_), 0.0);
} // test1 } // test1
void test2() void test2()
@ -37,9 +37,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(1); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(1);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> minus(new impl::MinusOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> minus(new impl::MinusOperator<string_type, string_adaptor>(p1, p2));
assertEquals(-1.0, minus->evaluateAsNumber(dummy_), 0.0); assertEquals(-1.0, minus.evaluateAsNumber(dummy_), 0.0);
} // test2 } // test2
void test3() void test3()
@ -48,9 +48,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(3); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(3);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> mult(new impl::MultiplyOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mult(new impl::MultiplyOperator<string_type, string_adaptor>(p1, p2));
assertEquals(6, mult->evaluateAsNumber(dummy_), 0.0); assertEquals(6, mult.evaluateAsNumber(dummy_), 0.0);
} // test3 } // test3
void test4() void test4()
@ -58,10 +58,10 @@ public:
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpression_impl<string_type, string_adaptor>* mult = new impl::MultiplyOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(4), new NumericValue<string_type, string_adaptor>(2)); XPathExpression_impl<string_type, string_adaptor>* mult = new impl::MultiplyOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(4), new NumericValue<string_type, string_adaptor>(2));
XPathExpressionPtr<string_type, string_adaptor> minus(new impl::MinusOperator<string_type, string_adaptor>(mult, new NumericValue<string_type, string_adaptor>(2))); XPathExpression<string_type, string_adaptor> minus(new impl::MinusOperator<string_type, string_adaptor>(mult, new NumericValue<string_type, string_adaptor>(2)));
assertEquals(8, mult->evaluateAsNumber(dummy_), 0.0); assertEquals(8, mult->evaluateAsNumber(dummy_), 0.0);
assertEquals(6, minus->evaluateAsNumber(dummy_), 0.0); assertEquals(6, minus.evaluateAsNumber(dummy_), 0.0);
} // test4 } // test4
void test5() void test5()
@ -70,9 +70,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(12); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(12);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> div(new impl::DivideOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> div(new impl::DivideOperator<string_type, string_adaptor>(p1, p2));
assertEquals(6, div->evaluateAsNumber(dummy_), 0.0); assertEquals(6, div.evaluateAsNumber(dummy_), 0.0);
} // test5 } // test5
void test6() void test6()
@ -81,9 +81,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(12); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(12);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(0, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(0, mod.evaluateAsNumber(dummy_), 0.0);
} // test6 } // test6
void test7() void test7()
@ -92,9 +92,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(11); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(11);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> div(new impl::DivideOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> div(new impl::DivideOperator<string_type, string_adaptor>(p1, p2));
assertEquals(5.5, div->evaluateAsNumber(dummy_), 0.0); assertEquals(5.5, div.evaluateAsNumber(dummy_), 0.0);
} // test7 } // test7
void test8() void test8()
@ -103,9 +103,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(11); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(11);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(4); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(4);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(3, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(3, mod.evaluateAsNumber(dummy_), 0.0);
} // test8 } // test8
void test9() void test9()
@ -114,9 +114,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(1.0, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(1.0, mod.evaluateAsNumber(dummy_), 0.0);
} // test9 } // test9
void test10() void test10()
@ -125,9 +125,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(-2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(-2);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(1.00, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(1.00, mod.evaluateAsNumber(dummy_), 0.0);
} // test10 } // test10
void test11() void test11()
@ -136,9 +136,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(2);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(-1.0, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(-1.0, mod.evaluateAsNumber(dummy_), 0.0);
} // test11 } // test11
void test12() void test12()
@ -147,27 +147,27 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5);
XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(-2); XPathExpression_impl<string_type, string_adaptor>* p2 = new NumericValue<string_type, string_adaptor>(-2);
XPathExpressionPtr<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> mod(new impl::ModOperator<string_type, string_adaptor>(p1, p2));
assertEquals(-1.0, mod->evaluateAsNumber(dummy_), 0.0); assertEquals(-1.0, mod.evaluateAsNumber(dummy_), 0.0);
} // test12 } // test12
void test13() void test13()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(5);
XPathExpressionPtr<string_type, string_adaptor> p2(new impl::UnaryNegative<string_type, string_adaptor>(p1)); XPathExpression<string_type, string_adaptor> p2(new impl::UnaryNegative<string_type, string_adaptor>(p1));
assertEquals(-5.0, p2->evaluateAsNumber(dummy_), 0.0); assertEquals(-5.0, p2.evaluateAsNumber(dummy_), 0.0);
} // test13 } // test13
void test14() void test14()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5); XPathExpression_impl<string_type, string_adaptor>* p1 = new NumericValue<string_type, string_adaptor>(-5);
XPathExpressionPtr<string_type, string_adaptor> p2(new impl::UnaryNegative<string_type, string_adaptor>(p1)); XPathExpression<string_type, string_adaptor> p2(new impl::UnaryNegative<string_type, string_adaptor>(p1));
assertEquals(5.0, p2->evaluateAsNumber(dummy_), 0.0); assertEquals(5.0, p2.evaluateAsNumber(dummy_), 0.0);
} // test14 } // test14
private: private:

22
tests/XPath/attr_value_test.hpp
View file

@ -25,16 +25,16 @@ public:
void testParse() void testParse()
{ {
Arabica::DOM::Node<string_type, string_adaptor> dummy; Arabica::DOM::Node<string_type, string_adaptor> dummy;
assertTrue(SA::construct_from_utf8("hello") == compileThis("hello")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("hello") == compileThis("hello").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("") == compileThis("{hello}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("") == compileThis("{hello}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("{hello}") == compileThis("{{hello}}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("{hello}") == compileThis("{{hello}}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("{hello}") == compileThis("{{{'hello'}}}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("{hello}") == compileThis("{{{'hello'}}}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("{}") == compileThis("{{{hello}}}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("{}") == compileThis("{{{hello}}}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("{") == compileThis("{{")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("{") == compileThis("{{").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("}") == compileThis("}}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("}") == compileThis("}}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("hello") == compileThis("hello{@there}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("hello") == compileThis("hello{@there}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("helloMOTHER{}") == compileThis("hello{@there}MOTHER{{}}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("helloMOTHER{}") == compileThis("hello{@there}MOTHER{{}}").evaluateAsString(dummy));
assertTrue(SA::construct_from_utf8("hello there everyone look a }") == compileThis("hello {string('there')} everyone {string('look a }')}")->evaluateAsString(dummy)); assertTrue(SA::construct_from_utf8("hello there everyone look a }") == compileThis("hello {string('there')} everyone {string('look a }')}").evaluateAsString(dummy));
} // testParse } // testParse
void testParseFail() void testParseFail()
@ -60,7 +60,7 @@ public:
return true; return true;
} // dontCompileThis } // dontCompileThis
Arabica::XPath::XPathExpressionPtr<string_type, string_adaptor> compileThis(const char* match) Arabica::XPath::XPathExpression<string_type, string_adaptor> compileThis(const char* match)
{ {
//std::cout << "----\n" << match << std::endl; //std::cout << "----\n" << match << std::endl;
return parser.compile_attribute_value_template(SA::construct_from_utf8(match)); return parser.compile_attribute_value_template(SA::construct_from_utf8(match));

102
tests/XPath/execute_test.hpp
View file

@ -62,7 +62,7 @@ class TestFunction : public Arabica::XPath::XPathFunction<string_type, string_ad
{ {
//typedef string_adaptorstring_adaptor; //typedef string_adaptorstring_adaptor;
public: public:
TestFunction(const std::vector<Arabica::XPath::XPathExpressionPtr<string_type, string_adaptor> >& args) : TestFunction(const std::vector<Arabica::XPath::XPathExpression<string_type, string_adaptor> >& args) :
Arabica::XPath::XPathFunction<string_type, string_adaptor>(0, 0, args) { } Arabica::XPath::XPathFunction<string_type, string_adaptor>(0, 0, args) { }
virtual Arabica::XPath::XPathValue_impl<string_type, string_adaptor>* evaluate(const Arabica::DOM::Node<string_type, string_adaptor>& context, virtual Arabica::XPath::XPathValue_impl<string_type, string_adaptor>* evaluate(const Arabica::DOM::Node<string_type, string_adaptor>& context,
@ -82,7 +82,7 @@ public:
virtual Arabica::XPath::XPathFunction<string_type, string_adaptor>* resolveFunction( virtual Arabica::XPath::XPathFunction<string_type, string_adaptor>* resolveFunction(
const string_type& namespace_uri, const string_type& namespace_uri,
const string_type& name, const string_type& name,
const std::vector<Arabica::XPath::XPathExpressionPtr<string_type, string_adaptor> >& argExprs) const const std::vector<Arabica::XPath::XPathExpression<string_type, string_adaptor> >& argExprs) const
{ {
if(name == string_adaptor::construct_from_utf8("test-function")) if(name == string_adaptor::construct_from_utf8("test-function"))
return new TestFunction<string_type, string_adaptor>(argExprs); return new TestFunction<string_type, string_adaptor>(argExprs);
@ -176,9 +176,9 @@ public:
void test1() void test1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath; XPathExpression<string_type, string_adaptor> xpath;
xpath = parser.compile(SA::construct_from_utf8("root")); xpath = parser.compile(SA::construct_from_utf8("root"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -189,8 +189,8 @@ public:
void test2() void test2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/child2")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/child2"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -201,8 +201,8 @@ public:
void test3() void test3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(3, result.asNodeSet().size()); assertValuesEqual(3, result.asNodeSet().size());
@ -214,8 +214,8 @@ public:
void test4() void test4()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*/text()")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*/text()"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -226,36 +226,36 @@ public:
void test5() void test5()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*/text()")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*/text()"));
assertTrue(text_.getNodeValue() == xpath->evaluateAsString(document_)); assertTrue(text_.getNodeValue() == xpath.evaluateAsString(document_));
} // test5 } // test5
void test6() void test6()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("*")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("*"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(root_ == result.asNodeSet()[0]); assertTrue(root_ == result.asNodeSet()[0]);
result = xpath->evaluate(root_); result = xpath.evaluate(root_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(3, result.asNodeSet().size()); assertValuesEqual(3, result.asNodeSet().size());
assertTrue(element1_ == result.asNodeSet()[0]); assertTrue(element1_ == result.asNodeSet()[0]);
assertTrue(element2_ == result.asNodeSet()[1]); assertTrue(element2_ == result.asNodeSet()[1]);
assertTrue(element3_ == result.asNodeSet()[2]); assertTrue(element3_ == result.asNodeSet()[2]);
result = xpath->evaluate(element1_); result = xpath.evaluate(element1_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(0, result.asNodeSet().size()); assertValuesEqual(0, result.asNodeSet().size());
result = xpath->evaluate(element2_); result = xpath.evaluate(element2_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
result = xpath->evaluate(element3_); result = xpath.evaluate(element3_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(0, result.asNodeSet().size()); assertValuesEqual(0, result.asNodeSet().size());
} // test6 } // test6
@ -263,14 +263,14 @@ public:
void test7() void test7()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(root_ == result.asNodeSet()[0]); assertTrue(root_ == result.asNodeSet()[0]);
result = xpath->evaluate(text_); result = xpath.evaluate(text_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(root_ == result.asNodeSet()[0]); assertTrue(root_ == result.asNodeSet()[0]);
@ -282,14 +282,14 @@ public:
StandardNamespaceContext<string_type, string_adaptor> nsContext; StandardNamespaceContext<string_type, string_adaptor> nsContext;
nsContext.addNamespaceDeclaration(SA::construct_from_utf8("urn:something:or:other"), SA::construct_from_utf8("ns")); nsContext.addNamespaceDeclaration(SA::construct_from_utf8("urn:something:or:other"), SA::construct_from_utf8("ns"));
parser.setNamespaceContext(nsContext); parser.setNamespaceContext(nsContext);
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/ns:root")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/ns:root"));
parser.resetNamespaceContext(); parser.resetNamespaceContext();
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(0, result.asNodeSet().size()); assertValuesEqual(0, result.asNodeSet().size());
result = xpath->evaluate(text_); result = xpath.evaluate(text_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(0, result.asNodeSet().size()); assertValuesEqual(0, result.asNodeSet().size());
} // test8 } // test8
@ -297,15 +297,15 @@ public:
void test9() void test9()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("child2")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("child2"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(root_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(root_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(element2_ == result.asNodeSet()[0]); assertTrue(element2_ == result.asNodeSet()[0]);
xpath = parser.compile(SA::construct_from_utf8("./child2")); xpath = parser.compile(SA::construct_from_utf8("./child2"));
result = xpath->evaluate(root_); result = xpath.evaluate(root_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(element2_ == result.asNodeSet()[0]); assertTrue(element2_ == result.asNodeSet()[0]);
@ -325,9 +325,9 @@ public:
void test11() void test11()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("..")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8(".."));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(element3_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(element3_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(root_ == result.asNodeSet()[0]); assertTrue(root_ == result.asNodeSet()[0]);
@ -336,8 +336,8 @@ public:
void test12() void test12()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[2]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[2]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -409,8 +409,8 @@ public:
void test19() void test19()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -421,8 +421,8 @@ public:
void test20() void test20()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -432,8 +432,8 @@ public:
void test21() void test21()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() != last()]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() != last()]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(2, result.asNodeSet().size()); assertValuesEqual(2, result.asNodeSet().size());
@ -444,8 +444,8 @@ public:
void test22() void test22()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2 or position() = 1]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2 or position() = 1]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(2, result.asNodeSet().size()); assertValuesEqual(2, result.asNodeSet().size());
@ -456,8 +456,8 @@ public:
void test23() void test23()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2 and @two = '1']")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[position() = 2 and @two = '1']"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -467,8 +467,8 @@ public:
void test24() void test24()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()][1]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()][1]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -478,8 +478,8 @@ public:
void test25() void test25()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()][2]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("root/*[last()][2]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(0, result.asNodeSet().size()); assertValuesEqual(0, result.asNodeSet().size());
@ -488,8 +488,8 @@ public:
void test26() void test26()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor::node()[2]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor::node()[2]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -500,8 +500,8 @@ public:
void test27() void test27()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor-or-self::node()[2]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor-or-self::node()[2]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
@ -512,8 +512,8 @@ public:
void test28() void test28()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor-or-self::node()[3]")); XPathExpression<string_type, string_adaptor> xpath = parser.compile(SA::construct_from_utf8("/root/child2/spinkle/ancestor-or-self::node()[3]"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());

6
tests/XPath/expression_test.hpp
View file

@ -95,14 +95,14 @@ public:
void testNode1() void testNode1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> xpath = parser.compile_expr(SA::construct_from_utf8("node()")); XPathExpression<string_type, string_adaptor> xpath = parser.compile_expr(SA::construct_from_utf8("node()"));
XPathValue<string_type, string_adaptor> result = xpath->evaluate(document_); XPathValue<string_type, string_adaptor> result = xpath.evaluate(document_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(1, result.asNodeSet().size()); assertValuesEqual(1, result.asNodeSet().size());
assertTrue(root_ == result.asNodeSet()[0]); assertTrue(root_ == result.asNodeSet()[0]);
result = xpath->evaluate(element2_); result = xpath.evaluate(element2_);
assertValuesEqual(NODE_SET, result.type()); assertValuesEqual(NODE_SET, result.type());
assertValuesEqual(4, result.asNodeSet().size()); assertValuesEqual(4, result.asNodeSet().size());
} // testNode1 } // testNode1

32
tests/XPath/logical_test.hpp
View file

@ -22,57 +22,57 @@ public:
void test1() void test1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false)));
assertEquals(false, orTest->evaluateAsBool(dummy_)); assertEquals(false, orTest.evaluateAsBool(dummy_));
} // test1 } // test1
void test2() void test2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(true, orTest->evaluateAsBool(dummy_)); assertEquals(true, orTest.evaluateAsBool(dummy_));
} // test2 } // test2
void test3() void test3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false)));
assertEquals(true, orTest->evaluateAsBool(dummy_)); assertEquals(true, orTest.evaluateAsBool(dummy_));
} // test3 } // test3
void test4() void test4()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> orTest(new impl::OrOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(true, orTest->evaluateAsBool(dummy_)); assertEquals(true, orTest.evaluateAsBool(dummy_));
} // test4 } // test4
void test5() void test5()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false)));
assertEquals(false, andTest->evaluateAsBool(dummy_)); assertEquals(false, andTest.evaluateAsBool(dummy_));
} // test5 } // test5
void test6() void test6()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(false, andTest->evaluateAsBool(dummy_)); assertEquals(false, andTest.evaluateAsBool(dummy_));
} // test6 } // test6
void test7() void test7()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false)));
assertEquals(false, andTest->evaluateAsBool(dummy_)); assertEquals(false, andTest.evaluateAsBool(dummy_));
} // test7 } // test7
void test8() void test8()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> andTest(new impl::AndOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(true, andTest->evaluateAsBool(dummy_)); assertEquals(true, andTest.evaluateAsBool(dummy_));
} // test8 } // test8
private: private:

2
tests/XPath/parse_test.hpp
View file

@ -14,7 +14,7 @@ public:
virtual Arabica::XPath::XPathFunction<string_type, string_adaptor>* resolveFunction( virtual Arabica::XPath::XPathFunction<string_type, string_adaptor>* resolveFunction(
const string_type& namespace_uri, const string_type& namespace_uri,
const string_type& name, const string_type& name,
const std::vector<Arabica::XPath::XPathExpressionPtr<string_type> >& argExprs) const const std::vector<Arabica::XPath::XPathExpression<string_type> >& argExprs) const
{ {
if((namespace_uri == string_adaptor::construct_from_utf8("something")) && if((namespace_uri == string_adaptor::construct_from_utf8("something")) &&
(name == string_adaptor::construct_from_utf8("true"))) (name == string_adaptor::construct_from_utf8("true")))

140
tests/XPath/relational_test.hpp
View file

@ -22,29 +22,29 @@ public:
void test1() void test1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1)));
XPathExpressionPtr<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1)));
assertEquals(true, equals1->evaluateAsBool(dummy_)); assertEquals(true, equals1.evaluateAsBool(dummy_));
assertEquals(true, equals2->evaluateAsBool(dummy_)); assertEquals(true, equals2.evaluateAsBool(dummy_));
} // test1 } // test1
void test2() void test2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(2))); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(2)));
XPathExpressionPtr<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2), new NumericValue<string_type, string_adaptor>(1)));
assertEquals(false, equals1->evaluateAsBool(dummy_)); assertEquals(false, equals1.evaluateAsBool(dummy_));
assertEquals(false, equals2->evaluateAsBool(dummy_)); assertEquals(false, equals2.evaluateAsBool(dummy_));
} // test2 } // test2
void test3() void test3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1), new NumericValue<string_type, string_adaptor>(1)));
assertEquals(true, equals1->evaluateAsBool(dummy_)); assertEquals(true, equals1.evaluateAsBool(dummy_));
} // test3 } // test3
void test4() void test4()
@ -53,9 +53,9 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new StringValue<string_type, string_adaptor>("charlie"); XPathExpression_impl<string_type, string_adaptor>* p1 = new StringValue<string_type, string_adaptor>("charlie");
XPathExpression_impl<string_type, string_adaptor>* p2 = new StringValue<string_type, string_adaptor>("charlie"); XPathExpression_impl<string_type, string_adaptor>* p2 = new StringValue<string_type, string_adaptor>("charlie");
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(p1, p2));
assertEquals(true, equals1->evaluateAsBool(dummy_)); assertEquals(true, equals1.evaluateAsBool(dummy_));
} // test4 } // test4
void test5() void test5()
@ -64,113 +64,113 @@ public:
XPathExpression_impl<string_type, string_adaptor>* p1 = new StringValue<string_type, string_adaptor>("trousers"); XPathExpression_impl<string_type, string_adaptor>* p1 = new StringValue<string_type, string_adaptor>("trousers");
XPathExpression_impl<string_type, string_adaptor>* p2 = new StringValue<string_type, string_adaptor>("charlie"); XPathExpression_impl<string_type, string_adaptor>* p2 = new StringValue<string_type, string_adaptor>("charlie");
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(p1, p2)); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(p1, p2));
assertEquals(false, equals1->evaluateAsBool(dummy_)); assertEquals(false, equals1.evaluateAsBool(dummy_));
} // test5 } // test5
void test6() void test6()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true)));
XPathExpressionPtr<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false)));
assertEquals(true, equals1->evaluateAsBool(dummy_)); assertEquals(true, equals1.evaluateAsBool(dummy_));
assertEquals(true, equals2->evaluateAsBool(dummy_)); assertEquals(true, equals2.evaluateAsBool(dummy_));
} // test6 } // test6
void test7() void test7()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> equals1(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false)));
XPathExpressionPtr<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> equals2(new impl::EqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(false, equals1->evaluateAsBool(dummy_)); assertEquals(false, equals1.evaluateAsBool(dummy_));
assertEquals(false, equals2->evaluateAsBool(dummy_)); assertEquals(false, equals2.evaluateAsBool(dummy_));
} // test7 } // test7
void testLessThan1() void testLessThan1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true)));
XPathExpressionPtr<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false)));
XPathExpressionPtr<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false)));
XPathExpressionPtr<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(false, lessThan1->evaluateAsBool(dummy_)); assertEquals(false, lessThan1.evaluateAsBool(dummy_));
assertEquals(false, lessThan2->evaluateAsBool(dummy_)); assertEquals(false, lessThan2.evaluateAsBool(dummy_));
assertEquals(false, lessThan3->evaluateAsBool(dummy_)); assertEquals(false, lessThan3.evaluateAsBool(dummy_));
assertEquals(true, lessThan4->evaluateAsBool(dummy_)); assertEquals(true, lessThan4.evaluateAsBool(dummy_));
} // testLessThan1 } // testLessThan1
void testLessThan2() void testLessThan2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1.0), new NumericValue<string_type, string_adaptor>(1.0))); XPathExpression<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1.0), new NumericValue<string_type, string_adaptor>(1.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(3.0), new NumericValue<string_type, string_adaptor>(2.0))); XPathExpression<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(3.0), new NumericValue<string_type, string_adaptor>(2.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2.0), new NumericValue<string_type, string_adaptor>(3.0))); XPathExpression<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2.0), new NumericValue<string_type, string_adaptor>(3.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(-1), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(-1), new NumericValue<string_type, string_adaptor>(1)));
assertEquals(false, lessThan1->evaluateAsBool(dummy_)); assertEquals(false, lessThan1.evaluateAsBool(dummy_));
assertEquals(false, lessThan2->evaluateAsBool(dummy_)); assertEquals(false, lessThan2.evaluateAsBool(dummy_));
assertEquals(true, lessThan3->evaluateAsBool(dummy_)); assertEquals(true, lessThan3.evaluateAsBool(dummy_));
assertEquals(true, lessThan4->evaluateAsBool(dummy_)); assertEquals(true, lessThan4.evaluateAsBool(dummy_));
} // testLessThan2 } // testLessThan2
void testLessThan3() void testLessThan3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("1.0"), new StringValue<string_type, string_adaptor>("1.0"))); XPathExpression<string_type, string_adaptor> lessThan1(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("1.0"), new StringValue<string_type, string_adaptor>("1.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("3.0"), new StringValue<string_type, string_adaptor>("2.0"))); XPathExpression<string_type, string_adaptor> lessThan2(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("3.0"), new StringValue<string_type, string_adaptor>("2.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("2.0"), new StringValue<string_type, string_adaptor>("3.0"))); XPathExpression<string_type, string_adaptor> lessThan3(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("2.0"), new StringValue<string_type, string_adaptor>("3.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("-1"), new StringValue<string_type, string_adaptor>("1"))); XPathExpression<string_type, string_adaptor> lessThan4(new impl::LessThanOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("-1"), new StringValue<string_type, string_adaptor>("1")));
assertEquals(false, lessThan1->evaluateAsBool(dummy_)); assertEquals(false, lessThan1.evaluateAsBool(dummy_));
assertEquals(false, lessThan2->evaluateAsBool(dummy_)); assertEquals(false, lessThan2.evaluateAsBool(dummy_));
assertEquals(true, lessThan3->evaluateAsBool(dummy_)); assertEquals(true, lessThan3.evaluateAsBool(dummy_));
assertEquals(true, lessThan4->evaluateAsBool(dummy_)); assertEquals(true, lessThan4.evaluateAsBool(dummy_));
} // testLessThan3 } // testLessThan3
void testLessThanEquals1() void testLessThanEquals1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(true)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(false)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false))); XPathExpression<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(true), new BoolValue<string_type, string_adaptor>(false)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true))); XPathExpression<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new BoolValue<string_type, string_adaptor>(false), new BoolValue<string_type, string_adaptor>(true)));
assertEquals(true, lessThanEquals1->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals1.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals2->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals2.evaluateAsBool(dummy_));
assertEquals(false, lessThanEquals3->evaluateAsBool(dummy_)); assertEquals(false, lessThanEquals3.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals4->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals4.evaluateAsBool(dummy_));
} // testLessThanEquals1 } // testLessThanEquals1
void testLessThanEquals2() void testLessThanEquals2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1.0), new NumericValue<string_type, string_adaptor>(1.0))); XPathExpression<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(1.0), new NumericValue<string_type, string_adaptor>(1.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(3.0), new NumericValue<string_type, string_adaptor>(2.0))); XPathExpression<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(3.0), new NumericValue<string_type, string_adaptor>(2.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2.0), new NumericValue<string_type, string_adaptor>(3.0))); XPathExpression<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(2.0), new NumericValue<string_type, string_adaptor>(3.0)));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(-1), new NumericValue<string_type, string_adaptor>(1))); XPathExpression<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new NumericValue<string_type, string_adaptor>(-1), new NumericValue<string_type, string_adaptor>(1)));
assertEquals(true, lessThanEquals1->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals1.evaluateAsBool(dummy_));
assertEquals(false, lessThanEquals2->evaluateAsBool(dummy_)); assertEquals(false, lessThanEquals2.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals3->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals3.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals4->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals4.evaluateAsBool(dummy_));
} // testLessThanEquals2 } // testLessThanEquals2
void testLessThanEquals3() void testLessThanEquals3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("1.0"), new StringValue<string_type, string_adaptor>("1.0"))); XPathExpression<string_type, string_adaptor> lessThanEquals1(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("1.0"), new StringValue<string_type, string_adaptor>("1.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("3.0"), new StringValue<string_type, string_adaptor>("2.0"))); XPathExpression<string_type, string_adaptor> lessThanEquals2(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("3.0"), new StringValue<string_type, string_adaptor>("2.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("2.0"), new StringValue<string_type, string_adaptor>("3.0"))); XPathExpression<string_type, string_adaptor> lessThanEquals3(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("2.0"), new StringValue<string_type, string_adaptor>("3.0")));
XPathExpressionPtr<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("-1"), new StringValue<string_type, string_adaptor>("1"))); XPathExpression<string_type, string_adaptor> lessThanEquals4(new impl::LessThanEqualsOperator<string_type, string_adaptor>(new StringValue<string_type, string_adaptor>("-1"), new StringValue<string_type, string_adaptor>("1")));
assertEquals(true, lessThanEquals1->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals1.evaluateAsBool(dummy_));
assertEquals(false, lessThanEquals2->evaluateAsBool(dummy_)); assertEquals(false, lessThanEquals2.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals3->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals3.evaluateAsBool(dummy_));
assertEquals(true, lessThanEquals4->evaluateAsBool(dummy_)); assertEquals(true, lessThanEquals4.evaluateAsBool(dummy_));
} // testLessThanEquals3 } // testLessThanEquals3
private: private:

12
tests/XPath/step_test.hpp
View file

@ -56,9 +56,9 @@ public:
void test1() void test1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> step(new impl::TestStepExpression<string_type, string_adaptor>(CHILD, new impl::AnyNodeTest<string_type, string_adaptor>())); XPathExpression<string_type, string_adaptor> step(new impl::TestStepExpression<string_type, string_adaptor>(CHILD, new impl::AnyNodeTest<string_type, string_adaptor>()));
XPathValue<string_type, string_adaptor> value = step->evaluate(root_); XPathValue<string_type, string_adaptor> value = step.evaluate(root_);
const NodeSet<string_type, string_adaptor>& set = value.asNodeSet(); const NodeSet<string_type, string_adaptor>& set = value.asNodeSet();
assertEquals(set.size(), 3); assertEquals(set.size(), 3);
@ -70,9 +70,9 @@ public:
void test2() void test2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> step(new impl::TestStepExpression<string_type, string_adaptor>(ATTRIBUTE, new impl::AnyNodeTest<string_type, string_adaptor>())); XPathExpression<string_type, string_adaptor> step(new impl::TestStepExpression<string_type, string_adaptor>(ATTRIBUTE, new impl::AnyNodeTest<string_type, string_adaptor>()));
NodeSet<string_type, string_adaptor> set = step->evaluateAsNodeSet(element2_); NodeSet<string_type, string_adaptor> set = step.evaluateAsNodeSet(element2_);
assertEquals(4, set.size()); assertEquals(4, set.size());
Arabica::DOM::Attr<string_type, string_adaptor> attr = static_cast<Arabica::DOM::Attr<string_type, string_adaptor> >(set[0]); Arabica::DOM::Attr<string_type, string_adaptor> attr = static_cast<Arabica::DOM::Attr<string_type, string_adaptor> >(set[0]);
@ -88,10 +88,10 @@ public:
void test3() void test3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> step(new impl::TestStepExpression<string_type, XPathExpression<string_type, string_adaptor> step(new impl::TestStepExpression<string_type,
string_adaptor>(CHILD, new impl::NameNodeTest<string_type, string_adaptor>(SA::construct_from_utf8("child2")))); string_adaptor>(CHILD, new impl::NameNodeTest<string_type, string_adaptor>(SA::construct_from_utf8("child2"))));
XPathValue<string_type, string_adaptor> value = step->evaluate(root_); XPathValue<string_type, string_adaptor> value = step.evaluate(root_);
const NodeSet<string_type, string_adaptor>& set = value.asNodeSet(); const NodeSet<string_type, string_adaptor>& set = value.asNodeSet();
assertEquals(1, set.size()); assertEquals(1, set.size());

130
tests/XPath/value_test.hpp
View file

@ -26,147 +26,147 @@ public:
void test1() void test1()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> b(new BoolValue<string_type, string_adaptor>(true)); XPathExpression<string_type, string_adaptor> b(new BoolValue<string_type, string_adaptor>(true));
assertEquals(true, b->evaluateAsBool(dummy_)); assertEquals(true, b.evaluateAsBool(dummy_));
assertEquals(1.0, b->evaluateAsNumber(dummy_), 0.0); assertEquals(1.0, b.evaluateAsNumber(dummy_), 0.0);
assertTrue(SA::construct_from_utf8("true") == b->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("true") == b.evaluateAsString(dummy_));
} }
void test2() void test2()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> b2(new BoolValue<string_type, string_adaptor>(false)); XPathExpression<string_type, string_adaptor> b2(new BoolValue<string_type, string_adaptor>(false));
assertEquals(false, b2->evaluateAsBool(dummy_)); assertEquals(false, b2.evaluateAsBool(dummy_));
assertEquals(0.0, b2->evaluateAsNumber(dummy_), 0.0); assertEquals(0.0, b2.evaluateAsNumber(dummy_), 0.0);
assertTrue(SA::construct_from_utf8("false") == b2->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("false") == b2.evaluateAsString(dummy_));
} // test2 } // test2
void test3() void test3()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(99.5)); XPathExpression<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(99.5));
assertEquals(true, n->evaluateAsBool(dummy_)); assertEquals(true, n.evaluateAsBool(dummy_));
assertEquals(99.5, n->evaluateAsNumber(dummy_), 0.0); assertEquals(99.5, n.evaluateAsNumber(dummy_), 0.0);
assertTrue(SA::construct_from_utf8("99.5") == n->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("99.5") == n.evaluateAsString(dummy_));
} }
void test4() void test4()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(0.0)); XPathExpression<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(0.0));
assertEquals(false, n->evaluateAsBool(dummy_)); assertEquals(false, n.evaluateAsBool(dummy_));
assertEquals(0, n->evaluateAsNumber(dummy_), 0); assertEquals(0, n.evaluateAsNumber(dummy_), 0);
assertTrue(SA::construct_from_utf8("0") == n->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("0") == n.evaluateAsString(dummy_));
} }
void test5() void test5()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("hello")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("hello"));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertTrue(SA::construct_from_utf8("hello") == s->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("hello") == s.evaluateAsString(dummy_));
} // test5 } // test5
void test6() void test6()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>(""));
assertEquals(false, s->evaluateAsBool(dummy_)); assertEquals(false, s.evaluateAsBool(dummy_));
} }
void test7() void test7()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("100")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("100"));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertEquals(100.0, s->evaluateAsNumber(dummy_), 0.0); assertEquals(100.0, s.evaluateAsNumber(dummy_), 0.0);
assertTrue(SA::construct_from_utf8("100") == s->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("100") == s.evaluateAsString(dummy_));
} // test7 } // test7
void test8() void test8()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("0")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("0"));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertEquals(0.0, s->evaluateAsNumber(dummy_), 0.0); assertEquals(0.0, s.evaluateAsNumber(dummy_), 0.0);
assertTrue(SA::construct_from_utf8("0") == s->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("0") == s.evaluateAsString(dummy_));
} // test8 } // test8
void test9() void test9()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> bt(new BoolValue<string_type, string_adaptor>(true)); XPathExpression<string_type, string_adaptor> bt(new BoolValue<string_type, string_adaptor>(true));
XPathExpressionPtr<string_type, string_adaptor> st(new StringValue<string_type, string_adaptor>("true")); XPathExpression<string_type, string_adaptor> st(new StringValue<string_type, string_adaptor>("true"));
XPathExpressionPtr<string_type, string_adaptor> bf(new BoolValue<string_type, string_adaptor>(false)); XPathExpression<string_type, string_adaptor> bf(new BoolValue<string_type, string_adaptor>(false));
XPathExpressionPtr<string_type, string_adaptor> sf(new StringValue<string_type, string_adaptor>("")); XPathExpression<string_type, string_adaptor> sf(new StringValue<string_type, string_adaptor>(""));
assertTrue((impl::areEqual<string_type, string_adaptor>(bt->evaluate(dummy_), (st->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bt.evaluate(dummy_), (st.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(st->evaluate(dummy_), (bt->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(st.evaluate(dummy_), (bt.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(sf->evaluate(dummy_), (bf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(sf.evaluate(dummy_), (bf.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(bf->evaluate(dummy_), (sf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bf.evaluate(dummy_), (sf.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(bt->evaluate(dummy_), (bt->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bt.evaluate(dummy_), (bt.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(bf->evaluate(dummy_), (bf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bf.evaluate(dummy_), (bf.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(st->evaluate(dummy_), (st->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(st.evaluate(dummy_), (st.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(sf->evaluate(dummy_), (sf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(sf.evaluate(dummy_), (sf.evaluate(dummy_)))));
} // test9 } // test9
void test10() void test10()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> bt(new BoolValue<string_type, string_adaptor>(true)); XPathExpression<string_type, string_adaptor> bt(new BoolValue<string_type, string_adaptor>(true));
XPathExpressionPtr<string_type, string_adaptor> nt(new NumericValue<string_type, string_adaptor>(1.0)); XPathExpression<string_type, string_adaptor> nt(new NumericValue<string_type, string_adaptor>(1.0));
XPathExpressionPtr<string_type, string_adaptor> bf(new BoolValue<string_type, string_adaptor>(false)); XPathExpression<string_type, string_adaptor> bf(new BoolValue<string_type, string_adaptor>(false));
XPathExpressionPtr<string_type, string_adaptor> nf(new NumericValue<string_type, string_adaptor>(0.0)); XPathExpression<string_type, string_adaptor> nf(new NumericValue<string_type, string_adaptor>(0.0));
assertTrue((impl::areEqual<string_type, string_adaptor>(bt->evaluate(dummy_), (nt->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bt.evaluate(dummy_), (nt.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(nt->evaluate(dummy_), (bt->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(nt.evaluate(dummy_), (bt.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(bf->evaluate(dummy_), (nf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(bf.evaluate(dummy_), (nf.evaluate(dummy_)))));
assertTrue((impl::areEqual<string_type, string_adaptor>(nf->evaluate(dummy_), (bf->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(nf.evaluate(dummy_), (bf.evaluate(dummy_)))));
} // test10 } // test10
void test11() void test11()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> nt(new NumericValue<string_type, string_adaptor>(1.0)); XPathExpression<string_type, string_adaptor> nt(new NumericValue<string_type, string_adaptor>(1.0));
XPathValue<string_type, string_adaptor> ns = nt->evaluate(dummy_); XPathValue<string_type, string_adaptor> ns = nt.evaluate(dummy_);
assertTrue((impl::areEqual<string_type, string_adaptor>(ns, (nt->evaluate(dummy_))))); assertTrue((impl::areEqual<string_type, string_adaptor>(ns, (nt.evaluate(dummy_)))));
} // test11 } // test11
void test12() void test12()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(NaN)); XPathExpression<string_type, string_adaptor> n(new NumericValue<string_type, string_adaptor>(NaN));
assertEquals(false, n->evaluateAsBool(dummy_)); assertEquals(false, n.evaluateAsBool(dummy_));
assertTrue(isNaN(n->evaluateAsNumber(dummy_))); assertTrue(isNaN(n.evaluateAsNumber(dummy_)));
assertTrue(SA::construct_from_utf8("NaN") == n->evaluateAsString(dummy_)); assertTrue(SA::construct_from_utf8("NaN") == n.evaluateAsString(dummy_));
} }
void test13() void test13()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>(" 100 ")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>(" 100 "));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertEquals(100.0, s->evaluateAsNumber(dummy_), 0.0); assertEquals(100.0, s.evaluateAsNumber(dummy_), 0.0);
} // test13 } // test13
void test14() void test14()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>(" -100 ")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>(" -100 "));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertEquals(-100.0, s->evaluateAsNumber(dummy_), 0.0); assertEquals(-100.0, s.evaluateAsNumber(dummy_), 0.0);
} // test14 } // test14
void test15() void test15()
{ {
using namespace Arabica::XPath; using namespace Arabica::XPath;
XPathExpressionPtr<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("trousers")); XPathExpression<string_type, string_adaptor> s(new StringValue<string_type, string_adaptor>("trousers"));
assertEquals(true, s->evaluateAsBool(dummy_)); assertEquals(true, s.evaluateAsBool(dummy_));
assertTrue(isNaN(s->evaluateAsNumber(dummy_))); assertTrue(isNaN(s.evaluateAsNumber(dummy_)));
} // test15 } // test15
}; // ValueTest }; // ValueTest