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);
});
}
