void vmxon_ut::test_stop_vmxoff_check_failure() { MockRepository mocks; auto in = bfn::mock_shared<intrinsics_intel_x64>(mocks); auto intrinsics = in.get(); auto l_mm = bfn::mock_shared<memory_manager>(mocks); mm = l_mm.get(); // execute_vmxoff mocks.OnCall(intrinsics, intrinsics_intel_x64::vmxoff).Return(true); // disable_vmx_operation Call &cr4_0 = mocks.ExpectCall(intrinsics, intrinsics_intel_x64::read_cr4).Return(0); mocks.OnCall(intrinsics, intrinsics_intel_x64::write_cr4).Do(stubbed_write_cr4); // is_vmx_operation_enabled mocks.ExpectCall(intrinsics, intrinsics_intel_x64::read_cr4).After(cr4_0).Return(CR4_VMXE_VMX_ENABLE_BIT); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { vmxon_intel_x64 vmxon(in); EXPECT_EXCEPTION(vmxon.stop(), bfn::vmxon_failure_error); }); }
TEST(TestTinyMock,TestIfFailureNotifierIsCalledOnlyWithTheFirstFailingExpectation) { const int argValue = 25 ; MockRepository<YaffutFailureNotifier> mockRepository; TestMock* testMock = mockRepository.CreateMock<TestMock, ExceptionFailureNotifier>("TestMock"); testMock->RegisterExpectation(new TinyMock::Method<int,void,void,void,void>("TestMethodWithAnArgument",argValue)); testMock->RegisterExpectation(new TinyMock::Method<int,void,void,void,void>("TestMethodWithAnArgument",argValue)); try { testMock->TestMethodWithAnArgument(argValue-1); } catch(exception) { try { testMock->TestMethodWithAnArgument(argValue-1); } catch(exception) { FAIL("PIES"); } mockRepository.verifyAll(); return; } FAIL(""); }
void vmxon_ut::test_start_check_vmx_capabilities_msr_addr_width_failure() { MockRepository mocks; auto in = bfn::mock_shared<intrinsics_intel_x64>(mocks); auto intrinsics = in.get(); auto l_mm = bfn::mock_shared<memory_manager>(mocks); mm = l_mm.get(); // is_vmx_operation_enabled mocks.ExpectCall(intrinsics, intrinsics_intel_x64::read_cr4).Return(0); // check_cpuid_vmx_supported mocks.OnCall(intrinsics, intrinsics_intel_x64::cpuid_ecx).With(1).Return((1 << 5)); // check_vmx_capabilities_msr auto basic = ((1ULL << 55) | ((~(1ULL << 48)))); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_VMX_BASIC_MSR).Return(basic); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { vmxon_intel_x64 vmxon(in); EXPECT_EXCEPTION(vmxon.start(), bfn::vmxon_capabilities_failure_error); }); }
TEST(DiscoveryManagerTest, CallbackWouldNotBeCalledForSameRemoteResource) { FindCallback callback; MockRepository mocks; mocks.OnCallFuncOverload(static_cast<OCFindResource>(findResource)).Do( [&callback](const std::string&, const std::string&, OCConnectivityType, FindCallback cb) { callback = cb; return OC_STACK_OK; } ).Return(OC_STACK_OK); ScopedTask aTask {RCSDiscoveryManager::getInstance()->discoverResource(RCSAddress::multicast(), onResourceDiscovered)}; std::vector< std::string > interfaces{ "interface" }; std::vector< std::string > resourceTypes{ "resource.type" }; constexpr char fakeHost[] { "coap://127.0.0.1:1" }; mocks.ExpectCallFunc(onResourceDiscovered); callback(OCPlatform::constructResourceObject(fakeHost, "/uri", OCConnectivityType::CT_ADAPTER_IP, true, interfaces, resourceTypes)); mocks.NeverCallFunc(onResourceDiscovered); callback(OCPlatform::constructResourceObject(fakeHost, "/uri", OCConnectivityType::CT_ADAPTER_IP, true, interfaces, resourceTypes)); }
TEST(TestTinyMock,IgnoringArgumentsInACallToASpecificMethodButNotIgnoringThemForTheSubsequentCalls) { MockRepository<YaffutFailureNotifier> mockRepository; TestMock* testMock = mockRepository.CreateMock<TestMock, ExceptionFailureNotifier>("TestMock"); const int doesNotMatter = 0 ; const int expectedArgument = 1 ; const int actualArgument = 255 ; testMock->RegisterExpectation(new TinyMock::Method<int,void,void,void,void>("TestMethodWithAnArgument",doesNotMatter)).ignoreArguments(); testMock->RegisterExpectation(new TinyMock::Method<int,void,void,void,void>("TestMethodWithAnArgument",expectedArgument)); try { testMock->TestMethodWithAnArgument(actualArgument); } catch(std::exception) { FAIL(""); } try { testMock->TestMethodWithAnArgument(actualArgument); } catch(std::exception) { mockRepository.verifyAll(); return ; } FAIL(""); }
void driver_entry_ut::test_common_dump_resolve_symbol_failed() { EXPECT_TRUE(common_add_module(m_dummy1, m_dummy1_length) == BF_SUCCESS); EXPECT_TRUE(common_add_module(m_dummy2, m_dummy2_length) == BF_SUCCESS); EXPECT_TRUE(common_add_module(m_dummy3, m_dummy3_length) == BF_SUCCESS); EXPECT_TRUE(common_load_vmm() == BF_SUCCESS); // We need to wrap the mocks variable in a temporary stack frame as the // current implementation of HippoMocks does not have a function to undo // it's hooks into c-style functions as the functionality to do this is // in the destructor. { MockRepository mocks; mocks.OnCallFunc(resolve_symbol).Return(-1); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_dump_vmm() == BF_ERROR_FAILED_TO_DUMP_DR); }); } EXPECT_TRUE(common_unload_vmm() == BF_SUCCESS); }
GTEST_TEST(ConstructResourceObjectTest, ConstructResourceObjectInValidReturnValue) { MockRepository mocks; OCResource::Ptr rightdoor = std::shared_ptr<OCResource>(); mocks.ExpectCallFunc(OCPlatform::constructResourceObject).Return(NULL); std::vector<std::string> types = {"core.rightdoor"}; OCResource::Ptr leftdoor = OCPlatform::constructResourceObject("192.168.1.2:5000", "a/rightdoor", false, types, ifaces); bool value = (leftdoor == NULL); EXPECT_EQ(true, value); }
//using mocks framework GTEST_TEST(ConstructResourceObjectTest, ConstructResourceObjectValidReturnValue) { MockRepository mocks; OCResource::Ptr rightdoor = std::shared_ptr<OCResource>(); OCConnectivityType connectivityType = OC_WIFI; mocks.ExpectCallFunc(OCPlatform::constructResourceObject).Return(rightdoor); std::vector<std::string> types = {"core.leftdoor"}; OCResource::Ptr leftdoor = OCPlatform::constructResourceObject("192.168.1.2:5000", "a/leftdoor", connectivityType, false, types, ifaces); EXPECT_EQ(leftdoor, rightdoor); }
void driver_entry_ut::test_common_load_loader_init_failed() { MockRepository mocks; mocks.OnCallFunc(bfelf_loader_init).Return(-1); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_load_vmm() == -1); }); }
void driver_entry_ut::test_common_load_status_running() { MockRepository mocks; mocks.OnCallFunc(vmm_status).Return(VMM_RUNNING); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_load_vmm() == BF_ERROR_VMM_INVALID_STATE); }); }
void driver_entry_ut::test_common_load_status_loaded() { MockRepository mocks; mocks.OnCallFunc(vmm_status).Return(VMM_LOADED); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_load_vmm() == BF_SUCCESS); }); }
void driver_entry_ut::test_common_load_status_corrupt() { MockRepository mocks; mocks.OnCallFunc(vmm_status).Return(VMM_CORRUPT); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_load_vmm() == BF_ERROR_VMM_CORRUPTED); }); }
TEST(TestTinyMock,TestReturningArguments) { MockRepository<YaffutFailureNotifier> mockRepository ; TestMock* testMock = mockRepository.CreateMock<TestMock,YaffutFailureNotifier>("TestMock"); testMock->RegisterExpectation(new TinyMock::Method<void,void,void,void,int>("TestMethodWithReturnValue",125)); EQUAL(125,testMock->TestMethodWithReturnValue()); mockRepository.verifyAll(); }
void driver_entry_ut::test_common_dump_status_unloaded() { MockRepository mocks; mocks.OnCallFunc(vmm_status).Return(VMM_UNLOADED); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(common_dump_vmm() == BF_ERROR_VMM_INVALID_STATE); }); }
TEST(SyncEngine, loadAllSources0) { MockRepository mocks; CDBAdapter* db = mocks.ClassMock<CDBAdapter>(); mocks.ExpectCall(db, CDBAdapter::prepareStatement).Return(new CDBResult(g_mxDB)); CSyncEngine oSyncEngine(*db); oSyncEngine.loadAllSources(); EXPECT_EQ(0, oSyncEngine.getSources().size()); }
TEST(TestTinyMock,TestIfAMethodIsCalled) { MockRepository<YaffutFailureNotifier> mockRepository; MockLogger* logger = mockRepository.CreateMock<MockLogger, ExceptionFailureNotifier>("Logger") ; logger->RegisterExpectation(new TinyMock::Method<void,void,void,void,void>("log")); OurTestClass testClass(logger) ; testClass.methodA() ; mockRepository.verifyAll(); }
virtual void TearDown() { try { mocks.VerifyAll(); } catch (...) { mocks.reset(); throw; } }
TEST(DiscoveryManagerTest, DiscoverInvokesFindResource) { MockRepository mocks; mocks.ExpectCallFuncOverload(static_cast<OCFindResource>(findResource)).Match( [](const std::string& host, const std::string& resourceURI, OCConnectivityType, FindCallback) { return host.empty() && resourceURI == (std::string(RESOURCE_URI) + "?rt=" + RESOURCE_TYPE); } ).Return(OC_STACK_OK); ScopedTask task {RCSDiscoveryManager::getInstance()->discoverResourceByType( RCSAddress::multicast(), RESOURCE_URI, RESOURCE_TYPE, onResourceDiscovered)}; }
TEST(TestTinyMock,WhenIgnoringAllCallsToAMethodYouDoNotNeedToRegisterExpectationForThisMethodCall) { MockRepository<YaffutFailureNotifier> mockRepository; TestMock* testMock = mockRepository.CreateMock<TestMock, YaffutFailureNotifier>("TestMock"); testMock->IgnoreAll("TestMethod"); testMock->TestMethod(); testMock->TestMethod(); mockRepository.verifyAll(); }
void memory_manager_ut::test_root_page_table_x64_map_add_md_failure() { MockRepository mocks; auto &&mm = setup_mm(mocks); mocks.OnCall(mm, memory_manager_x64::add_md).Throw(std::runtime_error("error")); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { this->expect_exception([&] { g_pt->map(0x12347000, 0x54323000, x64::memory_attr::rw_wb); }, ""_ut_ree); }); }
void entry_ut::test_start_vmm_success() { MockRepository mocks; auto vcm = mocks.Mock<vcpu_manager>(); mocks.OnCallFunc(vcpu_manager::instance).Return(vcm); mocks.OnCall(vcm, vcpu_manager::init); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_NO_EXCEPTION(start_vmm(0)); }); }
void entry_ut::test_init_vmm_throws_any_exception() { MockRepository mocks; auto vcm = mocks.Mock<vcpu_manager>(); mocks.OnCallFunc(vcpu_manager::instance).Return(vcm); mocks.OnCall(vcm, vcpu_manager::init).Throw(10); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_NO_EXCEPTION(init_vmm(0)); }); }
void vmxon_ut::test_start_check_ia32_feature_control_msr() { MockRepository mocks; auto in = bfn::mock_shared<intrinsics_intel_x64>(mocks); auto intrinsics = in.get(); auto l_mm = bfn::mock_shared<memory_manager>(mocks); mm = l_mm.get(); // is_vmx_operation_enabled mocks.OnCall(intrinsics, intrinsics_intel_x64::read_cr4).Return(0); // check_cpuid_vmx_supported mocks.OnCall(intrinsics, intrinsics_intel_x64::cpuid_ecx).With(1).Return((1 << 5)); // check_vmx_capabilities_msr auto basic = ((1ULL << 55) | ((6ULL << 50) & (~(1ULL << 48)))); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_VMX_BASIC_MSR).Return(basic); // check_ia32_vmx_cr0_fixed_msr mocks.OnCall(intrinsics, intrinsics_intel_x64::read_cr0).Return((0xffffffff)); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_VMX_CR0_FIXED0_MSR).Return(0); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_VMX_CR0_FIXED1_MSR).Return(0xffffffff); // check_ia32_feature_control_msr mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_FEATURE_CONTROL_MSR).Return(0); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { vmxon_intel_x64 vmxon(in); EXPECT_EXCEPTION(vmxon.start(), bfn::vmxon_failure_error); }); }
void memory_manager_ut::test_root_page_table_x64_init_failure() { MockRepository mocks; auto &&mm = setup_mm(mocks); mocks.OnCall(mm, memory_manager_x64::add_md).With(0xDEADBEEF, _, _).Throw(std::runtime_error("error")); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { this->expect_no_exception([&] { root_page_table_x64::instance(); }); this->expect_true(g_terminate_called); }); }
void vmm_ut::test_verify_vmx_capabilities_msr_failed_invalid_memory_type() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_VMX_BASIC_MSR).Return(0); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.verify_vmx_capabilities_msr() == vmm_error::not_supported); }); }
void vmm_ut::test_verify_cpuid_vmx_supported_success() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.OnCall(intrinsics, intrinsics_intel_x64::cpuid_ecx).Return((1 << 5)); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.verify_cpuid_vmx_supported() == vmm_error::success); }); }
void vmm_ut::test_execute_vmxoff_already_off() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.NeverCall(intrinsics, intrinsics_intel_x64::vmxoff); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.execute_vmxoff() == vmm_error::success); }); }
void vmm_ut::test_verify_vmx_operation_disabled_success() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_cr4).Return(0); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.verify_vmx_operation_disabled() == vmm_error::success); }); }
void vmm_ut::test_verify_v8086_disabled_failed() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_rflags).Return(RFLAGS_VM_VIRTUAL_8086_MODE); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.verify_v8086_disabled() == vmm_error::not_supported); }); }
void vmm_ut::test_verify_ia32_feature_control_msr_success() { MockRepository mocks; intrinsics_intel_x64 *intrinsics = mocks.Mock<intrinsics_intel_x64>(); vmm_intel_x64 vmm(intrinsics); mocks.OnCall(intrinsics, intrinsics_intel_x64::read_msr).With(IA32_FEATURE_CONTROL_MSR).Return(1); RUN_UNITTEST_WITH_MOCKS(mocks, [&] { EXPECT_TRUE(vmm.verify_ia32_feature_control_msr() == vmm_error::success); }); }