// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// Copyright (c) 2006-2007 International Computer Science Institute
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software")
// to deal in the Software without restriction, subject to the conditions
// listed in the XORP LICENSE file. These conditions include: you must
// preserve this copyright notice, and you cannot mention the copyright
// holders in advertising related to the Software without their permission.
// The Software is provided WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. This
// notice is a summary of the XORP LICENSE file; the license in that file is
// legally binding.
#ident "$XORP: xorp/libproto/test_packet.cc,v 1.2 2007/02/16 22:46:03 pavlin Exp $"
#include "libproto_module.h"
#include "libxorp/xorp.h"
#include "libxorp/xlog.h"
#include "libxorp/exceptions.hh"
#include "libxorp/test_main.hh"
#include "libproto/packet.hh"
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif
//
// TODO: XXX: remove after the switch to the TestMain facility is completed
//
#if 0
//
// XXX: MODIFY FOR YOUR TEST PROGRAM
//
static const char *program_name = "test_packet";
static const char *program_description = "Test packet header manipulation";
static const char *program_version_id = "0.1";
static const char *program_date = "August 21, 2006";
static const char *program_copyright = "See file LICENSE.XORP";
static const char *program_return_value = "0 on success, 1 if test error, 2 if internal error";
#endif // 0
static bool s_verbose = false;
bool verbose() { return s_verbose; }
void set_verbose(bool v) { s_verbose = v; }
static int s_failures = 0;
bool failures() { return (s_failures)? (true) : (false); }
void incr_failures() { s_failures++; }
void reset_failures() { s_failures = 0; }
//
// printf(3)-like facility to conditionally print a message if verbosity
// is enabled.
//
#define verbose_log(x...) _verbose_log(__FILE__,__LINE__, x)
#define _verbose_log(file, line, x...) \
do { \
if (verbose()) { \
printf("From %s:%d: ", file, line); \
printf(x); \
} \
} while(0)
//
// Test and print a message whether two strings are lexicographically same.
// The strings can be either C or C++ style.
//
#define verbose_match(s1, s2) \
_verbose_match(__FILE__, __LINE__, s1, s2)
bool
_verbose_match(const char* file, int line, const string& s1, const string& s2)
{
bool match = s1 == s2;
_verbose_log(file, line, "Comparing %s == %s : %s\n",
s1.c_str(), s2.c_str(), match ? "OK" : "FAIL");
if (match == false)
incr_failures();
return match;
}
//
// Test and print a message whether a condition is true.
//
// The first argument is the condition to test.
// The second argument is a string with a brief description of the tested
// condition.
//
#define verbose_assert(cond, desc) \
_verbose_assert(__FILE__, __LINE__, cond, desc)
bool
_verbose_assert(const char* file, int line, bool cond, const string& desc)
{
_verbose_log(file, line,
"Testing %s : %s\n", desc.c_str(), cond ? "OK" : "FAIL");
if (cond == false)
incr_failures();
return cond;
}
//
// TODO: XXX: remove after the switch to the TestMain facility is completed
//
#if 0
/**
* Print program info to output stream.
*
* @param stream the output stream the print the program info to.
*/
static void
print_program_info(FILE *stream)
{
fprintf(stream, "Name: %s\n", program_name);
fprintf(stream, "Description: %s\n", program_description);
fprintf(stream, "Version: %s\n", program_version_id);
fprintf(stream, "Date: %s\n", program_date);
fprintf(stream, "Copyright: %s\n", program_copyright);
fprintf(stream, "Return: %s\n", program_return_value);
}
/**
* Print program usage information to the stderr.
*
* @param progname the name of the program.
*/
static void
usage(const char* progname)
{
print_program_info(stderr);
fprintf(stderr, "usage: %s [-v] [-h]\n", progname);
fprintf(stderr, " -h : usage (this message)\n");
fprintf(stderr, " -v : verbose output\n");
}
#endif // 0
/**
* Test IPv4 packet header manipulation.
*/
bool
test_ipv4_header(TestInfo& test_info)
{
UNUSED(test_info);
uint8_t data[IpHeader4::SIZE];
// Test values
uint8_t ip_tos = 1;
uint16_t ip_len = 1024;
uint16_t ip_id = 1000;
uint16_t ip_fragment_offset = 2000;
uint16_t ip_fragment_flags = 0xe000;
uint8_t ip_ttl = 64;
uint8_t ip_p = 100;
uint16_t ip_sum = 0xf123;
IPv4 ip_src("1.2.3.4");
IPv4 ip_dst("5.6.7.8");
memset(data, 0, sizeof(data));
IpHeader4 iph(data);
IpHeader4Writer iphw(data);
//
// Test whether the packet version is valid
//
verbose_assert(iph.is_valid_version() == false,
"IPv4 invalid header version");
//
// Set all fields
//
iphw.set_ip_version(IpHeader4::IP_VERSION);
iphw.set_ip_header_len(IpHeader4::SIZE);
iphw.set_ip_tos(ip_tos);
iphw.set_ip_len(ip_len);
iphw.set_ip_id(ip_id);
iphw.set_ip_fragment_offset(ip_fragment_offset);
iphw.set_ip_fragment_flags(ip_fragment_flags);
iphw.set_ip_ttl(ip_ttl);
iphw.set_ip_p(ip_p);
iphw.set_ip_sum(ip_sum);
iphw.set_ip_src(ip_src);
iphw.set_ip_dst(ip_dst);
//
// Test the IPv4 version
//
verbose_assert(iph.is_valid_version() == true,
"IPv4 valid header version");
verbose_assert(iph.ip_version() == IpHeader4::IP_VERSION, "IPv4 version");
//
// Test the IPv4 packet header size
//
verbose_assert(iph.ip_header_len() == IpHeader4::SIZE,
"IPv4 header length");
//
// Test the IPv4 TOS field
//
verbose_assert(iph.ip_tos() == ip_tos, "IPv4 TOS field");
//
// Test the total IPv4 packet length
//
verbose_assert(iph.ip_len() == ip_len, "IPv4 total packet length");
//
// Test the IPv4 ID field
//
verbose_assert(iph.ip_id() == ip_id, "IPv4 identification field");
//
// Test the IPv4 fragment offset
//
verbose_assert(iph.ip_fragment_offset() == ip_fragment_offset,
"IPv4 fragment offset");
//
// Test the IPv4 fragment flags
//
verbose_assert(iph.ip_fragment_flags() == ip_fragment_flags,
"IPv4 fragment flags");
//
// Test the IPv4 TTL
//
verbose_assert(iph.ip_ttl() == ip_ttl, "IPv4 TTL");
//
// Test the IPv4 protocol
//
verbose_assert(iph.ip_p() == ip_p, "IPv4 protocol field");
//
// Test the IPv4 packet header checksum
//
verbose_assert(iph.ip_sum() == ip_sum, "IPv4 checksum");
//
// Test the IPv4 source and destination address
//
verbose_assert(iph.ip_src() == ip_src, "IPv4 source address");
verbose_assert(iph.ip_dst() == ip_dst, "IPv4 destination address");
return (! failures());
}
/**
* Test IPv6 packet header manipulation.
*/
bool
test_ipv6_header(TestInfo& test_info)
{
UNUSED(test_info);
uint8_t data[IpHeader6::SIZE];
// Test values
uint8_t ip_traffic_class = 10;
uint32_t ip_flow_label = 2000;
uint16_t ip_plen = 3000;
uint8_t ip_nxt = 123;
uint8_t ip_hlim = 64;
IPv6 ip_src("1:2:3:4::");
IPv6 ip_dst("5:6:7:8::");
memset(data, 0, sizeof(data));
IpHeader6 iph(data);
IpHeader6Writer iphw(data);
//
// Test whether the packet version is valid
//
verbose_assert(iph.is_valid_version() == false,
"IPv6 invalid header version");
//
// Set all fields
//
iphw.set_ip_version(IpHeader6::IP_VERSION);
iphw.set_ip_traffic_class(ip_traffic_class);
iphw.set_ip_flow_label(ip_flow_label);
iphw.set_ip_plen(ip_plen);
iphw.set_ip_nxt(ip_nxt);
iphw.set_ip_hlim(ip_hlim);
iphw.set_ip_src(ip_src);
iphw.set_ip_dst(ip_dst);
//
// Test the IPv6 version
//
verbose_assert(iph.is_valid_version() == true,
"IPv6 valid header version");
verbose_assert(iph.ip_version() == IpHeader6::IP_VERSION, "IPv6 version");
//
// Test the IPv6 traffic class
//
verbose_assert(iph.ip_traffic_class() == ip_traffic_class,
"IPv6 traffic class");
//
// Test the IPv6 flow label
//
verbose_assert(iph.ip_flow_label() == ip_flow_label, "IPv6 flow label");
//
// Test the IPv6 payload length
//
verbose_assert(iph.ip_plen() == ip_plen, "IPv6 payload length");
//
// Test the IPv6 next header
//
verbose_assert(iph.ip_nxt() == ip_nxt, "IPv6 next header");
//
// Test the IPv6 hop limit
//
verbose_assert(iph.ip_hlim() == ip_hlim, "IPv6 hop limit");
//
// Test the IPv6 source and destination address
//
verbose_assert(iph.ip_src() == ip_src, "IPv6 source address");
verbose_assert(iph.ip_dst() == ip_dst, "IPv6 destination address");
return (! failures());
}
int
main(int argc, char * const argv[])
{
XorpUnexpectedHandler x(xorp_unexpected_handler);
//
// Initialize and start xlog
//
xlog_init(argv[0], NULL);
xlog_set_verbose(XLOG_VERBOSE_LOW); // Least verbose messages
// XXX: verbosity of the error messages temporary increased
xlog_level_set_verbose(XLOG_LEVEL_ERROR, XLOG_VERBOSE_HIGH);
xlog_add_default_output();
xlog_start();
TestMain test_main(argc, argv);
string test = test_main.get_optional_args("-t", "--test",
"run only the specified test");
test_main.complete_args_parsing();
//
// TODO: XXX: a temporary glue until we complete the switch to the
// TestMain facility.
//
if (test_main.get_verbose())
set_verbose(true);
struct test {
string test_name;
XorpCallback1<bool, TestInfo&>::RefPtr cb;
bool run_by_default;
} tests[] = {
{ "test_ipv4_header",
callback(test_ipv4_header),
true
},
{ "test_ipv6_header",
callback(test_ipv6_header),
true
}
};
try {
if (test.empty()) {
for (size_t i = 0; i < sizeof(tests) / sizeof(struct test); i++) {
if (! tests[i].run_by_default)
continue;
reset_failures();
test_main.run(tests[i].test_name, tests[i].cb);
}
} else {
for (size_t i = 0; i < sizeof(tests) / sizeof(struct test); i++) {
if (test == tests[i].test_name) {
reset_failures();
test_main.run(tests[i].test_name, tests[i].cb);
return test_main.exit();
}
}
test_main.failed("No test with name " + test + " found\n");
}
} catch (...) {
xorp_print_standard_exceptions();
}
//
// Gracefully stop and exit xlog
//
xlog_stop();
xlog_exit();
return test_main.exit();
}
syntax highlighted by Code2HTML, v. 0.9.1