[custom]
sections: a:ns
-and there must be an "ns" section in addtion to "a".
+and there must be an "ns" section in addition to "a".
If a sequence of two or more RRs/RDATAs of the same RR type should be
generated, these should be uniquely indexed with the "/" separator.
and there must be "a/1" and "a/2" sections.
Another practical example that would be used for many tests is to
-generate data for a complete DNS ressponse message. The spec file of
+generate data for a complete DNS response message. The spec file of
such an example configuration would look like as follows:
[custom]
tag: 0x1234
Some others are expected to be string. A string value does not have
-to be quated:
+to be quoted:
address: 192.0.2.2
-but can also be quoated with single quotes:
+but can also be quoted with single quotes:
address: '192.0.2.2'
-Note 1: a string that can be interpreted as an integer must be quated.
+Note 1: a string that can be interpreted as an integer must be quoted.
For example, if you want to set a "string" entry to "3600", it should
be:
corresponding class documentation should be referenced.
One special string syntax that would be worth noting is domain names,
-which would natually be used in many kinds of entries. The simplest
+which would naturally be used in many kinds of entries. The simplest
form of acceptable syntax is a textual representation of domain names
such as "example.com" (note: names are always assumed to be
"absolute", so the trailing dot can be omitted). But a domain name in
valid domain name.
- rrtype (int or string): The question type. If specified
as an integer, it must be the 16-bit RR type value of the
- covered type. If specifed as a string, it must be the textual
+ covered type. If specified as a string, it must be the textual
mnemonic of the type.
- rrclass (int or string): The question class. If specified as an
integer, it must be the 16-bit RR class value of the covered
- type. If specifed as a string, it must be the textual mnemonic
+ type. If specified as a string, it must be the textual mnemonic
of the class.
'''
name = 'example.com.'
- bitmap[N] (string): The Bitmap. This must be the hexadecimal
representation of the bitmap field. For example, for a bitmap
where the 7th and 15th bits (and only these bits) are set, it
- must be '0101'. Note also that the value must be quated with
+ must be '0101'. Note also that the value must be quoted with
single quatations because it could also be interpreted as an
integer.
'''
same name of attribute for the default value):
- covered (int or string): The Type Covered field. If specified
as an integer, it must be the 16-bit RR type value of the
- covered type. If specifed as a string, it must be the textual
+ covered type. If specified as a string, it must be the textual
mnemonic of the type.
- algorithm (int or string): The Algorithm field. If specified
as an integer, it must be the 8-bit algorithm number as defined
- in RFC4034. If specifed as a string, it must be one of the keys
+ in RFC4034. If specified as a string, it must be one of the keys
of dict_algorithm (case insensitive).
- labels (int): The Labels field. If omitted (the corresponding
variable being set to None), the number of labels of "signer"
determined by the algorithm will be used.
- mac (int or string): The MAC field. If specified as an integer,
the integer value is used as the MAC, possibly with prepended
- 0's so that the total length will be mac_size. If specifed as a
+ 0's so that the total length will be mac_size. If specified as a
string, it is converted to a sequence of ascii codes and its
hexadecimal representation will be used. So, for example, if
"mac" is set to 'abc', it will be converted to '616263'. Note
EXPECT_THROW(obuffer.trim(3), OutOfRange);
}
-TEST_F(BufferTest, outputBufferReadat) {
+TEST_F(BufferTest, outputBufferReadAt) {
obuffer.writeData(testdata, sizeof(testdata));
for (int i = 0; i < sizeof(testdata); i ++) {
EXPECT_EQ(testdata[i], obuffer[i]);
TEST_F(CSVFileTest, validate) {
// Create CSV file with 2 invalid rows in it: one too long, one too short.
// Apart from that, there are two valid columns that should be read
- // successfuly.
+ // successfully.
writeFile("animal,age,color\n"
"cat,10,white\n"
"lion,15,yellow,black\n"
const pid_t sender(fork());
ASSERT_NE(-1, sender);
if (sender) { // We are in parent
- // Close the other side of pipe, we want only writible one
+ // Close the other side of pipe, we want only writable one
EXPECT_NE(-1, close(pipes[0]));
// Get a process to check data
int fd(0);
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
-/// \brief Test of asiolink utilties
+/// \brief Test of asiolink utilities
///
/// Tests the functionality of the asiolink utilities code by comparing them
/// with the equivalent methods in isc::dns::[Input/Output]Buffer.
/// \brief Invalidate Iterator
///
- /// Marks the iterator as invalid; it can oly be set valid again by a call
+ /// Marks the iterator as invalid; it can only be set valid again by a call
/// to setLruIterator.
virtual void invalidateIterator() {
valid_ = false;
EXPECT_EQ(0, lru.size());
}
-// Test of Get/Set the maximum number of entrys
+// Test of Get/Set the maximum number of entries
TEST_F(LruListTest, GetSet) {
LruList<TestEntry> lru(100);
EXPECT_EQ(100, lru.getMaxSize());
lru.add(entry2_);
lru.add(entry3_);
- // Check the reference counts of the entrys and the list size
+ // Check the reference counts of the entries and the list size
EXPECT_EQ(2, entry1_.use_count());
EXPECT_EQ(2, entry2_.use_count());
EXPECT_EQ(2, entry3_.use_count());
lru.add(entry4_);
lru.add(entry5_);
- // Check the status of the entrys and the list.
+ // Check the status of the entries and the list.
EXPECT_EQ(2, entry1_.use_count());
EXPECT_EQ(1, entry2_.use_count());
EXPECT_EQ(1, entry3_.use_count());
// last touch operation is valid.
lru.touch(entry1_);
- // Check this by adding two more entrys and checking reference counts
+ // Check this by adding two more entries and checking reference counts
// to see what is stored.
lru.add(entry6_);
lru.add(entry7_);
// Miscellaneous tests - pathological conditions
TEST_F(LruListTest, Miscellaneous) {
- // Zero size list should not allow entrys to be added
+ // Zero size list should not allow entries to be added
LruList<TestEntry> lru_1(0);
lru_1.add(entry1_);
EXPECT_EQ(0, lru_1.size());
EXPECT_EQ(1, entry1_.use_count());
- // Removing an uninserted entry should not affect the list.
+ // Removing a not-inserted entry should not affect the list.
LruList<TestEntry> lru_2(100);
lru_2.add(entry1_);
lru_2.add(entry2_);
EXPECT_EQ(1, entry5_.use_count());
EXPECT_EQ(3, lru_2.size());
- // Touching an uninserted entry should not affect the list.
+ // Touching a not-inserted entry should not affect the list.
lru_2.touch(entry5_);
EXPECT_EQ(2, entry1_.use_count());
EXPECT_EQ(2, entry2_.use_count());
ASSERT_TRUE(value.isSpecified());
}
-// This test checks if the assignment operator assignining an actual
+// This test checks if the assignment operator assigning an actual
// value to the optional value works as expected.
TEST(OptionalValueTest, assignValue) {
OptionalValue<int> value(10);
// Write a second known process id
pid_file.write(20);
- // And comapre the second pid
+ // And compare the second pid
fs.open(absolutePath(TESTNAME).c_str(), std::ifstream::in);
fs >> pid;
EXPECT_TRUE(fs.good());
PIDFile pid_file(absolutePath(TESTNAME));
int pid;
- // get a pid betwen 10000 and 20000
+ // get a pid between 10000 and 20000
pid = randomizePID(10000, 10000);
// write it
return;
}
- // get a pid betwen 40000 and 50000
+ // get a pid between 40000 and 50000
pid = randomizePID(10000, 40000);
// write it
fs << "text" << std::endl;
fs.close();
- // Run the check, we expect to get an execption
+ // Run the check, we expect to get an exception
EXPECT_THROW(pid_file.check(), PIDCantReadPID);
}
ASSERT_NO_THROW(signal_set_.reset(new SignalSet(SIGHUP)));
// Define another signal set and register a different signal.
ASSERT_NO_THROW(secondary_signal_set_.reset(new SignalSet(SIGINT)));
- // The SIGHUP has been already registsred with the other signal
+ // The SIGHUP has been already registered with the other signal
// set, so it should not be possible to register it again.
ASSERT_THROW(secondary_signal_set_->add(SIGHUP), SignalSetError);
// It shouldn't be possible to remove the signal registered in a different
// Check indirectly that the SIGINT is still registered. An attempt to
// register registered signal should result in failure.
EXPECT_THROW(secondary_signal_set_->add(SIGINT), SignalSetError);
- // But, we should be able to regsiter SIGHUP.
+ // But, we should be able to register SIGHUP.
EXPECT_NO_THROW(secondary_signal_set_->add(SIGHUP));
}
// A helper class to convert textual representation of IP address and port
// to a pair of sockaddr and its length (in the form of a SockAddrInfo
// pair). Its get method uses getaddrinfo(3) for the conversion and stores
-// the result in the addrinfo_list_ vector until the object is destructed.
+// the result in the addrinfo_list_ vector until the object is destroyed.
// The allocated resources will be automatically freed in an RAII manner.
class SockAddrCreator {
public:
}
// See below
- void checkPushAndPop(int family, int type, int protocoal,
+ void checkPushAndPop(int family, int type, int protocol,
const SockAddrInfo& local,
const SockAddrInfo& remote, const void* const data,
size_t data_len, bool new_connection);
// started, but we at least check the function is run and exceptions are
// propagated as they should.
//
-// We run some tests mutiple times to see if there happen to be a race
+// We run some tests multiple times to see if there happen to be a race
// condition (then it would have better chance showing up).
//
// The detached tests are not run as many times to prevent many threads being
pid_t pid(fork());
if (pid) { // We are in the parent
return pid;
- } else { // This is in the child, just puth the data there
+ } else { // This is in the child, just puts the data there
close(pipes[0]);
if (!write_data(pipes[1], input, length)) {
exit(1);
projects / thirdparty / kea.git / commitdiff
