kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'add-strverscmp' 

88494325 Tests: Add test for our strverscmp implementation
07f69bd5 cmSystemTools: Add strverscmp
This commit is contained in:
Brad King 2016-09-15 08:46:45 -04:00 committed by CMake Topic Stage
parent 6f31436c91 884943251b
commit b7dcadac44
3 changed files with 155 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
Source/cmSystemTools.cxx
View File

@ -2416,6 +2416,83 @@ bool cmSystemTools::VersionCompareGreaterEq(std::string const& lhs,
lhs.c_str(), rhs.c_str());
}
static size_t cm_strverscmp_find_first_difference_or_end(const char* lhs,
const char* rhs)
{
size_t i = 0;
/* Step forward until we find a difference or both strings end together.
The difference may lie on the null-terminator of one string. */
while (lhs[i] == rhs[i] && lhs[i] != 0) {
++i;
}
return i;
}
static size_t cm_strverscmp_find_digits_begin(const char* s, size_t i)
{
/* Step back until we are not preceded by a digit. */
while (i > 0 && isdigit(s[i - 1])) {
--i;
}
return i;
}
static size_t cm_strverscmp_find_digits_end(const char* s, size_t i)
{
/* Step forward over digits. */
while (isdigit(s[i])) {
++i;
}
return i;
}
static size_t cm_strverscmp_count_leading_zeros(const char* s, size_t b)
{
size_t i = b;
/* Step forward over zeros that are followed by another digit. */
while (s[i] == '0' && isdigit(s[i + 1])) {
++i;
}
return i - b;
}
static int cm_strverscmp(const char* lhs, const char* rhs)
{
size_t const i = cm_strverscmp_find_first_difference_or_end(lhs, rhs);
if (lhs[i] != rhs[i]) {
/* The strings differ starting at 'i'. Check for a digit sequence. */
size_t const b = cm_strverscmp_find_digits_begin(lhs, i);
if (b != i || (isdigit(lhs[i]) && isdigit(rhs[i]))) {
/* A digit sequence starts at 'b', preceding or at 'i'. */
/* Look for leading zeros, implying a leading decimal point. */
size_t const lhs_zeros = cm_strverscmp_count_leading_zeros(lhs, b);
size_t const rhs_zeros = cm_strverscmp_count_leading_zeros(rhs, b);
if (lhs_zeros != rhs_zeros) {
/* The side with more leading zeros orders first. */
return rhs_zeros > lhs_zeros ? 1 : -1;
}
if (lhs_zeros == 0) {
/* No leading zeros; compare digit sequence lengths. */
size_t const lhs_end = cm_strverscmp_find_digits_end(lhs, i);
size_t const rhs_end = cm_strverscmp_find_digits_end(rhs, i);
if (lhs_end != rhs_end) {
/* The side with fewer digits orders first. */
return lhs_end > rhs_end ? 1 : -1;
}
}
}
}
/* Ordering was not decided by digit sequence lengths; compare bytes. */
return lhs[i] - rhs[i];
}
int cmSystemTools::strverscmp(std::string const& lhs, std::string const& rhs)
{
return cm_strverscmp(lhs.c_str(), rhs.c_str());
}
bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg,
bool* removed)
{

10
Source/cmSystemTools.h
View File

@ -305,6 +305,16 @@ public:
static bool VersionCompareGreaterEq(std::string const& lhs,
std::string const& rhs);
/**
* Compare two ASCII strings using natural versioning order.
* Non-numerical characters are compared directly.
* Numerical characters are first globbed such that, e.g.
* `test000 < test01 < test0 < test1 < test10`.
* Return a value less than, equal to, or greater than zero if lhs
* precedes, equals, or succeeds rhs in the defined ordering.
*/
static int strverscmp(std::string const& lhs, std::string const& rhs);
/**
* Determine the file type based on the extension
*/

72
Tests/CMakeLib/testSystemTools.cxx
View File

@ -19,6 +19,13 @@
std::cout << "FAILED: " << (m) << "\n"; \
failed = 1
#define cmAssert(exp, m) \
if ((exp)) { \
cmPassed(m); \
} else { \
cmFailed(m); \
}
int testSystemTools(int /*unused*/, char* /*unused*/ [])
{
int failed = 0;
@ -26,10 +33,67 @@ int testSystemTools(int /*unused*/, char* /*unused*/ [])
// Test cmSystemTools::UpperCase
std::string str = "abc";
std::string strupper = "ABC";
if (cmSystemTools::UpperCase(str) == strupper) {
cmPassed("cmSystemTools::UpperCase is working");
} else {
cmFailed("cmSystemTools::UpperCase is working");
cmAssert(cmSystemTools::UpperCase(str) == strupper,
"cmSystemTools::UpperCase");
// ----------------------------------------------------------------------
// Test cmSystemTools::strverscmp
cmAssert(cmSystemTools::strverscmp("", "") == 0, "strverscmp empty string");
cmAssert(cmSystemTools::strverscmp("abc", "") > 0,
"strverscmp string vs empty string");
cmAssert(cmSystemTools::strverscmp("abc", "abc") == 0,
"strverscmp same string");
cmAssert(cmSystemTools::strverscmp("abd", "abc") > 0,
"strverscmp character string");
cmAssert(cmSystemTools::strverscmp("abc", "abd") < 0,
"strverscmp symmetric");
cmAssert(cmSystemTools::strverscmp("12345", "12344") > 0,
"strverscmp natural numbers");
cmAssert(cmSystemTools::strverscmp("100", "99") > 0,
"strverscmp natural numbers different digits");
cmAssert(cmSystemTools::strverscmp("12345", "00345") > 0,
"strverscmp natural against decimal (same length)");
cmAssert(cmSystemTools::strverscmp("99999999999999", "99999999999991") > 0,
"strverscmp natural overflow");
cmAssert(cmSystemTools::strverscmp("00000000000009", "00000000000001") > 0,
"strverscmp deciaml precision");
cmAssert(cmSystemTools::strverscmp("a.b.c.0", "a.b.c.000") > 0,
"strverscmp multiple zeros");
cmAssert(cmSystemTools::strverscmp("lib_1.2_10", "lib_1.2_2") > 0,
"strverscmp last number ");
cmAssert(cmSystemTools::strverscmp("12lib", "2lib") > 0,
"strverscmp first number ");
cmAssert(cmSystemTools::strverscmp("02lib", "002lib") > 0,
"strverscmp first number decimal ");
cmAssert(cmSystemTools::strverscmp("10", "9a") > 0,
"strverscmp letter filler ");
cmAssert(cmSystemTools::strverscmp("000", "0001") > 0,
"strverscmp zero and leading zeros ");
// test sorting using standard strvercmp input
std::vector<std::string> testString;
testString.push_back("000");
testString.push_back("00");
testString.push_back("01");
testString.push_back("010");
testString.push_back("09");
testString.push_back("0");
testString.push_back("1");
testString.push_back("9");
testString.push_back("10");
// test global ordering of input strings
for (size_t i = 0; i < testString.size() - 1; i++) {
for (size_t j = i + 1; j < testString.size(); j++) {
if (cmSystemTools::strverscmp(testString[i], testString[j]) >= 0) {
cmFailed("cmSystemTools::strverscmp error in comparing strings " +
testString[i] + " " + testString[j]);
}
}
}
if (!failed) {
cmPassed("cmSystemTools::strverscmp working");
}
return failed;
}