/*
 * This file was taken from RakNet 4.082 without any modifications.
 * Please see licenses/RakNet license.txt for the underlying license and related copyright.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Threading;
using System.Timers;
using System.IO;
using RakNet;

namespace InternalSwigTestApp
{
    class TestMain
    {
        static void Main(string[] args)
        {

           if(!File.Exists("RakNet.dll"))
           {
                Console.WriteLine("Error: The SWIG build of the DLL has not been copied to the executable directory.\nPress enter.");
                Console.Read();
                return;
           }
            
            Packet testPacket;
            int loopNumber;
            BitStream stringTestSendBitStream = new BitStream();
            BitStream rakStringTestSendBitStream = new BitStream();
            BitStream receiveBitStream = new BitStream();
            String holdingString;
            TimeSpan startTimeSpan;
            RakString rakStringTest = new RakString();

            RakPeerInterface testClient = RakPeer.GetInstance();
            testClient.Startup(1, new SocketDescriptor(60000, "127.0.0.1"), 1);

            RakPeerInterface testServer = RakPeer.GetInstance();
            testServer.Startup(1, new SocketDescriptor(60001, "127.0.0.1"), 1);
            testServer.SetMaximumIncomingConnections(1);

            Console.WriteLine("Press enter to start RakString send and receive loop using BitStream.\nBitStream read done into RakString");
            Console.WriteLine("Loop will run for 15 seconds");
            Console.ReadLine();

            testClient.Connect("127.0.0.1", 60001, "", 0);

            String sendString = "The test string";
            stringTestSendBitStream.Write((byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM);
            stringTestSendBitStream.Write(sendString);

            RakString testRakString = new RakString("Test RakString");
            rakStringTestSendBitStream.Write((byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM);
            rakStringTestSendBitStream.Write(testRakString);

            startTimeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1));
            loopNumber = 0;
                while (startTimeSpan.TotalSeconds + 15 > (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds)
                {
                    testPacket = testServer.Receive();
                    if (testPacket != null && testPacket.data[0] == (byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM)
                    {
                        receiveBitStream.Reset();
                        receiveBitStream.Write(testPacket.data, testPacket.length);
                        receiveBitStream.IgnoreBytes(1);
                        receiveBitStream.Read(rakStringTest);
                        Console.WriteLine("Loop number: " + loopNumber + "\nData: " + rakStringTest.C_String());
                    }
                    testServer.DeallocatePacket(testPacket);
                    loopNumber++;
                    System.Threading.Thread.Sleep(50);
                    testClient.Send(rakStringTestSendBitStream, PacketPriority.LOW_PRIORITY, PacketReliability.RELIABLE_ORDERED, (char)0, new AddressOrGUID(new SystemAddress("127.0.0.1", 60001)), false);
                }

                Console.WriteLine("Press enter to start String send and receive loop using BitStream.\nBitStream read done into String");
                Console.WriteLine("Loop will run for 15 seconds");
                Console.ReadLine();

                startTimeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1));
                loopNumber = 0;
                while (startTimeSpan.TotalSeconds + 15 > (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds)
                {
                    testPacket = testServer.Receive();
                    if (testPacket != null && testPacket.data[0] == (byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM)
                    {
                        receiveBitStream.Reset();
                        receiveBitStream.Write(testPacket.data, testPacket.length);
                        receiveBitStream.IgnoreBytes(1);
                        receiveBitStream.Read(out holdingString);
                        Console.WriteLine("Loop number: " + loopNumber + "\nData: " + holdingString);
                    }
                    testServer.DeallocatePacket(testPacket);
                    loopNumber++;
                    System.Threading.Thread.Sleep(50);
                    testClient.Send(stringTestSendBitStream, PacketPriority.LOW_PRIORITY, PacketReliability.RELIABLE_ORDERED, (char)0, new AddressOrGUID(new SystemAddress("127.0.0.1", 60001)), false);
                }
            //-----------------------------Above is the same as the public tests, below the internal tests are ran.
            /*Member variables are also tested to assure working typemaps
             * Also variables use functions as well, they are not direct access
             * act like it. Test write and read on these items, especially arrays.
             * Most tests in this section are simple running functions with no verification.
             * 
             * 
            */

            RakString workingRakStringCopy;//This is needed for temp RakString Instances in the main function so dispose can be called

            //RakNetStatistics
            Console.WriteLine("RakNetStatistics");
            string rakNetStatisticsTestString;
            RakNetStatistics testRakNetStatistics = new RakNetStatistics();
            testRakNetStatistics.bytesInSendBuffer[0] = 22.44;
            testRakNetStatistics.BPSLimitByCongestionControl = 9;
            testRakNetStatistics.BPSLimitByOutgoingBandwidthLimit = 9;
            testRakNetStatistics.connectionStartTime = 9;
            testRakNetStatistics.isLimitedByCongestionControl = false;
            testRakNetStatistics.isLimitedByOutgoingBandwidthLimit = true;
            testRakNetStatistics.messageInSendBuffer[0] = 112;
            testRakNetStatistics.messagesInResendBuffer = 9;
            testRakNetStatistics.packetlossLastSecond = 4.3f;
            testRakNetStatistics.packetlossTotal = 9.9f;
            testRakNetStatistics.runningTotal[0] = 121;
            testRakNetStatistics.valueOverLastSecond[0] = 112;

            Console.WriteLine(testRakNetStatistics.bytesInSendBuffer[0]);
            Console.WriteLine(testRakNetStatistics.BPSLimitByCongestionControl);
            Console.WriteLine(testRakNetStatistics.BPSLimitByOutgoingBandwidthLimit);
            Console.WriteLine(testRakNetStatistics.connectionStartTime);
            Console.WriteLine(testRakNetStatistics.isLimitedByCongestionControl);
            Console.WriteLine(testRakNetStatistics.isLimitedByOutgoingBandwidthLimit);
            Console.WriteLine(testRakNetStatistics.messageInSendBuffer[0]);
            Console.WriteLine(testRakNetStatistics.messagesInResendBuffer);
            Console.WriteLine(testRakNetStatistics.packetlossLastSecond);
            Console.WriteLine(testRakNetStatistics.packetlossTotal);
            Console.WriteLine(testRakNetStatistics.runningTotal[0]);
            Console.WriteLine(testRakNetStatistics.valueOverLastSecond[0]);

            RakNet.RakNet.StatisticsToString(testRakNetStatistics, out rakNetStatisticsTestString, 1);
            Console.WriteLine(rakNetStatisticsTestString);

            //SystemAddress
            Console.WriteLine("SystemAddress");
            SystemAddress testSystemAddress = new SystemAddress("127.0.0.1", 60001);

            //RakNetGUID
            RakNetGUID testRakNetGUID = testClient.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);

            Console.WriteLine(testRakNetGUID);

            //AddressOrGUID
            Console.WriteLine("AddressOrGUID");
            AddressOrGUID testAddressOrGUIDAddress = new AddressOrGUID(testSystemAddress);

            Console.WriteLine(testAddressOrGUIDAddress.systemAddress);

            AddressOrGUID testAddressOrGUIDRakNetGUID = new AddressOrGUID(testRakNetGUID);

            Console.WriteLine(testAddressOrGUIDRakNetGUID.rakNetGuid);

            //BitStream
            Console.WriteLine("BitStream");
            BitStream testBitStream1 = new BitStream();
            BitStream testBitStream2 = new BitStream();
            byte[] testBuffer = new byte[999];
            byte[] writeArray = new byte[99];
            Packet bitStreamTestPacket = null;

            testBitStream1.Write((byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM);
            testBitStream1.ResetWritePointer();
            testBitStream1.Write((byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM);

            writeArray[0] = (byte)127;
            testBitStream1.Write("xy");
            testBitStream1.WriteCompressed("xy");
            testBitStream1.WriteFloat16(23.5f, 0, 100);
            testBitStream1.WriteBits(writeArray, 7);
            testBitStream1.WriteAlignedBytesSafe(writeArray, 1, 1);
            testBitStream1.WriteAlignedBytes(writeArray, 1);
            testBitStream1.Write0();
            testBitStream1.Write1();
            int intForSerialization = 99;
            testBitStream1.Serialize(true, ref intForSerialization);

            testClient.Send(testBitStream1, PacketPriority.HIGH_PRIORITY, PacketReliability.RELIABLE_ORDERED, (char)0, new AddressOrGUID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS), true);

            while (bitStreamTestPacket == null || bitStreamTestPacket.data[0] != (byte)DefaultMessageIDTypes.ID_USER_PACKET_ENUM)
            {
                if (bitStreamTestPacket != null)
                {
                    testServer.DeallocatePacket(bitStreamTestPacket);
                }
                bitStreamTestPacket = testServer.Receive();
                testClient.Send(testBitStream1, PacketPriority.HIGH_PRIORITY, PacketReliability.RELIABLE_ORDERED, (char)0, new AddressOrGUID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS), true);
            }

            testBitStream2.Reset();
            testBitStream2 = new BitStream(bitStreamTestPacket.data, bitStreamTestPacket.length, true);

            testBitStream2.IgnoreBytes(1);
            testBitStream2.ResetReadPointer();
            testBitStream2.IgnoreBits(8);
            testBitStream2.ResetReadPointer();
            testBitStream2.ReadBits(testBuffer, 8);
            Console.WriteLine(testBuffer[0]);
            Console.WriteLine(DefaultMessageIDTypes.ID_USER_PACKET_ENUM);
            testBitStream2.ResetReadPointer();
            testBitStream2.ReadAlignedVar8(testBuffer);
            Console.WriteLine(testBuffer[0]);
            testBitStream2.ResetReadPointer();
            testBitStream2.ReadAlignedVar16(testBuffer);
            Console.WriteLine(testBuffer[1]);
            testBitStream2.ResetReadPointer();
            testBitStream2.ReadAlignedVar32(testBuffer);
            Console.WriteLine(testBuffer[1]);
            testBitStream2.ResetReadPointer();
            testBitStream2.IgnoreBits(8);

            Console.WriteLine("testBitStream1 hex and bits");
            testBitStream1.PrintHex();
            Console.WriteLine("\n");
            testBitStream1.PrintBits();
            Console.WriteLine("\ntestBitStream1 hex and bits");

            Console.WriteLine("testBitStream2 hex and bits end");
            testBitStream2.PrintHex();
            Console.WriteLine("\n");
            testBitStream2.PrintBits();
            Console.WriteLine("\ntestBitStream2 hex and bits end");

            String testString;
            Console.WriteLine("testBitStream2 hex and bits string output");
            testBitStream2.PrintHex(out testString);
            Console.WriteLine(testString + "\n");
            testBitStream2.PrintBits(out testString);
            Console.WriteLine(testString);
            Console.WriteLine("testBitStream2 hex and bits string output end");

            testBitStream2.Read(out testString);
            Console.WriteLine(testString);

            Console.WriteLine(testBitStream2.ReadCompressed(out testString));
            Console.WriteLine(testString);
            testBitStream2.WriteCompressedDelta("xy", "yz");
            testBitStream2.WriteCompressedDelta("xy", "xy");
            Console.WriteLine(testBitStream2.ReadCompressedDelta(out testString));
            Console.WriteLine(testString);
            Console.WriteLine(testBitStream2.ReadCompressedDelta(out testString));
            Console.WriteLine(testString);
            testBitStream2.WriteDelta("xy", "yz");
            testBitStream2.WriteDelta("xy", "xy");
            Console.WriteLine(testBitStream2.ReadDelta(out testString));
            Console.WriteLine(testString);
            Console.WriteLine(testBitStream2.ReadDelta(out testString));
            Console.WriteLine(testString);

            float testFloat;
            testBitStream2.ReadFloat16(out testFloat, 0, 100);
            Console.WriteLine(testFloat);
            testBitStream2.ReadBits(testBuffer, 7);
            Console.WriteLine(testBuffer[0]);
            testBitStream2.ReadAlignedBytesSafe(testBuffer, 1, 1);
            Console.WriteLine(testBuffer[0]);
            testBitStream2.ReadAlignedBytes(testBuffer, 1);
            Console.WriteLine(testBuffer[0]);
            Console.WriteLine(testBitStream2.ReadBit());
            Console.WriteLine(testBitStream2.ReadBit());
            int intForSerialization2 = 0;
            testBitStream2.Serialize(false, ref intForSerialization2);
            Console.WriteLine(intForSerialization2);

            testBitStream2.PadWithZeroToByteLength(99);
            testBitStream2.PrintBits();
            testBitStream2.SetData(testBuffer);
            Console.WriteLine("setbuff");
            testBitStream2.PrintBits();

            Console.WriteLine(testBitStream2.GetNumberOfBitsAllocated());

            //ByteQueue
            Console.WriteLine("ByteQueue");
            ByteQueue testByteQueue = new ByteQueue();
            testByteQueue.WriteBytes(testBuffer, (uint)testBuffer.Length, "", 0);
            testByteQueue.DecrementReadOffset(1);
            Console.WriteLine(testByteQueue.GetBytesWritten());
            testByteQueue.IncrementReadOffset(1);
            uint testUint;
            byte[] returnArray = testByteQueue.PeekContiguousBytes(out testUint);
            testByteQueue.Print();
            testByteQueue.ReadBytes(returnArray, (uint)returnArray.Length, true);
            testByteQueue.Clear("", 0);

            testBitStream2.AddBitsAndReallocate(99);
            testBitStream2.AlignReadToByteBoundary();
            testBitStream2.AlignWriteToByteBoundary();
            testBitStream2.EndianSwapBytes(5, 5);
            returnArray = testBitStream2.GetData();
            Console.WriteLine(testBitStream2.GetNumberOfBitsAllocated());
            Console.WriteLine(testBitStream2.GetNumberOfBitsUsed());
            Console.WriteLine(testBitStream2.GetNumberOfBytesUsed());
            Console.WriteLine(testBitStream2.GetNumberOfUnreadBits());
            Console.WriteLine(testBitStream2.GetReadOffset());
            Console.WriteLine(testBitStream2.GetWriteOffset());
            testBitStream2.SetData(returnArray);
            testBitStream2.SetNumberOfBitsAllocated(testBitStream2.GetNumberOfBitsAllocated());
            testBitStream2.SetReadOffset(3);
            testBitStream2.SetWriteOffset(3);
            testBitStream2.WriteBits(returnArray, (uint)returnArray.Length);

            //Cell, Table, Row
            Console.WriteLine("Cell, Table, Row");
            Cell testCell = new Cell();
            Byte[] tableTestByteArray = new byte[1];
            tableTestByteArray[0] = (byte)'t';
            int outInt;
            double outDouble;

            testCell.Set("test1232");
            testCell.Get(out testString);
            Console.WriteLine(testString);
            Console.WriteLine((int)testCell.EstimateColumnType());
            testCell.CopyData(testCell);
            testCell.Set(12.5d);
            testCell.Get(out outDouble);
            Console.WriteLine(outDouble);
            testCell.Set((uint)1);
            testCell.Set((int)1);
            testCell.Get(out outInt);
            Console.WriteLine(outInt);
            testCell.Set(tableTestByteArray, tableTestByteArray.Length);
            testCell.Get(tableTestByteArray, out outInt);
            Console.WriteLine(testCell.i);
            Console.WriteLine(testCell.isEmpty);

            Table testTable = new Table();
            testTable.Clear();
            testTable.AddColumn("testNumeric", Table.ColumnType.NUMERIC);
            testTable.AddColumn("testString", Table.ColumnType.STRING);
            testTable.AddColumn("testBinary", Table.ColumnType.BINARY);
            testTable.AddRow(0, new RakNetListCell());
            testTable.AddRow(1, new RakNetListCell());
            testTable.AddRow(2);
            testTable.AddRow(3);
            testTable.AddRow(4);
            testTable.AddRow(5);

            Console.WriteLine(testTable.ColumnIndex("testNumeric"));
            Console.WriteLine(testTable.ColumnName(0));
            Console.WriteLine(testTable.GetAvailableRowId());
            testTable.UpdateCell(0, 0, 9);
            testTable.UpdateCell(0, 1, "testCell");
            testTable.UpdateCell(0, 2, 1, tableTestByteArray);
            testTable.GetCellValueByIndex(0, 0, out outInt);
            Console.WriteLine(outInt);
            string outString;
            testTable.GetCellValueByIndex(0, 1, out outString);
            Console.WriteLine(outString);

            int outLen;
            testTable.GetCellValueByIndex(0, 2, out tableTestByteArray, out outLen);
            Console.WriteLine(tableTestByteArray[0]);
            Console.WriteLine(outLen);
            Console.WriteLine(testTable.GetColumnCount());
            RakNetListColumnDescriptor descriptorList = testTable.GetColumns();
            Console.WriteLine(testTable.GetColumnType(1) == Table.ColumnType.STRING);

            RakNetPageRow testPageRow = testTable.GetListHead();
            Console.WriteLine(testPageRow.isLeaf);
            Console.WriteLine(testPageRow.size);
            Row testRow = testTable.GetRowByID(0);
            Console.WriteLine(testRow.cells[0]);

            Console.WriteLine(testTable.GetRowCount());
            RakNetBPlusTreeRow bplus = testTable.GetRows();

            byte[] byteTest = new byte[999];
            testTable.PrintColumnHeaders(byteTest, 999, ';');

            testTable.PrintRow(byteTest, 999, ';', true, testRow);

            uint[] columnIds = new uint[1];
            columnIds[0] = 0;
            uint[] rowIds = new uint[1];
            rowIds[0] = 0;

            Table outTable = new Table();
            testTable.QueryTable(columnIds, 1, null, 0, rowIds, 1, outTable);
            Row[] testRows;
            testTable.SortTable(null, 0, out testRows);

            testTable.UpdateCellByIndex(0, 1, "5");
            testTable.PrintColumnHeaders(testBuffer, testBuffer.Length, ';');
            Console.WriteLine(System.Text.Encoding.GetEncoding(1251).GetString(testBuffer).Trim('\0'));

            testTable.PrintRow(testBuffer, testBuffer.Length, ';', true, testRow);
            Console.WriteLine(System.Text.Encoding.GetEncoding(1251).GetString(testBuffer).Trim('\0'));

            testTable.RemoveColumn(2);
            testTable.RemoveRow(2);
            testTable.RemoveRows(outTable);

            //ColumnDescriptor
            Console.WriteLine("ColumnDescriptor");
            ColumnDescriptor testColumnDescriptor = descriptorList.Pop();
            Console.WriteLine(testColumnDescriptor.columnName);
            Console.WriteLine(testColumnDescriptor.columnType);

            //ConnectionGraph2
            Console.WriteLine("ConnectionGraph2");
            ConnectionGraph2 testConnectionGraph2 = new ConnectionGraph2();

            testClient.AttachPlugin(testConnectionGraph2);
            testConnectionGraph2.ConnectionExists(testClient.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS), testServer.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS));
            SystemAddress[] outSystemAddressList = new SystemAddress[1];
            RakNetGUID[] outGuidList = new RakNetGUID[1];
            uint inOutUint = 1;
            testConnectionGraph2.GetConnectionListForRemoteSystem(testServer.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS), outSystemAddressList, outGuidList, ref inOutUint);

            //DirectoryDeltaTransfer
            Console.WriteLine("DirectoryDeltaTransfer");
            DirectoryDeltaTransfer testDirectoryDeltaTransfer = new DirectoryDeltaTransfer();
            testClient.AttachPlugin(testDirectoryDeltaTransfer);

            testDirectoryDeltaTransfer.AddUploadsFromSubdirectory("./");
            testDirectoryDeltaTransfer.ClearUploads();

            FileListTransferCBInterface testCallBack = new FileListTransferCB();
            FileListProgress testFileListProgress = new FileListProgress();

            Console.WriteLine(testDirectoryDeltaTransfer.GetNumberOfFilesForUpload());
            testDirectoryDeltaTransfer.SetApplicationDirectory("./");
           
            IncrementalReadInterface testIncrementalReadInterface = null;
            testDirectoryDeltaTransfer.SetDownloadRequestIncrementalReadInterface(testIncrementalReadInterface, 24);
            FileListTransfer testFileListTransfer = new FileListTransfer();
            testDirectoryDeltaTransfer.SetFileListTransferPlugin(testFileListTransfer);
            testDirectoryDeltaTransfer.SetUploadSendParameters(PacketPriority.HIGH_PRIORITY, (char)0);

            testDirectoryDeltaTransfer.DownloadFromSubdirectory("./", "./", false, testClient.GetSystemAddressFromIndex(0), testCallBack, PacketPriority.HIGH_PRIORITY, (char)0, testFileListProgress);

            //FileListNode
            Console.WriteLine("FileListNode");
            FileListNode testFileListNode = new FileListNode();

            //FileListNodeContext
            Console.WriteLine("FileListNodeContext");
            FileListNodeContext testFileListNodeContext = new FileListNodeContext();
            testFileListNodeContext.op = 0;
            testFileListNodeContext.fileId = 0;
            Console.WriteLine(testFileListNodeContext.op);
            Console.WriteLine(testFileListNodeContext.fileId);

            //FileList
            Console.WriteLine("FileList");
            FileList testFileList = FileList.GetInstance();

            testFileList.AddFile("./", "RakNet.dll", testFileListNodeContext);
            testFileList.AddFilesFromDirectory("./", "./", true, true, false, testFileListNodeContext);
            testFileList.FlagFilesAsReferences();
            FileList outFileList = FileList.GetInstance();
            testFileList.GetDeltaToCurrent(testFileList, outFileList, "", "./");
            Console.WriteLine(testFileList.fileList);
            testFileList.Clear();
            testFileList.DeleteFiles("./notexisting");
            testFileList.ListMissingOrChangedFiles("./", outFileList, false, false);
            testFileList.PopulateDataFromDisk("./", false, false, false);
            testFileList.WriteDataToDisk("./notexisting/");
            testFileList.Serialize(testBitStream2);
            testFileList.SetCallback(testFileListProgress);

            //FileListProgress
            Console.WriteLine("FileListProgress");
            testFileListProgress.OnAddFilesFromDirectoryStarted(testFileList, "./");
            testFileListProgress.OnDirectory(testFileList, "./", 9);
            testFileListProgress.OnFile(testFileList, "./", "nonexist", 22);
            testFileListProgress.OnFilePush("./Nonexist", 99, 99, 99, true, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);

            //FileListTransferCBInterface
            Console.WriteLine("FileListTransferCBInterface");
            FileListTransferCBInterface testFileListTransferCBInterface = new FileListTransferCBInterface();

            //FileListTransfer
            Console.WriteLine("FileListTransfer");
            FileListTransfer testFileListTransferServer = new FileListTransfer();

            testClient.AttachPlugin(testFileListTransfer);
            testServer.AttachPlugin(testFileListTransferServer);
            testFileListTransfer.GetCallback();
            testFileListTransfer.GetPendingFilesToAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testFileListTransfer.IsHandlerActive(99);
            testFileListTransfer.SetCallback(testFileListProgress);
            testFileListTransfer.SetupReceive(testFileListTransferCBInterface, false, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testFileListTransfer.Send(testFileList, testClient, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, 99, PacketPriority.LOW_PRIORITY, (char)0, testIncrementalReadInterface);
            testFileListTransfer.CancelReceive(0);
            testFileListTransfer.RemoveReceiver(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);

            //FileProgressStruct
            Console.WriteLine("FileProgressStruct");
            FileProgressStruct testFileProgressStruct = new FileProgressStruct();

            testFileProgressStruct.allocateIrIDataChunkAutomatically = true;
            testFileProgressStruct.dataChunkLength = 99;
            testFileProgressStruct.firstDataChunk = testBuffer;
            testFileProgressStruct.iriDataChunk = testBuffer;
            testFileProgressStruct.iriWriteOffset = 99;
            testFileProgressStruct.onFileStruct = new OnFileStruct();
            testFileProgressStruct.partCount = 99;
            testFileProgressStruct.partTotal = 99;

            Console.WriteLine(testFileProgressStruct.allocateIrIDataChunkAutomatically);
            Console.WriteLine(testFileProgressStruct.dataChunkLength);
            Console.WriteLine(testFileProgressStruct.firstDataChunk[0]);
            Console.WriteLine(testFileProgressStruct.iriDataChunk[0]);
            Console.WriteLine(testFileProgressStruct.iriWriteOffset);
            Console.WriteLine(testFileProgressStruct.onFileStruct);
            Console.WriteLine(testFileProgressStruct.partCount);
            Console.WriteLine(testFileProgressStruct.partTotal);

            //FilterQuery
            Console.WriteLine("FilterQuery");
            FilterQuery testFilterQuery = new FilterQuery();
            testFilterQuery.cellValue = testCell;
            testFilterQuery.columnIndex = 0;
            testFilterQuery.columnName = "TestName";
            testFilterQuery.operation = Table.FilterQueryType.QF_EQUAL;

            Console.WriteLine(testFilterQuery.cellValue);
            Console.WriteLine(testFilterQuery.columnIndex);
            Console.WriteLine(testFilterQuery.columnName);
            Console.WriteLine(testFilterQuery.operation);

            //FLP_Printf
            Console.WriteLine("FLP_Printf");
            FLP_Printf testFLP_Printf = new FLP_Printf();

            testFLP_Printf.OnAddFilesFromDirectoryStarted(testFileList, "./");
            testFLP_Printf.OnDirectory(testFileList, "./", 9);
            testFLP_Printf.OnFile(testFileList, "./", "nonexist", 22);
            testFLP_Printf.OnFilePush("./Nonexist", 99, 99, 99, true, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);

            //FullyConnectedMesh2
            Console.WriteLine("FullyConnectedMesh2");
            FullyConnectedMesh2 testFullyConnectedMesh2 = FullyConnectedMesh2.GetInstance();
            testClient.AttachPlugin(testFullyConnectedMesh2);
            testFullyConnectedMesh2.AddParticipant(testServer.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS));
            Console.WriteLine(testFullyConnectedMesh2.GetConnectedHost());
            Console.WriteLine(testFullyConnectedMesh2.GetConnectedHostAddr());
            Console.WriteLine(testFullyConnectedMesh2.GetHostSystem());
            Console.WriteLine(testFullyConnectedMesh2.GetParticipantCount());
            uint outUint;
            testFullyConnectedMesh2.GetParticipantCount(out outUint);
            Console.WriteLine(outUint);
            Console.WriteLine(testFullyConnectedMesh2.IsConnectedHost());
            Console.WriteLine(testFullyConnectedMesh2.IsHostSystem());
            testFullyConnectedMesh2.ResetHostCalculation();
            testFullyConnectedMesh2.SetAutoparticipateConnections(true);
            workingRakStringCopy = "none";
            testFullyConnectedMesh2.SetConnectOnNewRemoteConnection(false, workingRakStringCopy);
            workingRakStringCopy.Dispose();

            //MessageFilter
            Console.WriteLine("MessageFilter");
            MessageFilter testMessageFilter = new MessageFilter();
            testClient.AttachPlugin(testMessageFilter);

            testMessageFilter.SetSystemFilterSet(testClient.GetSystemAddressFromIndex(0), 99);
            testMessageFilter.SetAllowRPC(false, "test", 99);
            testMessageFilter.SetAllowMessageID(true, 99, 99, 99);
            testMessageFilter.SetAutoAddNewConnectionsToFilter(99);
            testMessageFilter.SetFilterMaxTime(99, false, 0, 98);
            testMessageFilter.GetSystemFilterSet(testClient.GetSystemAddressFromIndex(0));
            testMessageFilter.GetSystemCount(99);
            testMessageFilter.GetSystemByIndex(99, 0);
            testMessageFilter.GetFilterSetIDByIndex(0);
            testMessageFilter.GetFilterSetCount();
            testMessageFilter.DeleteFilterSet(99);

            //NatPunchthroughClient
            Console.WriteLine("NatPunchthroughClient");
            NatPunchthroughClient testNatPunchthroughClient = new NatPunchthroughClient();
            testClient.AttachPlugin(testNatPunchthroughClient);
            testNatPunchthroughClient.GetPunchthroughConfiguration();
            testNatPunchthroughClient.GetUPNPExternalPort();
            workingRakStringCopy = testNatPunchthroughClient.GetUPNPInternalAddress();
            workingRakStringCopy.Dispose();
            testNatPunchthroughClient.GetUPNPInternalPort();
            testNatPunchthroughClient.OpenNAT(testServer.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS), testClient.GetSystemAddressFromIndex(0));
            NatPunchthroughDebugInterface_PacketLogger testNatPunchthroughDebugInterface_PacketLogger = new NatPunchthroughDebugInterface_PacketLogger();
            testNatPunchthroughClient.SetDebugInterface(testNatPunchthroughDebugInterface_PacketLogger);
            
            //NatPunchthroughDebugInterface_PacketLogger
            Console.WriteLine("NatPunchthroughDebugInterface_PacketLogger");
            testNatPunchthroughDebugInterface_PacketLogger.OnClientMessage("test");
            Console.WriteLine(testNatPunchthroughDebugInterface_PacketLogger.pl);

            //NatPunchthroughDebugInterface_Printf
            Console.WriteLine("NatPunchthroughDebugInterface_Printf");
            NatPunchthroughDebugInterface_Printf testNatPunchthroughDebugInterface_Printf = new NatPunchthroughDebugInterface_Printf();
            testNatPunchthroughClient.SetDebugInterface(testNatPunchthroughDebugInterface_Printf);
            testNatPunchthroughDebugInterface_Printf.OnClientMessage("test");
 
            //NatTypeDetectionClient
            Console.WriteLine("NatTypeDetectionClient");
            NatTypeDetectionClient testNatTypeDetectionClient = new NatTypeDetectionClient();
            testClient.AttachPlugin(testNatTypeDetectionClient);
            testNatTypeDetectionClient.DetectNATType(testClient.GetSystemAddressFromIndex(0));

            //NatTypeDetectionServer
            Console.WriteLine("NatTypeDetectionServer");
            NatTypeDetectionServer testNatTypeDetectionServer = new NatTypeDetectionServer();
            testServer.AttachPlugin(testNatTypeDetectionServer);
            testNatTypeDetectionServer.Startup("127.0.0.1","127.0.0.1","127.0.0.1");
            testNatTypeDetectionServer.Shutdown();

            //NetworkIDObject
            Console.WriteLine("NetworkIDObject");
            NetworkIDManager testNetworkIDManager = new NetworkIDManager();
            NetworkIDObject testNetworkIDObject = new TestNetworkIDObjectSubClass();
            testNetworkIDObject.SetNetworkIDManager(testNetworkIDManager);
            testNetworkIDObject.GetNetworkIDManager();
            testNetworkIDObject.GetNetworkID();

            //OnFileStruct
            Console.WriteLine("OnFileStruct");
            OnFileStruct testOnFileStruct = new OnFileStruct();
            testOnFileStruct.byteLengthOfThisFile = 99;
            testOnFileStruct.byteLengthOfThisSet = 99;
            testOnFileStruct.bytesDownloadedForThisFile = 99;
            testOnFileStruct.bytesDownloadedForThisSet = 99;
            testOnFileStruct.context = testFileListNodeContext;
            testOnFileStruct.fileIndex = 99;
            testOnFileStruct.fileName = "99";
            testOnFileStruct.numberOfFilesInThisSet = 99;
            testOnFileStruct.setID = 99;
            testOnFileStruct.fileData = testBuffer;
            Console.WriteLine(testOnFileStruct.fileData[0]);

            //OutOfBandIdentifiers
            Console.WriteLine("OutOfBandIdentifiers");
            OutOfBandIdentifiers testOutOfBandIdentifiers = new OutOfBandIdentifiers();

            //Packet
            Console.WriteLine("Packet");

            //PacketConsoleLogger
            Console.WriteLine("PacketConsoleLogger");
            PacketConsoleLogger testPacketConsoleLogger = new PacketConsoleLogger();

            testClient.AttachPlugin(testPacketConsoleLogger);

            LogCommandParser testLogCommandParser = new LogCommandParser();

            testPacketConsoleLogger.SetLogCommandParser(testLogCommandParser);

            //LogCommandParser
            Console.WriteLine("LogCommandParser");

            //PacketFileLogger
            Console.WriteLine("PacketFileLogger");
            PacketFileLogger testPacketFileLogger = new PacketFileLogger();
            string bigString = new string('c', 9999);

            testPacketFileLogger.StartLog("TestLog");
            testClient.AttachPlugin(testPacketFileLogger);
            testPacketFileLogger.FormatLine(ref bigString, "./", "none", 9, 9, 99, 99, 99, testClient.GetSystemAddressFromIndex(0), testClient.GetSystemAddressFromIndex(0), 99, 99, 99, 99);
            testPacketFileLogger.LogHeader();
            testPacketFileLogger.SetLogDirectMessages(false);
            testPacketFileLogger.SetPrefix("lv");
            testPacketFileLogger.SetPrintAcks(false);
            testPacketFileLogger.SetPrintID(false);
            testPacketFileLogger.SetSuffix("tr");
            testPacketFileLogger.WriteLog("gr");
            testPacketFileLogger.WriteMiscellaneous("lf", "mr");

            testClient.DetachPlugin(testPacketFileLogger);
            testPacketFileLogger.Dispose();

            foreach (string file in Directory.GetFiles("./", "TestLog*.csv"))
            {
                File.Delete(file);
            }
             
            //PluginInterface2
            Console.WriteLine("PluginInterface2");
            PluginInterface2 testPluginInterface2 = new PluginInterface2();

            //PluginReceiveResult
            Console.WriteLine("PluginReceiveResult");
            PluginReceiveResult testPluginReceiveResult = new PluginReceiveResult();

            //PunchthroughConfiguration
            Console.WriteLine("PunchthroughConfiguration");
            PunchthroughConfiguration testPunchthroughConfiguration = new PunchthroughConfiguration();

            //Raknet
            RakNet.RakNet.NonNumericHostString("12");

            //RakNetBPlusTreeRow
            Console.WriteLine("RakNetBPlusTreeRow");
            RakNetBPlusTreeRow testRakNetBPlusTreeRow = new RakNetBPlusTreeRow();

            //RakNetGUID
            Console.WriteLine("RakNetGUID");
            Console.WriteLine(testRakNetGUID.g);
            Console.WriteLine(testRakNetGUID.systemIndex);
            Console.WriteLine(testRakNetGUID == RakNet.RakNet.UNASSIGNED_RAKNET_GUID);
            Console.WriteLine(testRakNetGUID > RakNet.RakNet.UNASSIGNED_RAKNET_GUID);
            Console.WriteLine(testRakNetGUID < RakNet.RakNet.UNASSIGNED_RAKNET_GUID);

            //RakNetList, only one is needed
            //RakNetListSystemAddress
            Console.WriteLine("RakNetListSystemAddress");
            RakNetListSystemAddress testRakNetListSystemAddress = new RakNetListSystemAddress();
            testRakNetListSystemAddress.Insert(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS,"",0);
            testRakNetListSystemAddress.Preallocate(99, "", 0);
            testRakNetListSystemAddress.Push(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS,"",0);
            testRakNetListSystemAddress.RemoveAtIndex(0);
            testRakNetListSystemAddress.RemoveAtIndexFast(0);
            testRakNetListSystemAddress.Insert(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, "", 0);
            testRakNetListSystemAddress.Push(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, "", 0);
            testRakNetListSystemAddress.RemoveFromEnd();
            testRakNetListSystemAddress.Replace(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testRakNetListSystemAddress.Size();
            testRakNetListSystemAddress.Pop();
            testRakNetListSystemAddress.Compress("", 0);
            testRakNetListSystemAddress.CopyData(testRakNetListSystemAddress);
            testRakNetListSystemAddress.Clear(false, "", 0);
            testRakNetListSystemAddress.Insert(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, "", 0);
            testRakNetListSystemAddress.Push(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, "", 0);
            testRakNetListSystemAddress.Get(0);
            testRakNetListSystemAddress.GetIndexOf(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);

            //RakNetPageRow
            Console.WriteLine("RakNetPageRow");
            RakNetPageRow testRakNetPageRow = new RakNetPageRow();
            testRakNetPageRow.isLeaf = false;
            testRakNetPageRow.next = testRakNetPageRow;
            testRakNetPageRow.previous = testRakNetPageRow;
            testRakNetPageRow.size = 9;

            Console.WriteLine(testRakNetPageRow.isLeaf);
            Console.WriteLine(testRakNetPageRow.next);
            Console.WriteLine(testRakNetPageRow.previous);
            Console.WriteLine(testRakNetPageRow.size);

            //RakNetSocket
            Console.WriteLine("RakNetSocket");
            RakNetSocket testRakNetSocket = new RakNetSocket();
            testRakNetSocket.boundAddress = RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS;
            testRakNetSocket.remotePortRakNetWasStartedOn_PS3 = 0;
            testRakNetSocket.s = 99;
            testRakNetSocket.userConnectionSocketIndex = 0;

            Console.WriteLine(testRakNetSocket.boundAddress);
            Console.WriteLine(testRakNetSocket.remotePortRakNetWasStartedOn_PS3);
            Console.WriteLine(testRakNetSocket.s);
            Console.WriteLine(testRakNetSocket.userConnectionSocketIndex);

            //ReadyEvent
            Console.WriteLine("ReadyEvent");
            ReadyEvent testReadyEvent = new ReadyEvent();
            testClient.AttachPlugin(testReadyEvent);
            testReadyEvent.AddToWaitList(99, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testReadyEvent.GetEventAtIndex(0);
            testReadyEvent.GetEventListSize();
            testReadyEvent.GetFromWaitListAtIndex(99, 0);
            testReadyEvent.GetReadyStatus(99, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testReadyEvent.GetRemoteWaitListSize(99);
            testReadyEvent.HasEvent(99);
            testReadyEvent.IsEventCompleted(99);
            testReadyEvent.IsEventCompletionProcessing(99);
            testReadyEvent.IsEventSet(99);
            testReadyEvent.IsInWaitList(99, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testReadyEvent.SetEvent(99, false);
            testReadyEvent.SetSendChannel(9);
            testReadyEvent.RemoveFromWaitList(99, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testReadyEvent.ForceCompletion(99);
            testReadyEvent.DeleteEvent(99);

            //RemoteSystemIndex
            Console.WriteLine("RemoteSystemIndex");
            RemoteSystemIndex testRemoteSystemIndex = new RemoteSystemIndex();
            testRemoteSystemIndex.index = 5;
            testRemoteSystemIndex.next = testRemoteSystemIndex;

            Console.WriteLine(testRemoteSystemIndex.index);
            Console.WriteLine(testRemoteSystemIndex.next);

            //Router2
            Console.WriteLine("Router2");
            Router2 testRouter2 = new Router2();
            testClient.AttachPlugin(testRouter2);
            testRouter2.EstablishRouting(testClient.GetGUIDFromIndex(0));
            testRouter2.GetConnectionRequestIndex(testClient.GetGUIDFromIndex(0));
            testRouter2.SetMaximumForwardingRequests(99);
         

            //SimpleMutex
            Console.WriteLine("SimpleMutex");
            SimpleMutex testSimpleMutex = new SimpleMutex();
            testSimpleMutex.Lock();
            testSimpleMutex.Unlock();

            //SocketDescriptor
            Console.WriteLine("SocketDescriptor");
            SocketDescriptor testSocketDescriptor = new SocketDescriptor();
            testSocketDescriptor.hostAddress = "127.0.0.1";
            testSocketDescriptor.port = 60002;
            testSocketDescriptor.remotePortRakNetWasStartedOn_PS3 = 0;

            Console.WriteLine(testSocketDescriptor.hostAddress);
            Console.WriteLine(testSocketDescriptor.port);
            Console.WriteLine(testSocketDescriptor.remotePortRakNetWasStartedOn_PS3);

            //TeamBalancer
            Console.WriteLine("TeamBalancer");
            TeamBalancer testTeamBalancer = new TeamBalancer();
            testClient.AttachPlugin(testTeamBalancer);
            testTeamBalancer.SetAllowHostMigration(false);
            testTeamBalancer.SetDefaultAssignmentAlgorithm(TeamBalancer.DefaultAssigmentAlgorithm.FILL_IN_ORDER);
            testTeamBalancer.SetHostGuid(testClient.GetGUIDFromIndex(0));
            testTeamBalancer.SetLockTeams(false);
            RakNetListUnsignedShort ushortList = new RakNetListUnsignedShort();
            ushortList.Push(5, "", 0);
            testTeamBalancer.SetTeamSizeLimits(ushortList);
            testTeamBalancer.SetForceEvenTeams(true);
            testTeamBalancer.CancelRequestSpecificTeam();
            testTeamBalancer.GetMyTeam();
            testTeamBalancer.RequestAnyTeam(); 
            testTeamBalancer.RequestSpecificTeam(0);
            
            //ThreadsafePacketLogger
            Console.WriteLine("ThreadsafePacketLogger");
            ThreadsafePacketLogger testThreadsafePacketLogger = new ThreadsafePacketLogger();
            testClient.AttachPlugin(testThreadsafePacketLogger);
            testThreadsafePacketLogger.FormatLine(ref bigString,"./","none",9,9,99,99,99,testClient.GetSystemAddressFromIndex(0),testClient.GetSystemAddressFromIndex(0),99,99,99,99);
            testThreadsafePacketLogger.LogHeader();
            testThreadsafePacketLogger.SetLogDirectMessages(false);
            testThreadsafePacketLogger.SetPrefix("lv");
            testThreadsafePacketLogger.SetPrintAcks(false);
            testThreadsafePacketLogger.SetPrintID(false);
            testThreadsafePacketLogger.SetSuffix("tr");
            testThreadsafePacketLogger.WriteLog("gr");
            testThreadsafePacketLogger.WriteMiscellaneous("lf","mr");

            //UDPForwarder
            Console.WriteLine("UDPForwarder");
            UDPForwarder testUDPForwarder = new UDPForwarder();
            testUDPForwarder.Startup();
            testUDPForwarder.GetMaxForwardEntries();
            testUDPForwarder.GetUsedForwardEntries();
            testUDPForwarder.SetMaxForwardEntries(99);
            ushort outUshort;
            testUDPForwarder.StartForwarding(testClient.GetSystemAddressFromIndex(0), testServer.GetSystemAddressFromIndex(0), 99, "127.0.0.1", out outUshort, out outUint);
            testUDPForwarder.StopForwarding(testClient.GetSystemAddressFromIndex(0),testServer.GetSystemAddressFromIndex(0));
            Thread.Sleep(2000);
            testUDPForwarder.StartForwardingThreaded(testClient.GetSystemAddressFromIndex(0), testServer.GetSystemAddressFromIndex(0), 99, "127.0.0.1", out outUshort, out outUint);
            testUDPForwarder.StopForwardingThreaded(testClient.GetSystemAddressFromIndex(0), testServer.GetSystemAddressFromIndex(0));
            Thread.Sleep(1000);
            //testUDPForwarder.threadOperationIncomingMutex=new SimpleMutex();
           // testUDPForwarder.threadOperationOutgoingMutex=new SimpleMutex();
            testUDPForwarder.threadRunning=false;
            testUDPForwarder.isRunning=false;
            testUDPForwarder.maxForwardEntries = 99;

            Console.WriteLine(testUDPForwarder.threadOperationIncomingMutex);
            Console.WriteLine(testUDPForwarder.threadOperationOutgoingMutex);
            Console.WriteLine(testUDPForwarder.threadRunning);
            Console.WriteLine(testUDPForwarder.isRunning);
            Console.WriteLine(testUDPForwarder.maxForwardEntries);

            testUDPForwarder.Shutdown();

            //UDPProxyClient
            Console.WriteLine("UDPProxyClient");
            UDPProxyClient testUDPProxyClient = new UDPProxyClient();
            UDPProxyClientResultHandler testUDPProxyClientResultHandler= new UDPProxyClientResultHandlerCB();

            testUDPProxyClient.SetResultHandler(testUDPProxyClientResultHandler);
            testClient.AttachPlugin(testUDPProxyClient);
            testUDPProxyClient.RequestForwarding(testClient.GetSystemAddressFromIndex(0), testServer.GetSystemAddressFromIndex(0),testClient.GetGUIDFromIndex(0),1);
 
            //UDPProxyCoordinator
            Console.WriteLine("UDPProxyCoordinator");
            UDPProxyCoordinator testUDPProxyCoordinator = new UDPProxyCoordinator();
            testClient.AttachPlugin(testUDPProxyCoordinator);
            testUDPProxyCoordinator.SetRemoteLoginPassword(rakStringTest);
           
            //UDPProxyServer
            Console.WriteLine("UDPProxyServer");
            UDPProxyServer testUDPProxyServer = new UDPProxyServer();
            UDPProxyServerResultHandler testUDPProxyServerResultHandler= new UDPProxyServerResultHandlerCB();
            testServer.AttachPlugin(testUDPProxyServer);
            testUDPProxyServer.SetResultHandler(testUDPProxyServerResultHandler);
            testUDPProxyServer.LoginToCoordinator(rakStringTest,testServer.GetSystemAddressFromIndex(0));
            testUDPProxyServer.udpForwarder = testUDPProxyServer.udpForwarder;
            Console.WriteLine(testUDPProxyServer.udpForwarder);

            //RakString
            Console.WriteLine("RakString");
            testRakString.AppendBytes(testBuffer, (uint)testBuffer.Length);
            Console.WriteLine(testRakString.C_String());
            Console.WriteLine(testRakString.C_StringUnsafe());
            testRakString.Clear();
            Console.WriteLine(testRakString.ContainsNonprintableExceptSpaces());
            workingRakStringCopy = testRakString.Assign("MayJuneJuly", 0, 3);
            workingRakStringCopy.Dispose();
            Console.WriteLine(testRakString);
            testRakString.CopyData(testRakString);
            testRakString.Serialize(testBitStream2);
            testRakString.Deserialize(testBitStream2);
            testRakString.SerializeCompressed(testBitStream2);
            testRakString.DeserializeCompressed(testBitStream2);
            workingRakStringCopy = testRakString.Assign("MayJuneJuly", 0, 3);
            workingRakStringCopy.Dispose();

            testRakString.Erase(0, 1);

            Console.WriteLine(testRakString.Find("y", 0));
            Console.WriteLine(testRakString.GetLength());
            Console.WriteLine(testRakString.IPAddressMatch("127.0.0.1"));
            Console.WriteLine(testRakString.IsEmailAddress());
            Console.WriteLine(testRakString.IsEmpty());
            Console.WriteLine(testRakString.MakeFilePath());
            testRakString.Printf();
            testRakString.RemoveCharacter('a');
            testRakString.Replace(0, 1, 'c');
            testRakString.Set("cat");
            testRakString.SetChar(0, 'r');
            testRakString.SQLEscape();
            Console.WriteLine(testRakString.StrCmp(testRakString));
            Console.WriteLine(testRakString.StrICmp(testRakString));
            workingRakStringCopy = testRakString.SubStr(0, 2);
            Console.WriteLine(workingRakStringCopy);
            workingRakStringCopy.Dispose();
            Console.WriteLine(testRakString);
            testRakString.TerminateAtFirstCharacter('y');
            testRakString.TerminateAtLastCharacter('y');
            Console.WriteLine(testRakString.ToLower());
            Console.WriteLine(testRakString.ToUpper());
            testRakString.Truncate(2);
            testRakString.URLDecode();
            testRakString.URLEncode();

            //PluginInterface2
            testUDPProxyServer.GetRakPeerInterface();

            //RakPeerInterface
            testPacket = testClient.AllocatePacket(5);
            testClient.AddToBanList("127.0.0.1", 10);
            testClient.AddToSecurityExceptionList("127.0.0.1");
            testBuffer = testPacket.data;
            testClient.AdvertiseSystem("127.0.0.1",60002,testBuffer,testBuffer.Length);
            testClient.AllowConnectionResponseIPMigration(false);
            testClient.CancelConnectionAttempt(testClient.GetSystemAddressFromIndex(0));
            testClient.ChangeSystemAddress(testClient.GetGUIDFromIndex(0),testClient.GetSystemAddressFromIndex(0));
            testClient.ClearBanList();
            uint[] testFrequencyTable = new uint[256];
            testClient.DisableSecurity();
            testClient.GetAveragePing(new AddressOrGUID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS));
            SystemAddress[] remoteSystems;
            ushort numberOfSystems=4;
            testClient.GetConnectionList(out remoteSystems,ref numberOfSystems);
            testClient.GetExternalID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testClient.GetGUIDFromIndex(0);
            testClient.GetGuidFromSystemAddress(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            int inOutInt=testBuffer.Length;
            testClient.GetIncomingPassword(testBuffer,ref inOutInt);
            testClient.GetIndexFromSystemAddress(testClient.GetSystemAddressFromIndex(0));
            testClient.GetInternalID();
            testClient.GetLastPing(new AddressOrGUID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS));
            testClient.GetLocalIP(0);
            testClient.GetLowestPing(new AddressOrGUID(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS));
            testClient.GetMaximumIncomingConnections();
            testClient.GetMaximumNumberOfPeers();
            testClient.GetMTUSize(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testClient.GetNextSendReceipt();
            testClient.GetNumberOfAddresses();
            testClient.SetOfflinePingResponse(testBuffer, (uint)testBuffer.Length);
            testClient.GetOfflinePingResponse(testBuffer,out outUint);
            testClient.GetReceiveBufferSize();
            testClient.GetSplitMessageProgressInterval();
            testClient.GetStatistics(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testClient.GetSystemAddressFromGuid(testClient.GetGUIDFromIndex(0));
            testClient.GetSystemAddressFromIndex(0);
            RakNetListSystemAddress systemAddressList= new RakNetListSystemAddress();
            RakNetListRakNetGUID guidList= new RakNetListRakNetGUID();
            testClient.GetSystemList(systemAddressList,guidList);
            testClient.GetTimeoutTime(RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testClient.IncrementNextSendReceipt();
            testClient.InitializeSecurity("dsf","sdaf");
            testClient.IsActive();
            testClient.IsBanned("127.0.0.1");
            testClient.GetConnectionState(new AddressOrGUID(testClient.GetSystemAddressFromIndex(0)));
            testClient.IsInSecurityExceptionList("127.0.0.1");
            testClient.IsLocalIP("127.0.0.1");
            testClient.NumberOfConnections();
            testClient.Ping(testClient.GetSystemAddressFromIndex(0));
            testClient.PushBackPacket(testPacket,true);
            testClient.RemoveFromBanList("127.0.0.1");
            testClient.RemoveFromSecurityExceptionList("127.0.0.1");
            testClient.SendLoopback(testBuffer,testBuffer.Length);
            testClient.SendTTL("127.0.0.1",60002,5);
            testClient.SetIncomingPassword(testBuffer,testBuffer.Length);
            testClient.SetLimitIPConnectionFrequency(true);
            testClient.SetMaximumIncomingConnections(99);
            testClient.SetOccasionalPing(true);
            testClient.SetPerConnectionOutgoingBandwidthLimit(10);
            testClient.SetSplitMessageProgressInterval(99);
            testClient.SetTimeoutTime(99,RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS);
            testClient.SetUnreliableTimeout(99);
            testClient.WriteOutOfBandHeader(testBitStream1);
            testClient.CloseConnection(testClient.GetSystemAddressFromIndex(0),false);
            testClient.Shutdown(20);

            RakPeer.DestroyInstance(testClient);
            RakPeer.DestroyInstance(testServer);

            //These need to be freed if used in the main function.
            testUDPForwarder.Dispose();
            testUDPProxyCoordinator.Dispose();
            FileList.DestroyInstance(testFileList);
            FileList.DestroyInstance(outFileList);
            FullyConnectedMesh2.DestroyInstance(testFullyConnectedMesh2);
            //If RakString is not freed before program exit it will crash
            rakStringTest.Dispose();
            testRakString.Dispose();
            workingRakStringCopy.Dispose();
            RakString.FreeMemory();

            Console.WriteLine("Demo complete. Press enter.");
            Console.Read();
        }
    }
}
