Second Life viewer sources 1.18.0.6

1 files changed, 237 insertions, 0 deletions

diff --git a/linden/indra/test/llhost_tut.cpp b/linden/indra/test/llhost_tut.cpp
new file mode 100644
index 0000000..01f3079
--- /dev/null
+++ b/linden/indra/test/llhost_tut.cpp
@@ -0,0 +1,237 @@
+/**
+ * @file llhost_tut.cpp
+ * @author Adroit
+ * @date 2007-02
+ * @brief llhost test cases.
+ *
+ * Copyright (c) 2007-2007, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+ 
+#include <tut/tut.h>
+#include "lltut.h"
+#include "linden_common.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);
+        }
+}