You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by bp...@apache.org on 2015/12/14 14:40:03 UTC
celix git commit: CELIX-323: moved version and version_range from
framework to tests (Note that the mocks are still in the framework)
Repository: celix
Updated Branches:
refs/heads/develop c5bc7496c -> 8e6e4572a
CELIX-323: moved version and version_range from framework to tests (Note that the mocks are still in the framework)
Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/8e6e4572
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/8e6e4572
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/8e6e4572
Branch: refs/heads/develop
Commit: 8e6e4572ae1eb308b8f01f06ce22de47c5e64b8b
Parents: c5bc749
Author: Bjoern Petri <bp...@apache.org>
Authored: Mon Dec 14 14:39:13 2015 +0100
Committer: Bjoern Petri <bp...@apache.org>
Committed: Mon Dec 14 14:39:13 2015 +0100
----------------------------------------------------------------------
utils/private/include/version_private.h | 41 +++
utils/private/include/version_range_private.h | 41 +++
utils/private/src/version.c | 242 ++++++++++++++
utils/private/src/version_range.c | 179 +++++++++++
utils/private/test/version_range_test.cpp | 254 +++++++++++++++
utils/private/test/version_test.cpp | 356 +++++++++++++++++++++
utils/public/include/version.h | 161 ++++++++++
utils/public/include/version_range.h | 111 +++++++
8 files changed, 1385 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/include/version_private.h
----------------------------------------------------------------------
diff --git a/utils/private/include/version_private.h b/utils/private/include/version_private.h
new file mode 100644
index 0000000..15e5c89
--- /dev/null
+++ b/utils/private/include/version_private.h
@@ -0,0 +1,41 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_private.h
+ *
+ * \date Dec 18, 2012
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+
+#ifndef VERSION_PRIVATE_H_
+#define VERSION_PRIVATE_H_
+
+#include "version.h"
+
+struct version {
+ int major;
+ int minor;
+ int micro;
+ char *qualifier;
+};
+
+
+#endif /* VERSION_PRIVATE_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/include/version_range_private.h
----------------------------------------------------------------------
diff --git a/utils/private/include/version_range_private.h b/utils/private/include/version_range_private.h
new file mode 100644
index 0000000..dfccd59
--- /dev/null
+++ b/utils/private/include/version_range_private.h
@@ -0,0 +1,41 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_range_private.h
+ *
+ * \date Dec 18, 2012
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+
+#ifndef VERSION_RANGE_PRIVATE_H_
+#define VERSION_RANGE_PRIVATE_H_
+
+#include "version_range.h"
+
+struct versionRange {
+ version_pt low;
+ bool isLowInclusive;
+ version_pt high;
+ bool isHighInclusive;
+
+};
+
+#endif /* VERSION_RANGE_PRIVATE_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/src/version.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version.c b/utils/private/src/version.c
new file mode 100644
index 0000000..3f8ddfa
--- /dev/null
+++ b/utils/private/src/version.c
@@ -0,0 +1,242 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version.c
+ *
+ * \date Jul 12, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "celix_errno.h"
+#include "version_private.h"
+
+celix_status_t version_createVersion(int major, int minor, int micro, char * qualifier, version_pt *version) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ if (*version != NULL) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ } else {
+ *version = (version_pt) malloc(sizeof(**version));
+ if (!*version) {
+ status = CELIX_ENOMEM;
+ } else {
+ unsigned int i;
+
+ (*version)->major = major;
+ (*version)->minor = minor;
+ (*version)->micro = micro;
+ if (qualifier == NULL) {
+ qualifier = "";
+ }
+ (*version)->qualifier = strdup(qualifier);
+
+ if (major < 0) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+ if (minor < 0) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+ if (micro < 0) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ for (i = 0; i < strlen(qualifier); i++) {
+ char ch = qualifier[i];
+ if (('A' <= ch) && (ch <= 'Z')) {
+ continue;
+ }
+ if (('a' <= ch) && (ch <= 'z')) {
+ continue;
+ }
+ if (('0' <= ch) && (ch <= '9')) {
+ continue;
+ }
+ if ((ch == '_') || (ch == '-')) {
+ continue;
+ }
+ status = CELIX_ILLEGAL_ARGUMENT;
+ break;
+ }
+ }
+ }
+
+ return status;
+}
+
+celix_status_t version_clone(version_pt version, version_pt *clone) {
+ return version_createVersion(version->major, version->minor, version->micro, version->qualifier, clone);
+}
+
+celix_status_t version_destroy(version_pt version) {
+ version->major = 0;
+ version->minor = 0;
+ version->micro = 0;
+ free(version->qualifier);
+ version->qualifier = NULL;
+ free(version);
+ return CELIX_SUCCESS;
+}
+
+celix_status_t version_createVersionFromString(char * versionStr, version_pt *version) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ int major = 0;
+ int minor = 0;
+ int micro = 0;
+ char * qualifier = NULL;
+
+ char delims[] = ".";
+ char *token = NULL;
+ char *last = NULL;
+
+ int i = 0;
+
+ token = strtok_r(versionStr, delims, &last);
+ if (token != NULL) {
+ for (i = 0; i < strlen(token); i++) {
+ char ch = token[i];
+ if (('0' <= ch) && (ch <= '9')) {
+ continue;
+ }
+ status = CELIX_ILLEGAL_ARGUMENT;
+ break;
+ }
+ major = atoi(token);
+ token = strtok_r(NULL, delims, &last);
+ if (token != NULL) {
+ for (i = 0; i < strlen(token); i++) {
+ char ch = token[i];
+ if (('0' <= ch) && (ch <= '9')) {
+ continue;
+ }
+ status = CELIX_ILLEGAL_ARGUMENT;
+ break;
+ }
+ minor = atoi(token);
+ token = strtok_r(NULL, delims, &last);
+ if (token != NULL) {
+ for (i = 0; i < strlen(token); i++) {
+ char ch = token[i];
+ if (('0' <= ch) && (ch <= '9')) {
+ continue;
+ }
+ status = CELIX_ILLEGAL_ARGUMENT;
+ break;
+ }
+ micro = atoi(token);
+ token = strtok_r(NULL, delims, &last);
+ if (token != NULL) {
+ qualifier = strdup(token);
+ token = strtok_r(NULL, delims, &last);
+ if (token != NULL) {
+ *version = NULL;
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+ }
+ }
+ }
+ }
+ if (status == CELIX_SUCCESS) {
+ status = version_createVersion(major, minor, micro, qualifier, version);
+ }
+
+ if (qualifier != NULL) {
+ free(qualifier);
+ }
+
+ return status;
+}
+
+celix_status_t version_createEmptyVersion(version_pt *version) {
+ return version_createVersion(0, 0, 0, "", version);
+}
+
+celix_status_t version_getMajor(version_pt version, int *major) {
+ celix_status_t status = CELIX_SUCCESS;
+ *major = version->major;
+ return status;
+}
+
+celix_status_t version_getMinor(version_pt version, int *minor) {
+ celix_status_t status = CELIX_SUCCESS;
+ *minor = version->minor;
+ return status;
+}
+
+celix_status_t version_getMicro(version_pt version, int *micro) {
+ celix_status_t status = CELIX_SUCCESS;
+ *micro = version->micro;
+ return status;
+}
+
+celix_status_t version_getQualifier(version_pt version, char **qualifier) {
+ celix_status_t status = CELIX_SUCCESS;
+ *qualifier = version->qualifier;
+ return status;
+}
+
+celix_status_t version_compareTo(version_pt version, version_pt compare, int *result) {
+ celix_status_t status = CELIX_SUCCESS;
+ if (compare == version) {
+ *result = 0;
+ } else {
+ int res = version->major - compare->major;
+ if (res != 0) {
+ *result = res;
+ } else {
+ res = version->minor - compare->minor;
+ if (res != 0) {
+ *result = res;
+ } else {
+ res = version->micro - compare->micro;
+ if (res != 0) {
+ *result = res;
+ } else {
+ *result = strcmp(version->qualifier, compare->qualifier);
+ }
+ }
+ }
+ }
+
+ return status;
+}
+
+celix_status_t version_toString(version_pt version, char **string) {
+ celix_status_t status = CELIX_SUCCESS;
+ if (strlen(version->qualifier) > 0) {
+ char str[512];
+ int written = snprintf(str, 512, "%d.%d.%d.%s", version->major, version->minor, version->micro, version->qualifier);
+ if (written >= 512 || written < 0) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ *string = strdup(str);
+ } else {
+ char str[512];
+ int written = snprintf(str, 512, "%d.%d.%d", version->major, version->minor, version->micro);
+ if (written >= 512 || written < 0) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ *string = strdup(str);
+ }
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/src/version_range.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version_range.c b/utils/private/src/version_range.c
new file mode 100644
index 0000000..bb3d82e
--- /dev/null
+++ b/utils/private/src/version_range.c
@@ -0,0 +1,179 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_range.c
+ *
+ * \date Jul 12, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "version_range_private.h"
+
+celix_status_t versionRange_createVersionRange(version_pt low, bool isLowInclusive,
+ version_pt high, bool isHighInclusive, version_range_pt *range) {
+ celix_status_t status = CELIX_SUCCESS;
+ *range = (version_range_pt) malloc(sizeof(**range));
+ if (!*range) {
+ status = CELIX_ENOMEM;
+ } else {
+ (*range)->low = low;
+ (*range)->isLowInclusive = isLowInclusive;
+ (*range)->high = high;
+ (*range)->isHighInclusive = isHighInclusive;
+ }
+
+ return status;
+}
+
+celix_status_t versionRange_destroy(version_range_pt range) {
+ if (range->high != NULL) {
+ version_destroy(range->high);
+ }
+ if (range->low != NULL) {
+ version_destroy(range->low);
+ }
+
+ range->high = NULL;
+ range->isHighInclusive = false;
+ range->low = NULL;
+ range->isLowInclusive = false;
+
+ free(range);
+
+ return CELIX_SUCCESS;
+}
+
+celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range) {
+ celix_status_t status;
+
+ version_pt version = NULL;
+ status = version_createEmptyVersion(&version);
+ if (status == CELIX_SUCCESS) {
+ status = versionRange_createVersionRange(version, true, NULL, true, range);
+ }
+
+ return status;
+}
+
+celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version, bool *inRange) {
+ celix_status_t status;
+ if (versionRange->high == NULL) {
+ int cmp;
+ status = version_compareTo(version, versionRange->low, &cmp);
+ if (status == CELIX_SUCCESS) {
+ *inRange = (cmp >= 0);
+ }
+ } else if (versionRange->isLowInclusive && versionRange->isHighInclusive) {
+ int low, high;
+ status = version_compareTo(version, versionRange->low, &low);
+ if (status == CELIX_SUCCESS) {
+ status = version_compareTo(version, versionRange->high, &high);
+ if (status == CELIX_SUCCESS) {
+ *inRange = (low >= 0) && (high <= 0);
+ }
+ }
+ } else if (versionRange->isHighInclusive) {
+ int low, high;
+ status = version_compareTo(version, versionRange->low, &low);
+ if (status == CELIX_SUCCESS) {
+ status = version_compareTo(version, versionRange->high, &high);
+ if (status == CELIX_SUCCESS) {
+ *inRange = (low > 0) && (high <= 0);
+ }
+ }
+ } else if (versionRange->isLowInclusive) {
+ int low, high;
+ status = version_compareTo(version, versionRange->low, &low);
+ if (status == CELIX_SUCCESS) {
+ status = version_compareTo(version, versionRange->high, &high);
+ if (status == CELIX_SUCCESS) {
+ *inRange = (low >= 0) && (high < 0);
+ }
+ }
+ } else {
+ int low, high;
+ status = version_compareTo(version, versionRange->low, &low);
+ if (status == CELIX_SUCCESS) {
+ status = version_compareTo(version, versionRange->high, &high);
+ if (status == CELIX_SUCCESS) {
+ *inRange = (low > 0) && (high < 0);
+ }
+ }
+ }
+
+ return status;
+}
+
+celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range) {
+ celix_status_t status;
+ if (strchr(rangeStr, ',') != NULL) {
+ int vlowL = strcspn(rangeStr+1, ",");
+ char * vlow = (char *) malloc(sizeof(char) * (vlowL + 1));
+ if (!vlow) {
+ status = CELIX_ENOMEM;
+ } else {
+ int vhighL;
+ char * vhigh;
+ vlow = strncpy(vlow, rangeStr+1, vlowL);
+ vlow[vlowL] = '\0';
+ vhighL = strlen(rangeStr+1) - vlowL - 2;
+ vhigh = (char *) malloc(sizeof(char) * (vhighL+1));
+ if (!vhigh) {
+ status = CELIX_ENOMEM;
+ } else {
+ version_pt versionLow = NULL;
+ int rangeL = strlen(rangeStr);
+ char start = rangeStr[0];
+ char end = rangeStr[rangeL-1];
+
+ vhigh = strncpy(vhigh, rangeStr+vlowL+2, vhighL);
+ vhigh[vhighL] = '\0';
+ status = version_createVersionFromString(vlow, &versionLow);
+ if (status == CELIX_SUCCESS) {
+ version_pt versionHigh = NULL;
+ status = version_createVersionFromString(vhigh, &versionHigh);
+ if (status == CELIX_SUCCESS) {
+ status = versionRange_createVersionRange(
+ versionLow,
+ start == '[',
+ versionHigh,
+ end ==']',
+ range
+ );
+ }
+ }
+ free(vhigh);
+ }
+ free(vlow);
+
+ }
+ } else {
+ version_pt version = NULL;
+ status = version_createVersionFromString(rangeStr, &version);
+ if (status == CELIX_SUCCESS) {
+ status = versionRange_createVersionRange(version, true, NULL, false, range);
+ }
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/test/version_range_test.cpp
----------------------------------------------------------------------
diff --git a/utils/private/test/version_range_test.cpp b/utils/private/test/version_range_test.cpp
new file mode 100644
index 0000000..1e1336c
--- /dev/null
+++ b/utils/private/test/version_range_test.cpp
@@ -0,0 +1,254 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_range_test.cpp
+ *
+ * \date Dec 18, 2012
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTest/TestHarness_c.h"
+#include "CppUTest/CommandLineTestRunner.h"
+#include "CppUTestExt/MockSupport.h"
+#include "string.h"
+
+extern "C"
+{
+#include "version_range_private.h"
+#include "version_private.h"
+
+#include "celix_log.h"
+
+framework_logger_pt logger = (framework_logger_pt) 0x42;
+}
+
+int main(int argc, char** argv) {
+ return RUN_ALL_TESTS(argc, argv);
+}
+
+static char* my_strdup(const char* s) {
+ if (s == NULL) {
+ return NULL;
+ }
+
+ size_t len = strlen(s);
+
+ char *d = (char*) calloc(len + 1, sizeof(char));
+
+ if (d == NULL) {
+ return NULL;
+ }
+
+ strncpy(d, s, len);
+ return d;
+}
+
+//----------------------TESTGROUP DEFINES----------------------
+
+TEST_GROUP(version_range) {
+
+ void setup(void) {
+ }
+
+ void teardown() {
+ mock().checkExpectations();
+ mock().clear();
+ }
+};
+
+TEST(version_range, create) {
+ celix_status_t status = CELIX_SUCCESS;
+ version_range_pt range = NULL;
+ version_pt version = (version_pt) malloc(sizeof(*version));
+
+ status = versionRange_createVersionRange(version, false, version, true, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C((range != NULL));
+ LONGS_EQUAL(true, range->isHighInclusive);
+ LONGS_EQUAL(false, range->isLowInclusive);
+ POINTERS_EQUAL(version, range->low);
+ POINTERS_EQUAL(version, range->high);
+
+ mock().expectNCalls(2, "version_destroy")
+ .withParameter("version", version);
+
+ versionRange_destroy(range);
+ free(version);
+}
+
+TEST(version_range, createInfinite) {
+ celix_status_t status = CELIX_SUCCESS;
+ version_range_pt range = NULL;
+ version_pt version = (version_pt) malloc(sizeof(*version));
+ version->major = 1;
+ version->minor = 2;
+ version->micro = 3;
+
+ mock()
+ .expectOneCall("version_createEmptyVersion")
+ .withOutputParameterReturning("version", &version, sizeof("version"));
+ status = versionRange_createInfiniteVersionRange(&range);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(range != NULL);
+ LONGS_EQUAL(true, range->isHighInclusive);
+ LONGS_EQUAL(true, range->isLowInclusive);
+ POINTERS_EQUAL(version, range->low);
+ POINTERS_EQUAL(NULL, range->high);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", version);
+
+ versionRange_destroy(range);
+ free(version);
+}
+
+TEST(version_range, isInRange) {
+ bool result;
+ version_range_pt range = NULL;
+ version_pt version = (version_pt) malloc(sizeof(*version));
+ version->major = 1;
+ version->minor = 2;
+ version->micro = 3;
+
+ version_pt low = (version_pt) malloc(sizeof(*low));
+ low->major = 1;
+ low->minor = 2;
+ low->micro = 3;
+
+ version_pt high = (version_pt) malloc(sizeof(*high));
+ high->major = 1;
+ high->minor = 2;
+ high->micro = 3;
+
+ int stat = 1;
+ mock()
+ .expectNCalls(5, "version_compareTo")
+ .withParameter("version", version)
+ .withParameter("compare", low)
+ .withOutputParameterReturning("result", &stat, sizeof(int));
+ int stat2 = -1;
+ mock()
+ .expectNCalls(4, "version_compareTo")
+ .withParameter("version", version)
+ .withParameter("compare", high)
+ .withOutputParameterReturning("result", &stat2, sizeof(int));
+
+ versionRange_createVersionRange(low, true, high, true, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+ LONGS_EQUAL(true, result);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", low);
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", high);
+ versionRange_destroy(range);
+
+ versionRange_createVersionRange(low, true, NULL, true, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+ LONGS_EQUAL(true, result);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", low);
+ versionRange_destroy(range);
+
+ versionRange_createVersionRange(low, false, high, true, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+ LONGS_EQUAL(true, result);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", low);
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", high);
+ versionRange_destroy(range);
+
+ versionRange_createVersionRange(low, true, high, false, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+ LONGS_EQUAL(true, result);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", low);
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", high);
+ versionRange_destroy(range);
+
+ versionRange_createVersionRange(low, false, high, false, &range);
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+ LONGS_EQUAL(true, result);
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", low);
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", high);
+ versionRange_destroy(range);
+
+ free(version);
+ free(high);
+ free(low);
+}
+
+TEST(version_range, parse) {
+ version_range_pt range = NULL;
+ version_pt low = (version_pt) malloc(sizeof(*low));
+ version_pt high = (version_pt) malloc(sizeof(*high));
+ char * version = my_strdup("[1.2.3,7.8.9]");
+ low->major = 1;
+ low->minor = 2;
+ low->micro = 3;
+
+ high->major = 7;
+ high->minor = 8;
+ high->micro = 9;
+
+ mock().expectOneCall("version_destroy")
+ .withParameter("version", high);
+
+ mock().expectNCalls(2, "version_destroy")
+ .withParameter("version", low);
+
+ mock().expectOneCall("version_createVersionFromString")
+ .withParameter("versionStr", "1.2.3")
+ .withOutputParameterReturning("version", &low, sizeof(low));
+
+ mock().expectOneCall("version_createVersionFromString")
+ .withParameter("versionStr", "7.8.9")
+ .withOutputParameterReturning("version", &high, sizeof(high));
+
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+
+ versionRange_destroy(range);
+ free(version);
+ version = my_strdup("[1.2.3");
+
+ mock().expectOneCall("version_createVersionFromString")
+ .withParameter("versionStr", "[1.2.3")
+ .withOutputParameterReturning("version", &low, sizeof(low));
+
+ LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+
+ versionRange_destroy(range);
+ free(version);
+ free(high);
+ free(low);
+}
+
+
+
+
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/test/version_test.cpp
----------------------------------------------------------------------
diff --git a/utils/private/test/version_test.cpp b/utils/private/test/version_test.cpp
new file mode 100644
index 0000000..e1b0eee
--- /dev/null
+++ b/utils/private/test/version_test.cpp
@@ -0,0 +1,356 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_test.cpp
+ *
+ * \date Dec 18, 2012
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <string.h>
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTest/TestHarness_c.h"
+#include "CppUTest/CommandLineTestRunner.h"
+#include "CppUTestExt/MockSupport.h"
+
+extern "C"
+{
+#include "version_private.h"
+#include "celix_log.h"
+
+framework_logger_pt logger = (framework_logger_pt) 0x666;
+}
+
+int main(int argc, char** argv) {
+ return RUN_ALL_TESTS(argc, argv);
+}
+
+static char* my_strdup(const char* s){
+ if(s==NULL){
+ return NULL;
+ }
+
+ size_t len = strlen(s);
+
+ char *d = (char*) calloc (len + 1,sizeof(char));
+
+ if (d == NULL){
+ return NULL;
+ }
+
+ strncpy (d,s,len);
+ return d;
+}
+
+TEST_GROUP(version) {
+
+ void setup(void) {
+ }
+
+ void teardown() {
+ mock().checkExpectations();
+ mock().clear();
+ }
+
+};
+
+
+TEST(version, create) {
+ version_pt version = NULL;
+ char * str;
+
+// str = my_strdup("abc");
+// status = version_createVersion(1, 2, 3, str, &version);
+// LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+
+ str = my_strdup("abc");
+ LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+ STRCMP_EQUAL("abc", version->qualifier);
+
+ version_destroy(version);
+ version = NULL;
+ LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, NULL, &version));
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+ STRCMP_EQUAL("", version->qualifier);
+
+ version_destroy(version);
+ version = NULL;
+ free(str);
+ str = my_strdup("abc");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(-1, -2, -3, str, &version));
+
+ version_destroy(version);
+ version = NULL;
+ free(str);
+ str = my_strdup("abc|xyz");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(1, 2, 3, str, &version));
+
+ version_destroy(version);
+ free(str);
+}
+
+TEST(version, clone) {
+ version_pt version = NULL, clone = NULL;
+ char * str;
+
+ str = my_strdup("abc");
+ LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+ LONGS_EQUAL(CELIX_SUCCESS, version_clone(version, &clone));
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, clone->major);
+ LONGS_EQUAL(2, clone->minor);
+ LONGS_EQUAL(3, clone->micro);
+ STRCMP_EQUAL("abc", clone->qualifier);
+
+ version_destroy(clone);
+ version_destroy(version);
+ free(str);
+}
+
+TEST(version, createFromString) {
+ version_pt version = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+ char * str;
+
+ str = my_strdup("1");
+ LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+
+ version_destroy(version);
+
+ free(str);
+ str = my_strdup("a");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+ free(str);
+ str = my_strdup("1.a");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+ free(str);
+ str = my_strdup("1.1.a");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+ free(str);
+ str = my_strdup("-1");
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+ free(str);
+ str = my_strdup("1.2");
+ version = NULL;
+ LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+
+ version_destroy(version);
+
+ free(str);
+ str = my_strdup("1.2.3");
+ version = NULL;
+ status = version_createVersionFromString(str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+
+ version_destroy(version);
+ free(str);
+ str = my_strdup("1.2.3.abc");
+ version = NULL;
+ status = version_createVersionFromString(str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+ STRCMP_EQUAL("abc", version->qualifier);
+
+ version_destroy(version);
+ free(str);
+ str = my_strdup("1.2.3.abc_xyz");
+ version = NULL;
+ status = version_createVersionFromString(str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+ STRCMP_EQUAL("abc_xyz", version->qualifier);
+
+ version_destroy(version);
+ free(str);
+ str = my_strdup("1.2.3.abc-xyz");
+ version = NULL;
+ status = version_createVersionFromString(str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(1, version->major);
+ LONGS_EQUAL(2, version->minor);
+ LONGS_EQUAL(3, version->micro);
+ STRCMP_EQUAL("abc-xyz", version->qualifier);
+
+ version_destroy(version);
+ free(str);
+ str = my_strdup("1.2.3.abc|xyz");
+ status = version_createVersionFromString(str, &version);
+ LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+
+ free(str);
+}
+
+TEST(version, createEmptyVersion) {
+ version_pt version = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+
+ status = version_createEmptyVersion(&version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ LONGS_EQUAL(0, version->major);
+ LONGS_EQUAL(0, version->minor);
+ LONGS_EQUAL(0, version->micro);
+ STRCMP_EQUAL("", version->qualifier);
+
+ version_destroy(version);
+}
+
+TEST(version, getters) {
+ version_pt version = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+ char * str;
+ int major, minor, micro;
+ char *qualifier;
+
+ str = my_strdup("abc");
+ status = version_createVersion(1, 2, 3, str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+
+ version_getMajor(version, &major);
+ LONGS_EQUAL(1, major);
+
+ version_getMinor(version, &minor);
+ LONGS_EQUAL(2, minor);
+
+ version_getMicro(version, µ);
+ LONGS_EQUAL(3, micro);
+
+ version_getQualifier(version, &qualifier);
+ STRCMP_EQUAL("abc", qualifier);
+
+ version_destroy(version);
+ free(str);
+}
+
+TEST(version, compare) {
+ version_pt version = NULL, compare = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+ char * str;
+ int result;
+
+ // Base version to compare
+ str = my_strdup("abc");
+ status = version_createVersion(1, 2, 3, str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+
+ // Compare equality
+ free(str);
+ str = my_strdup("abc");
+ compare = NULL;
+ status = version_createVersion(1, 2, 3, str, &compare);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ status = version_compareTo(version, compare, &result);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ LONGS_EQUAL(0, result);
+
+ // Compare against a higher version
+ free(str);
+ str = my_strdup("bcd");
+ version_destroy(compare);
+ compare = NULL;
+ status = version_createVersion(1, 2, 3, str, &compare);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ status = version_compareTo(version, compare, &result);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK(result < 0);
+
+ // Compare againts a lower version
+ free(str);
+ str = my_strdup("abc");
+ version_destroy(compare);
+ compare = NULL;
+ status = version_createVersion(1, 1, 3, str, &compare);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+ status = version_compareTo(version, compare, &result);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK(result > 0);
+
+ version_destroy(compare);
+ version_destroy(version);
+ free(str);
+}
+
+TEST(version, toString) {
+ version_pt version = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+ char * str;
+ char *result = NULL;
+
+ str = my_strdup("abc");
+ status = version_createVersion(1, 2, 3, str, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+
+ status = version_toString(version, &result);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(result != NULL);
+ STRCMP_EQUAL("1.2.3.abc", result);
+ free(result);
+
+ version_destroy(version);
+ version = NULL;
+ status = version_createVersion(1, 2, 3, NULL, &version);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(version != NULL);
+
+ status = version_toString(version, &result);
+ LONGS_EQUAL(CELIX_SUCCESS, status);
+ CHECK_C(result != NULL);
+ STRCMP_EQUAL("1.2.3", result);
+
+ version_destroy(version);
+ free(result);
+ free(str);
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/public/include/version.h
----------------------------------------------------------------------
diff --git a/utils/public/include/version.h b/utils/public/include/version.h
new file mode 100644
index 0000000..ca1a2fa
--- /dev/null
+++ b/utils/public/include/version.h
@@ -0,0 +1,161 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version.h
+ *
+ * \date Jul 12, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#ifndef VERSION_H_
+#define VERSION_H_
+
+#include "celix_errno.h"
+/**
+ * The definition of the version_pt abstract data type.
+ */
+typedef struct version * version_pt;
+
+/**
+ * Creates a new version_pt using the supplied arguments.
+ *
+ * @param major Major component of the version identifier.
+ * @param minor Minor component of the version identifier.
+ * @param micro Micro component of the version identifier.
+ * @param qualifier Qualifier component of the version identifier. If
+ * <code>null</code> is specified, then the qualifier will be set to
+ * the empty string.
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ * or the qualifier string is invalid.
+ */
+celix_status_t version_createVersion(int major, int minor, int micro, char * qualifier, version_pt *version);
+
+celix_status_t version_destroy(version_pt version);
+
+/**
+ * Creates a clone of <code>version</code>.
+ *
+ * @param version The version to clone
+ * @param clone The cloned version
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ * or the qualifier string is invalid.
+ */
+celix_status_t version_clone(version_pt version, version_pt *clone);
+
+/**
+ * Creates a version identifier from the specified string.
+ *
+ * <p>
+ * Here is the grammar for version strings.
+ *
+ * <pre>
+ * version ::= major('.'minor('.'micro('.'qualifier)?)?)?
+ * major ::= digit+
+ * minor ::= digit+
+ * micro ::= digit+
+ * qualifier ::= (alpha|digit|'_'|'-')+
+ * digit ::= [0..9]
+ * alpha ::= [a..zA..Z]
+ * </pre>
+ *
+ * There must be no whitespace in version.
+ *
+ * @param versionStr String representation of the version identifier.
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
+ */
+celix_status_t version_createVersionFromString(char * versionStr, version_pt *version);
+
+/**
+ * The empty version "0.0.0".
+ *
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
+ */
+celix_status_t version_createEmptyVersion(version_pt *version);
+
+celix_status_t version_getMajor(version_pt version, int *major);
+celix_status_t version_getMinor(version_pt version, int *minor);
+celix_status_t version_getMicro(version_pt version, int *micro);
+celix_status_t version_getQualifier(version_pt version, char **qualifier);
+
+/**
+ * Compares this <code>Version</code> object to another object.
+ *
+ * <p>
+ * A version is considered to be <b>less than </b> another version if its
+ * major component is less than the other version's major component, or the
+ * major components are equal and its minor component is less than the other
+ * version's minor component, or the major and minor components are equal
+ * and its micro component is less than the other version's micro component,
+ * or the major, minor and micro components are equal and it's qualifier
+ * component is less than the other version's qualifier component (using
+ * <code>String.compareTo</code>).
+ *
+ * <p>
+ * A version is considered to be <b>equal to</b> another version if the
+ * major, minor and micro components are equal and the qualifier component
+ * is equal (using <code>String.compareTo</code>).
+ *
+ * @param version The <code>version_pt</code> to be compared with <code>compare</code>.
+ * @param compare The <code>version_pt</code> to be compared with <code>version</code>.
+ * @param result A negative integer, zero, or a positive integer if <code>version</code> is
+ * less than, equal to, or greater than the <code>compare</code>.
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t version_compareTo(version_pt version, version_pt compare, int *result);
+
+/**
+ * Returns the string representation of <code>version</code> identifier.
+ *
+ * <p>
+ * The format of the version string will be <code>major.minor.micro</code>
+ * if qualifier is the empty string or
+ * <code>major.minor.micro.qualifier</code> otherwise.
+ *
+ * @return The string representation of this version identifier.
+ * @param version The <code>version_pt</code> to get the string representation from.
+ * @param string Pointer to the string (char *) in which the result will be placed.
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t version_toString(version_pt version, char **string);
+
+/**
+ * @}
+ */
+
+#endif /* VERSION_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/public/include/version_range.h
----------------------------------------------------------------------
diff --git a/utils/public/include/version_range.h b/utils/public/include/version_range.h
new file mode 100644
index 0000000..a979eca
--- /dev/null
+++ b/utils/public/include/version_range.h
@@ -0,0 +1,111 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements. See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership. The ASF licenses this file
+ *to you 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.
+ */
+/*
+ * version_range.h
+ *
+ * \date Jul 12, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#ifndef VERSION_RANGE_H_
+#define VERSION_RANGE_H_
+
+/**
+ * @defgroup VersionRange Version Range functions
+ * @ingroup framework
+ * @{
+ */
+
+#include "celixbool.h"
+#include "celix_errno.h"
+#include "version.h"
+
+/**
+ * Type definition for the version_range_pt abstract data type.
+ */
+typedef struct versionRange * version_range_pt;
+
+/**
+ * Creates a new <code>version_range_pt</code>.
+ *
+ * @param low Lower bound version
+ * @param isLowInclusive True if lower bound should be included in the range
+ * @param high Upper bound version
+ * @param isHighInclusive True if upper bound should be included in the range
+ * @param versionRange The created range
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ */
+celix_status_t versionRange_createVersionRange(version_pt low, bool isLowInclusive, version_pt high, bool isHighInclusive, version_range_pt *versionRange);
+
+/**
+ * Creates an infinite version range using ::version_createEmptyVersion for the low version,
+ * NULL for the high version and high and low inclusive set to true.
+ *
+ * @param range The created range
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>range</code> failed.
+ */
+celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range);
+
+celix_status_t versionRange_destroy(version_range_pt range);
+
+/**
+ * Determine if the specified version is part of the version range or not.
+ *
+ * @param versionRange The range to check <code>version</code> against.
+ * @param version The version to check.
+ * @param inRange True if the specified version is included in this version range, false otherwise.
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version, bool *inRange);
+
+/**
+ * Parses a version range from the specified string.
+ *
+ * <p>
+ * Here is the grammar for version range strings.
+ *
+ * <pre>
+ * version-range ::= interval | atleast
+ * interval ::= ( '[' | '(' ) floor ',' ceiling ( ']' | ')' )
+ * atleast ::= version
+ * floor ::= version
+ * ceiling ::= version
+ * </pre>
+ *
+ * @param rangeStr String representation of the version range.
+ * @param range The created version_range_pt.
+ * @return Status code indication failure or success:
+ * - CELIX_SUCCESS when no errors are encountered.
+ * - CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ * - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * the qualifier string is invalid or <code>versionStr</code> is impropertly formatted.
+ */
+celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range);
+
+/**
+ * @}
+ */
+
+#endif /* VERSION_RANGE_H_ */