/builddir/build/BUILD/libutil++-1.4.0/src/test.cpp

/*
** libutil++
** $Id: test.cpp 1243 2014-11-21 01:01:24Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: test.cpp 1243 2014-11-21 01:01:24Z sella $";

#include "test.h"

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <syscall.h>

#include <iostream>
#include <string>
#include <vector>

#include "alias.h"
#include "version.h"
#include "sella/net/IPAddressPort.h"
#include "sella/net/IPPrefix.h"
#include "sella/net/SocketMux.h"
#include "sella/net/EtherSocket.h"
#include "sella/net/DNS.h"
#include "sella/net/DNSCallback.h"
#include "sella/net/Pipe.h"
#include "sella/net/SocketPair.h"
#include "sella/net/SocketTrigger.h"
#include "sella/util/Log.h"
#include "sella/util/SimpleLogFormat.h"
#include "sella/util/MixedLogFormat.h"
#include "sella/util/VerboseLogFormat.h"
#include "sella/util/Log.h"
#include "sella/util/String.h"
#include "sella/util/Process.h"
#include "sella/util/File.h"
#include "sella/util/LockFile.h"
#include "sella/util/Interface.h"
#include "sella/util/Packet.h"
#include "sella/util/UUID.h"
#include "sella/variant/Variant.h"
#include "sella/util/ThreadPool.h"
#include "sella/util/Time.h"

#include <linux/if_packet.h>
#include <netinet/ip_icmp.h>

using namespace sella::util;
using namespace sella::net;

/* Global Variables */

int main(int argc, char **argv) {
        printf("Using %s v%s\n\n", libutilxx__package(), libutilxx__version());

        SET_FORMAT(SimpleLogFormat());
        SET_IDENTIFIER("test");
        SET_OPTION(Log::WithStderrOption);
        SET_LOGMASK(LOG_UPTO(LOG_DEBUG));
        
#if 0
        testLog();
        testString();
        testProcess();
        testFile();
        testLockFile();
        testInterface();
        testSocket();
        testIPPrefix();
        testIPAddress();
        testIPAddressPort();
        testVariant();
        testException();
        testDNS();
        testThreadPool();
        testSocketPair();
        testSocketTrigger();
        testPipe();
#else
        testIPPrefix();
#endif

#if 0
        try {
                std::string buf = "This is a test ${foo}. Time to make the ${donuts}[bob=1] ${bar} and ${front}[${sub}[jack=1]]. Yawn.";

                std::vector<std::string> v;
                su::String::regex_search(buf, "(\\$\\{[^{}]+\\}(?:\\[[^\\]]*\\]+)?)", v, true, false);

                for (auto it = v.begin(); it != v.end(); ++it) {
                        INFO("MATCH: %s", it->c_str());
                }
        } catch (sella::Exception &e) {
                WARNING("Got: %s", e.what());
        }
#endif

        return EXIT_SUCCESS;
}

void testLog(void) {
        printf("--------------------\n");
        printf("- sella/util/Log.h -\n");
        printf("--------------------\n");

        DLOG("Debug message which only shows with ./configure --enable-debug");

        sella::Exception e(false, __func__, __FILE__, __LINE__, 100, "exception message");
        SET_TRACE("foo");

        {
                printf("Using SimpleLogFormat:\n");
                SET_FORMAT(SimpleLogFormat());
                SET_IDENTIFIER("test");
                SET_OPTION(Log::WithStderrOption);

                INFO("Informational message");
                WARNING("Warning message");
                ERROR("Error message");
                EXCEPTION(e, NULL);

                SET_TRACE("test-trace");
                TRACE("test-trace", "#1: Display when 'test-trace' is set") || INFO("#1: Display when 'test-trace' is not set");
                UNSET_TRACE("test-trace");
                TRACE("test-trace", "#2: Display when 'test-trace' is set") || INFO("#2: Display when 'test-trace' is not set");

                if (IS_TRACE("test-trace")) {
                        printf("Perform action only when 'test-trace' is set\n");
                }
        }

        {
                printf("Using MixedLogFormat:\n");
                SET_FORMAT(MixedLogFormat());

                INFO("Informational message");
                WARNING("Warning message");
                ERROR("Error message");
                TRACE("foo", "Trace message");
                EXCEPTION(e, NULL);
        }

        {
                printf("Using VerboseLogFormat:\n");
                SET_FORMAT(VerboseLogFormat());

                INFO("Informational message");
                WARNING("Warning message");
                ERROR("Error message");
                TRACE("foo", "Trace message");
                EXCEPTION(e, NULL);
        }

        SET_FORMAT(SimpleLogFormat());

        printf("\n");
}

void testString(void) {
        using namespace sella::util;

        boost::cmatch m;
        std::string in, match;
        std::vector<std::string> matches;

        printf("-----------------------\n");
        printf("- sella/util/String.h -\n");
        printf("-----------------------\n");

        printf("String::sprintf(): %s\n", String::sprintf("Dulce et %s est pro %s mori", "decorum", "patria").c_str());

        in = "Dulce Et Decorum Est Pro Patria Mori";
        printf("\nString::substr_replace(): %s\n", String::substr_replace((const std::string) in, "e", "X", false).c_str());
        printf("String::substr_ireplace(): %s\n", String::substr_ireplace((const std::string) in, "MORI", "VITA").c_str());

        String::substr_ireplace(in, "D", "XXX");
        printf("String::substr_ireplace(): %s\n", in.c_str());
        String::substr_ireplace(in, "XXX", "D");

        printf("\nString::regex_replace(): %s\n", String::regex_replace((const std::string) in, "e", "X", String::DefaultREFlags, boost::regex_constants::format_first_only).c_str());
        printf("String::regex_ireplace(): %s\n", String::regex_ireplace((const std::string) in, "(M.RI)", "(was: $1, now: VITA)").c_str());

        in = "Dulce Et Decorum Est Pro Patria Mori";
        printf("\nString::regex_match(): %s\n", (String::regex_match(in, ".*Dulce.*", m)) ? "MATCH" : "no match");
        printf("String::regex_imatch(): %s\n", (String::regex_imatch(in, ".*DULCE.*")) ? "MATCH" : "no match");

        printf("\nString::regex_search(): %s\n", (String::regex_search(in, "D.lce", m)) ? "MATCH" : "no match");
        printf("String::regex_isearch(): %s\n", (String::regex_isearch(in, "D.LCE")) ? "MATCH" : "no match");

        in = "Dulce Et Decorum Est Pro Patria Mori";
        if (String::regex_match(in, ".*Decorum.*Patria.*", match)) {
                printf("\nString::regex_match(): %s\n", match.c_str());
        } else {
                printf("\nString::regex_match(): no match\n");
        }

        if (String::regex_imatch(in, ".*DECORUM.*PATRIA.*", match)) {
                printf("String::regex_imatch(): %s\n", match.c_str());
        } else {
                printf("String::regex_imatch(): no match\n");
        }

        if (String::regex_search(in, "([DP][^ ]+|Dul)(ce)?", matches, true, false)) {
                printf("\nString::regex_search(): ");

                for (auto it = matches.begin(); it != matches.end(); ++it) {
                        printf("%s, ", it->c_str());
                }
                matches.clear();

                printf("\b\b \n");
        } else {
                printf("\nString::regex_search(): no match\n");
        }

        if (String::regex_isearch(in, "([dp][^ ]+|dul)(ce)?", matches, true, false)) {
                printf("String::regex_isearch(): ");

                for (auto it = matches.begin(); it != matches.end(); ++it) {
                        printf("%s, ", it->c_str());
                }
                matches.clear();

                printf("\b\b \n");
        } else {
                printf("String::regex_isearch(): no match\n");
        }

        try {
                String::regex_isearch("foobar", "^bad-regex [a-z]{");
        } catch (RegexException &e) {
                printf("RegexException: %s\n", e.what());
        }

        in = "  dulce et DECORUM est pro pAtRiA mori  ";
        printf("\nString::rtrim(): |%s|\n", String::rtrim(in).c_str());
        printf("String::ltrim(): |%s|\n", String::ltrim(in).c_str());

        printf("String::lower(): %s\n", String::lower(in).c_str());
        printf("String::upper(): %s\n", String::upper(in).c_str());
        printf("String::ucfirst(): %s\n", String::ucfirst(in).c_str());
        printf("String::ucword(): %s\n", String::ucword(in).c_str());

        std::vector<std::string> v;
        in = "first,second,,forth,";
        in = "first::second::::forth::";
        v = String::split(in, "::", true, true);
        printf("\n");
        for (auto it = v.begin(); it != v.end(); ++it) {
                printf("String::split(): '%s'\n", it->c_str());
        }

        in = "jack=jill=olaf";
        v = String::split(in, '=', false, 2);
        printf("\n");
        for (auto it = v.begin(); it != v.end(); ++it) {
                printf("String::split(): '%s'\n", it->c_str());
        }

        in = ".jack.jill..olaf";
        v = String::split(in, '.', false);
        printf("\n");
        for (auto it = v.begin(); it != v.end(); ++it) {
                printf("String::split(): '%s'\n", it->c_str());
        }

        printf("\nString::join(): %s\n", String::join(v, ", ").c_str());

        std::list<std::string> l = { "foo", "bar" };
        printf("String::join(): %s\n", String::join(l, ", ").c_str());

        std::set<std::string> s = { "Sucker", "Punch" };
        printf("String::join(): %s\n", String::join(s, ", ").c_str());

        printf("String::bandwidth(): %s\n", String::bandwidth(1250000000LL).c_str());
        printf("String::bandwidth(): %s\n", String::bandwidth(1250000000LL, 2).c_str());
        printf("String::dataRate(): %s\n", String::dataRate(1250000000LL).c_str());
        printf("String::dataRate(): %s\n", String::dataRate(1250000000LL, 2).c_str());
        printf("String::dataSize(): %s\n", String::dataSize(5772800LL).c_str());
        printf("String::dataSize(): %s\n", String::dataSize(5772800LL, 1).c_str());
        printf("String::duration(): %s\n", String::duration(1250000LL).c_str());
        printf("String::duration(): %s\n", String::duration(1250000LL, 2).c_str());

        printf("\n");
}

