CopyHandler

Clone
ixen
committed
f6e8ab2
on 23 Oct 20
Fixed unit tests issues with strict strings (CH-350)
src/.../Tests/TestsTSharedMemory.cpp (+6 -6)
47 47         EXPECT_EQ(2UL, *(unsigned int*)memory.GetFullData());
48 48         EXPECT_EQ(2UL, memory.GetDataSize());
49 49         EXPECT_EQ(6UL, memory.GetSharedMemorySize());
50 50 }
51 51
52 52 TEST(TestsTSharedMemory, Create_FromFullString)
53 53 {
54 54         TString strData(L"SomeString");
55 55         TSharedMemory memory;
56 56         memory.Create(L"UnitTestsSharedMemoryName", strData);
57 57         EXPECT_TRUE(memory.GetData() != nullptr);
58 58         EXPECT_EQ(L'S', *memory.GetData());
59 59         EXPECT_TRUE(memory.GetFullData() != nullptr);
60 60         EXPECT_EQ(22, *memory.GetFullData());
61 61         EXPECT_EQ(22UL, memory.GetDataSize());
62 62         EXPECT_EQ(26UL, memory.GetSharedMemorySize());
63 63 }
64 64
65 65 TEST(TestsTSharedMemory, Create_FromBufferZeroSize)
66 66 {
67           char* pszData = "SomeString";
  67         const char* pszData = "SomeString";
68 68         TSharedMemory memory;
69 69         EXPECT_THROW(memory.Create(L"UnitTestsSharedMemoryName", (BYTE*)pszData, 0), TCoreException);
70 70 }
71 71
72 72 TEST(TestsTSharedMemory, Create_FromNullBufferWithZeroSize)
73 73 {
74 74         TSharedMemory memory;
75 75         EXPECT_THROW(memory.Create(L"UnitTestsSharedMemoryName", nullptr, 0), TCoreException);
76 76 }
77 77
78 78 TEST(TestsTSharedMemory, Create_FromNullBufferWithNonZeroSize)
79 79 {
80 80         TSharedMemory memory;
81 81         EXPECT_THROW(memory.Create(L"UnitTestsSharedMemoryName", nullptr, 5), TCoreException);
82 82 }
83 83
84 84 TEST(TestsTSharedMemory, Create_FromEmptyBuffer)
85 85 {
86           char* pszData = "";
  86         const char* pszData = "";
87 87         TSharedMemory memory;
88 88         memory.Create(L"UnitTestsSharedMemoryName", (BYTE*)pszData, 1);
89 89         EXPECT_TRUE(memory.GetData() != nullptr);
90 90         EXPECT_EQ(0UL, *(unsigned int*)memory.GetData());
91 91         EXPECT_TRUE(memory.GetFullData() != nullptr);
92 92         EXPECT_EQ(1UL, *(unsigned int*)memory.GetFullData());
93 93         EXPECT_EQ(1UL, memory.GetDataSize());
94 94         EXPECT_EQ(5UL, memory.GetSharedMemorySize());
95 95 }
96 96
97 97 TEST(TestsTSharedMemory, Create_FromFullBuffer)
98 98 {
99           char* pszData = "SomeString";
  99         const char* pszData = "SomeString";
100 100         TSharedMemory memory;
101 101         memory.Create(L"UnitTestsSharedMemoryName", (BYTE*)pszData, 4);
102 102         EXPECT_TRUE(memory.GetData() != nullptr);
103 103         EXPECT_EQ(L'S', *memory.GetData());
104 104         EXPECT_TRUE(memory.GetFullData() != nullptr);
105 105         EXPECT_EQ(4, *memory.GetFullData());
106 106         EXPECT_EQ(4UL, memory.GetDataSize());
107 107         EXPECT_EQ(8UL, memory.GetSharedMemorySize());
108 108 }
109 109
110 110 ////////////////////////////////////////////////////////////////////////////////
111 111 // Receiving side
112 112
113 113 TEST(TestsTSharedMemory, Open)
114 114 {
115           char* pszData = "SomeString";
  115         const char* pszData = "SomeString";
116 116         TSharedMemory srcMemory;
117 117         srcMemory.Create(L"UnitTestsSharedMemoryName", (BYTE*)pszData, 4);
118 118
119 119         TSharedMemory dstMemory;
120 120         dstMemory.Open(L"UnitTestsSharedMemoryName");
121 121
122 122         EXPECT_TRUE(dstMemory.GetData() != nullptr);
123 123         EXPECT_EQ(L'S', *dstMemory.GetData());
124 124         EXPECT_TRUE(dstMemory.GetFullData() != nullptr);
125 125         EXPECT_EQ(4, *dstMemory.GetFullData());
126 126         EXPECT_EQ(4UL, dstMemory.GetDataSize());
127 127         EXPECT_EQ(8UL, dstMemory.GetSharedMemorySize());
128 128 }
129 129
130 130 TEST(TestsTSharedMemory, OpenNonExistentMemory)
131 131 {
132 132         TSharedMemory dstMemory;
133 133         EXPECT_THROW(dstMemory.Open(L"UnitTestsSharedMemoryName"), TCoreException);
134 134 }
135 135
 
