1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 18 #include "softbus_sequence_verification.h" 19 20 using namespace testing::ext; 21 22 namespace { 23 const int32_t MAX_RECEIVE_SEQUENCE = 5; 24 } 25 26 namespace OHOS { 27 class SequenceVerificationTest : public testing::Test { 28 public: SetUpTestCase(void)29 static void SetUpTestCase(void) {} TearDownTestCase(void)30 static void TearDownTestCase(void) {} 31 }; 32 33 /** 34 * @tc.name: Softbus_SeqVerifyTest_Test_NormalCase_001 35 * @tc.desc: Verify normal case, seq >= 0. 36 * @tc.type: FUNC 37 * @tc.require: 38 */ 39 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_NormalCase_001, TestSize.Level0) 40 { 41 SeqVerifyInfo seqInfo = {0}; 42 for (int32_t recvSeq = 0; recvSeq < MAX_RECEIVE_SEQUENCE; recvSeq++) { 43 bool ret = IsPassSeqCheck(&seqInfo, recvSeq); 44 EXPECT_EQ(ret, true); 45 } 46 } 47 48 /** 49 * @tc.name: Softbus_SeqVerifyTest_Test_NormalCase_002 50 * @tc.desc: Verify normal case, seq < 0. 51 * @tc.type: FUNC 52 * @tc.require: 53 */ 54 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_NormalCase_002, TestSize.Level0) 55 { 56 SeqVerifyInfo seqInfo = {0}; 57 /* 2: offset */ 58 seqInfo.minSeq = INT32_MIN + 1; 59 seqInfo.maxSeq = INT32_MIN + 1; 60 int32_t recvSeq = INT32_MIN + 1; 61 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 62 bool ret = IsPassSeqCheck(&seqInfo, recvSeq++); 63 EXPECT_EQ(ret, true); 64 } 65 } 66 67 /** 68 * @tc.name: Softbus_SeqVerifyTest_Test_NormalCase_003 69 * @tc.desc: Verify normal case and seq flip negative. 70 * @tc.type: FUNC 71 * @tc.require: 72 */ 73 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_NormalCase_003, TestSize.Level0) 74 { 75 SeqVerifyInfo seqInfo = {0}; 76 /* 2: offset */ 77 seqInfo.minSeq = INT32_MAX - 2; 78 seqInfo.maxSeq = INT32_MAX - 2; 79 int32_t recvSeq = INT32_MAX - 2; 80 81 for (volatile int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 82 bool ret = IsPassSeqCheck(&seqInfo, recvSeq++); 83 EXPECT_EQ(ret, true); 84 } 85 } 86 87 /** 88 * @tc.name: Softbus_SeqVerifyTest_Test_NormalCase_004 89 * @tc.desc: Verify normal case and seq flip positive. 90 * @tc.type: FUNC 91 * @tc.require: 92 */ 93 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_NormalCase_004, TestSize.Level0) 94 { 95 SeqVerifyInfo seqInfo = {0}; 96 /* -2: offset */ 97 seqInfo.minSeq = -2; 98 seqInfo.maxSeq = -2; 99 int32_t recvSeq = -2; 100 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 101 bool ret = IsPassSeqCheck(&seqInfo, recvSeq++); 102 EXPECT_EQ(ret, true); 103 } 104 } 105 106 /** 107 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_001 108 * @tc.desc: Verify disorder seq. 109 * @tc.type: FUNC 110 * @tc.require: 111 */ 112 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_001, TestSize.Level0) 113 { 114 SeqVerifyInfo seqInfo = {0}; 115 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {0, 1, 4, 3, 2}; 116 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 117 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 118 EXPECT_EQ(ret, true); 119 } 120 } 121 122 /** 123 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_002 124 * @tc.desc: Verify disorder seq, boundary valueseq(61-1=60[MAX_SEQ_BIAS]). 125 * @tc.type: FUNC 126 * @tc.require: 127 */ 128 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_002, TestSize.Level0) 129 { 130 SeqVerifyInfo seqInfo = {0}; 131 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {0, 1, 61, 8, 7}; 132 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 133 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 134 EXPECT_EQ(ret, true); 135 } 136 } 137 138 /** 139 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_003 140 * @tc.desc: Verify disorder seq, boundary valueseq(62-1>60[MAX_SEQ_BIAS]). 141 * @tc.type: FUNC 142 * @tc.require: 143 */ 144 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_003, TestSize.Level0) 145 { 146 SeqVerifyInfo seqInfo = {0}; 147 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {0, 1, 62, 8, 7}; 148 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 149 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 150 if (i < 2) { 151 EXPECT_EQ(ret, true); 152 } else if (i == 2) { 153 EXPECT_EQ(ret, false); 154 } else { 155 EXPECT_EQ(ret, true); 156 } 157 } 158 } 159 160 /** 161 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_004 162 * @tc.desc: Verify disorder seq, boundary valueseq(99-39=60[MAX_SEQ_BIAS]). 163 * @tc.type: FUNC 164 * @tc.require: 165 */ 166 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_004, TestSize.Level0) 167 { 168 SeqVerifyInfo seqInfo = {0}; 169 seqInfo.minSeq = -100; 170 seqInfo.maxSeq = -100; 171 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-100, -99, -39, -96, -90}; 172 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 173 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 174 EXPECT_EQ(ret, true); 175 } 176 } 177 178 /** 179 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_005 180 * @tc.desc: Verify disorder seq, boundary valueseq(99-38>60[MAX_SEQ_BIAS]). 181 * @tc.type: FUNC 182 * @tc.require: 183 */ 184 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_005, TestSize.Level0) 185 { 186 SeqVerifyInfo seqInfo = {0}; 187 seqInfo.minSeq = -100; 188 seqInfo.maxSeq = -100; 189 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-100, -99, -38, -96, -90}; 190 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 191 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 192 if (i < 2) { 193 EXPECT_EQ(ret, true); 194 } else if (i == 2) { 195 EXPECT_EQ(ret, false); 196 } else { 197 EXPECT_EQ(ret, true); 198 } 199 } 200 } 201 202 /** 203 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_006 204 * @tc.desc: Verify disorder seq, seq flip negative, boundary valueseq. 205 * INT32_MIN + 58 - INT32_MIN + INT32_MAX - (INT32_MAX - 1) + 1 = 60[MAX_SEQ_BIAS] 206 * @tc.type: FUNC 207 * @tc.require: 208 */ 209 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_006, TestSize.Level0) 210 { 211 SeqVerifyInfo seqInfo = {0}; 212 seqInfo.minSeq = INT32_MAX - 2; 213 seqInfo.maxSeq = INT32_MAX - 2; 214 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {INT32_MAX - 2, INT32_MAX - 1, INT32_MIN + 58, INT32_MIN, INT32_MIN + 7}; 215 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 216 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 217 EXPECT_EQ(ret, true); 218 } 219 } 220 221 /** 222 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_007 223 * @tc.desc: Verify disorder seq, seq flip negative, boundary valueseq. 224 * INT32_MIN + 59 - INT32_MIN + INT32_MAX - (INT32_MAX - 1) + 1 > 60[MAX_SEQ_BIAS] 225 * @tc.type: FUNC 226 * @tc.require: 227 */ 228 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_007, TestSize.Level0) 229 { 230 SeqVerifyInfo seqInfo = {0}; 231 seqInfo.minSeq = INT32_MAX - 2; 232 seqInfo.maxSeq = INT32_MAX - 2; 233 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {INT32_MAX - 2, INT32_MAX - 1, INT32_MIN + 59, INT32_MIN, INT32_MIN + 7}; 234 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 235 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 236 if (i < 2) { 237 EXPECT_EQ(ret, true); 238 } else if (i == 2) { 239 EXPECT_EQ(ret, false); 240 } else { 241 EXPECT_EQ(ret, true); 242 } 243 } 244 } 245 246 /** 247 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_008 248 * @tc.desc: Verify disorder seq, seq flip positive, boundary valueseq. 249 * 31 + 29 = 60[MAX_SEQ_BIAS] 250 * @tc.type: FUNC 251 * @tc.require: 252 */ 253 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_008, TestSize.Level0) 254 { 255 SeqVerifyInfo seqInfo = {0}; 256 seqInfo.minSeq = -30; 257 seqInfo.maxSeq = -30; 258 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-30, -29, 31, 0, -3}; 259 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 260 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 261 EXPECT_EQ(ret, true); 262 } 263 } 264 265 /** 266 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_009 267 * @tc.desc: Verify disorder seq, seq flip positive, boundary valueseq. 268 * 32 + 29 > 60[MAX_SEQ_BIAS] 269 * @tc.type: FUNC 270 * @tc.require: 271 */ 272 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_009, TestSize.Level0) 273 { 274 SeqVerifyInfo seqInfo = {0}; 275 seqInfo.minSeq = -30; 276 seqInfo.maxSeq = -30; 277 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-30, -29, 32, 0, -3}; 278 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 279 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 280 if (i < 2) { 281 EXPECT_EQ(ret, true); 282 } else if (i == 2) { 283 EXPECT_EQ(ret, false); 284 } else { 285 EXPECT_EQ(ret, true); 286 } 287 } 288 } 289 290 /** 291 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_001 292 * @tc.desc: Verify repeat seq. 293 * @tc.type: FUNC 294 * @tc.require: 295 */ 296 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_001, TestSize.Level0) 297 { 298 SeqVerifyInfo seqInfo = {0}; 299 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {2, 10, 2, 3, 3}; 300 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 301 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 302 if (i < 2 || i == 3) { 303 EXPECT_EQ(ret, true); 304 } else { 305 EXPECT_EQ(ret, false); 306 } 307 } 308 } 309 310 /** 311 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_002 312 * @tc.desc: Verify repeat seq. 313 * @tc.type: FUNC 314 * @tc.require: 315 */ 316 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_002, TestSize.Level0) 317 { 318 SeqVerifyInfo seqInfo = {0}; 319 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {0, 10, 1, 5, 5}; 320 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 321 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 322 if (i < 4) { 323 EXPECT_EQ(ret, true); 324 } else { 325 EXPECT_EQ(ret, false); 326 } 327 } 328 } 329 330 /** 331 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_003 332 * @tc.desc: Verify repeat seq, flip negative. 333 * @tc.type: FUNC 334 * @tc.require: 335 */ 336 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_003, TestSize.Level0) 337 { 338 SeqVerifyInfo seqInfo = {0}; 339 seqInfo.minSeq = INT32_MAX - 2; 340 seqInfo.maxSeq = INT32_MAX - 2; 341 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {INT32_MAX - 2, INT32_MAX - 1, INT32_MIN + 5, INT32_MAX - 1, INT32_MIN + 3}; 342 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 343 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 344 if (i < 3 || i == 4) { 345 EXPECT_EQ(ret, true); 346 } else { 347 EXPECT_EQ(ret, false); 348 } 349 } 350 } 351 352 /** 353 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_004 354 * @tc.desc: Verify repeat seq, flip negative. 355 * @tc.type: FUNC 356 * @tc.require: 357 */ 358 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_004, TestSize.Level0) 359 { 360 SeqVerifyInfo seqInfo = {0}; 361 seqInfo.minSeq = INT32_MAX - 2; 362 seqInfo.maxSeq = INT32_MAX - 2; 363 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {INT32_MAX - 2, INT32_MIN, INT32_MIN + 5, INT32_MIN, INT32_MIN + 3}; 364 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 365 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 366 if (i < 3 || i == 4) { 367 EXPECT_EQ(ret, true); 368 } else { 369 EXPECT_EQ(ret, false); 370 } 371 } 372 } 373 374 /** 375 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_005 376 * @tc.desc: Verify repeat seq, flip positive. 377 * @tc.type: FUNC 378 * @tc.require: 379 */ 380 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_005, TestSize.Level0) 381 { 382 SeqVerifyInfo seqInfo = {0}; 383 seqInfo.minSeq = -10; 384 seqInfo.maxSeq = -10; 385 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-10, -1, 10, -1, 3}; 386 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 387 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 388 if (i < 3 || i == 4) { 389 EXPECT_EQ(ret, true); 390 } else { 391 EXPECT_EQ(ret, false); 392 } 393 } 394 } 395 396 /** 397 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_006 398 * @tc.desc: Verify repeat seq, flip positive. 399 * @tc.type: FUNC 400 * @tc.require: 401 */ 402 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_006, TestSize.Level0) 403 { 404 SeqVerifyInfo seqInfo = {0}; 405 seqInfo.minSeq = -10; 406 seqInfo.maxSeq = -10; 407 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-10, 1, 10, 1, 3}; 408 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 409 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 410 if (i < 3 || i == 4) { 411 EXPECT_EQ(ret, true); 412 } else { 413 EXPECT_EQ(ret, false); 414 } 415 } 416 } 417 418 /** 419 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_007 420 * @tc.desc: Verify repeat seq. 421 * @tc.type: FUNC 422 * @tc.require: 423 */ 424 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_007, TestSize.Level0) 425 { 426 SeqVerifyInfo seqInfo = {0}; 427 seqInfo.minSeq = 0; 428 seqInfo.maxSeq = 0; 429 int32_t recvSeq[12] = {0, 1, 2, 3, 4, 3, 3, 10, 5, 5, 5, 5}; 430 for (int i = 0; i < 12; i++) { 431 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 432 if (i < 5 || i == 7 || i == 8) { 433 EXPECT_EQ(ret, true); 434 } else { 435 EXPECT_EQ(ret, false); 436 } 437 } 438 } 439 440 /** 441 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_001 442 * @tc.desc: Verify abnormal seq, minSeq positive. 443 * @tc.type: FUNC 444 * @tc.require: 445 */ 446 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_001, TestSize.Level0) 447 { 448 SeqVerifyInfo seqInfo = {0}; 449 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-10, -2, 10, 1, 3}; 450 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 451 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 452 if (i >= 2) { 453 EXPECT_EQ(ret, true); 454 } else { 455 EXPECT_EQ(ret, false); 456 } 457 } 458 } 459 460 /** 461 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_002 462 * @tc.desc: Verify abnormal seq, minSeq negative. 463 * @tc.type: FUNC 464 * @tc.require: 465 */ 466 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_002, TestSize.Level0) 467 { 468 SeqVerifyInfo seqInfo = {0}; 469 seqInfo.minSeq = -10; 470 seqInfo.maxSeq = -10; 471 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-15, -12, 10, 1, 3}; 472 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 473 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 474 if (i >= 2) { 475 EXPECT_EQ(ret, true); 476 } else { 477 EXPECT_EQ(ret, false); 478 } 479 } 480 } 481 482 /** 483 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_003 484 * @tc.desc: Verify abnormal seq, minSeq negative. 485 * @tc.type: FUNC 486 * @tc.require: 487 */ 488 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_003, TestSize.Level0) 489 { 490 SeqVerifyInfo seqInfo = {0}; 491 seqInfo.minSeq = -10; 492 seqInfo.maxSeq = 10; 493 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {-15, -12, 10, 1, 3}; 494 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 495 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 496 if (i >= 2) { 497 EXPECT_EQ(ret, true); 498 } else { 499 EXPECT_EQ(ret, false); 500 } 501 } 502 } 503 504 /** 505 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_004 506 * @tc.desc: Verify abnormal seq, minSeq negative. 507 * @tc.type: FUNC 508 * @tc.require: 509 */ 510 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_004, TestSize.Level0) 511 { 512 SeqVerifyInfo seqInfo = {0}; 513 seqInfo.minSeq = INT32_MAX - 2; 514 seqInfo.maxSeq = INT32_MIN + 10; 515 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = {INT32_MAX - 10, INT32_MAX - 5, INT32_MIN, INT32_MIN + 1, INT32_MIN + 3}; 516 for (int i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 517 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 518 if (i >= 2) { 519 EXPECT_EQ(ret, true); 520 } else { 521 EXPECT_EQ(ret, false); 522 } 523 } 524 } 525 } // namespace OHOS