void testProcess(void) {
        printf("------------------------\n");
        printf("- sella/util/Process.h -\n");
        printf("------------------------\n");

        printf("Process::getBaseName(): %s\n", Process::getBaseName().c_str());
        printf("Process::getDirName(): %s\n", Process::getDirName().c_str());
        printf("Process::getPath(): %s\n", Process::getPath().c_str());

        {
                std::string org = Process::getName();

                Process::setName("new-name");
                printf("Process::setName(): %s\n", Process::getName().c_str());
                Process::setName(org);
                printf("Process::getName(): %s\n", Process::getName().c_str());
        }

        printf("Process::runCommand(): %s\n", Process::runCommand("echo -n \"it works\" 2> /dev/null").c_str());
        printf("Process::stackTrace(): Output below:\n%s\n", Process::stackTrace(Process::getPath()).c_str());

        printf("\n");
}

void testLockFile(void) {
        printf("-------------------------\n");
        printf("- sella/util/LockFile.h -\n");
        printf("-------------------------\n");

        try {
                LockFile lockfile("/var/tmp/test.lock");

                if (lockfile.isLocked() && !lockfile.ownLock()) {
                        lockfile.remove();
                }

                printf("LockFile::tryLock(): %s == true\n", (lockfile.tryLock()) ? "true" : "false");
                printf("LockFile::ownLock(): %s == true\n", (lockfile.ownLock()) ? "true" : "false");
                printf("LockFile::isLocked(): %s == true\n", (lockfile.isLocked()) ? "true" : "false");
                printf("LockFile::isStale(): %s == false\n", (lockfile.isStale()) ? "true" : "false");

                if (lockfile.ownLock()) {
                        printf("LockFile::unlock(): %s == true\n", (lockfile.unlock()) ? "true" : "false");
                }

                printf("LockFile::ownLock(): %s == true\n", (lockfile.ownLock()) ? "true" : "false");
                printf("LockFile::isLocked(): %s == true\n", (lockfile.isLocked()) ? "true" : "false");
        } catch (FileException &e) {
                ERROR(e);
        }

        printf("\n");
}

void testFile(void) {
        printf("---------------------\n");
        printf("- sella/util/File.h -\n");
        printf("---------------------\n");

        printf("File::getBaseName(): %s\n", File::getBaseName("/proc/cpuinfo").c_str());
        printf("File::getDirName(): %s\n", File::getDirName("/proc/cpuinfo").c_str());
        printf("File::getRealPath(): %s\n", File::getRealPath("/proc/./self").c_str());
        printf("File::exists(): %s\n", (File::exists("/proc/cpuinfo")) ? "true" : "false");
        printf("File::isRegularFile(): %s\n", (File::isRegularFile("/proc/cpuinfo")) ? "true" : "false");
        printf("File::isDirectory(): %s\n", (File::isDirectory("/proc/self")) ? "true" : "false");
        printf("File::isSymLink(): %s\n", (File::isSymLink("/proc/self")) ? "true" : "false");
        printf("File::getSize(): %"PRId64"B (%s)\n", File::getSize("/proc/self/exe"), String::dataSize(File::getSize("/proc/self/exe"), 1).c_str());

        printf("\n");
}

void testInterface(void) {
        printf("--------------------------\n");
        printf("- sella/util/Interface.h -\n");
        printf("--------------------------\n");

        printf("Interface::getNames():\n");
        auto names = Interface::getNames(0);

        for (auto it = names.begin(); it != names.end(); ++it) {
                printf("name: %s\n", it->c_str());
        }


        printf("\nInterface::getEthernetNames():\n");
        auto enames = Interface::getEthernetNames(0);

        for (auto it = enames.begin(); it != enames.end(); ++it) {
                printf("name: %s\n", it->c_str());
        }


        printf("\nInterface::getIPAddresses(\"%s\"):\n", names.front().c_str());
        auto addresses = Interface::getIPAddresses(names.front());

        for (auto it = addresses.begin(); it != addresses.end(); ++it) {
                printf("address: %s\n", (*it)->c_str());
        }


        printf("\nInterface::getIPAddresses():\n");
        addresses = Interface::getIPAddresses();

        for (auto it = addresses.begin(); it != addresses.end(); ++it) {
                printf("address: %s\n", (*it)->c_str());
        }


        printf("\nInterface::getMAC(\"%s\"):\n", names.front().c_str());
        std::string mac = Interface::getMAC(names.front());
        printf("mac: %s\n", mac.c_str());


        printf("\nInterface::getMACs():\n");
        auto macs = Interface::getMACs();

        for (auto it = macs.begin(); it != macs.end(); ++it) {
                printf("mac: %s\n", it->c_str());
        }

        
        printf("\nInterface::getIndex():\n");

        for (auto it = names.begin(); it != names.end(); ++it) {
                int idx = Interface::getIndex(*it);
                printf("%s: %d (reverse: %s)\n", it->c_str(), idx, Interface::getName(idx).c_str());
        }

        {
                printf("\nInterface::convertMAC():\n");

                unsigned char addr[6] = { 0, 1, 2, 3, 4, 5 };
                uint64_t mac1, mac2;
                std::string buf1, buf2;

                Interface::convertMAC(mac1, (const unsigned char*) addr);
                Interface::convertMAC(addr, mac1);
                Interface::convertMAC(mac2, (const unsigned char*) addr);
                printf("%"PRIu64" == %"PRIu64"\n", mac1, mac2);
                printf("%s == %s\n", Interface::convertMAC(buf1, mac1).c_str(), Interface::convertMAC(buf2, mac2).c_str());
                Interface::convertMAC(buf1, mac1);
                Interface::convertMAC(mac2, buf1);
                Interface::convertMAC(buf2, mac2);
                printf("%s == %s\n", buf1.c_str(), buf2.c_str());
        }

        printf("\n");
}

