summaryrefslogtreecommitdiff
path: root/qpid/cpp
diff options
context:
space:
mode:
Diffstat (limited to 'qpid/cpp')
-rw-r--r--qpid/cpp/src/qpid/acl/AclLexer.cpp244
-rw-r--r--qpid/cpp/src/qpid/acl/AclLexer.h31
-rw-r--r--qpid/cpp/src/tests/Acl.cpp157
-rw-r--r--qpid/cpp/src/tests/CMakeLists.txt1
4 files changed, 257 insertions, 176 deletions
diff --git a/qpid/cpp/src/qpid/acl/AclLexer.cpp b/qpid/cpp/src/qpid/acl/AclLexer.cpp
index 4fa2c64d1c..4bc2573cf1 100644
--- a/qpid/cpp/src/qpid/acl/AclLexer.cpp
+++ b/qpid/cpp/src/qpid/acl/AclLexer.cpp
@@ -30,189 +30,107 @@
namespace qpid {
namespace acl {
+// ObjectType
+const std::string objectNames[OBJECTSIZE] = {
+ "queue", "exchange", "broker", "link", "method", "query" };
+
ObjectType AclHelper::getObjectType(const std::string& str) {
- if (str.compare("queue") == 0) return OBJ_QUEUE;
- if (str.compare("exchange") == 0) return OBJ_EXCHANGE;
- if (str.compare("broker") == 0) return OBJ_BROKER;
- if (str.compare("link") == 0) return OBJ_LINK;
- if (str.compare("method") == 0) return OBJ_METHOD;
- if (str.compare("query") == 0) return OBJ_QUERY;
+ for (int i=0; i< OBJECTSIZE; ++i) {
+ if (str.compare(objectNames[i]) == 0)
+ return ObjectType(i);
+ }
throw qpid::Exception(str);
}
-std::string AclHelper::getObjectTypeStr(const ObjectType o) {
- switch (o) {
- case OBJ_QUEUE: return "queue";
- case OBJ_EXCHANGE: return "exchange";
- case OBJ_BROKER: return "broker";
- case OBJ_LINK: return "link";
- case OBJ_METHOD: return "method";
- case OBJ_QUERY: return "query";
- default: assert(false); // should never get here
- }
- return "";
+
+const std::string& AclHelper::getObjectTypeStr(const ObjectType o) {
+ return objectNames[o];
}
+
+// Action
+const std::string actionNames[ACTIONSIZE] = {
+ "consume", "publish", "create", "access", "bind",
+ "unbind", "delete", "purge", "update", "move",
+ "redirect", "reroute" };
+
Action AclHelper::getAction(const std::string& str) {
- if (str.compare("consume") == 0) return ACT_CONSUME;
- if (str.compare("publish") == 0) return ACT_PUBLISH;
- if (str.compare("create") == 0) return ACT_CREATE;
- if (str.compare("access") == 0) return ACT_ACCESS;
- if (str.compare("bind") == 0) return ACT_BIND;
- if (str.compare("unbind") == 0) return ACT_UNBIND;
- if (str.compare("delete") == 0) return ACT_DELETE;
- if (str.compare("purge") == 0) return ACT_PURGE;
- if (str.compare("update") == 0) return ACT_UPDATE;
- if (str.compare("move") == 0) return ACT_MOVE;
- if (str.compare("redirect") == 0) return ACT_REDIRECT;
- if (str.compare("reroute") == 0) return ACT_REROUTE;
+ for (int i=0; i< ACTIONSIZE; ++i) {
+ if (str.compare(actionNames[i]) == 0)
+ return Action(i);
+ }
throw qpid::Exception(str);
}
-std::string AclHelper::getActionStr(const Action a) {
- switch (a) {
- case ACT_CONSUME: return "consume";
- case ACT_PUBLISH: return "publish";
- case ACT_CREATE: return "create";
- case ACT_ACCESS: return "access";
- case ACT_BIND: return "bind";
- case ACT_UNBIND: return "unbind";
- case ACT_DELETE: return "delete";
- case ACT_PURGE: return "purge";
- case ACT_UPDATE: return "update";
- case ACT_MOVE: return "move";
- case ACT_REDIRECT: return "redirect";
- case ACT_REROUTE: return "reroute";
- default: assert(false); // should never get here
- }
- return "";
+
+const std::string& AclHelper::getActionStr(const Action a) {
+ return actionNames[a];
}
+
+// Property
+// These are shared between broker and acl using code enums.
+const std::string propertyNames[PROPERTYSIZE] = {
+ "name", "durable", "owner", "routingkey", "autodelete", "exclusive", "type",
+ "alternate", "queuename", "exchangename", "schemapackage",
+ "schemaclass", "policytype", "paging",
+
+ "maxpages", "maxpagefactor",
+ "maxqueuesize", "maxqueuecount", "maxfilesize", "maxfilecount"};
+
Property AclHelper::getProperty(const std::string& str) {
- if (str.compare("name") == 0) return PROP_NAME;
- if (str.compare("durable") == 0) return PROP_DURABLE;
- if (str.compare("owner") == 0) return PROP_OWNER;
- if (str.compare("routingkey") == 0) return PROP_ROUTINGKEY;
- if (str.compare("autodelete") == 0) return PROP_AUTODELETE;
- if (str.compare("exclusive") == 0) return PROP_EXCLUSIVE;
- if (str.compare("type") == 0) return PROP_TYPE;
- if (str.compare("alternate") == 0) return PROP_ALTERNATE;
- if (str.compare("queuename") == 0) return PROP_QUEUENAME;
- if (str.compare("exchangename") == 0) return PROP_EXCHANGENAME;
- if (str.compare("schemapackage") == 0) return PROP_SCHEMAPACKAGE;
- if (str.compare("schemaclass") == 0) return PROP_SCHEMACLASS;
- if (str.compare("policytype") == 0) return PROP_POLICYTYPE;
- if (str.compare("paging") == 0) return PROP_PAGING;
- if (str.compare("maxpages") == 0) return PROP_MAXPAGES;
- if (str.compare("maxpagefactor") == 0) return PROP_MAXPAGEFACTOR;
- if (str.compare("maxqueuesize") == 0) return PROP_MAXQUEUESIZE;
- if (str.compare("maxqueuecount") == 0) return PROP_MAXQUEUECOUNT;
- if (str.compare("maxfilesize") == 0) return PROP_MAXFILESIZE;
- if (str.compare("maxfilecount") == 0) return PROP_MAXFILECOUNT;
+ for (int i=0; i< PROPERTYSIZE; ++i) {
+ if (str.compare(propertyNames[i]) == 0)
+ return Property(i);
+ }
throw qpid::Exception(str);
}
-std::string AclHelper::getPropertyStr(const Property p) {
- switch (p) {
- case PROP_NAME: return "name";
- case PROP_DURABLE: return "durable";
- case PROP_OWNER: return "owner";
- case PROP_ROUTINGKEY: return "routingkey";
- case PROP_AUTODELETE: return "autodelete";
- case PROP_EXCLUSIVE: return "exclusive";
- case PROP_TYPE: return "type";
- case PROP_ALTERNATE: return "alternate";
- case PROP_QUEUENAME: return "queuename";
- case PROP_EXCHANGENAME: return "exchangename";
- case PROP_SCHEMAPACKAGE: return "schemapackage";
- case PROP_SCHEMACLASS: return "schemaclass";
- case PROP_POLICYTYPE: return "policytype";
- case PROP_PAGING: return "paging";
- case PROP_MAXPAGES: return "maxpages";
- case PROP_MAXPAGEFACTOR: return "maxpagefactor";
- case PROP_MAXQUEUESIZE: return "maxqueuesize";
- case PROP_MAXQUEUECOUNT: return "maxqueuecount";
- case PROP_MAXFILESIZE: return "maxfilesize";
- case PROP_MAXFILECOUNT: return "maxfilecount";
- default: assert(false); // should never get here
- }
- return "";
+
+const std::string& AclHelper::getPropertyStr(const Property p) {
+ return propertyNames[p];
}
+
+// SpecProperty
+// These are shared between user acl files and acl using text.
+const std::string specPropertyNames[SPECPROPSIZE] = {
+ "name", "durable", "owner", "routingkey", "autodelete", "exclusive", "type",
+ "alternate", "queuename", "exchangename", "schemapackage",
+ "schemaclass", "policytype", "paging",
+
+ "queuemaxsizelowerlimit", "queuemaxsizeupperlimit",
+ "queuemaxcountlowerlimit", "queuemaxcountupperlimit",
+ "filemaxsizelowerlimit", "filemaxsizeupperlimit",
+ "filemaxcountlowerlimit", "filemaxcountupperlimit",
+ "pageslowerlimit", "pagesupperlimit",
+ "pagefactorlowerlimit", "pagefactorupperlimit" };
+
SpecProperty AclHelper::getSpecProperty(const std::string& str) {
- if (str.compare("name") == 0) return SPECPROP_NAME;
- if (str.compare("durable") == 0) return SPECPROP_DURABLE;
- if (str.compare("owner") == 0) return SPECPROP_OWNER;
- if (str.compare("routingkey") == 0) return SPECPROP_ROUTINGKEY;
- if (str.compare("autodelete") == 0) return SPECPROP_AUTODELETE;
- if (str.compare("exclusive") == 0) return SPECPROP_EXCLUSIVE;
- if (str.compare("type") == 0) return SPECPROP_TYPE;
- if (str.compare("alternate") == 0) return SPECPROP_ALTERNATE;
- if (str.compare("queuename") == 0) return SPECPROP_QUEUENAME;
- if (str.compare("exchangename") == 0) return SPECPROP_EXCHANGENAME;
- if (str.compare("schemapackage") == 0) return SPECPROP_SCHEMAPACKAGE;
- if (str.compare("schemaclass") == 0) return SPECPROP_SCHEMACLASS;
- if (str.compare("policytype") == 0) return SPECPROP_POLICYTYPE;
- if (str.compare("paging") == 0) return SPECPROP_PAGING;
- if (str.compare("queuemaxsizelowerlimit") == 0) return SPECPROP_MAXQUEUESIZELOWERLIMIT;
- if (str.compare("queuemaxsizeupperlimit") == 0) return SPECPROP_MAXQUEUESIZEUPPERLIMIT;
- if (str.compare("queuemaxcountlowerlimit") == 0) return SPECPROP_MAXQUEUECOUNTLOWERLIMIT;
- if (str.compare("queuemaxcountupperlimit") == 0) return SPECPROP_MAXQUEUECOUNTUPPERLIMIT;
- if (str.compare("filemaxsizelowerlimit") == 0) return SPECPROP_MAXFILESIZELOWERLIMIT;
- if (str.compare("filemaxsizeupperlimit") == 0) return SPECPROP_MAXFILESIZEUPPERLIMIT;
- if (str.compare("filemaxcountlowerlimit") == 0) return SPECPROP_MAXFILECOUNTLOWERLIMIT;
- if (str.compare("filemaxcountupperlimit") == 0) return SPECPROP_MAXFILECOUNTUPPERLIMIT;
- if (str.compare("pageslowerlimit") == 0) return SPECPROP_MAXPAGESLOWERLIMIT;
- if (str.compare("pagesupperlimit") == 0) return SPECPROP_MAXPAGESUPPERLIMIT;
- if (str.compare("pagefactorlowerlimit") == 0) return SPECPROP_MAXPAGEFACTORLOWERLIMIT;
- if (str.compare("pagefactorupperlimit") == 0) return SPECPROP_MAXPAGEFACTORUPPERLIMIT;
+ for (int i=0; i< SPECPROPSIZE; ++i) {
+ if (str.compare(specPropertyNames[i]) == 0)
+ return SpecProperty(i);
+ }
// Allow old names in ACL file as aliases for newly-named properties
- if (str.compare("maxqueuesize") == 0) return SPECPROP_MAXQUEUESIZEUPPERLIMIT;
- if (str.compare("maxqueuecount") == 0) return SPECPROP_MAXQUEUECOUNTUPPERLIMIT;
+ if (str.compare("maxqueuesize") == 0)
+ return SPECPROP_MAXQUEUESIZEUPPERLIMIT;
+ if (str.compare("maxqueuecount") == 0)
+ return SPECPROP_MAXQUEUECOUNTUPPERLIMIT;
throw qpid::Exception(str);
}
-std::string AclHelper::getPropertyStr(const SpecProperty p) {
- switch (p) {
- case SPECPROP_NAME: return "name";
- case SPECPROP_DURABLE: return "durable";
- case SPECPROP_OWNER: return "owner";
- case SPECPROP_ROUTINGKEY: return "routingkey";
- case SPECPROP_AUTODELETE: return "autodelete";
- case SPECPROP_EXCLUSIVE: return "exclusive";
- case SPECPROP_TYPE: return "type";
- case SPECPROP_ALTERNATE: return "alternate";
- case SPECPROP_QUEUENAME: return "queuename";
- case SPECPROP_EXCHANGENAME: return "exchangename";
- case SPECPROP_SCHEMAPACKAGE: return "schemapackage";
- case SPECPROP_SCHEMACLASS: return "schemaclass";
- case SPECPROP_POLICYTYPE: return "policytype";
- case SPECPROP_PAGING: return "paging";
- case SPECPROP_MAXQUEUESIZELOWERLIMIT: return "queuemaxsizelowerlimit";
- case SPECPROP_MAXQUEUESIZEUPPERLIMIT: return "queuemaxsizeupperlimit";
- case SPECPROP_MAXQUEUECOUNTLOWERLIMIT: return "queuemaxcountlowerlimit";
- case SPECPROP_MAXQUEUECOUNTUPPERLIMIT: return "queuemaxcountupperlimit";
- case SPECPROP_MAXFILESIZELOWERLIMIT: return "filemaxsizelowerlimit";
- case SPECPROP_MAXFILESIZEUPPERLIMIT: return "filemaxsizeupperlimit";
- case SPECPROP_MAXFILECOUNTLOWERLIMIT: return "filemaxcountlowerlimit";
- case SPECPROP_MAXFILECOUNTUPPERLIMIT: return "filemaxcountupperlimit";
- case SPECPROP_MAXPAGESLOWERLIMIT: return "pageslowerlimit";
- case SPECPROP_MAXPAGESUPPERLIMIT: return "pagesupperlimit";
- case SPECPROP_MAXPAGEFACTORLOWERLIMIT: return "pagefactorlowerlimit";
- case SPECPROP_MAXPAGEFACTORUPPERLIMIT: return "pagefactorupperlimit";
- default: assert(false); // should never get here
- }
- return "";
+
+const std::string& AclHelper::getPropertyStr(const SpecProperty p) {
+ return specPropertyNames[p];
}
+
+// AclResult
+const std::string resultNames[RESULTSIZE] = {
+ "allow", "allow-log", "deny", "deny-log" };
+
AclResult AclHelper::getAclResult(const std::string& str) {
- if (str.compare("allow") == 0) return ALLOW;
- if (str.compare("allow-log") == 0) return ALLOWLOG;
- if (str.compare("deny") == 0) return DENY;
- if (str.compare("deny-log") == 0) return DENYLOG;
+ for (int i=0; i< RESULTSIZE; ++i) {
+ if (str.compare(resultNames[i]) == 0)
+ return AclResult(i);
+ }
throw qpid::Exception(str);
}
-std::string AclHelper::getAclResultStr(const AclResult r) {
- switch (r) {
- case ALLOW: return "allow";
- case ALLOWLOG: return "allow-log";
- case DENY: return "deny";
- case DENYLOG: return "deny-log";
- default: assert(false); // should never get here
- }
- return "";
+
+const std::string& AclHelper::getAclResultStr(const AclResult r) {
+ return resultNames[r];
}
// This map contains the legal combinations of object/action/properties
diff --git a/qpid/cpp/src/qpid/acl/AclLexer.h b/qpid/cpp/src/qpid/acl/AclLexer.h
index 6cc867aae5..4c2c8048ef 100644
--- a/qpid/cpp/src/qpid/acl/AclLexer.h
+++ b/qpid/cpp/src/qpid/acl/AclLexer.h
@@ -21,6 +21,7 @@
#include "qpid/Exception.h"
+#include "qpid/broker/BrokerImportExport.h"
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <map>
@@ -121,30 +122,34 @@ namespace acl {
SPECPROP_MAXPAGESLOWERLIMIT,
SPECPROP_MAXPAGESUPPERLIMIT,
SPECPROP_MAXPAGEFACTORLOWERLIMIT,
- SPECPROP_MAXPAGEFACTORUPPERLIMIT };
+ SPECPROP_MAXPAGEFACTORUPPERLIMIT,
+ SPECPROPSIZE // SPECPROPSIZE must be last
+ };
// AclResult shared between ACL spec and ACL authorise interface
enum AclResult {
ALLOW,
ALLOWLOG,
DENY,
- DENYLOG };
+ DENYLOG,
+ RESULTSIZE
+ };
- class AclHelper {
+ QPID_BROKER_CLASS_EXTERN class AclHelper {
private:
AclHelper(){}
public:
- static ObjectType getObjectType(const std::string& str);
- static std::string getObjectTypeStr(const ObjectType o);
- static Action getAction(const std::string& str);
- static std::string getActionStr(const Action a);
- static Property getProperty(const std::string& str);
- static std::string getPropertyStr(const Property p);
- static SpecProperty getSpecProperty(const std::string& str);
- static std::string getPropertyStr(const SpecProperty p);
- static AclResult getAclResult(const std::string& str);
- static std::string getAclResultStr(const AclResult r);
+ static QPID_BROKER_EXTERN ObjectType getObjectType(const std::string& str);
+ static QPID_BROKER_EXTERN const std::string& getObjectTypeStr(const ObjectType o);
+ static QPID_BROKER_EXTERN Action getAction(const std::string& str);
+ static QPID_BROKER_EXTERN const std::string& getActionStr(const Action a);
+ static QPID_BROKER_EXTERN Property getProperty(const std::string& str);
+ static QPID_BROKER_EXTERN const std::string& getPropertyStr(const Property p);
+ static QPID_BROKER_EXTERN SpecProperty getSpecProperty(const std::string& str);
+ static QPID_BROKER_EXTERN const std::string& getPropertyStr(const SpecProperty p);
+ static QPID_BROKER_EXTERN AclResult getAclResult(const std::string& str);
+ static QPID_BROKER_EXTERN const std::string& getAclResultStr(const AclResult r);
typedef std::set<Property> propSet;
typedef boost::shared_ptr<propSet> propSetPtr;
diff --git a/qpid/cpp/src/tests/Acl.cpp b/qpid/cpp/src/tests/Acl.cpp
new file mode 100644
index 0000000000..e04d3e1d5e
--- /dev/null
+++ b/qpid/cpp/src/tests/Acl.cpp
@@ -0,0 +1,157 @@
+/*
+ *
+ * Copyright (c) 2014 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#include "unit_test.h"
+#include "test_tools.h"
+#include "qpid/acl/AclLexer.h"
+#include <boost/assign.hpp>
+
+using namespace std;
+using namespace qpid;
+using namespace qpid::acl;
+using namespace boost::assign;
+
+namespace qpid {
+namespace tests {
+
+QPID_AUTO_TEST_SUITE(AclTestSuite)
+
+#define OBJ_ENUMS(e, s) \
+ BOOST_CHECK_EQUAL(AclHelper::getObjectTypeStr((e)),(s)); \
+ BOOST_CHECK_EQUAL(AclHelper::getObjectType((s)),(e))
+
+QPID_AUTO_TEST_CASE(TestLexerObjectEnums) {
+ OBJ_ENUMS(OBJ_QUEUE, "queue");
+ OBJ_ENUMS(OBJ_EXCHANGE, "exchange");
+ OBJ_ENUMS(OBJ_BROKER, "broker");
+ OBJ_ENUMS(OBJ_LINK, "link");
+ OBJ_ENUMS(OBJ_METHOD, "method");
+ OBJ_ENUMS(OBJ_QUERY, "query");
+}
+
+#define ACT_ENUMS(e, s) \
+ BOOST_CHECK_EQUAL(AclHelper::getActionStr((e)),(s)); \
+ BOOST_CHECK_EQUAL(AclHelper::getAction((s)),(e))
+
+QPID_AUTO_TEST_CASE(TestLexerActionEnums) {
+ ACT_ENUMS(ACT_CONSUME, "consume");
+ ACT_ENUMS(ACT_PUBLISH, "publish");
+ ACT_ENUMS(ACT_CREATE, "create");
+ ACT_ENUMS(ACT_ACCESS, "access");
+ ACT_ENUMS(ACT_BIND, "bind");
+ ACT_ENUMS(ACT_UNBIND, "unbind");
+ ACT_ENUMS(ACT_DELETE, "delete");
+ ACT_ENUMS(ACT_PURGE, "purge");
+ ACT_ENUMS(ACT_UPDATE, "update");
+ ACT_ENUMS(ACT_MOVE, "move");
+ ACT_ENUMS(ACT_REDIRECT, "redirect");
+ ACT_ENUMS(ACT_REROUTE, "reroute");
+}
+
+#define PROP_ENUMS(e, s) \
+ BOOST_CHECK_EQUAL(AclHelper::getPropertyStr((e)),(s)); \
+ BOOST_CHECK_EQUAL(AclHelper::getProperty((s)),(e))
+
+QPID_AUTO_TEST_CASE(TestLexerPropertyEnums) {
+ PROP_ENUMS(PROP_NAME, "name");
+ PROP_ENUMS(PROP_DURABLE, "durable");
+ PROP_ENUMS(PROP_OWNER, "owner");
+ PROP_ENUMS(PROP_ROUTINGKEY, "routingkey");
+ PROP_ENUMS(PROP_AUTODELETE, "autodelete");
+ PROP_ENUMS(PROP_EXCLUSIVE, "exclusive");
+ PROP_ENUMS(PROP_TYPE, "type");
+ PROP_ENUMS(PROP_ALTERNATE, "alternate");
+ PROP_ENUMS(PROP_QUEUENAME, "queuename");
+ PROP_ENUMS(PROP_EXCHANGENAME, "exchangename");
+ PROP_ENUMS(PROP_SCHEMAPACKAGE, "schemapackage");
+ PROP_ENUMS(PROP_SCHEMACLASS, "schemaclass");
+ PROP_ENUMS(PROP_POLICYTYPE, "policytype");
+ PROP_ENUMS(PROP_PAGING, "paging");
+ PROP_ENUMS(PROP_MAXPAGES, "maxpages");
+ PROP_ENUMS(PROP_MAXPAGEFACTOR, "maxpagefactor");
+ PROP_ENUMS(PROP_MAXQUEUESIZE, "maxqueuesize");
+ PROP_ENUMS(PROP_MAXQUEUECOUNT, "maxqueuecount");
+ PROP_ENUMS(PROP_MAXFILESIZE, "maxfilesize");
+ PROP_ENUMS(PROP_MAXFILECOUNT, "maxfilecount");
+
+}
+
+#define SPECPROP_ENUMS(e, s) \
+ BOOST_CHECK_EQUAL(AclHelper::getPropertyStr((e)),(s)); \
+ BOOST_CHECK_EQUAL(AclHelper::getSpecProperty((s)),(e))
+
+QPID_AUTO_TEST_CASE(TestLexerSpecPropertyEnums) {
+ SPECPROP_ENUMS(SPECPROP_NAME, "name");
+ SPECPROP_ENUMS(SPECPROP_DURABLE, "durable");
+ SPECPROP_ENUMS(SPECPROP_OWNER, "owner");
+ SPECPROP_ENUMS(SPECPROP_ROUTINGKEY, "routingkey");
+ SPECPROP_ENUMS(SPECPROP_AUTODELETE, "autodelete");
+ SPECPROP_ENUMS(SPECPROP_EXCLUSIVE, "exclusive");
+ SPECPROP_ENUMS(SPECPROP_TYPE, "type");
+ SPECPROP_ENUMS(SPECPROP_ALTERNATE, "alternate");
+ SPECPROP_ENUMS(SPECPROP_QUEUENAME, "queuename");
+ SPECPROP_ENUMS(SPECPROP_EXCHANGENAME, "exchangename");
+ SPECPROP_ENUMS(SPECPROP_SCHEMAPACKAGE, "schemapackage");
+ SPECPROP_ENUMS(SPECPROP_SCHEMACLASS, "schemaclass");
+ SPECPROP_ENUMS(SPECPROP_POLICYTYPE, "policytype");
+ SPECPROP_ENUMS(SPECPROP_PAGING, "paging");
+ SPECPROP_ENUMS(SPECPROP_MAXQUEUESIZELOWERLIMIT, "queuemaxsizelowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXQUEUESIZEUPPERLIMIT, "queuemaxsizeupperlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXQUEUECOUNTLOWERLIMIT, "queuemaxcountlowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXQUEUECOUNTUPPERLIMIT, "queuemaxcountupperlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXFILESIZELOWERLIMIT, "filemaxsizelowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXFILESIZEUPPERLIMIT, "filemaxsizeupperlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXFILECOUNTLOWERLIMIT, "filemaxcountlowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXFILECOUNTUPPERLIMIT, "filemaxcountupperlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXPAGESLOWERLIMIT, "pageslowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXPAGESUPPERLIMIT, "pagesupperlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXPAGEFACTORLOWERLIMIT, "pagefactorlowerlimit");
+ SPECPROP_ENUMS(SPECPROP_MAXPAGEFACTORUPPERLIMIT, "pagefactorupperlimit");
+
+ BOOST_CHECK_EQUAL(AclHelper::getSpecProperty("maxqueuesize"), SPECPROP_MAXQUEUESIZEUPPERLIMIT);
+ BOOST_CHECK_EQUAL(AclHelper::getSpecProperty("maxqueuecount"), SPECPROP_MAXQUEUECOUNTUPPERLIMIT);
+}
+
+#define RESULT_ENUMS(e, s) \
+ BOOST_CHECK_EQUAL(AclHelper::getAclResultStr((e)),(s)); \
+ BOOST_CHECK_EQUAL(AclHelper::getAclResult((s)),(e))
+
+QPID_AUTO_TEST_CASE(TestLexerResultEnums) {
+ RESULT_ENUMS(ALLOW, "allow");
+ RESULT_ENUMS(ALLOWLOG, "allow-log");
+ RESULT_ENUMS(DENY, "deny");
+ RESULT_ENUMS(DENYLOG, "deny-log");
+}
+
+#define ENUM_ENUMS(enum, func, size) \
+ for (int i=0; i<(int)(size); i++) \
+ BOOST_CHECK((func)( (enum)(i) ).length() != 0 );
+
+QPID_AUTO_TEST_CASE(TextLexerEnumEnums) {
+ ENUM_ENUMS(ObjectType, AclHelper::getObjectTypeStr, OBJECTSIZE);
+ ENUM_ENUMS(Action, AclHelper::getActionStr, ACTIONSIZE);
+ ENUM_ENUMS(Property, AclHelper::getPropertyStr, PROPERTYSIZE);
+ ENUM_ENUMS(SpecProperty, AclHelper::getPropertyStr, SPECPROPSIZE);
+ ENUM_ENUMS(AclResult, AclHelper::getAclResultStr, RESULTSIZE);
+
+}
+
+QPID_AUTO_TEST_SUITE_END()
+
+}} // namespace qpid::tests
diff --git a/qpid/cpp/src/tests/CMakeLists.txt b/qpid/cpp/src/tests/CMakeLists.txt
index 9fa5fc88e5..b556464db8 100644
--- a/qpid/cpp/src/tests/CMakeLists.txt
+++ b/qpid/cpp/src/tests/CMakeLists.txt
@@ -166,6 +166,7 @@ set (qpid_test_boost_libs
set(all_unit_tests
AccumulatedAckTest
+ Acl
Array
AsyncCompletion
AtomicValue
View Lorry Controller Status