llhost_tut.cpp

Go to the documentation of this file.

#include <tut/tut.h>
#include "linden_common.h"
#include "lltut.h"
#include "llhost.h"

namespace tut
{
        struct host_data
        {
        };
        typedef test_group<host_data> host_test;
        typedef host_test::object host_object;
        tut::host_test host_testcase("llhost");


        template<> template<>
        void host_object::test<1>()
        {
                LLHost host;
                ensure("IP address is not NULL", (0 == host.getAddress()) && (0 == host.getPort()) && !host.isOk());
        }
        template<> template<>
        void host_object::test<2>()
        {
                U32 ip_addr = 0xc098017d;
                U32 port = 8080;
                LLHost host(ip_addr, port);
                ensure("IP address is invalid", ip_addr == host.getAddress());
                ensure("Port Number is invalid", port == host.getPort());
                ensure("IP address and port number both should be ok", host.isOk());
        }

        template<> template<>
        void host_object::test<3>()
        {
                const char* str = "192.168.1.1";
                U32 port = 8080;
                LLHost host(str, port);
                ensure("IP address could not be processed", (host.getAddress() == ip_string_to_u32(str)));
                ensure("Port Number is invalid", (port == host.getPort()));
        }

        template<> template<>
        void host_object::test<4>()
        {
                U32 ip = ip_string_to_u32("192.168.1.1");
                U32 port = 22;
                U64 ip_port = (((U64) ip) << 32) | port;
                LLHost host(ip_port);
                ensure("IP address is invalid", ip == host.getAddress());
                ensure("Port Number is invalid", port == host.getPort());
        }

        template<> template<>
        void host_object::test<5>()
        {
                std::string ip_port_string = "192.168.1.1:8080";
                U32 ip = ip_string_to_u32("192.168.1.1");
                U32 port = 8080;

                LLHost host(ip_port_string.c_str());
                ensure("IP address from IP:port is invalid", ip == host.getAddress());
                ensure("Port Number from from IP:port is invalid", port == host.getPort());
        }

        template<> template<>
        void host_object::test<6>()
        {
                U32 ip = 0xc098017d, port = 8080;
                LLHost host;
                host.set(ip,port);
                ensure("IP address is invalid", (ip == host.getAddress()));
                ensure("Port Number is invalid", (port == host.getPort()));
        }

        template<> template<>
        void host_object::test<7>()
        {
                const char* str = "192.168.1.1";
                U32 port = 8080, ip;
                LLHost host;
                host.set(str,port);
                ip = ip_string_to_u32(str);
                ensure("IP address is invalid", (ip == host.getAddress()));
                ensure("Port Number is invalid", (port == host.getPort()));
                
                str = "64.233.187.99";
                ip = ip_string_to_u32(str);
                host.setAddress(str);
                ensure("IP address is invalid", (ip == host.getAddress()));

                ip = 0xc098017b;
                host.setAddress(ip);
                ensure("IP address is invalid", (ip == host.getAddress()));
                // should still use the old port
                ensure("Port Number is invalid", (port == host.getPort()));

                port = 8084;
                host.setPort(port);
                ensure("Port Number is invalid", (port == host.getPort()));
                // should still use the old address
                ensure("IP address is invalid", (ip == host.getAddress()));
        }

        template<> template<>
        void host_object::test<8>()
        {
                char buffer[50];
                char buffer1[50];
                const char* str = "192.168.1.1";
                U32 port = 8080;
                LLHost host;
                host.set(str,port);
                host.getString(buffer, 50);     
                ensure("Function Failed", (0 == strcmp("192.168.1.1:8080", buffer)));

                host.getIPString(buffer1, 50);
                ensure("Function Failed", (0 == strcmp(str, buffer1)));

                std::string ip_string = host.getIPString();
                ensure("Function Failed", (0 == strcmp(str, buffer1)));

                std::string ip_string_port = host.getIPandPort();
                ensure("Function Failed", (0 == strcmp("192.168.1.1:8080", buffer)));
        }


//      getHostName()  and setHostByName
        template<> template<>
        void host_object::test<9>()
        {
                std::string hostStr = "google.com";             
                char buffer[50] = {0};
                LLHost host;
                host.setHostByName(hostStr.c_str());    
                host.getHostName(buffer, 50);
                // reverse DNS will likely result in appending of some
                // sub-domain to the main hostname. so look for
                // the main domain name and not do the exact compare
                ensure("getHostName failed", (NULL != strstr(buffer, hostStr.c_str())));
                
                LLString hostname = host.getHostName();
                ensure("getHostName failed", (NULL != strstr(hostname.c_str(), hostStr.c_str())));
        }

//      setHostByName for dotted IP
        template<> template<>
        void host_object::test<10>()
        {
                std::string hostStr = "64.233.167.99";          
                LLHost host;
                host.setHostByName(hostStr.c_str());    
                ensure("SetHostByName for dotted IP Address failed", host.getAddress() == ip_string_to_u32(hostStr.c_str()));
        }

        template<> template<>
        void host_object::test<11>()
        {
                LLHost host1(0xc098017d, 8080);
                LLHost host2 = host1;
                ensure("Both IP addresses are not same", (host1.getAddress() == host2.getAddress()));
                ensure("Both port numbers are not same", (host1.getPort() == host2.getPort()));
        }

        template<> template<>
        void host_object::test<12>()
        {
                LLHost host1("192.168.1.1", 8080);
                std::string str1 = "192.168.1.1:8080";
                std::ostringstream stream;
                stream << host1;
                ensure("Operator << failed", ( stream.str()== str1));

                // There is no istream >> llhost operator.
                //std::istringstream is(stream.str());
                //LLHost host2;
                //is >> host2;
                //ensure("Operator >> failed. Not compatible with <<", host1 == host2);
        }

        // operators ==, !=, <
        template<> template<>
        void host_object::test<13>()
        {
                U32 ip_addr = 0xc098017d;
                U32 port = 8080;
                LLHost host1(ip_addr, port);
                LLHost host2(ip_addr, port);
                ensure("operator== failed", host1 == host2);

                // change port
                host2.setPort(7070);
                ensure("operator!= failed", host1 != host2);

                // set port back to 8080 and change IP address now
                host2.setPort(8080);
                host2.setAddress(ip_addr+10);
                ensure("operator!= failed", host1 != host2);

                ensure("operator<  failed", host1 < host2);

                // set IP address back to same value and change port
                host2.setAddress(ip_addr);
                host2.setPort(host1.getPort() + 10);
                ensure("operator<  failed", host1 < host2);
        }
}

---