Skip to content

Commit ca1d1db

Browse files
bratpiorkabratpiorka
committed
add missing negative provider tests
1 parent 047432a commit ca1d1db

8 files changed

+143
-0
lines changed

‎test/provider_devdax_memory.cpp‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -565,3 +565,51 @@ TEST_F(test, create_wrong_size_0) {
565565
ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params);
566566
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
567567
}
568+
569+
TEST_F(test, create_NULL_params) {
570+
umf_memory_provider_handle_t hProvider = nullptr;
571+
auto ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), nullptr,
572+
&hProvider);
573+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
574+
ASSERT_EQ(hProvider, nullptr);
575+
}
576+
577+
TEST_F(test, params_NULL_name) {
578+
umf_devdax_memory_provider_params_handle_t params = nullptr;
579+
auto ret =
580+
umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
581+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
582+
ASSERT_NE(params, nullptr);
583+
584+
ret = umfDevDaxMemoryProviderParamsSetName(params, nullptr);
585+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
586+
587+
ret = umfDevDaxMemoryProviderParamsDestroy(params);
588+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
589+
590+
ret = umfDevDaxMemoryProviderParamsSetName(nullptr, "test");
591+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
592+
}
593+
594+
TEST_F(test, get_NULL_name) {
595+
umf_devdax_memory_provider_params_handle_t params = nullptr;
596+
auto ret =
597+
umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
598+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
599+
ASSERT_NE(params, nullptr);
600+
601+
umf_memory_provider_handle_t hProvider = nullptr;
602+
ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), params,
603+
&hProvider);
604+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
605+
ASSERT_NE(hProvider, nullptr);
606+
607+
ret = umfMemoryProviderGetName(hProvider, NULL);
608+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
609+
610+
ret = umfMemoryProviderDestroy(hProvider);
611+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
612+
613+
ret = umfDevDaxMemoryProviderParamsDestroy(params);
614+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
615+
}

‎test/provider_devdax_memory_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,9 @@ TEST_F(test, devdax_provider_not_implemented) {
2525
umf_result = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 0);
2626
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
2727

28+
umf_result = umfDevDaxMemoryProviderParamsSetName(params, "test");
29+
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
30+
2831
const umf_memory_provider_ops_t *ops = umfDevDaxMemoryProviderOps();
2932
EXPECT_EQ(ops, nullptr);
3033
}

‎test/provider_file_memory.cpp‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -624,3 +624,66 @@ TEST_P(FileProviderParamsShared, IPC_file_not_exist) {
624624
umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
625625
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
626626
}
627+
628+
TEST_F(test, create_NULL_params) {
629+
umf_memory_provider_handle_t hProvider = nullptr;
630+
auto ret = umfMemoryProviderCreate(umfFileMemoryProviderOps(), nullptr,
631+
&hProvider);
632+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
633+
ASSERT_EQ(hProvider, nullptr);
634+
}
635+
636+
TEST_F(test, params_NULL_name) {
637+
umf_file_memory_provider_params_handle_t params = nullptr;
638+
umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
639+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
640+
ASSERT_NE(params, nullptr);
641+
642+
ret = umfFileMemoryProviderParamsSetName(params, nullptr);
643+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
644+
645+
ret = umfFileMemoryProviderParamsDestroy(params);
646+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
647+
648+
ret = umfFileMemoryProviderParamsSetName(nullptr, "test");
649+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
650+
}
651+
652+
TEST_F(test, get_NULL_name) {
653+
umf_file_memory_provider_params_handle_t params = nullptr;
654+
umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
655+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
656+
ASSERT_NE(params, nullptr);
657+
658+
umf_memory_provider_handle_t hProvider = nullptr;
659+
ret =
660+
umfMemoryProviderCreate(umfFileMemoryProviderOps(), params, &hProvider);
661+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
662+
ASSERT_NE(hProvider, nullptr);
663+
664+
ret = umfMemoryProviderGetName(hProvider, NULL);
665+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
666+
667+
ret = umfMemoryProviderDestroy(hProvider);
668+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
669+
670+
ret = umfFileMemoryProviderParamsDestroy(params);
671+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
672+
}
673+
674+
TEST_F(test, params_protection_flag) {
675+
umf_file_memory_provider_params_handle_t params = nullptr;
676+
umf_result_t ret =
677+
umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
678+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
679+
ASSERT_NE(params, nullptr);
680+
681+
// test all valid combinations
682+
for (unsigned protection = UMF_PROTECTION_NONE;
683+
protection < (UMF_PROTECTION_MAX - 1) << 1; ++protection) {
684+
ret = umfFileMemoryProviderParamsSetProtection(params, protection);
685+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
686+
}
687+
688+
umfFileMemoryProviderParamsDestroy(params);
689+
}

‎test/provider_file_memory_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,9 @@ TEST_F(test, file_provider_not_implemented) {
2828
umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
2929
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
3030

31+
umf_result = umfFileMemoryProviderParamsSetName(params, "test");
32+
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
33+
3134
const umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps();
3235
EXPECT_EQ(ops, nullptr);
3336
}

‎test/providers/provider_cuda.cpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -276,6 +276,10 @@ TEST_P(umfCUDAProviderTest, getName) {
276276
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
277277
ASSERT_STREQ(name, "CUDA");
278278

279+
// negative case - pass NULL as a name pointer
280+
umf_result = umfMemoryProviderGetName(provider, nullptr);
281+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
282+
279283
umfMemoryProviderDestroy(provider);
280284
}
281285

@@ -469,6 +473,12 @@ TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
469473
res =
470474
umfCUDAMemoryProviderParamsSetMemoryType(nullptr, expected_memory_type);
471475
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
476+
477+
res = umfCUDAMemoryProviderParamsSetAllocFlags(nullptr, 0);
478+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
479+
480+
res = umfCUDAMemoryProviderParamsSetName(nullptr, "test");
481+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
472482
}
473483

474484
TEST_P(umfCUDAProviderTest, cudaProviderInvalidCreate) {

‎test/providers/provider_cuda_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,9 @@ TEST_F(test, cuda_provider_not_implemented) {
2929
result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
3030
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
3131

32+
result = umfCUDAMemoryProviderParamsSetName(hParams, "test");
33+
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
34+
3235
const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
3336
ASSERT_EQ(ops, nullptr);
3437
}

‎test/providers/provider_level_zero.cpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -396,6 +396,10 @@ TEST_P(umfLevelZeroProviderTest, getName) {
396396
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
397397
ASSERT_STREQ(name, "LEVEL_ZERO");
398398

399+
// negative case - pass NULL as a name pointer
400+
umf_result = umfMemoryProviderGetName(provider, nullptr);
401+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
402+
399403
umfMemoryProviderDestroy(provider);
400404
}
401405

@@ -546,6 +550,12 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) {
546550

547551
res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0);
548552
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
553+
554+
res = umfLevelZeroMemoryProviderParamsSetAllocFlags(nullptr, 0);
555+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
556+
557+
res = umfLevelZeroMemoryProviderParamsSetName(nullptr, "test");
558+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
549559
}
550560

551561
TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) {

‎test/providers/provider_level_zero_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,9 @@ TEST_F(test, level_zero_provider_not_implemented) {
3838
result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0);
3939
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
4040

41+
result = umfLevelZeroMemoryProviderParamsSetName(hParams, "test");
42+
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
43+
4144
const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
4245
ASSERT_EQ(ops, nullptr);
4346
}

0 commit comments

Comments
 (0)