void testSocket(void) {
        size_t c;
        unsigned char buf[9216] = { 0 };
        size_t ethhdr_size = 18; // 14 without VLAN
        struct ethhdr *eh = (struct ethhdr*) buf; 
        struct ip *iphdr = (struct ip*) (buf + ethhdr_size);
        struct icmphdr *ich = (struct icmphdr*) (buf + ethhdr_size + sizeof(struct ip));
        size_t pktlen = ethhdr_size + sizeof(struct ip) + sizeof(struct icmphdr);

        printf("--------------------------\n");
        printf("- sella/net/Socket.h -\n");
        printf("--------------------------\n");

        auto names = Interface::getNames();

        /* View outgoiong packets with:
                # tcpdump -v -nettti eth2 '(ether dst host 00:11:22:33:44:55)'
        */

        try {
                std::string destination = "00:11:22:33:44:55";
                std::string name = names.front();
                name = "eth2";

                printf("EtherSocket(): %s\n", name.c_str());
                EtherSocket::shared s = std::make_shared<EtherSocket>(ETH_P_ALL, name, true);
                SocketMux mux;

                s->setPromiscous();
                s->setSoReuseAddr();
                s->bindInterface();
                s->setSoBindToDevice();

//#define ZEROCOPY
#ifdef ZEROCOPY
                size_t ring_frames = 256;
                //#define PKT_OFFSET (TPACKET_ALIGN(sizeof(struct tpacket_hdr)) + TPACKET_ALIGN(sizeof(struct sockaddr_ll)))

                struct tpacket_req req;
                req.tp_block_size = ring_frames * getpagesize();
                req.tp_block_nr = 1;
                req.tp_frame_size = getpagesize();
                req.tp_frame_nr = ring_frames;

                unsigned char *tx, *rx;
                s->mmapRingBuffer(&tx, req);
                s->mmapRingBuffer(&rx, req);

                s->setPacketRxRing(req);
                s->setPacketTxRing(req);

                s->munmapRingBuffer(&tx, req);
                s->munmapRingBuffer(&rx, req);
#endif

                unsigned char dst_mac[6], src_mac[6];

                su::Interface::convertMAC(dst_mac, destination);
                su::Interface::convertMAC(src_mac, su::Interface::getMAC(name));

                memset(&buf, 0, sizeof(buf));
                memcpy((void*) (buf), (void*) &dst_mac, 6);
                memcpy((void*) (buf + 6), (void*) &src_mac, 6);

                eh->h_proto = htons(0x8100);
                unsigned short int vid = htons(200);
                memcpy((void*) (buf + 14), (void*) &vid, 2);
                
                unsigned short int vlanproto = htons(0x0800);
                memcpy((void*) (buf + 16), (void*) &vlanproto, 2);

                iphdr->ip_hl = 5;
                iphdr->ip_v = 4;
                iphdr->ip_tos = 0;
                iphdr->ip_len = htons(pktlen - ethhdr_size);
                iphdr->ip_id = 0;
                iphdr->ip_off = 0;
                iphdr->ip_ttl = 64;
                iphdr->ip_p = 1; /* ICMP */
                iphdr->ip_sum = 0;
                iphdr->ip_src.s_addr = inet_addr(su::Interface::getIPAddress(name).c_str());
                iphdr->ip_dst.s_addr = inet_addr(destination.c_str());

                ich->type = 8;
                ich->code = 0;
                ich->checksum = 0;
                ich->un.echo.id = 0;
                ich->un.echo.sequence = htons(11); 

                ich->checksum = su::Packet::csum((unsigned short*) (buf + ethhdr_size + sizeof(struct ip)), 4); 
                iphdr->ip_sum = su::Packet::csum((unsigned short*) (buf + ethhdr_size), iphdr->ip_hl << 1); 

                printf("Sending packet on vlan %d to %s (size: %zd)...\n", ntohs(vid), su::Interface::getMAC(name).c_str(), pktlen);
                for (size_t i = 0; i < pktlen; i++) {
                        printf("%02X", buf[i]);
                }
                printf("\n");

                s->sendto(&buf, pktlen, destination);

                mux.insertRead(s);

                struct timeval delay = { 0, 5000 };

                if (mux.select(&delay) > 0) {   
                        const auto &list = mux.getReadList();

                        for (auto it = list.begin(); it != list.end(); ++it) {
                                s = std::static_pointer_cast<EtherSocket>(*it);
                                std::string mac;

                                if ((c = s->recvfrom(&buf, sizeof(buf), mac)) > 0) {

                                        printf("Received packet on from %s.\n", mac.c_str());
                                        for (size_t i = 0; i < c; i++) {
                                                printf("%X", buf[i]);
                                        }
                                        printf("\n");

                                } else {
                                        printf("Received no packet.\n");
                                }
                        }
                } else {
                        printf("Receive timed out (nothing to receive)\n");
                }
        } catch (sella::Exception &e) {
                printf("Exception: %s\n", e.what());
        }

#if 0
        try {
                printf("\nEtherSocket(): %s\n", names.front().c_str());
                EtherSocket s(ETH_P_MPLS_UC, "eth2");
                SocketMux mux;

                s.setSoReuseAddr(true);
                //s.setSoBindToDevice(names.front());
                s.setSoBindToDevice("eth2");
//              s.bindInterface(names.front());
//              Interface::setPromiscous(names.front());

                printf("sendto...\n");

                struct header_8021q {
                        uint32_t vid:12;
                } __attribute__((packed));

                union mpls_shim {
                        uint32_t shim;
                        struct mpls_label {
                                uint32_t label:20;
                                uint8_t exp:3;
                                uint8_t s:1;
                                uint8_t ttl:8;
                        } __attribute__((__packed__)) bits;
                };

                mpls_shim *h = (mpls_shim*) buf;

                h->bits.label = htons(500);
                h->bits.exp = 0;
                h->bits.s = 1;
                h->bits.ttl = 10;

                h->shim = htonl(h->shim);

                s.sendto(&buf, 4, "68:05:CA:0F:C5:FF");

#if 0
                printf("GET GET\n");
                read(s.getFD(), buf, sizeof(buf));
#endif

                printf("recvfrom()...\n");
                if (s.recvfrom(&buf, sizeof(buf)) > 0) {
                        printf("Got some packets\n");
                } else {
                        printf("Got no packets\n");
                }
        } catch (sella::Exception &e) {
                printf("Exception: %s\n", e.what());
        }
#endif

        printf("\n");
}

