size_t fsecs = dur.fractional_seconds();
size_t width = MAX_FSECS_PRECISION;
if (fsecs_precision < width) {
- for (auto i = 0; i < width - fsecs_precision; ++i) {
+ for (size_t i = 0; i < width - fsecs_precision; ++i) {
fsecs /= 10;
}
auto fsecs = frac.count();
size_t width = MAX_FSECS_PRECISION;
if (fsecs_precision < width) {
- for (auto i = 0; i < width - fsecs_precision; ++i) {
+ for (size_t i = 0; i < width - fsecs_precision; ++i) {
fsecs /= 10;
}
auto fsecs = frac.count();
size_t width = MAX_FSECS_PRECISION;
if (fsecs_precision < width) {
- for (auto i = 0; i < width - fsecs_precision; ++i) {
+ for (size_t i = 0; i < width - fsecs_precision; ++i) {
fsecs /= 10;
}
// the digit and start the index value over.
int digit_idx = 0; // Digit index we are currently constructing.
- int cnt = 0; // How many bits we have in the current digit idx
+ size_t cnt = 0; // How many bits we have in the current digit idx
int cur_byte = 0; // Current input byte.
uint8_t cur_bit_mask = 0x0; // Bitmask of the current bit in the current byte.
auto bytes = input.begin(); // Start with the first byte.
dig_bits <<= shift_bits;
// Add digit's decoded bits to current byte.
- for (auto i = 0; i < bits_per_digit_; ++i) {
+ for (size_t i = 0; i < bits_per_digit_; ++i) {
if (cur_bit_cnt < 8) {
// Shift contents over one to make room for next bit.
cur_byte <<= 1;
/// @brief Encodes binary data using the encoder's algorithm
///
/// @param input binary data to encode
+ ///
/// @return resultant encoded data string
/// @throw BadValue if an error occurs during encoding
std::string encode(const std::vector<uint8_t>& input);
///
/// @param encoded_str encoded string to decode
/// @param[out] output vector into which the decoded data is stored
+ ///
/// @throw BadValue if an error occurs during decoding
void decode(const std::string& encoded_str, std::vector<uint8_t>& output);
/// @brief Translate a byte of binary data into the appropriate algorithm digit
///
/// @param bits binary value to translate
+ ///
/// @return char containing the digit corresponding to the binary value
/// @throw BadValue if the bits value is out of range
char bitsToDigit(uint8_t bits);
/// char is invalid.
///
/// @param digit the algorithm digit to translate
+ ///
/// @return byte containing the binary value corresponding to the digit
uint8_t digitToBits(uint8_t digit);
///
/// @param encoded_str string containing a base32-hex encoded value.
/// @param[out] output vector into which the decoded binary data is stored.
+///
/// @throw BadValue if the input string is invalid.
void decodeBase32Hex(const std::string& encoded_str, std::vector<uint8_t>& output);
///
/// @param encoded_str string containing a base64 encoded value.
/// @param[out] output vector into which the decoded binary data is stored.
+///
/// @throw BadValue if the input string is invalid.
void decodeBase64(const std::string& encoded_str, std::vector<uint8_t>& output);
///
/// @param encoded_str string containing a base16 encoded value.
/// @param[out] output vector into which the decoded binary data is stored.
+///
/// @throw BadValue if the input string is invalid.
void decodeHex(const std::string& encoded_str, std::vector<uint8_t>& output);
/// @brief Encode in hexadecimal inline.
///
/// @param value the value to encode.
+///
/// @return 0x followed by the value encoded in hex.
inline std::string toHex(std::string value) {
std::vector<uint8_t> bin(value.begin(), value.end());
// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
-//
+//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
+
#ifndef KEA_UTIL_STR_H
#define KEA_UTIL_STR_H
#include <exceptions/exceptions.h>
-
-#include <algorithm>
+
+#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <sstream>
#include <string>
-#include <vector>
+#include <vector>
#include <boost/lexical_cast.hpp>
-
-namespace isc {
-namespace util {
-namespace str {
-
+
+namespace isc {
+namespace util {
+namespace str {
+
/// @brief A Set of C++ Utilities for Manipulating Strings
-
+
///
/// @brief A standard string util exception that is thrown if getToken or
/// numToToken are called with bad input data
};
/// @brief Trim leading and trailing spaces.
-///
-/// Returns a copy of the input string but with any leading or trailing spaces
-/// or tabs removed.
-///
+///
+/// Returns a copy of the input string but with any leading or trailing spaces
+/// or tabs removed.
+///
/// @param input Input string to modify.
-///
+///
/// @return String with leading and trailing spaces removed.
std::string
trim(const std::string& input);
-
+
/// @brief Finds the "trimmed" end of a buffer
///
/// Works backward from the end of the buffer, looking for the first
}
return (end);
}
-
+
/// @brief Split string into tokens.
-///
-/// Splits a string into tokens (the tokens being delimited by one or more of
+///
+/// Splits a string into tokens (the tokens being delimited by one or more of
/// the delimiter characters) and returns the tokens in a vector.
/// Adjacent delimiters are considered to be a single delimiter.
-///
-/// Special cases are:
-/// -# The empty string is considered to be zero tokens.
-/// -# A string comprising nothing but delimiters is considered to be zero
-/// tokens.
-///
-/// The reasoning behind this is that the string can be thought of as having
-/// invisible leading and trailing delimiter characters. Therefore both cases
-/// reduce to a set of contiguous delimiters, which are considered a single
-/// delimiter (so getting rid of the string).
+///
+/// Special cases are:
+/// -# The empty string is considered to be zero tokens.
+/// -# A string comprising nothing but delimiters is considered to be zero
+/// tokens.
+///
+/// The reasoning behind this is that the string can be thought of as having
+/// invisible leading and trailing delimiter characters. Therefore both cases
+/// reduce to a set of contiguous delimiters, which are considered a single
+/// delimiter (so getting rid of the string).
/// Optional escape allows to escape delimiter characters (and *only* them
/// and the escape character itself) using backslash.
-///
-/// We could use Boost for this, but this (simple) function eliminates one
-/// dependency in the code.
-///
+///
+/// We could use Boost for this, but this (simple) function eliminates one
+/// dependency in the code.
+///
/// @param text String to be split. Passed by value as the internal copy is
-/// altered during the processing.
+/// altered during the processing.
/// @param delim Delimiter characters
/// @param escape Use backslash to escape delimiter characters
-///
+///
/// @return Vector of tokens.
std::vector<std::string>
tokens(const std::string& text, const std::string& delim = " \t\n", bool escape = false);
-
+
/// @brief Convert character to uppercase.
-///
+///
/// Used in uppercase() to pass as a parameter to std::transform(). The
/// function std::toupper() can't be used as it takes an "int" as its parameter;
-/// this confuses the template expansion mechanism because dereferencing a
-/// string::iterator returns a char.
-///
+/// this confuses the template expansion mechanism because dereferencing a
+/// string::iterator returns a char.
+///
/// @param chr Character to be upper-cased.
-///
+///
/// @return Uppercase version of the input character.
char
toUpper(char const chr);
-
+
/// @brief Convert string to uppercase.
-///
+///
/// @param text String to be upper-cased.
void
uppercase(std::string& text);
-
+
/// @brief Convert character to lowercase.
-///
+///
/// Used in lowercase() to pass as a parameter to std::transform(). The
/// function std::tolower() can't be used as it takes an "int" as its parameter;
-/// this confuses the template expansion mechanism because dereferencing a
-/// string::iterator returns a char.
-///
+/// this confuses the template expansion mechanism because dereferencing a
+/// string::iterator returns a char.
+///
/// @param chr Character to be lower-cased.
-///
+///
/// @return Lowercase version of the input character.
char
toLower(char const chr);
-
+
/// @brief Convert string to lowercase.
-///
+///
/// @param text String to be lower-cased.
void
lowercase(std::string& text);
} // namespace str
} // namespace util
} // namespace isc
-
+
#endif // KEA_UTIL_STR_H
-SUBDIRS = .
-
-AM_CPPFLAGS = -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
-AM_CPPFLAGS += $(BOOST_INCLUDES)
+SUBDIRS = .
+
+AM_CPPFLAGS =
AM_CPPFLAGS += -DABS_SRCDIR=\"$(abs_srcdir)\"
AM_CPPFLAGS += -DTEST_DATA_BUILDDIR=\"$(abs_builddir)\"
+AM_CPPFLAGS += -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
+AM_CPPFLAGS += $(BOOST_INCLUDES)
AM_CXXFLAGS = $(KEA_CXXFLAGS)
-
-if USE_STATIC_LINK
-AM_LDFLAGS = -static
-endif
-
-CLEANFILES = *.gcno *.gcda
+
+if USE_STATIC_LINK
+AM_LDFLAGS = -static
+endif
+
+CLEANFILES = *.gcno *.gcda
# CSV files are created by unit tests for CSVFile class.
CLEANFILES += *.csv
-
+
TESTS_ENVIRONMENT = $(LIBTOOL) --mode=execute $(VALGRIND_COMMAND)
-TESTS =
-if HAVE_GTEST
-TESTS += run_unittests
+TESTS =
+if HAVE_GTEST
+TESTS += run_unittests
run_unittests_SOURCES = run_unittests.cc
run_unittests_SOURCES += bigint_unittest.cc
run_unittests_SOURCES += boost_time_utils_unittest.cc
-run_unittests_SOURCES += buffer_unittest.cc
+run_unittests_SOURCES += buffer_unittest.cc
run_unittests_SOURCES += chrono_time_utils_unittest.cc
run_unittests_SOURCES += csv_file_unittest.cc
run_unittests_SOURCES += dhcp_space_unittest.cc
run_unittests_SOURCES += encode_unittest.cc
run_unittests_SOURCES += fd_share_tests.cc
run_unittests_SOURCES += fd_tests.cc
-run_unittests_SOURCES += file_utilities_unittest.cc
-run_unittests_SOURCES += filename_unittest.cc
+run_unittests_SOURCES += filesystem_unittests.cc
run_unittests_SOURCES += hash_unittest.cc
-run_unittests_SOURCES += io_utilities_unittest.cc
+run_unittests_SOURCES += io_unittests.cc
run_unittests_SOURCES += labeled_value_unittest.cc
-run_unittests_SOURCES += memory_segment_local_unittest.cc
-run_unittests_SOURCES += memory_segment_common_unittest.h
run_unittests_SOURCES += memory_segment_common_unittest.cc
+run_unittests_SOURCES += memory_segment_common_unittest.h
+run_unittests_SOURCES += memory_segment_local_unittest.cc
run_unittests_SOURCES += multi_threading_mgr_unittest.cc
run_unittests_SOURCES += optional_unittest.cc
run_unittests_SOURCES += pid_file_unittest.cc
+run_unittests_SOURCES += range_utilities_unittest.cc
+run_unittests_SOURCES += readwrite_mutex_unittest.cc
run_unittests_SOURCES += staged_value_unittest.cc
run_unittests_SOURCES += state_model_unittest.cc
-run_unittests_SOURCES += strutil_unittest.cc
+run_unittests_SOURCES += stopwatch_unittest.cc
+run_unittests_SOURCES += str_unittests.cc
run_unittests_SOURCES += thread_pool_unittest.cc
run_unittests_SOURCES += triplet_unittest.cc
-run_unittests_SOURCES += range_utilities_unittest.cc
-run_unittests_SOURCES += readwrite_mutex_unittest.cc
-run_unittests_SOURCES += stopwatch_unittest.cc
run_unittests_SOURCES += unlock_guard_unittests.cc
run_unittests_SOURCES += utf8_unittest.cc
run_unittests_SOURCES += versioned_csv_file_unittest.cc
run_unittests_SOURCES += watch_socket_unittests.cc
run_unittests_SOURCES += watched_thread_unittest.cc
-run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
-run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
-
+run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
+run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
+
run_unittests_LDADD = $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/io/libkea-util-io.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/libkea-util.la
run_unittests_LDADD += $(top_builddir)/src/lib/exceptions/libkea-exceptions.la
run_unittests_LDADD += $(GTEST_LDADD)
-endif
-
-noinst_PROGRAMS = $(TESTS)
+endif
+
+noinst_PROGRAMS = $(TESTS)
// secs/1000 and so on. The initial string has no fraction seconds.
std::string expected("1970-01-01 00:00:00");
std::string sepoch;
- for (int precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
+ for (size_t precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
if (precision == 1) {
// Adding fractional seconds so we need append a decimal point.
expected.push_back('.');
// secs/1000 and so on. The initial string has no fraction seconds.
std::string expected("2015-07-14 12:13:14");
std::string sbast;
- for (int precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
+ for (size_t precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
if (precision == 1) {
// Adding fractional seconds so we need append a decimal point
// and the digit 5 (i.e. 500 ms = .5 secs).
another = obuffer;
ASSERT_EQ(sizeof(testdata), another.getLength());
ASSERT_NE(obuffer.getData(), another.getData());
- for (int i = 0; i < sizeof(testdata); i ++) {
+ for (size_t i = 0; i < sizeof(testdata); ++i) {
EXPECT_EQ(testdata[i], another[i]);
if (i + 1 < sizeof(testdata)) {
obuffer.writeUint16At(0, i);
// secs/1000 and so on. The initial string has no fraction seconds.
std::string expected("1970-01-01 00:00:00");
std::string sepoch;
- for (int precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
+ for (size_t precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
if (precision == 1) {
// Adding fractional seconds so we need append a decimal point.
expected.push_back('.');
// secs/1000 and so on. The initial string has no fraction seconds.
std::string expected("01:02:03");
std::string s123;
- for (int precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
+ for (size_t precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
if (precision == 1) {
// Adding fractional seconds so we need append a decimal point.
expected.push_back('.');
// secs/1000 and so on. The initial string has no fraction seconds.
std::string expected("2015-07-14 12:13:14");
std::string sbast;
- for (int precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
+ for (size_t precision = 0; precision <= MAX_FSECS_PRECISION; ++precision) {
if (precision == 1) {
// Adding fractional seconds so we need append a decimal point
// and the digit 5 (i.e. 500 ms = .5 secs).
// Verify the reader thread is waiting for the read lock.
cout << "pausing for one second" << std::endl;
- bool ret = syncr_.done_cv.wait_for(doner_lock, chrono::seconds(1), [this](){ return syncr_.done; });
+ ret = syncr_.done_cv.wait_for(doner_lock, chrono::seconds(1), [this](){ return syncr_.done; });
EXPECT_FALSE(syncr_.done);
EXPECT_FALSE(ret);
// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC")
-//
+//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
+
#include <config.h>
-#include <gtest/gtest.h>
#include <util/unittests/run_all.h>
-#include <stdlib.h>
-
-int
-main(int argc, char* argv[]) {
- ::testing::InitGoogleTest(&argc, argv);
+
+#include <gtest/gtest.h>
+
+int
+main(int argc, char* argv[]) {
+ ::testing::InitGoogleTest(&argc, argv);
return (isc::util::unittests::run_all());
-}
+}
{
// call lock_guard constructor which locks mutex resulting in an
// exception as the mutex is already locked (dead lock)
- EXPECT_THROW(lock_guard<TestMutex> lock(*test_mutex.get()),
+ EXPECT_THROW(lock_guard<TestMutex> lock2(*test_mutex.get()),
isc::InvalidOperation);
// expect lock 1 lock_count 1 unlock_count 0 dead_lock true
// you should not be able to get here...using a real mutex
{
// call lock_guard constructor which locks mutex but does not block
// as this is done on the same thread and the mutex is recursive
- EXPECT_NO_THROW(lock_guard<TestMutex> lock(*test_mutex.get()));
+ EXPECT_NO_THROW(lock_guard<TestMutex> lock2(*test_mutex.get()));
// expect lock 1 lock_count 2 unlock_count 1 dead_lock false
// the destructor was already called in EXPECT_NO_THROW scope
test_mutex->testMutexState(1, 2, 1, false);
projects / thirdparty / kea.git / commitdiff
