mirror of
https://github.com/intel/linux-sgx
synced 2026-06-08 14:49:32 +00:00
Li, Xun
d10cabebb5
Added new APIs in sgx_uae_service.h and sgx_ukey_exchange.h to support ECDSA quote based remote attestation. The set of legacy APIs supports EPID only and the set of new APIs supports ECDSA quotes. Enhanced Edger8r with structure deep-copy feature. Fixed bugs. Signed-off-by: Li, Xun <xun.li@intel.com>
194 lines
8.1 KiB
C++
194 lines
8.1 KiB
C++
/*=============================================================================
|
|
|
|
Library: CppMicroServices
|
|
|
|
Copyright (c) The CppMicroServices developers. See the COPYRIGHT
|
|
file at the top-level directory of this distribution and at
|
|
https://github.com/CppMicroServices/CppMicroServices/COPYRIGHT .
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
|
|
=============================================================================*/
|
|
|
|
#include "cppmicroservices/FrameworkEvent.h"
|
|
#include "cppmicroservices/Framework.h"
|
|
#include "cppmicroservices/FrameworkFactory.h"
|
|
|
|
#include "TestUtils.h"
|
|
#include "TestingConfig.h"
|
|
#include "TestingMacros.h"
|
|
|
|
#include <iostream>
|
|
#include <typeinfo>
|
|
|
|
using namespace cppmicroservices;
|
|
|
|
namespace {
|
|
|
|
std::string GetMessageFromStdExceptionPtr(const std::exception_ptr ptr)
|
|
{
|
|
if (ptr) {
|
|
try {
|
|
std::rethrow_exception(ptr);
|
|
} catch (const std::exception& e) {
|
|
return e.what();
|
|
}
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
} // end anonymous namespace
|
|
|
|
int FrameworkEventTest(int /*argc*/, char* /*argv*/ [])
|
|
{
|
|
US_TEST_BEGIN("FrameworkEventTest");
|
|
|
|
// The OSGi spec assigns specific values to event types for future extensibility.
|
|
// Ensure we don't deviate from those assigned values.
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_STARTED ==
|
|
static_cast<FrameworkEvent::Type>(1),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_ERROR ==
|
|
static_cast<FrameworkEvent::Type>(2),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_INFO ==
|
|
static_cast<FrameworkEvent::Type>(32),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_WARNING ==
|
|
static_cast<FrameworkEvent::Type>(16),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_STOPPED ==
|
|
static_cast<FrameworkEvent::Type>(64),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_STOPPED_UPDATE ==
|
|
static_cast<FrameworkEvent::Type>(128),
|
|
"Test assigned event type values");
|
|
US_TEST_CONDITION_REQUIRED(FrameworkEvent::Type::FRAMEWORK_WAIT_TIMEDOUT ==
|
|
static_cast<FrameworkEvent::Type>(512),
|
|
"Test assigned event type values");
|
|
|
|
// @todo mock the framework. We only need a Bundle object to construct a FrameworkEvent object.
|
|
auto const f = FrameworkFactory().NewFramework();
|
|
|
|
std::string default_exception_message(GetMessageFromStdExceptionPtr(nullptr));
|
|
|
|
FrameworkEvent invalid_event;
|
|
US_TEST_CONDITION_REQUIRED((!invalid_event),
|
|
"Test for invalid FrameworkEvent construction.");
|
|
US_TEST_CONDITION_REQUIRED(invalid_event.GetType() ==
|
|
FrameworkEvent::Type::FRAMEWORK_ERROR,
|
|
"invalid event GetType()");
|
|
US_TEST_CONDITION_REQUIRED(!invalid_event.GetBundle(),
|
|
"invalid event GetBundle()");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
(GetMessageFromStdExceptionPtr(invalid_event.GetThrowable()) ==
|
|
default_exception_message),
|
|
"invalid event GetThrowable()");
|
|
std::cout << invalid_event << std::endl;
|
|
|
|
FrameworkEvent error_event(
|
|
FrameworkEvent::Type::FRAMEWORK_ERROR,
|
|
f,
|
|
"test framework error event",
|
|
std::make_exception_ptr(std::runtime_error("test exception")));
|
|
US_TEST_CONDITION_REQUIRED((!error_event) == false,
|
|
"FrameworkEvent construction - error type");
|
|
US_TEST_CONDITION_REQUIRED(error_event.GetType() ==
|
|
FrameworkEvent::Type::FRAMEWORK_ERROR,
|
|
"error event GetType()");
|
|
US_TEST_CONDITION_REQUIRED(error_event.GetBundle() == f,
|
|
"error event GetBundle()");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
GetMessageFromStdExceptionPtr(error_event.GetThrowable()) ==
|
|
std::string("test exception"),
|
|
"error event GetThrowable");
|
|
std::cout << error_event << std::endl;
|
|
|
|
bool exception_caught = false;
|
|
try {
|
|
std::rethrow_exception(error_event.GetThrowable());
|
|
} catch (const std::exception& ex) {
|
|
exception_caught = true;
|
|
|
|
US_TEST_CONDITION_REQUIRED(
|
|
ex.what() == std::string("test exception"),
|
|
"Test FrameworkEvent::Type::FRAMEWORK_ERROR exception");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
std::string(typeid(std::runtime_error).name()) == typeid(ex).name(),
|
|
std::string("Test that the correct exception type was thrown: ") +
|
|
typeid(std::runtime_error).name() + " == " + typeid(ex).name());
|
|
}
|
|
US_TEST_CONDITION_REQUIRED(exception_caught,
|
|
"Test throw/catch a FrameworkEvent exception");
|
|
|
|
FrameworkEvent info_event(
|
|
FrameworkEvent::Type::FRAMEWORK_INFO, f, "test info framework event");
|
|
US_TEST_CONDITION_REQUIRED((!info_event) == false,
|
|
"FrameworkEvent construction - info type");
|
|
US_TEST_CONDITION_REQUIRED(info_event.GetType() ==
|
|
FrameworkEvent::Type::FRAMEWORK_INFO,
|
|
"info event GetType()");
|
|
US_TEST_CONDITION_REQUIRED(info_event.GetBundle() == f,
|
|
"info event GetBundle()");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
GetMessageFromStdExceptionPtr(info_event.GetThrowable()) ==
|
|
default_exception_message,
|
|
"info event GetThrowable()");
|
|
std::cout << info_event << std::endl;
|
|
|
|
FrameworkEvent warn_event(
|
|
FrameworkEvent::Type::FRAMEWORK_WARNING, f, "test warning framework event");
|
|
US_TEST_CONDITION_REQUIRED((!warn_event) == false,
|
|
"FrameworkEvent construction - warning type");
|
|
US_TEST_CONDITION_REQUIRED(warn_event.GetType() ==
|
|
FrameworkEvent::Type::FRAMEWORK_WARNING,
|
|
"warning event GetType()");
|
|
US_TEST_CONDITION_REQUIRED(warn_event.GetBundle() == f,
|
|
"warning event GetBundle()");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
GetMessageFromStdExceptionPtr(warn_event.GetThrowable()) ==
|
|
default_exception_message,
|
|
"wanring event GetThrowable()");
|
|
std::cout << warn_event << std::endl;
|
|
|
|
FrameworkEvent unknown_event(
|
|
static_cast<FrameworkEvent::Type>(127), f, "test unknown framework event");
|
|
US_TEST_CONDITION_REQUIRED((!unknown_event) == false,
|
|
"FrameworkEvent construction - unknown type");
|
|
US_TEST_CONDITION_REQUIRED(unknown_event.GetType() ==
|
|
static_cast<FrameworkEvent::Type>(127),
|
|
"unknown event GetType()");
|
|
US_TEST_CONDITION_REQUIRED(unknown_event.GetBundle() == f,
|
|
"unknown event GetBundle()");
|
|
US_TEST_CONDITION_REQUIRED(
|
|
GetMessageFromStdExceptionPtr(unknown_event.GetThrowable()) ==
|
|
default_exception_message,
|
|
"unknown event GetThrowable()");
|
|
std::cout << unknown_event << std::endl;
|
|
|
|
// copy test
|
|
FrameworkEvent dup_error_event(error_event);
|
|
US_TEST_CONDITION_REQUIRED(dup_error_event == error_event, "Test copy ctor");
|
|
|
|
// copy assignment test
|
|
dup_error_event = invalid_event;
|
|
US_TEST_CONDITION_REQUIRED(!(dup_error_event == error_event),
|
|
"Test copy assignment");
|
|
|
|
dup_error_event =
|
|
FrameworkEvent(FrameworkEvent::Type::FRAMEWORK_STARTED, f, "");
|
|
US_TEST_CONDITION_REQUIRED(!(dup_error_event == error_event), "Test move");
|
|
|
|
US_TEST_END()
|
|
}
|