void testIPAddress(void) {
        printf("------------------------\n");
        printf("- sella/net/IPAddress.h -\n");
        printf("------------------------\n");

        try {
                printf("IPAddress Constructors\n");
                IPAddress a("192.168.0.0");
                IPAddress b("192.168.0.25");
                IPAddress c("192.168.0.75");
                IPAddress e("fe80::6a05:caff:fe0f:0000");
                IPAddress f("fe80::6a05:caff:fe0f:5555");
                IPAddress g("ffff::ffff:ffff:ffff:ffff");
                IPAddress m("0.0.0.255");
                IPAddress j("::FFFF");

                printf("a: %s\n", a.c_str());
                printf("b: %s\n", b.c_str());
                printf("c: %s\n", c.c_str());
                printf("e: %s\n", e.c_str());
                printf("f: %s\n", f.c_str());
                printf("g: %s\n", g.c_str());
                printf("m: %s\n", m.c_str());
                printf("j: %s\n", j.c_str());

                printf("\nIPAddress::operator==()\n");
                printf("(%s == %s) == %s\n", a.c_str(), b.c_str(), (a == b) ? "true" : "false");
                printf("(%s == %s) == %s\n", b.c_str(), c.c_str(), (b == c) ? "true" : "false");
                printf("(%s == %s) == %s\n", b.c_str(), b.c_str(), (b == b) ? "true" : "false");
                printf("(%s == %s) == %s\n", e.c_str(), f.c_str(), (e == f) ? "true" : "false");
                printf("(%s == %s) == %s\n", f.c_str(), g.c_str(), (f == g) ? "true" : "false");
                printf("(%s == %s) == %s\n", f.c_str(), f.c_str(), (f == f) ? "true" : "false");

                printf("\nIPAddress::operator>()\n");
                printf("(%s > %s) == %s\n", a.c_str(), b.c_str(), (a > b) ? "true" : "false");
                printf("(%s > %s) == %s\n", c.c_str(), b.c_str(), (c > b) ? "true" : "false");
                printf("(%s > %s) == %s\n", f.c_str(), e.c_str(), (f > e) ? "true" : "false");
                printf("(%s > %s) == %s\n", f.c_str(), g.c_str(), (f > g) ? "true" : "false");

                printf("\nIPAddress::operator<()\n");
                printf("(%s < %s) == %s\n", a.c_str(), b.c_str(), (a < b) ? "true" : "false");
                printf("(%s < %s) == %s\n", b.c_str(), c.c_str(), (b < c) ? "true" : "false");
                printf("(%s < %s) == %s\n", f.c_str(), e.c_str(), (f < e) ? "true" : "false");
                printf("(%s < %s) == %s\n", f.c_str(), g.c_str(), (f < g) ? "true" : "false");

                printf("\nIPAddress::operator>=()\n");
                printf("(%s >= %s) == %s\n", a.c_str(), b.c_str(), (a >= b) ? "true" : "false");
                printf("(%s >= %s) == %s\n", c.c_str(), b.c_str(), (c >= b) ? "true" : "false");
                printf("(%s >= %s) == %s\n", f.c_str(), e.c_str(), (f >= e) ? "true" : "false");
                printf("(%s >= %s) == %s\n", f.c_str(), g.c_str(), (f >= g) ? "true" : "false");

                printf("\nIPAddress::operator<=()\n");
                printf("(%s <= %s) == %s\n", a.c_str(), b.c_str(), (a <= b) ? "true" : "false");
                printf("(%s <= %s) == %s\n", b.c_str(), c.c_str(), (b <= c) ? "true" : "false");
                printf("(%s <= %s) == %s\n", f.c_str(), e.c_str(), (f <= e) ? "true" : "false");
                printf("(%s <= %s) == %s\n", f.c_str(), g.c_str(), (f <= g) ? "true" : "false");

                printf("\nIPAddress::operator&()\n");
                printf("(%s & %s) == %s\n", a.c_str(), m.c_str(), (a & m).str().c_str());
                printf("(%s & %s) == %s\n", b.c_str(), m.c_str(), (b & m).str().c_str());
                printf("(%s & %s) == %s\n", e.c_str(), j.c_str(), (e & j).str().c_str());
                printf("(%s & %s) == %s\n", f.c_str(), j.c_str(), (f & j).str().c_str());

                printf("\nIPAddress::operator|()\n");
                printf("(%s | %s) == %s\n", a.c_str(), m.c_str(), (a | m).str().c_str());
                printf("(%s | %s) == %s\n", b.c_str(), m.c_str(), (b | m).str().c_str());
                printf("(%s | %s) == %s\n", e.c_str(), j.c_str(), (e | j).str().c_str());
                printf("(%s | %s) == %s\n", f.c_str(), j.c_str(), (f | j).str().c_str());

                printf("\nIPAddress::operator^()\n");
                printf("(%s ^ %s) == %s\n", a.c_str(), m.c_str(), (a ^ m).str().c_str());
                printf("(%s ^ %s) == %s\n", b.c_str(), m.c_str(), (b ^ m).str().c_str());
                printf("(%s ^ %s) == %s\n", e.c_str(), j.c_str(), (e ^ j).str().c_str());
                printf("(%s ^ %s) == %s\n", f.c_str(), j.c_str(), (f ^ j).str().c_str());

                printf("\nIPAddress::operator~()\n");
                printf("(~ %s) == %s\n", a.c_str(), (~a).str().c_str());
                printf("(~ %s) == %s\n", b.c_str(), (~b).str().c_str());
                printf("(~ %s) == %s\n", e.c_str(), (~e).str().c_str());
                printf("(~ %s) == %s\n", f.c_str(), (~f).str().c_str());

                printf("\nIPAddress::getU32()\n");
                printf("%s => %u\n", a.c_str(), a.getU32());
                printf("%s => %u\n", b.c_str(), b.getU32());
                printf("%s => %u\n", e.c_str(), e.getU32());
                printf("%s => %u\n", f.c_str(), f.getU32());

                printf("\nIPAddress::getHash()\n");
                printf("%s => %u\n", a.c_str(), a.getHash());
                printf("%s => %u\n", b.c_str(), b.getHash());
                printf("%s => %u\n", e.c_str(), e.getHash());
                printf("%s => %u\n", f.c_str(), f.getHash());

                printf("\nIPAddress::operator++()\n");
                printf("%s++ == %s\n", a.c_str(), (a++).c_str());
                printf("%s++ == %s\n", e.c_str(), (e++).c_str());
                g = IPAddress("::ffff:ffff:ffff:ffff");
                printf("%s++ == %s\n", g.c_str(), (g++).c_str());
                g = IPAddress("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
                printf("%s++ == %s\n", g.c_str(), (g++).c_str());

                printf("\nIPAddress::operator+()\n");
                printf("%s++ == %s\n", a.c_str(), (a++).c_str());
                printf("%s++ == %s\n", e.c_str(), (e++).c_str());
                g = IPAddress("::ffff:ffff:ffff:ffff");
                printf("%s + 256 == %s\n", g.c_str(), (g + 256).c_str());
                g = IPAddress("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
                printf("%s + 256 == %s\n", g.c_str(), (g + 256).c_str());

                printf("\nIPAddress::operator--()\n");
                printf("%s-- == %s\n", a.c_str(), (a--).c_str());
                printf("%s-- == %s\n", e.c_str(), (e--).c_str());
                g = IPAddress("::1");
                printf("%s-- == %s\n", g.c_str(), (g--).c_str());
                g = IPAddress("::ffff:ffff:ffff:ffff");
                printf("%s-- == %s\n", g.c_str(), (g--).c_str());
                g = IPAddress("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
                printf("%s-- == %s\n", g.c_str(), (g--).c_str());

                printf("\nIPAddress::operator-()\n");
                printf("%s-- == %s\n", a.c_str(), (a--).c_str());
                printf("%s-- == %s\n", e.c_str(), (e--).c_str());
                g = IPAddress("::ffff:ffff:ffff:ffff");
                printf("%s - 1 == %s\n", g.c_str(), (g - 1).c_str());
                g = IPAddress("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
                printf("%s - 1 == %s\n", g.c_str(), (g - 1).c_str());
                g = IPAddress("::");
                printf("%s - 1 == %s\n", g.c_str(), (g - 1).c_str());
                g = IPAddress("::1:ffff:ffff:ffff:ffff");
                printf("%s - 2 == %s\n", g.c_str(), (g - 2).c_str());
                g = IPAddress("ffff:ffff:ffff:ffff::");
                printf("%s - 1 == %s\n", g.c_str(), (g - 1).c_str());
                g = IPAddress("0:0:0:1::");
                printf("%s - 1 == %s\n", g.c_str(), (g - 1).c_str());

                printf("\nIPAddress::operator+=()\n");
                a = IPAddress("10.0.0.5") += 1;
                printf("%s += 1 == %s\n", IPAddress("10.0.0.5").c_str(), a.c_str());
                a = IPAddress("::ffff:ffff:ffff:ffff") += 2;
                printf("%s += 2 == %s\n", IPAddress("::ffff:ffff:ffff:ffff").c_str(), a.c_str());

                printf("\nIPAddress::operator-=()\n");
                a = IPAddress("10.0.0.6") -= 1;
                printf("%s -= 1 == %s\n", IPAddress("10.0.0.6").c_str(), a.c_str());
                a = IPAddress("0:0:0:2::") -= 2;
                printf("%s -= 2 == %s\n", IPAddress("0:0:0:2::").c_str(), a.c_str());

        } catch (AddressException &e) {
                printf("AddressException: %s\n", e.what());

                exit(1);
        }

        printf("\n");
}

void testIPAddressPort(void) {
        printf("-----------------------------\n");
        printf("- sella/net/IPAddressPort.h -\n");
        printf("-----------------------------\n");

        try {
                printf("\nIPAddressPort Constructors\n");
                IPAddressPort a("192.168.0.0");
                IPAddressPort b("[192.168.0.25]:80");
                IPAddressPort c("192.168.0.75:8080", 9999);
                IPAddressPort e("fe80::6a05:caff:fe0f:5151");
                IPAddressPort f("[fe80::6a05:caff:fe0f:5555]:8080", 9999);
                IPAddressPort g("ffff::ffff:ffff:ffff:ffff", 9999);
                IPAddressPort h("[::]:0");
                IPAddressPort m("[0.0.0.255]");
                IPAddressPort j("[::FFFF]");

                printf("a: %s\n", a.c_str());
                printf("b: %s\n", b.c_str());
                printf("c: %s\n", c.c_str());
                printf("e: %s\n", e.c_str());
                printf("f: %s\n", f.c_str());
                printf("g: %s\n", g.c_str());
                printf("h: %s\n", h.c_str());
                printf("m: %s\n", m.c_str());
                printf("j: %s\n", j.c_str());

                printf("\nIPAddressPort::operator==()\n");
                printf("(%s == %s) == %s\n", a.c_str(), b.c_str(), (a == b) ? "true" : "false");
                printf("(%s == %s) == %s\n", b.c_str(), c.c_str(), (b == c) ? "true" : "false");
                printf("(%s == %s) == %s\n", b.c_str(), b.c_str(), (b == b) ? "true" : "false");
                printf("(%s == %s) == %s\n", e.c_str(), f.c_str(), (e == f) ? "true" : "false");
                printf("(%s == %s) == %s\n", f.c_str(), g.c_str(), (f == g) ? "true" : "false");
                printf("(%s == %s) == %s\n", f.c_str(), f.c_str(), (f == f) ? "true" : "false");

                printf("\nIPAddressPort::operator>()\n");
                printf("(%s > %s) == %s\n", a.c_str(), b.c_str(), (a > b) ? "true" : "false");
                printf("(%s > %s) == %s\n", c.c_str(), b.c_str(), (c > b) ? "true" : "false");
                printf("(%s > %s) == %s\n", f.c_str(), e.c_str(), (f > e) ? "true" : "false");
                printf("(%s > %s) == %s\n", f.c_str(), g.c_str(), (f > g) ? "true" : "false");

                printf("\nIPAddressPort::operator<()\n");
                printf("(%s < %s) == %s\n", a.c_str(), b.c_str(), (a < b) ? "true" : "false");
                printf("(%s < %s) == %s\n", b.c_str(), c.c_str(), (b < c) ? "true" : "false");
                printf("(%s < %s) == %s\n", f.c_str(), e.c_str(), (f < e) ? "true" : "false");
                printf("(%s < %s) == %s\n", f.c_str(), g.c_str(), (f < g) ? "true" : "false");

                printf("\nIPAddressPort::operator>=()\n");
                printf("(%s >= %s) == %s\n", a.c_str(), b.c_str(), (a >= b) ? "true" : "false");
                printf("(%s >= %s) == %s\n", c.c_str(), b.c_str(), (c >= b) ? "true" : "false");
                printf("(%s >= %s) == %s\n", f.c_str(), e.c_str(), (f >= e) ? "true" : "false");
                printf("(%s >= %s) == %s\n", f.c_str(), g.c_str(), (f >= g) ? "true" : "false");

                printf("\nIPAddressPort::operator<=()\n");
                printf("(%s <= %s) == %s\n", a.c_str(), b.c_str(), (a <= b) ? "true" : "false");
                printf("(%s <= %s) == %s\n", b.c_str(), c.c_str(), (b <= c) ? "true" : "false");
                printf("(%s <= %s) == %s\n", f.c_str(), e.c_str(), (f <= e) ? "true" : "false");
                printf("(%s <= %s) == %s\n", f.c_str(), g.c_str(), (f <= g) ? "true" : "false");

                printf("\nIPAddressPort::getU32()\n");
                printf("%s => %u\n", b.c_str(), b.getU32());
                printf("%s => %u\n", e.c_str(), e.getU32());

                printf("\nIPAddressPort::getHash()\n");
                printf("%s => %u\n", b.c_str(), b.getHash());
                printf("%s => %u\n", e.c_str(), e.getHash());
        } catch (AddressException &e) {
                printf("AddressException: %s\n", e.what());

                exit(1);
        }

        printf("\n");
}

void testIPPrefix(void) {
        printf("------------------------\n");
        printf("- sella/net/IPPrefix.h -\n");
        printf("------------------------\n");

        try {
                printf("IPPrefix Constructors\n");
                IPPrefix a("192.168.50.25");
                IPPrefix b("192.168.50.1/24");
                IPPrefix c("192.168.50.25", 24);
                IPPrefix d(IPAddress("192.168.50.25"), 16);
                IPPrefix e("fe80::6a05:caff:fe0f:c55f", 128);
                IPPrefix f("fe80::6a05:caff:fe0f:c55f");
                IPPrefix g("fe80::6a05:caff:fe0f:dead/128");
                IPPrefix h("fe80::6a05:caff/64");
                IPPrefix m("0.0.0.255");
                IPPrefix j("::FFFF");
                IPPrefix y("fe80::6a05:caff:fe0f:dead/36");
                IPPrefix z("fe80::6a05:caff:fe0f:dead/56");
                IPAddress aa("192.168.50.1");

                printf("a: %s\n", a.c_str());
                printf("b: %s\n", b.c_str());
                printf("c: %s\n", c.c_str());
                printf("d: %s\n", d.c_str());
                printf("e: %s\n", e.c_str());
                printf("f: %s\n", f.c_str());
                printf("g: %s\n", g.c_str());
                printf("h: %s\n", h.c_str());

                printf("\nIPPrefix::operator==()\n");
                printf("(%s == %s) == %s\n", a.c_str(), b.c_str(), (a == b) ? "true" : "false");
                printf("(%s == %s) == %s\n", b.c_str(), c.c_str(), (b == c) ? "true" : "false");
                printf("(%s == %s) == %s\n", e.c_str(), f.c_str(), (e == f) ? "true" : "false");
                printf("(%s == %s) == %s\n", f.c_str(), g.c_str(), (f == g) ? "true" : "false");

                printf("\nIPPrefix::operator>()\n");
                printf("(%s > %s) == %s\n", a.c_str(), b.c_str(), (a > b) ? "true" : "false");
                printf("(%s > %s) == %s\n", b.c_str(), c.c_str(), (b > c) ? "true" : "false");
                printf("(%s > %s) == %s\n", e.c_str(), f.c_str(), (e > f) ? "true" : "false");
                printf("(%s > %s) == %s\n", f.c_str(), g.c_str(), (f > g) ? "true" : "false");

                printf("\nIPPrefix::operator<()\n");
                printf("(%s < %s) == %s\n", a.c_str(), b.c_str(), (a < b) ? "true" : "false");
                printf("(%s < %s) == %s\n", b.c_str(), c.c_str(), (b < c) ? "true" : "false");
                printf("(%s < %s) == %s\n", e.c_str(), f.c_str(), (e < f) ? "true" : "false");
                printf("(%s < %s) == %s\n", f.c_str(), g.c_str(), (f < g) ? "true" : "false");

                printf("\nIPPrefix::operator>=()\n");
                printf("(%s >= %s) == %s\n", a.c_str(), b.c_str(), (a >= b) ? "true" : "false");
                printf("(%s >= %s) == %s\n", b.c_str(), c.c_str(), (b >= c) ? "true" : "false");
                printf("(%s >= %s) == %s\n", e.c_str(), f.c_str(), (e >= f) ? "true" : "false");
                printf("(%s >= %s) == %s\n", f.c_str(), g.c_str(), (f >= g) ? "true" : "false");

                printf("\nIPPrefix::operator<=()\n");
                printf("(%s <= %s) == %s\n", a.c_str(), b.c_str(), (a <= b) ? "true" : "false");
                printf("(%s <= %s) == %s\n", b.c_str(), c.c_str(), (b <= c) ? "true" : "false");
                printf("(%s <= %s) == %s\n", e.c_str(), f.c_str(), (e <= f) ? "true" : "false");
                printf("(%s <= %s) == %s\n", f.c_str(), g.c_str(), (f <= g) ? "true" : "false");

                printf("\nIPPrefix::contains()\n");
                printf("(%s contains %s) == %s\n", a.c_str(), b.c_str(), (a.contains(b)) ? "true" : "false");
                printf("(%s contains %s) == %s\n", b.c_str(), a.c_str(), (b.contains(a)) ? "true" : "false");
                printf("(%s contains %s) == %s\n", b.c_str(), c.c_str(), (b.contains(c)) ? "true" : "false");
                printf("(%s contains %s) == %s\n", g.c_str(), h.c_str(), (g.contains(h)) ? "true" : "false");
                printf("(%s contains %s) == %s\n", h.c_str(), g.c_str(), (h.contains(g)) ? "true" : "false");
                printf("(%s contains %s) == %s\n", b.c_str(), aa.c_str(), (b.contains(aa)) ? "true" : "false");

                printf("\nIPPrefix::operator>>=()\n");
                printf("(%s >>= %s) == %s\n", a.c_str(), b.c_str(), (a >>= b) ? "true" : "false");
                printf("(%s >>= %s) == %s\n", b.c_str(), a.c_str(), (b >>= a) ? "true" : "false");
                printf("(%s >>= %s) == %s\n", b.c_str(), c.c_str(), (b >>= c) ? "true" : "false");
                printf("(%s >>= %s) == %s\n", g.c_str(), h.c_str(), (g >>= h) ? "true" : "false");
                printf("(%s >>= %s) == %s\n", h.c_str(), g.c_str(), (h >>= g) ? "true" : "false");
                printf("(%s >>= %s) == %s\n", b.c_str(), aa.c_str(), (b >>= aa) ? "true" : "false");

                printf("\nIPPrefix::operator>>()\n");
                printf("(%s >> %s) == %s\n", a.c_str(), b.c_str(), (a >> b) ? "true" : "false");
                printf("(%s >> %s) == %s\n", b.c_str(), a.c_str(), (b >> a) ? "true" : "false");
                printf("(%s >> %s) == %s\n", b.c_str(), c.c_str(), (b >> c) ? "true" : "false");
                printf("(%s >> %s) == %s\n", g.c_str(), h.c_str(), (g >> h) ? "true" : "false");
                printf("(%s >> %s) == %s\n", h.c_str(), g.c_str(), (h >> g) ? "true" : "false");
                printf("(%s >> %s) == %s\n", b.c_str(), aa.c_str(), (b >> aa) ? "true" : "false");

                printf("\nIPPrefix::operator<<=()\n");
                printf("(%s <<= %s) == %s\n", a.c_str(), b.c_str(), (a <<= b) ? "true" : "false");
                printf("(%s <<= %s) == %s\n", b.c_str(), a.c_str(), (b <<= a) ? "true" : "false");
                printf("(%s <<= %s) == %s\n", b.c_str(), c.c_str(), (b <<= c) ? "true" : "false");
                printf("(%s <<= %s) == %s\n", g.c_str(), h.c_str(), (g <<= h) ? "true" : "false");
                printf("(%s <<= %s) == %s\n", h.c_str(), g.c_str(), (h <<= g) ? "true" : "false");
                printf("(%s <<= %s) == %s\n", b.c_str(), aa.c_str(), (b <<= aa) ? "true" : "false");

                printf("\nIPPrefix::operator<<()\n");
                printf("(%s << %s) == %s\n", a.c_str(), b.c_str(), (a << b) ? "true" : "false");
                printf("(%s << %s) == %s\n", b.c_str(), a.c_str(), (b << a) ? "true" : "false");
                printf("(%s << %s) == %s\n", b.c_str(), c.c_str(), (b << c) ? "true" : "false");
                printf("(%s << %s) == %s\n", g.c_str(), h.c_str(), (g << h) ? "true" : "false");
                printf("(%s << %s) == %s\n", h.c_str(), g.c_str(), (h << g) ? "true" : "false");
                printf("(%s << %s) == %s\n", b.c_str(), aa.c_str(), (b << aa) ? "true" : "false");

                printf("\nIPPrefix::getU32()\n");
                printf("%s => %u\n", a.c_str(), a.getU32());
                printf("%s => %u\n", b.c_str(), b.getU32());
                printf("%s => %u\n", e.c_str(), e.getU32());
                printf("%s => %u\n", h.c_str(), h.getU32());

                printf("\nIPPrefix::getHash()\n");
                printf("%s => %u\n", a.c_str(), a.getHash());
                printf("%s => %u\n", b.c_str(), b.getHash());
                printf("%s => %u\n", e.c_str(), e.getHash());
                printf("%s => %u\n", h.c_str(), h.getHash());

                printf("\nIPPrefix::getNetmask()\n");
                printf("%s => %s\n", a.c_str(), a.getNetmask().c_str());
                printf("%s => %s\n", b.c_str(), b.getNetmask().c_str());
                printf("%s => %s\n", d.c_str(), d.getNetmask().c_str());
                printf("%s => %s\n", e.c_str(), e.getNetmask().c_str());
                printf("%s => %s\n", h.c_str(), h.getNetmask().c_str());

                printf("\nIPPrefix::getInverseMask()\n");
                printf("%s => %s\n", a.c_str(), a.getInverseMask().c_str());
                printf("%s => %s\n", b.c_str(), b.getInverseMask().c_str());
                printf("%s => %s\n", d.c_str(), d.getInverseMask().c_str());
                printf("%s => %s\n", e.c_str(), e.getInverseMask().c_str());
                printf("%s => %s\n", h.c_str(), h.getInverseMask().c_str());

                printf("\nIPPrefix::getIPAddresses()\n");
                a = IPPrefix("192.168.50.0/29");
                auto addresses = a.getIPAddresses(true);

                for (auto ip = addresses.begin(); ip != addresses.end(); ++ip) {
                        printf("%s => %s\n", a.c_str(), ip->c_str());
                }
                
        } catch (AddressException &e) {
                printf("AddressException: %s\n", e.what());

                exit(1);
        }

        printf("\n");
}

void testVariant(void) {
        using namespace sella::variant;

        printf("---------------------------\n");
        printf("- sella/variant/Variant.h -\n");
        printf("---------------------------\n");

        try {
                Variant vvv(std::make_shared<sv::Null>(), 1);
                printf("Variant:null => null: %s (%s)\n", vvv.c_str(), vvv.getTypeName());

                Variant n;
                Variant a(true);
                Variant b; b = false;
                Variant c; c = 1.23;
                Variant c2(1.23);
                Variant d("abc");
                Variant d2; d2 = "bogus";
                Variant e = -100;
                Variant e2 = e;
                Variant f = 100;
                Variant v("[ 100, [ 200, \"str\" ], 300 ]", Variant::TypeAuto);
                Variant o("{ \"foo\": \"bar\", \"100\": 200 }", Variant::TypeAuto);
                Variant vv("[{ \"a\": 100, \"b\": { \"c\": [100,200] } }, 50.1,[ 200, \"aa\\\"bb\", [0,\f\r\n1, [ 2, \t3]]] ]", Variant::TypeAuto);
                Variant u(sella::util::UUID("35898CBD-BAC6-468b-a0cb-efa700954925"));
                Variant m;

                printf("Variant:cast<const std::string&> => null: %s (%s)\n", static_cast<const std::string &>(n).c_str(), n.getTypeName());
                printf("Variant:(const char*) => true: %s (%s)\n", (const char*) a, a.getTypeName());
                printf("Variant:c_str() => false: %s (%s)\n", b.c_str(), b.getTypeName());
                printf("Variant:operator+ => 2.25: %s (%s)\n", (++c + 0.02).c_str(), c.getTypeName());
                printf("Variant:contains() => true: %s\n", (d.contains("abc")) ? "true" : "false");
                printf("Variant:contains() => false: %s\n", (d.contains("zozo")) ? "true" : "false");
                printf("Variant:operator+ => abcabc: %s (%s)\n", (d + d).c_str(), d.getTypeName());
                printf("Variant:operator+ => abcxxx: %s (%s)\n", (d + "xxx").c_str(), d.getTypeName());
                printf("Variant:operator+ => abc100: %s (%s)\n", (d + 100).c_str(), d.getTypeName());
                printf("Variant:cast<int64_t> => -100: %" PRId64 " (%s)\n", e.cast<int64_t>(), e.getTypeName());
                printf("Variant:contains() => true: %s\n", (e.contains(-100)) ? "true" : "false");
                printf("Variant:contains() => false: %s\n", (e.contains(919)) ? "true" : "false");
                printf("Variant:cast<uint64_t> => 100: %" PRIu64 " (%s)\n", f.cast<uint64_t>(), f.getTypeName());
                printf("Variant:operator+ => 200: %" PRId64 " (%s)\n", static_cast<int64_t>(f + f), f.getTypeName());
                printf("Variant:operator+,/%%^ => 25: %" PRId64 " (%s)\n", static_cast<int64_t>((400 + f) / 100 % 10 ^ 2), f.getTypeName());
                printf("Variant:(int64_t) => 100: %" PRId64 " (%s)\n", (int64_t) f, f.getTypeName());
                printf("Variant:operator- => 99.0: %.1f (%s)\n", static_cast<double>(f - true), f.getTypeName());
                printf("Variant:c_str() => [ 100, [ 200, \"str\" ], 300 ]: %s (%s)\n", v.c_str(), v.getTypeName());
                printf("Variant:c_str() => { \"foo\": \"bar\", \"100\": 200 }: %s (%s)\n", o.c_str(), o.getTypeName());
                printf("Variant:c_str() => [ { messy } ]: %s (%s)\n", vv.c_str(), vv.getTypeName());
                printf("Variant:(const char*) => 35898cbd-bac6-468b-a0cb-efa700954925: %s (%s)\n", (const char*) u, u.getTypeName());
                u.shrink_to_fit();
                printf("Variant:contains() => true: %s\n", (u.contains(u)) ? "true" : "false");
                printf("Variant:contains() => false: %s\n", (u.contains("bogus")) ? "true" : "false");
                f = "150";
                f.setType(Variant::TypeDouble);
                printf("Variant:c_str() => 150.0: %s (%s)\n", f.c_str(), f.getTypeName());
                f.setType(Variant::TypeUnsigned);
                std::cout << "Variant:operator<< => 151: " << f << " (" << f.getTypeName() << ")" << std::endl;

                vv.clear();
                printf("Variant:clear() => null: %s (%s)\n", vv.c_str(), vv.getTypeName());

                printf("Variant:operator== => true: %s\n", (c == c2) ? "true" : "false");
                printf("Variant:operator== => true: %s\n", (e == e2) ? "true" : "false");
                printf("Variant:operator!= => true: %s\n", (d != d2) ? "true" : "false");
                printf("Variant:operator== => false: %s\n", (b == c) ? "true" : "false");
                printf("Variant:operator!= => true: %s\n", (b != c) ? "true" : "false");
                printf("Variant:operator! => false: %s\n", (!c) ? "true" : "false");
                printf("Variant:operator>= => false: %s\n", (b >= a) ? "true" : "false");
                printf("Variant:operator<= => false: %s\n", (c <= c2) ? "true" : "false");
                printf("Variant:operator>= => true: %s\n", (b >= "false") ? "true" : "false");

                m["foo"] = 100;
                m["bar"] = "zoo";
                m["nullptr"].clear();

                printf("Variant:c_str() => { \"bar\": \"zoo\", \"foo\": 100, \"nullptr\": null }: %s\n", m.c_str());
                printf("Variant:operator[] => 100: %s\n", m["foo"].c_str());
                printf("Variant:contains() => true: %s\n", (m.contains("foo")) ? "true" : "false");
                printf("Variant:contains() => false: %s\n", (m.contains("zzz")) ? "true" : "false");

                v.clear();
                v[0] = 100;
                v[2] = 300;
                v[3] = 350;
                v.erase(3);
                v.push_back(400);
                v.erase("400"); /* pure virtual? */
                v += 500;

                for (Variant::iterator it = v.begin(); it != v.end(); ++it) {
                        printf("iterator => key: %s, value: %s\n", it.key().c_str(), it->c_str());
                }

                printf("*Variant:c_str() => [ 100, null, 300, 500 ]: %s\n", v.c_str());
                printf("Variant[2]:c_str() => 300: %s\n", v[2].c_str());
                printf("Variant:contains() => true: %s\n", (v.contains(100)) ? "true" : "false");
                printf("Variant:contains() => false: %s\n", (v.contains(919)) ? "true" : "false");

                c.clear();
                printf("Variant:empty() => true: %s\n", (c.empty()) ? "true" : "false");
                printf("Variant:empty() => false: %s\n", (m.empty()) ? "true" : "false");

                printf("really have: %s\n", m.c_str());
                for (auto it = m.begin(); it != m.end(); ++it) {
                        printf("key: %s, value: %s\n", it.key().c_str(), it->c_str());
                }

                m.clear();
                m["test"] = 100; m.erase("test");
                printf("Variant:empty() => true: %s\n", (m.empty()) ? "true" : "false");

                printf("really have: %s\n", f.c_str());
                for (auto it = f.begin(); it != f.end(); ++it) {
                        printf("key: %s, value: %s\n", it.key().c_str(), it->c_str());
                }

                f = 100;
                printf("Variant:c_str() => 101: %" PRIu64 " (%s)\n", (int64_t) ++f, f.getTypeName());

                f = 65535;
                printf("Variant:>> => 3: %" PRIu64 " (%s)\n", (int64_t) (f >> 14), f.getTypeName());

                printf("Variant:&& => true: %s\n", (m && f && true) ? "true" : "false");

                f = (void*) NULL;
                printf("Variant:NULL => null: %s (%s)\n", f.c_str(), f.getTypeName());

                {
                        Variant data;
                        Variant d2;
                        Variant o;
//                      v.clear();
                        //v[0] = 0;
                        //data["x"] = v;

                        o[0] = 5;

                        printf("data: %s\n", data.c_str());
//                      printf("o: %s\n", o.c_str());

//                      data["x"] += o;
//                      printf("data2: %s\n", data.c_str());

                        printf("\n+= first\n");
                        data = o;
                        printf("data3: %s\n", data.c_str());

//                      o.clear();
//                      o[0] = 6;

                        printf("\n+= second\n");
                        data += o;
                        printf("data4: %s\n", data.c_str());

                        data.clear();
                        void *x = (void*) new int8_t(4);
                        data["foo"] = *((int8_t*) x);

                        printf("data: %s\n", data.c_str());
                }

                b.clear();

#if 0 /* Does not work correctly. Need std::nullptr to make this work. */
                printf("Variant:operator== NULL => true: %s\n", (b == NULL) ? "true" : "false");
#endif
                printf("Variant:isNull => true: %s\n", (b.isNull()) ? "true" : "false");

                Variant bin("0x01AABBCCEEFF");

                printf("Variant:c_str() => binary: %s (%s)\n", bin.c_str(), bin.getTypeName());

                Variant str2("{ \"x\": \"35898CBD-BAC6-468b-a0cb-efa700954925\" }", Variant::TypeAuto);

                str2["x"] = u;

                printf("str2: %s\n", str2.c_str());

                Variant ip("192.168.0.2");
                printf("ip: %s (%s)\n", ip.c_str(), ip.getTypeName());

                Variant ip2("2601:1:af00:28f:6a05:caff:fe0f:c55f");
                printf("ip2: %s (%s)\n", ip2.c_str(), ip2.getTypeName());

                Variant prefix("2601:1:af00:28f:6a05:caff:fe0f:c55f/64");
                printf("prefix: %s (%s)\n", prefix.c_str(), prefix.getTypeName());

                Variant prefix2("192.168.0.2/24");
                printf("prefix2: %s (%s)\n", prefix2.c_str(), prefix2.getTypeName());
        } catch (su::UUIDException &e) {
                printf("UUIDException: %s\n", e.what());

                exit(1);
        } catch (TypeCastException &e) {
                printf("TypeCastException: %s\n", e.what());

                exit(1);
        } catch (sella::Exception &e) {
                printf("sella::Exception: %s\n", e.what());

                exit(1);
        } catch (...) {
                printf("Unknown Exception\n");

                exit(1);
        }

        printf("\n");
}

namespace sella {
        namespace test {
                BUILD_EXCEPTION(TestException);
        }
}

void testException(void) {
        printf("---------------------\n");
        printf("- sella/Exception.h -\n");
        printf("---------------------\n");

        SET_FORMAT(MixedLogFormat());

        try {
                THROW(sella::test::TestException, "TestException test!");
        } catch (sella::test::TestException &e) {
                ERROR(e);
                WARNING(e);

                /* SWIG PERL functions. */
                INFO("code: %d, what: %s", e.getCode(), e.what());

                try {
                        RETHROW2_CODE(sella::test::TestException, 200, e, "Added rethrow text.");
                } catch (sella::test::TestException &e) {
                        ERROR(e);
                }
        } 

        try {
                std::string x = "bobert";
                std::string y = "janert";
                THROW(sella::test::TestException, "TestException with Bob %s and Jane %s", x.c_str(), y.c_str());
        } catch (sella::test::TestException &e) {
                INFO("ExceptionName: %s", e.getName().c_str());
                ERROR(e);
        } 

        SET_FORMAT(SimpleLogFormat());

        try {
                printf("\n");
                INFO("throwing...");
                THROW(sella::Exception, "Important message text!");
        } catch (sella::Exception &e) {
                INFO("caught...");
                try {
                        RETHROW(sella::Exception, e);
                } catch (sella::Exception &e) {
                        WARNING(e);
                }       
        }

        try {
                printf("\n");
                INFO("throwing with code...");
                THROW_CODE(sella::Exception, 100, "Important message text!");
        } catch (sella::Exception &e) {
                INFO("caught...");
                try {
                        RETHROW(sella::Exception, e);
                } catch (sella::Exception &e) {
                        INFO("found code: %d", e.getCode());
                        WARNING(e);
                }       
        }

        printf("\n");
}

class TestCallback : public sn::DNSCallback {
        virtual void success(const std::string &qname, const std::string &cname, int ttl, const std::vector<sn::IPAddress> &response) const throw () {
                if (cname.empty()) {
                        INFO("DNS::resolve[async/success]: %s [ttl: %d]", qname.c_str(), ttl);
                } else {
                        INFO("DNS::resolve[async/success]: %s <- %s [ttl: %d]", qname.c_str(), cname.c_str(), ttl);
                }

                for (auto r = response.begin(); r != response.end(); ++r) {
                        INFO("   - response: %s", r->c_str());
                }
        }

        virtual void failure(const std::string &qname, Error error) const throw () {
                INFO("DNS::resolve[async/failure](%s): %s => %s", qname.c_str(), getErrorName(error), getErrorDetail(error));
        }
};

void testDNS(void) {
        using namespace sella::net;

        printf("-------------------\n");
        printf("- sella/net/DNS.h -\n");
        printf("-------------------\n");

//      SET_TRACE(PACKAGE);
//      SET_TRACE(PACKAGE "-detail");

        try {
                if (1) { /* Sync */
                        INFO("[Sync]");
                        INFO("");

                        DNS dns({ std::string("216.136.9.22"), std::string("8.8.8.8") }, { std::string("digital-genesis.com"), std::string("google.com") });

                        auto ipv4a = dns.resolve("www.digital-genesis.com", DNS::IPv4Required);
                        INFO("DNS::resolve(www.digital-genesis.com, DNS::IPv4Required): %s", ipv4a.front().c_str());

                        auto ipv4b = dns.resolve("www.digital-genesis.com", DNS::IPv4Preferred);
                        INFO("DNS::resolve(www.digital-genesis.com, DNS::IPv4Preferred): %s", ipv4b.front().c_str());

                        auto ipv6a = dns.resolve("www.digital-genesis.com", DNS::IPv6Required);
                        INFO("DNS::resolve(www.digital-genesis.com, DNS::IPv6Required): %s", ipv6a.front().c_str());

                        auto ipv6b = dns.resolve("www.digital-genesis.com", DNS::IPv6Preferred);
                        INFO("DNS::resolve(www.digital-genesis.com, DNS::IPv6Preferred): %s", ipv6b.front().c_str());

                        try { /* Exception is expected since this not a real hostname. */
                                auto bogus = dns.resolve("bogus.digital-genesis.com", DNS::AnyProtocol);
                                INFO("DNS::resolve(bogus.digital-genesis.com, DNS::AnyProtocol): %s", bogus.front().c_str());
                        } catch (DNSException &e) {
                                INFO("DNS::resolve(bogus.digital-genesis.com, DNS::AnyProtocol): %s", e.what());
                        }
                }

                if (1) { /* Async single thread */
                        INFO("[Async]");
                        INFO("");

                        DNS dns({ std::string("216.136.9.22"), std::string("8.8.8.8") }, { std::string("digital-genesis.com"), std::string("google.com") });
                        TestCallback c1, c2, c3, c4, c5, c6;
                        std::vector<TestCallback> callbacks(10);

                        dns.setTimeout(1);
                        dns.setNoSearch(true);
                        dns.setAuthoritativeOnly(true);

                        dns.resolve(&callbacks[0], "www.google.com", DNS::IPv4Preferred);
                        dns.resolve(&callbacks[1], "bogus", DNS::IPv4Required);
                        dns.resolve(&callbacks[2], "www.digital-genesis.com", DNS::IPv4Required);
                        dns.resolve(&callbacks[3], "www.digital-genesis.com", DNS::IPv4Preferred);
                        dns.resolve(&callbacks[4], "www.digital-genesis.com", DNS::IPv6Required);
                        dns.resolve(&callbacks[5], "www.digital-genesis.com", DNS::IPv6Preferred);

                        while (dns.getActive() > 0) {
                                dns.receive(1);
                        }
                }

                if (1) { /* Async ThreadPool */
                        using namespace sella::util;

                        INFO("[Async with ThreadPool]");
                        INFO("");

                        ThreadPool pool(10);
                        DNS dns(&pool, { std::string("8.8.8.8") }, { std::string("digital-genesis.com") });
                        TestCallback c1, c2, c3, c4, c5, c6;
                        std::vector<TestCallback> callbacks(10);

                        dns.setTimeout(1);

                        dns.resolve(&callbacks[0], "www.google.com", DNS::IPv4Preferred);
                        dns.resolve(&callbacks[1], "bogus", DNS::IPv4Required);
                        dns.resolve(&callbacks[2], "www.digital-genesis.com", DNS::IPv4Required);
                        dns.resolve(&callbacks[3], "www.digital-genesis.com", DNS::IPv4Preferred);
                        dns.resolve(&callbacks[4], "www.digital-genesis.com", DNS::IPv6Required);
                        dns.resolve(&callbacks[5], "www.digital-genesis.com", DNS::IPv6Preferred);

                        INFO("Waiting for ThreadPool to complete all tasks.");
                        pool.wait();
                        INFO("ThreadPool has no remaining tasks");
                }
        } catch (DNSException &e) {
                WARNING(e);
        }

        printf("\n");
}

void example(int &s) {
#if 0
        sleep(seconds);
#else
        long i = 0; double res = 0;
        while (i < (s * 1000000000LL)) { i++; res += sqrt(i); }
#endif

        //INFO("task example(%d) - exiting", syscall(SYS_gettid));
}

void testThreadPool(void) {
        using namespace sella::util;

        printf("--------------------------\n");
        printf("- sella/util/ThreadPool.h -\n");
        printf("--------------------------\n");

        SET_TRACE(PACKAGE);
        SET_TRACE(PACKAGE "-detail");

        {
#if 1
                ThreadPool pool(8, 2, 2); /* Scaling ThreadPool */
#else
                ThreadPool pool(8); /* Simple non-scaling ThreadPool */
#endif
                Task::shared task;
                Task::callback function;

                INFO("Setting ThreadPool CPU Affinity");
                pool.addCPUAffinity({2,99}); /* CPU 99 unlikely to exist on system */

                INFO("Pausing ThreadPool");
                pool.pause();

                /* Priority based tasks */
                for (size_t i = 0; i < 15; i++) {
                        task = Task::shared_ptr();
                        function = std::bind(&example, 2);
                        task->setCallback(function);

                        pool.schedule(task, 10 * i);
                }

                /* Delay based task */
                task = Task::shared_ptr();
                function = std::bind(&example, 1);
                task->setCallback(function);

                pool.schedule(task, std::chrono::seconds(2), 64);

                /* Timer based task */
                task = Task::shared_ptr();
                function = std::bind(&example, 1);
                task->setCallback(function);

                pool.schedule(task, std::chrono::system_clock::now(), 32);

                pool.print();
                usleep(10000);

                /* Resume pool workers */
                INFO("Resuming ThreadPool");
                pool.resume();

                sleep(2);
                pool.clearCPUAffinity({1,2});

                INFO("Waiting for ThreadPool to complete all tasks.");
                pool.wait();
                INFO("ThreadPool has no remaining tasks");
        }

        printf("\n");
}

void testSocketPair(void) {
        using namespace sella::net;

        printf("--------------------------\n");
        printf("- sella/net/SocketPair.h -\n");
        printf("--------------------------\n");

        SET_TRACE(PACKAGE);
        SET_TRACE(PACKAGE "-detail");

        try {
                SocketPair pair;
                UnixSocket::shared first = pair.getFirst();
                UnixSocket::shared second = pair.getSecond();

                printf("Send: test\n");
                first->send("test");

                std::string data;
                if (second->recv(data) > 0) {
                        printf("Recv: %s\n", data.c_str());
                } else {
                        printf("Recv: <empty>\n");
                }
                
        } catch (SocketException &e) {
                ERROR(e);
        }

        printf("\n");
}

void testSocketTrigger(void) {
        using namespace sella::net;

        printf("-----------------------------\n");
        printf("- sella/net/SocketTrigger.h -\n");
        printf("-----------------------------\n");

        SET_TRACE(PACKAGE);
        SET_TRACE(PACKAGE "-detail");

        try {
                SocketTrigger trigger;

                printf("trigger::isSet(): %d\n", trigger.isSet());

                printf("trigger::set() [2x]\n");
                trigger.set();
                trigger.set();
                printf("trigger::isSet(): %d\n", trigger.isSet());
                
                printf("trigger::clear()\n");
                trigger.clear();
                printf("trigger::isSet(): %d\n", trigger.isSet());
        } catch (SocketException &e) {
                ERROR(e);
        }

        printf("\n");
}

void testPipe(void) {
        using namespace sella::net;

        printf("--------------------\n");
        printf("- sella/net/Pipe.h -\n");
        printf("--------------------\n");

        SET_TRACE(PACKAGE);
        SET_TRACE(PACKAGE "-detail");

        try {
                std::string buf;
                Pipe pipe;

                printf("Write: test\n");
                pipe.write("test");

                if (pipe.read(buf) > 0) {
                        printf("Read: %s\n", buf.c_str());
                } else {
                        printf("Read: <empty>\n");
                }
        } catch (SocketException &e) {
                ERROR(e);
        }

        printf("\n");
}

/*
** vim: noet ts=3 sw=3
*/

---