0312 加密处理

hch

2024-04-11 4c71d74b77c9eb62a0323698c9a0db3b641a917e

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#if ENABLE_UNIT_TESTS
 
#include "UnitTest++.h"
#include <string>
#include <cstring>
#include <vector>
 
#include "../../Socket.h"
#include "../../../utils/Memory.h"
#include "../Socket-c-api.h"
 
SUITE(Socket)
{
    const char* hostname = "";
 
    struct GetHostByNameFixture
    {
        std::string className;
        int32_t classFamily;
        std::vector<std::string> classAliases;
        std::vector<void*> classAddressList;
        int32_t classAddressSize;
 
        char* palName;
        int32_t palFamily;
        char** palAliases;
        void** palAddresses;
        int32_t palAddresseSize;
 
        GetHostByNameFixture()
        {
            palName = NULL;
            palFamily = -1;
            palAliases = NULL;
            palAddresses = NULL;
            palAddresseSize = -1;
        }
 
        ~GetHostByNameFixture()
        {
            il2cpp::utils::Memory::Free(palName);
            FreeNullTerminatedArray((void**)palAliases);
            FreeNullTerminatedArray((void**)palAddresses);
        }
 
        int NullTerminatedArrayLength(void** array)
        {
            int i = 0;
            if (array != NULL)
            {
                while (array[i] != NULL)
                    i++;
            }
 
            return i;
        }
 
        void FreeNullTerminatedArray(void** array)
        {
            if (array != NULL)
            {
                int i = 0;
                while (array[i] != NULL)
                {
                    free(array[i]);
                    i++;
                }
            }
            free(array);
        }
    };
 
    TEST_FIXTURE(GetHostByNameFixture, ReturnsSuccessForEmptyHostname)
    {
        CHECK(UnityPalGetHostByName(hostname, NULL, NULL, NULL, NULL, NULL) == kWaitStatusSuccess);
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReturnsTheSameValueAsClass)
    {
        CHECK(UnityPalGetHostByName(hostname, NULL, NULL, NULL, NULL, NULL) == il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize));
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameNameAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, NULL, NULL, NULL, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        CHECK(className == palName);
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameFamilyAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, NULL, NULL, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        CHECK(classFamily == palFamily);
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameNumberOfAliasesAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, &palAliases, NULL, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        CHECK(classAliases.size() == NullTerminatedArrayLength((void**)palAliases));
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameAliasesAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, &palAliases, NULL, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        for (size_t i = 0; i < classAliases.size(); ++i)
            CHECK(classAliases[i] == palAliases[i]);
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameAddressSizeAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, &palAliases, &palAddresses, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        CHECK(classAddressList.size() == NullTerminatedArrayLength((void**)palAddresses));
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameNumberOfAddressesAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, &palAliases, &palAddresses, &palAddresseSize);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        CHECK(classAddressSize == palAddresseSize);
    }
 
    TEST_FIXTURE(GetHostByNameFixture, ReportsTheSameAddressesAsClass)
    {
        UnityPalGetHostByName(hostname, &palName, &palFamily, &palAliases, &palAddresses, NULL);
        il2cpp::os::Socket::GetHostByName(hostname, className, classFamily, classAliases, classAddressList, classAddressSize);
        for (size_t i = 0; i < classAddressList.size(); ++i)
            CHECK(std::memcmp(classAddressList[i], palAddresses[i], classAddressSize) == 0);
    }
}
 
#endif // ENABLE_UNIT_TESTS