Terminology of the Primitive is not specific.
Change-Id: I473310416076eb6929e00a1d4c47b05f7ae858fb
Signed-off-by: coderhyme <jhyo.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/1499
Reviewed-by: Uze Choi <uzchoi@samsung.com>
Tested-by: Uze Choi <uzchoi@samsung.com>
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#ifndef __PRIMITIVESERVERRESOURCE_H
-#define __PRIMITIVESERVERRESOURCE_H
+#ifndef __OIC_RESOURCEOBJECT_H
+#define __OIC_RESOURCEOBJECT_H
#include <string>
#include <mutex>
DeadLockException(std::string&& what) : PrimitiveException{ std::move(what) } {}
};
- class PrimitiveServerResource
+ class ResourceObject
{
private:
class WeakGuard;
// UPDATED
// };
- using Ptr = std::shared_ptr<PrimitiveServerResource>;
- using ConstPtr = std::shared_ptr<const PrimitiveServerResource>;
+ using Ptr = std::shared_ptr< ResourceObject >;
+ using ConstPtr = std::shared_ptr< const ResourceObject >;
class Builder
{
/**
* @throw PlatformException
*/
- PrimitiveServerResource::Ptr create();
+ ResourceObject::Ptr build();
private:
std::string m_uri;
ResourceAttributes&) >;
public:
- PrimitiveServerResource(PrimitiveServerResource&&) = delete;
- PrimitiveServerResource(const PrimitiveServerResource&) = delete;
+ ResourceObject(ResourceObject&&) = delete;
+ ResourceObject(const ResourceObject&) = delete;
- PrimitiveServerResource& operator=(PrimitiveServerResource&&) = delete;
- PrimitiveServerResource& operator=(const PrimitiveServerResource&) = delete;
+ ResourceObject& operator=(ResourceObject&&) = delete;
+ ResourceObject& operator=(const ResourceObject&) = delete;
- virtual ~PrimitiveServerResource();
+ virtual ~ResourceObject();
template< typename T >
void setAttribute(const std::string& key, T&& value)
// void setAutoNotifyPolicy(AutoNotifyPolicy);
private:
- PrimitiveServerResource(uint8_t, ResourceAttributes&&);
+ ResourceObject(uint8_t, ResourceAttributes&&);
OCEntityHandlerResult entityHandler(std::shared_ptr< OC::OCResourceRequest >);
mutable std::mutex m_mutex;
};
- class PrimitiveServerResource::LockGuard
+ class ResourceObject::LockGuard
{
public:
- LockGuard(const PrimitiveServerResource&);
- LockGuard(const PrimitiveServerResource::Ptr);
+ LockGuard(const ResourceObject&);
+ LockGuard(const ResourceObject::Ptr);
~LockGuard();
LockGuard(const LockGuard&) = delete;
LockGuard& operator=(LockGuard&&) = delete;
private:
- const PrimitiveServerResource& m_serverResource;
+ const ResourceObject& m_resourceObject;
};
- class PrimitiveServerResource::WeakGuard
+ class ResourceObject::WeakGuard
{
public:
- WeakGuard(const PrimitiveServerResource&);
+ WeakGuard(const ResourceObject&);
~WeakGuard();
WeakGuard(const WeakGuard&) = delete;
WeakGuard& operator=(WeakGuard&&) = delete;
private:
- const PrimitiveServerResource& m_serverResource;
+ const ResourceObject& m_serverResource;
bool m_hasLocked;
};
}
}
-#endif
+#endif // __OIC_RESOURCEOBJECT_H
#ifndef __REQUESTHANDLER_H
#define __REQUESTHANDLER_H
-#include <PrimitiveServerResource.h>
+#include <ResourceObject.h>
#include <internal/ResourceAtrributesConverter.h>
#include <OCResourceResponse.h>
class RequestHandler
{
public:
- using Ptr = std::shared_ptr<RequestHandler>;
+ using Ptr = std::shared_ptr< RequestHandler >;
static constexpr int DEFAULT_ERROR_CODE = 200;
static constexpr OCEntityHandlerResult DEFAULT_RESULT = OC_EH_OK;
}
virtual std::shared_ptr< OC::OCResourceResponse > buildResponse(
- PrimitiveServerResource&, const ResourceAttributes& requestAttrs) = 0;
+ ResourceObject&, const ResourceAttributes& requestAttrs) = 0;
};
class SimpleRequestHandler: public RequestHandler
int errorCode = DEFAULT_ERROR_CODE);
std::shared_ptr< OC::OCResourceResponse > buildResponse(
- PrimitiveServerResource&, const ResourceAttributes&) override;
+ ResourceObject&, const ResourceAttributes&) override;
protected:
- virtual int getErrorCode(PrimitiveServerResource&);
- virtual OCEntityHandlerResult getResponseResult(PrimitiveServerResource&);
- virtual OC::OCRepresentation getOCRepresentation(PrimitiveServerResource& resource);
+ virtual int getErrorCode(ResourceObject&);
+ virtual OCEntityHandlerResult getResponseResult(ResourceObject&);
+ virtual OC::OCRepresentation getOCRepresentation(ResourceObject& resource);
private:
OCEntityHandlerResult m_result;
}
protected:
- OC::OCRepresentation getOCRepresentation(PrimitiveServerResource& resource) override;
+ OC::OCRepresentation getOCRepresentation(ResourceObject& resource) override;
private:
ResourceAttributes m_attrs;
SetRequestProxyHandler(RequestHandler::Ptr requestHandler);
std::shared_ptr< OC::OCResourceResponse > buildResponse(
- PrimitiveServerResource& resource,
+ ResourceObject& resource,
const ResourceAttributes& requestAttrs) override;
private:
}
std::shared_ptr< OC::OCResourceResponse > SimpleRequestHandler::buildResponse(
- PrimitiveServerResource& resource, const ResourceAttributes&)
+ ResourceObject& resource, const ResourceAttributes&)
{
auto response = std::make_shared< OC::OCResourceResponse >();
return response;
}
- int SimpleRequestHandler::getErrorCode(PrimitiveServerResource&)
+ int SimpleRequestHandler::getErrorCode(ResourceObject&)
{
return m_errorCode;
}
- OCEntityHandlerResult SimpleRequestHandler::getResponseResult(PrimitiveServerResource&)
+ OCEntityHandlerResult SimpleRequestHandler::getResponseResult(ResourceObject&)
{
return m_result;
}
OC::OCRepresentation SimpleRequestHandler::getOCRepresentation(
- PrimitiveServerResource& resource)
+ ResourceObject& resource)
{
- PrimitiveServerResource::LockGuard lock{ resource };
+ ResourceObject::LockGuard lock{ resource };
return ResourceAttributesConverter::toOCRepresentation(resource.getAttributes());
}
OC::OCRepresentation CustomAttrRequestHandler::getOCRepresentation(
- PrimitiveServerResource& resource)
+ ResourceObject& resource)
{
return ResourceAttributesConverter::toOCRepresentation(m_attrs);
}
}
std::shared_ptr< OC::OCResourceResponse > SetRequestProxyHandler::buildResponse(
- PrimitiveServerResource& resource, const ResourceAttributes& requestAttrs)
+ ResourceObject& resource, const ResourceAttributes& requestAttrs)
{
{
- PrimitiveServerResource::LockGuard lock(resource);
+ ResourceObject::LockGuard lock(resource);
if (!acceptableAttributes(resource.getAttributes(), requestAttrs))
{
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include <PrimitiveServerResource.h>
+#include <ResourceObject.h>
#include <string>
#include <functional>
namespace Detail
{
template <typename RESPONSE>
- OCEntityHandlerResult sendResponse(PrimitiveServerResource& resource,
+ OCEntityHandlerResult sendResponse(ResourceObject& resource,
std::shared_ptr< OC::OCResourceRequest > ocRequest,
const ResourceAttributes& requestAttrs, RESPONSE&& response)
{
}
template< typename HANDLER, typename RESPONSE = typename std::decay<HANDLER>::type::result_type>
- OCEntityHandlerResult handleRequest(PrimitiveServerResource& resource,
+ OCEntityHandlerResult handleRequest(ResourceObject& resource,
std::shared_ptr< OC::OCResourceRequest > ocRequest, HANDLER&& handler)
{
ResourceAttributes attrs{ ResourceAttributesConverter::fromOCRepresentation(
{
namespace Service
{
- PrimitiveServerResource::PrimitiveServerResource(uint8_t properties,
+ ResourceObject::ResourceObject(uint8_t properties,
ResourceAttributes&& attrs) :
m_properties { properties }, m_resourceHandle{},
m_resourceAttributes{ std::move(attrs) }, m_getRequestHandler{ },
{
}
- PrimitiveServerResource::Builder::Builder(const std::string& uri, const std::string& type,
+ ResourceObject::Builder::Builder(const std::string& uri, const std::string& type,
const std::string& interface) :
m_uri{ uri }, m_type{ type }, m_interface{ interface },
m_properties{ OC_DISCOVERABLE | OC_OBSERVABLE }
{
}
- PrimitiveServerResource::Builder& PrimitiveServerResource::Builder::setDiscoverable(
+ ResourceObject::Builder& ResourceObject::Builder::setDiscoverable(
bool discoverable)
{
m_properties = ::makePropertyFlags(m_properties, OC_DISCOVERABLE, discoverable);
return *this;
}
- PrimitiveServerResource::Builder& PrimitiveServerResource::Builder::setObservable(
+ ResourceObject::Builder& ResourceObject::Builder::setObservable(
bool observable)
{
m_properties = ::makePropertyFlags(m_properties, OC_OBSERVABLE, observable);
return *this;
}
- PrimitiveServerResource::Builder& PrimitiveServerResource::Builder::setAttributes(
+ ResourceObject::Builder& ResourceObject::Builder::setAttributes(
const ResourceAttributes& attrs)
{
m_resourceAttributes = attrs;
return *this;
}
- PrimitiveServerResource::Builder& PrimitiveServerResource::Builder::setAttributes(
+ ResourceObject::Builder& ResourceObject::Builder::setAttributes(
ResourceAttributes&& attrs)
{
m_resourceAttributes = std::move(attrs);
return *this;
}
- PrimitiveServerResource::Ptr PrimitiveServerResource::Builder::create()
+ ResourceObject::Ptr ResourceObject::Builder::build()
{
OCResourceHandle handle{ nullptr };
- PrimitiveServerResource::Ptr server {
- new PrimitiveServerResource{ m_properties, std::move(m_resourceAttributes) } };
+ ResourceObject::Ptr server {
+ new ResourceObject{ m_properties, std::move(m_resourceAttributes) } };
- OC::EntityHandler entityHandler{ std::bind(&PrimitiveServerResource::entityHandler,
+ OC::EntityHandler entityHandler{ std::bind(&ResourceObject::entityHandler,
server.get(), std::placeholders::_1) };
try
}
- PrimitiveServerResource::~PrimitiveServerResource()
+ ResourceObject::~ResourceObject()
{
if (m_resourceHandle)
{
}
}
- bool PrimitiveServerResource::removeAttribute(const std::string& key)
+ bool ResourceObject::removeAttribute(const std::string& key)
{
WeakGuard lock(*this);
return m_resourceAttributes.erase(key);
}
- bool PrimitiveServerResource::hasAttribute(const std::string& key) const
+ bool ResourceObject::hasAttribute(const std::string& key) const
{
WeakGuard lock(*this);
return m_resourceAttributes.contains(key);
}
- ResourceAttributes& PrimitiveServerResource::getAttributes()
+ ResourceAttributes& ResourceObject::getAttributes()
{
expectOwnLock();
return m_resourceAttributes;
}
- const ResourceAttributes& PrimitiveServerResource::getAttributes() const
+ const ResourceAttributes& ResourceObject::getAttributes() const
{
expectOwnLock();
return m_resourceAttributes;
}
- void PrimitiveServerResource::expectOwnLock() const
+ void ResourceObject::expectOwnLock() const
{
if (m_lockOwner != std::this_thread::get_id())
{
}
}
- bool PrimitiveServerResource::isObservable() const
+ bool ResourceObject::isObservable() const
{
return ::hasProperty(m_properties, OC_OBSERVABLE);
}
- bool PrimitiveServerResource::isDiscoverable() const
+ bool ResourceObject::isDiscoverable() const
{
return ::hasProperty(m_properties, OC_DISCOVERABLE);
}
- void PrimitiveServerResource::setGetRequestHandler(GetRequestHandler h)
+ void ResourceObject::setGetRequestHandler(GetRequestHandler h)
{
m_getRequestHandler = h;
}
- void PrimitiveServerResource::setSetRequestHandler(SetRequestHandler h)
+ void ResourceObject::setSetRequestHandler(SetRequestHandler h)
{
m_setRequestHandler = h;
}
- void PrimitiveServerResource::notify() const
+ void ResourceObject::notify() const
{
using NotifyAllObservers = OCStackResult (*)(OCResourceHandle);
m_resourceHandle);
}
- OCEntityHandlerResult PrimitiveServerResource::entityHandler(
+ OCEntityHandlerResult ResourceObject::entityHandler(
std::shared_ptr< OC::OCResourceRequest > request)
{
if (!request)
return OC_EH_ERROR;
}
- OCEntityHandlerResult PrimitiveServerResource::handleRequest(
+ OCEntityHandlerResult ResourceObject::handleRequest(
std::shared_ptr< OC::OCResourceRequest > request)
{
if (request->getRequestType() == "GET")
return OC_EH_ERROR;
}
- OCEntityHandlerResult PrimitiveServerResource::handleRequestGet(
+ OCEntityHandlerResult ResourceObject::handleRequestGet(
std::shared_ptr< OC::OCResourceRequest > request)
{
return ::handleRequest(*this, request, m_getRequestHandler);
}
- OCEntityHandlerResult PrimitiveServerResource::handleRequestSet(
+ OCEntityHandlerResult ResourceObject::handleRequestSet(
std::shared_ptr< OC::OCResourceRequest > request)
{
return ::handleRequest(*this, request, m_setRequestHandler);
}
- OCEntityHandlerResult PrimitiveServerResource::handleObserve(
+ OCEntityHandlerResult ResourceObject::handleObserve(
std::shared_ptr< OC::OCResourceRequest > request)
{
if (!isObservable())
return OC_EH_OK;
}
- PrimitiveServerResource::LockGuard::LockGuard(const PrimitiveServerResource::Ptr ptr) :
+ ResourceObject::LockGuard::LockGuard(const ResourceObject::Ptr ptr) :
LockGuard{ *ptr }
{
}
- PrimitiveServerResource::LockGuard::LockGuard(
- const PrimitiveServerResource& serverResource) :
- m_serverResource(serverResource)
+ ResourceObject::LockGuard::LockGuard(
+ const ResourceObject& serverResource) :
+ m_resourceObject(serverResource)
{
- if (m_serverResource.m_lockOwner == std::this_thread::get_id())
+ if (m_resourceObject.m_lockOwner == std::this_thread::get_id())
{
throw DeadLockException{ "Can't lock recursively in same thread." };
}
- m_serverResource.m_mutex.lock();
- m_serverResource.m_lockOwner = std::this_thread::get_id();
+ m_resourceObject.m_mutex.lock();
+ m_resourceObject.m_lockOwner = std::this_thread::get_id();
}
- PrimitiveServerResource::LockGuard::~LockGuard()
+ ResourceObject::LockGuard::~LockGuard()
{
- m_serverResource.m_lockOwner = std::thread::id();
- m_serverResource.m_mutex.unlock();
+ m_resourceObject.m_lockOwner = std::thread::id();
+ m_resourceObject.m_mutex.unlock();
}
- PrimitiveServerResource::WeakGuard::WeakGuard(
- const PrimitiveServerResource& serverResource) :
+ ResourceObject::WeakGuard::WeakGuard(
+ const ResourceObject& serverResource) :
m_serverResource(serverResource), m_hasLocked{ false }
{
if (m_serverResource.m_lockOwner != std::this_thread::get_id())
}
}
- PrimitiveServerResource::WeakGuard::~WeakGuard()
+ ResourceObject::WeakGuard::~WeakGuard()
{
if (m_hasLocked)
{
#include <HippoMocks/hippomocks.h>
#include <PrimitiveResponse.h>
-#include <PrimitiveServerResource.h>
+#include <ResourceObject.h>
+
#include <internal/RequestHandler.h>
#include <internal/ResourceAtrributesConverter.h>
{
public:
MockRepository mocks;
- PrimitiveServerResource::Ptr server;
+ ResourceObject::Ptr server;
public:
template< typename T >
shared_ptr< OCResourceResponse > buildResponse(const T& response)
{
- PrimitiveServerResource::Ptr server =
- PrimitiveServerResource::Builder("a/test", "", "").create();
+ ResourceObject::Ptr server =
+ ResourceObject::Builder("a/test", "", "").build();
return response.getHandler()->buildResponse(*server, ResourceAttributes());
}
mocks.OnCallFunc(OCPlatform::unregisterResource).Return(OC_STACK_OK);
- server = PrimitiveServerResource::Builder("a/test", "", "").create();
+ server = ResourceObject::Builder("a/test", "", "").build();
}
};
class SimpleRequestHandlerTest: public Test
{
public:
- PrimitiveServerResource::Ptr server;
+ ResourceObject::Ptr server;
ResourceAttributes requestAttrs;
mocks.OnCallFuncOverload(static_cast<RegisterResource>(OC::OCPlatform::registerResource))
.Return(OC_STACK_OK);
- server = PrimitiveServerResource::Builder("a/test", "resourceType", "").create();
+ server = ResourceObject::Builder("a/test", "resourceType", "").build();
server->setAttribute(EXISTING, ORIGIN_VALUE);
}
class SetRequestProxyHandlerTest: public Test
{
public:
- PrimitiveServerResource::Ptr server;
+ ResourceObject::Ptr server;
ResourceAttributes requestAttrs;
RequestHandler::Ptr setRequestProxyHandler;
setRequestProxyHandler = make_shared<SetRequestProxyHandler>(
make_shared<SimpleRequestHandler>());
- server = PrimitiveServerResource::Builder("a/test", "resourceType", "").create();
+ server = ResourceObject::Builder("a/test", "resourceType", "").build();
server->setAttribute(EXISTING, ORIGIN_VALUE);
}
#include <gtest/gtest.h>
#include <HippoMocks/hippomocks.h>
-#include <PrimitiveServerResource.h>
+#include <ResourceObject.h>
#include <OCPlatform.h>
static constexpr char RESOURCE_TYPE[]{ "resourceType" };
static constexpr char KEY[]{ "key" };
-TEST(ServerResourceBuilderCreateTest, ThrowIfUriIsInvalid)
+TEST(ResourceObjectBuilderCreateTest, ThrowIfUriIsInvalid)
{
- ASSERT_THROW(PrimitiveServerResource::Builder("", "", "").create(), PlatformException);
+ ASSERT_THROW(ResourceObject::Builder("", "", "").build(), PlatformException);
}
-class ServerResourceBuilderTest: public Test
+class ResourceObjectBuilderTest: public Test
{
public:
MockRepository mocks;
}
};
-TEST_F(ServerResourceBuilderTest, RegisterResourceWhenCallCreate)
+TEST_F(ResourceObjectBuilderTest, RegisterResourceWhenCallCreate)
{
mocks.ExpectCallFuncOverload(static_cast<registerResourceSig>(OCPlatform::registerResource))
.Return(OC_STACK_OK);
- PrimitiveServerResource::Builder(RESOURCE_URI, RESOURCE_TYPE, "").create();
+ ResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE, "").build();
}
-TEST_F(ServerResourceBuilderTest, ResourceServerHasPropertiesSetByBuilder)
+TEST_F(ResourceObjectBuilderTest, ResourceServerHasPropertiesSetByBuilder)
{
- auto serverResource = PrimitiveServerResource::Builder(RESOURCE_URI, RESOURCE_TYPE, "").
- setDiscoverable(false).setObservable(true).create();
+ auto serverResource = ResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE, "").
+ setDiscoverable(false).setObservable(true).build();
EXPECT_FALSE(serverResource->isDiscoverable());
EXPECT_TRUE(serverResource->isObservable());
}
-TEST_F(ServerResourceBuilderTest, ResourceServerHasAttrsSetByBuilder)
+TEST_F(ResourceObjectBuilderTest, ResourceServerHasAttrsSetByBuilder)
{
ResourceAttributes attrs;
attrs[KEY] = 100;
- auto serverResource = PrimitiveServerResource::Builder(RESOURCE_URI, RESOURCE_TYPE, "").
- setAttributes(attrs).create();
+ auto serverResource = ResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE, "").
+ setAttributes(attrs).build();
- PrimitiveServerResource::LockGuard lock{ serverResource };
+ ResourceObject::LockGuard lock{ serverResource };
EXPECT_EQ(attrs, serverResource->getAttributes());
}
-class ServerResourceTest: public Test
+class ResourceObjectTest: public Test
{
public:
MockRepository mocks;
- PrimitiveServerResource::Ptr server;
+ ResourceObject::Ptr server;
protected:
void SetUp() override
{
initMocks();
- server = PrimitiveServerResource::Builder(RESOURCE_URI, RESOURCE_TYPE, "").create();
+ server = ResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE, "").build();
}
virtual void initMocks()
}
};
-TEST_F(ServerResourceTest, AccessAttributesWithLock)
+TEST_F(ResourceObjectTest, AccessAttributesWithLock)
{
constexpr int value{ 100 };
{
- PrimitiveServerResource::LockGuard lock{ server };
+ ResourceObject::LockGuard lock{ server };
auto& attr = server->getAttributes();
attr[KEY] = value;
}
ASSERT_EQ(value, server->getAttribute<int>(KEY));
}
-TEST_F(ServerResourceTest, ThrowIfTryToAccessAttributesWithoutLock)
+TEST_F(ResourceObjectTest, ThrowIfTryToAccessAttributesWithoutLock)
{
ASSERT_THROW(server->getAttributes(), NoLockException);
}
-TEST_F(ServerResourceTest, ThrowIfLockRecursively)
+TEST_F(ResourceObjectTest, ThrowIfLockRecursively)
{
- PrimitiveServerResource::LockGuard lock{ server };
+ ResourceObject::LockGuard lock{ server };
- ASSERT_THROW(PrimitiveServerResource::LockGuard again{ server }, DeadLockException);
+ ASSERT_THROW(ResourceObject::LockGuard again{ server }, DeadLockException);
}
-TEST_F(ServerResourceTest, AccessingAttributesWithMethodsWithinLockDoesntCauseDeadLock)
+TEST_F(ResourceObjectTest, AccessingAttributesWithMethodsWithinLockDoesntCauseDeadLock)
{
constexpr int value{ 100 };
{
- PrimitiveServerResource::LockGuard lock{ server };
+ ResourceObject::LockGuard lock{ server };
server->setAttribute(KEY, value);
}
-class ServerResourceHandlingRequestTest: public ServerResourceTest
+class ResourceObjectHandlingRequestTest: public ResourceObjectTest
{
public:
EntityHandler handler;
{
mocks.OnCallFuncOverload(
static_cast<registerResourceSig>(OCPlatform::registerResource)).Do(
- bind(&ServerResourceHandlingRequestTest::registerResourceFake,
+ bind(&ResourceObjectHandlingRequestTest::registerResourceFake,
this, _1, _2, _3, _4, _5, _6));
mocks.OnCallFunc(OCPlatform::unregisterResource).Return(OC_STACK_OK);
}
};
-TEST_F(ServerResourceHandlingRequestTest, CallSendResponseWhenReceiveRequest)
+TEST_F(ResourceObjectHandlingRequestTest, CallSendResponseWhenReceiveRequest)
{
mocks.ExpectCallFunc(OCPlatform::sendResponse).Return(OC_STACK_OK);
ASSERT_EQ(OC_EH_OK, handler(createRequest()));
}
-TEST_F(ServerResourceHandlingRequestTest, ReturnErrorCodeWhenSendResponseFailed)
+TEST_F(ResourceObjectHandlingRequestTest, ReturnErrorCodeWhenSendResponseFailed)
{
mocks.ExpectCallFunc(OCPlatform::sendResponse).Return(OC_STACK_ERROR);
ASSERT_EQ(OC_EH_ERROR, handler(createRequest()));
}
-TEST_F(ServerResourceHandlingRequestTest, SendResponseWithSameHandlesPassedByRequest)
+TEST_F(ResourceObjectHandlingRequestTest, SendResponseWithSameHandlesPassedByRequest)
{
mocks.ExpectCallFunc(OCPlatform::sendResponse).Match(
[](const shared_ptr<OCResourceResponse> response)
ASSERT_EQ(OC_EH_OK, handler(createRequest()));
}
-TEST_F(ServerResourceHandlingRequestTest, SendResponseWithPrimitiveResponseResults)
+TEST_F(ResourceObjectHandlingRequestTest, SendResponseWithPrimitiveResponseResults)
{
constexpr int errorCode{ 1999 };
constexpr OCEntityHandlerResult result{ OC_EH_SLOW };
ASSERT_EQ(OC_EH_OK, handler(createRequest()));
}
-TEST_F(ServerResourceHandlingRequestTest, SendSetResponseWithCustomAttrsAndResults)
+TEST_F(ResourceObjectHandlingRequestTest, SendSetResponseWithCustomAttrsAndResults)
{
constexpr int errorCode{ 1999 };
constexpr OCEntityHandlerResult result{ OC_EH_SLOW };
-class ServerResourceSynchronizationTest: public ServerResourceHandlingRequestTest
+class ResourceObjectSynchronizationTest: public ResourceObjectHandlingRequestTest
{
public:
- static void withLock(PrimitiveServerResource::Ptr serverResource, int count)
+ static void withLock(ResourceObject::Ptr serverResource, int count)
{
for (int i=0; i<count; ++i)
{
- PrimitiveServerResource::LockGuard lock{ serverResource };
+ ResourceObject::LockGuard lock{ serverResource };
auto& attrs = serverResource->getAttributes();
}
}
- static void withSetter(PrimitiveServerResource::Ptr serverResource, int count)
+ static void withSetter(ResourceObject::Ptr serverResource, int count)
{
for (int i=0; i<count; ++i)
{
- PrimitiveServerResource::LockGuard lock{ serverResource };
+ ResourceObject::LockGuard lock{ serverResource };
serverResource->setAttribute(KEY, serverResource->getAttribute<int>(KEY) + 1);
}
}
};
-TEST_F(ServerResourceSynchronizationTest, MultipleAccessToServerResource)
+TEST_F(ResourceObjectSynchronizationTest, MultipleAccessToServerResource)
{
int expected { 0 };
vector<thread> threads;
ASSERT_EQ(expected, server->getAttribute<int>(KEY));
}
-TEST_F(ServerResourceSynchronizationTest, MultipleAccessToServerResourceWithRequests)
+TEST_F(ResourceObjectSynchronizationTest, MultipleAccessToServerResourceWithRequests)
{
int expected { 0 };
vector<thread> threads;
projects / platform / upstream / iotivity.git / commitdiff