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 (int32_t 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 int32_t i = 0; i < 2; 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 (int32_t 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 (int32_t 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, 11, 8, 7 }; 132 for (int32_t 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 (int32_t 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, -56, -50 }; 172 for (int32_t 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 (int32_t 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, 58, 0, 7 }; 215 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 216 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 217 if (i < 2) { 218 EXPECT_EQ(ret, true); 219 } else { 220 EXPECT_EQ(ret, false); 221 } 222 } 223 } 224 225 /** 226 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_007 227 * @tc.desc: Verify disorder seq, seq flip negative, boundary valueseq. 228 * INT32_MIN + 59 - INT32_MIN + INT32_MAX - (INT32_MAX - 1) + 1 > 60[MAX_SEQ_BIAS] 229 * @tc.type: FUNC 230 * @tc.require: 231 */ 232 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_007, TestSize.Level0) 233 { 234 SeqVerifyInfo seqInfo = { 0 }; 235 seqInfo.minSeq = INT32_MAX - 2; 236 seqInfo.maxSeq = INT32_MAX - 2; 237 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { INT32_MAX - 2, INT32_MAX - 1, 59, 0, 7 }; 238 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 239 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 240 if (i < 2) { 241 EXPECT_EQ(ret, true); 242 } else { 243 EXPECT_EQ(ret, false); 244 } 245 } 246 } 247 248 /** 249 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_008 250 * @tc.desc: Verify disorder seq, seq flip positive, boundary valueseq. 251 * 31 + 29 = 60[MAX_SEQ_BIAS] 252 * @tc.type: FUNC 253 * @tc.require: 254 */ 255 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_008, TestSize.Level0) 256 { 257 SeqVerifyInfo seqInfo = { 0 }; 258 seqInfo.minSeq = -30; 259 seqInfo.maxSeq = -30; 260 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -30, -29, 31, 10, 5 }; 261 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 262 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 263 EXPECT_EQ(ret, true); 264 } 265 } 266 267 /** 268 * @tc.name: Softbus_SeqVerifyTest_Test_DisorderCase_009 269 * @tc.desc: Verify disorder seq, seq flip positive, boundary valueseq. 270 * 32 + 29 > 60[MAX_SEQ_BIAS] 271 * @tc.type: FUNC 272 * @tc.require: 273 */ 274 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_DisorderCase_009, TestSize.Level0) 275 { 276 SeqVerifyInfo seqInfo = { 0 }; 277 seqInfo.minSeq = -30; 278 seqInfo.maxSeq = -30; 279 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -30, -29, 32, 0, -3 }; 280 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 281 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 282 if (i < 2) { 283 EXPECT_EQ(ret, true); 284 } else if (i == 2) { 285 EXPECT_EQ(ret, false); 286 } else { 287 EXPECT_EQ(ret, true); 288 } 289 } 290 } 291 292 /** 293 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_001 294 * @tc.desc: Verify repeat seq. 295 * @tc.type: FUNC 296 * @tc.require: 297 */ 298 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_001, TestSize.Level0) 299 { 300 SeqVerifyInfo seqInfo = { 0 }; 301 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { 2, 10, 2, 3, 3 }; 302 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 303 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 304 if (i < 2 || i == 3) { 305 EXPECT_EQ(ret, true); 306 } else { 307 EXPECT_EQ(ret, false); 308 } 309 } 310 } 311 312 /** 313 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_002 314 * @tc.desc: Verify repeat seq. 315 * @tc.type: FUNC 316 * @tc.require: 317 */ 318 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_002, TestSize.Level0) 319 { 320 SeqVerifyInfo seqInfo = { 0 }; 321 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { 0, 10, 1, 5, 5 }; 322 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 323 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 324 if (i < 4) { 325 EXPECT_EQ(ret, true); 326 } else { 327 EXPECT_EQ(ret, false); 328 } 329 } 330 } 331 332 /** 333 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_003 334 * @tc.desc: Verify repeat seq, flip negative. 335 * @tc.type: FUNC 336 * @tc.require: 337 */ 338 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_003, TestSize.Level0) 339 { 340 SeqVerifyInfo seqInfo = { 0 }; 341 seqInfo.minSeq = INT32_MAX - 2; 342 seqInfo.maxSeq = INT32_MAX - 2; 343 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { INT32_MAX - 2, INT32_MAX - 1, 5, INT32_MAX - 1, 3 }; 344 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 345 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 346 if (i < 2) { 347 EXPECT_EQ(ret, true); 348 } else { 349 EXPECT_EQ(ret, false); 350 } 351 } 352 } 353 354 /** 355 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_004 356 * @tc.desc: Verify repeat seq, flip negative. 357 * @tc.type: FUNC 358 * @tc.require: 359 */ 360 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_004, TestSize.Level0) 361 { 362 SeqVerifyInfo seqInfo = { 0 }; 363 seqInfo.minSeq = INT32_MAX - 2; 364 seqInfo.maxSeq = INT32_MAX - 2; 365 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { INT32_MAX - 2, 0, 5, 0, 3 }; 366 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 367 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 368 if (i < 1) { 369 EXPECT_EQ(ret, true); 370 } else { 371 EXPECT_EQ(ret, false); 372 } 373 } 374 } 375 376 /** 377 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_005 378 * @tc.desc: Verify repeat seq, flip positive. 379 * @tc.type: FUNC 380 * @tc.require: 381 */ 382 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_005, TestSize.Level0) 383 { 384 SeqVerifyInfo seqInfo = { 0 }; 385 seqInfo.minSeq = -10; 386 seqInfo.maxSeq = -10; 387 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -10, -1, 10, -1, 3 }; 388 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 389 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 390 if (i < 3 || i == 4) { 391 EXPECT_EQ(ret, true); 392 } else { 393 EXPECT_EQ(ret, false); 394 } 395 } 396 } 397 398 /** 399 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_006 400 * @tc.desc: Verify repeat seq, flip positive. 401 * @tc.type: FUNC 402 * @tc.require: 403 */ 404 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_006, TestSize.Level0) 405 { 406 SeqVerifyInfo seqInfo = { 0 }; 407 seqInfo.minSeq = -10; 408 seqInfo.maxSeq = -10; 409 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -10, 1, 10, 1, 3 }; 410 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 411 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 412 if (i < 3 || i == 4) { 413 EXPECT_EQ(ret, true); 414 } else { 415 EXPECT_EQ(ret, false); 416 } 417 } 418 } 419 420 /** 421 * @tc.name: Softbus_SeqVerifyTest_Test_RepeatCase_007 422 * @tc.desc: Verify repeat seq. 423 * @tc.type: FUNC 424 * @tc.require: 425 */ 426 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_RepeatCase_007, TestSize.Level0) 427 { 428 SeqVerifyInfo seqInfo = { 0 }; 429 seqInfo.minSeq = 0; 430 seqInfo.maxSeq = 0; 431 int32_t recvSeq[12] = { 0, 1, 2, 3, 4, 3, 3, 10, 5, 5, 5, 5 }; 432 for (int32_t i = 0; i < 12; i++) { 433 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 434 if (i < 5 || i == 7 || i == 8) { 435 EXPECT_EQ(ret, true); 436 } else { 437 EXPECT_EQ(ret, false); 438 } 439 } 440 } 441 442 /** 443 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_001 444 * @tc.desc: Verify abnormal seq, minSeq positive. 445 * @tc.type: FUNC 446 * @tc.require: 447 */ 448 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_001, TestSize.Level0) 449 { 450 SeqVerifyInfo seqInfo = { 0 }; 451 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -10, -2, 10, 1, 3 }; 452 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 453 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 454 if (i >= 2) { 455 EXPECT_EQ(ret, true); 456 } else { 457 EXPECT_EQ(ret, false); 458 } 459 } 460 } 461 462 /** 463 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_002 464 * @tc.desc: Verify abnormal seq, minSeq negative. 465 * @tc.type: FUNC 466 * @tc.require: 467 */ 468 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_002, TestSize.Level0) 469 { 470 SeqVerifyInfo seqInfo = { 0 }; 471 seqInfo.minSeq = -10; 472 seqInfo.maxSeq = -10; 473 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -15, -12, 10, 1, 3 }; 474 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 475 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 476 if (i >= 2) { 477 EXPECT_EQ(ret, true); 478 } else { 479 EXPECT_EQ(ret, false); 480 } 481 } 482 } 483 484 /** 485 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_003 486 * @tc.desc: Verify abnormal seq, minSeq negative. 487 * @tc.type: FUNC 488 * @tc.require: 489 */ 490 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_003, TestSize.Level0) 491 { 492 SeqVerifyInfo seqInfo = { 0 }; 493 seqInfo.minSeq = -10; 494 seqInfo.maxSeq = 10; 495 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { -15, -12, 10, 1, 3 }; 496 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 497 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 498 if (i >= 2) { 499 EXPECT_EQ(ret, true); 500 } else { 501 EXPECT_EQ(ret, false); 502 } 503 } 504 } 505 506 /** 507 * @tc.name: Softbus_SeqVerifyTest_Test_LessThanMinCase_004 508 * @tc.desc: Verify abnormal seq, minSeq negative. 509 * @tc.type: FUNC 510 * @tc.require: 511 */ 512 HWTEST_F(SequenceVerificationTest, Softbus_SeqVerifyTest_Test_LessThanMinCase_004, TestSize.Level0) 513 { 514 SeqVerifyInfo seqInfo = { 0 }; 515 seqInfo.minSeq = INT32_MAX - 2; 516 seqInfo.maxSeq = INT32_MIN + 10; 517 int32_t recvSeq[MAX_RECEIVE_SEQUENCE] = { INT32_MAX - 10, INT32_MAX - 5, 0, 1, 3 }; 518 for (int32_t i = 0; i < MAX_RECEIVE_SEQUENCE; i++) { 519 bool ret = IsPassSeqCheck(&seqInfo, recvSeq[i]); 520 EXPECT_EQ(ret, false); 521 } 522 } 523 } // namespace OHOS