140 140 {
141 141         TString strData(L"SomeString");
142 142         TSharedMemory memory;
143 143         memory.Create(L"UnitTestsSharedMemoryName", 256);
144 144         memory.Write(strData);
145 145
146 146         EXPECT_TRUE(memory.GetData() != nullptr);
147 147         EXPECT_EQ(L'S', *memory.GetData());
148 148         EXPECT_TRUE(memory.GetFullData() != nullptr);
149 149         EXPECT_EQ(22, *memory.GetFullData());
150 150         EXPECT_EQ(22UL, memory.GetDataSize());
151 151         EXPECT_EQ(260UL, memory.GetSharedMemorySize());
152 152
153 153         TString strReadData;
154 154         memory.Read(strReadData);
155 155         EXPECT_EQ(strData, strReadData);
156 156 }
157 157
158 158 TEST(TestsTSharedMemory, WriteBufferReadString)
159 159 {
160           wchar_t* pszData = L"SomeString";
  160         const wchar_t* pszData = L"SomeString";
161 161         TSharedMemory memory;
162 162         memory.Create(L"UnitTestsSharedMemoryName", 256);
163 163         memory.Write((BYTE*)pszData, (unsigned int)((wcslen(pszData) + 1) * sizeof(wchar_t)));
164 164
165 165         EXPECT_TRUE(memory.GetData() != nullptr);
166 166         EXPECT_EQ(L'S', *memory.GetData());
167 167         EXPECT_TRUE(memory.GetFullData() != nullptr);
168 168         EXPECT_EQ(22, *memory.GetFullData());
169 169         EXPECT_EQ(22UL, memory.GetDataSize());
170 170         EXPECT_EQ(260UL, memory.GetSharedMemorySize());
171 171
172 172         TString strReadData;
173 173         memory.Read(strReadData);
174 174         EXPECT_STREQ(L"SomeString", strReadData.c_str());
175 175 }
176 176
177 177 TEST(TestsTSharedMemory, WriteStringReadString_ReceiverSide)
178 178 {
179 179         TString strData(L"SomeString");
180 180         TSharedMemory srcMemory;
181 181         srcMemory.Create(L"UnitTestsSharedMemoryName", 256);
182 182         srcMemory.Write(strData);
183 183
184 184         TSharedMemory memory;
185 185         memory.Open(L"UnitTestsSharedMemoryName");
186 186
187 187         EXPECT_TRUE(memory.GetData() != nullptr);
188 188         EXPECT_EQ(L'S', *memory.GetData());
189 189         EXPECT_TRUE(memory.GetFullData() != nullptr);
190 190         EXPECT_EQ(22, *memory.GetFullData());
191 191         EXPECT_EQ(22UL, memory.GetDataSize());
192 192         EXPECT_EQ(26UL, memory.GetSharedMemorySize());
193 193
194 194         TString strReadData;
195 195         memory.Read(strReadData);
196 196         EXPECT_EQ(strData, strReadData);
197 197 }
198 198
199 199 TEST(TestsTSharedMemory, WriteBufferReadString_ReceiverSide)
200 200 {
201           wchar_t* pszData = L"SomeString";
  201         const wchar_t* pszData = L"SomeString";
202 202         TSharedMemory srcMemory;
203 203         srcMemory.Create(L"UnitTestsSharedMemoryName", 256);
204 204         srcMemory.Write((BYTE*)pszData, (unsigned int)((wcslen(pszData) + 1) * sizeof(wchar_t)));
205 205
206 206         TSharedMemory memory;
207 207         memory.Open(L"UnitTestsSharedMemoryName");
208 208
209 209         EXPECT_TRUE(memory.GetData() != nullptr);
210 210         EXPECT_EQ(L'S', *memory.GetData());
211 211         EXPECT_TRUE(memory.GetFullData() != nullptr);
212 212         EXPECT_EQ(22, *memory.GetFullData());
213 213         EXPECT_EQ(22UL, memory.GetDataSize());
214 214         EXPECT_EQ(26UL, memory.GetSharedMemorySize());
215 215
216 216         TString strReadData;
217 217         memory.Read(strReadData);
218 218         EXPECT_STREQ(L"SomeString", strReadData.c_str());
219 219 }