#include <string>
-using namespace std;
-
namespace OIC
{
namespace Service
*/
class BundleInfo
{
- public:
- BundleInfo();
- virtual ~BundleInfo();
- virtual void setID(string name) = 0;
- virtual string getID() = 0;
- virtual void setPath(string path) = 0;
- virtual string getPath() = 0;
- virtual void setActivatorName(string activator) = 0;
- virtual string getActivatorName() = 0;
- virtual void setLibraryPath(string libpath) = 0;
- virtual string getLibraryPath() = 0;
- virtual void setVersion(string version) = 0;
- virtual string getVersion() = 0;
- static BundleInfo* build();
- protected:
- string m_ID, m_path, m_version;
+ public:
+ BundleInfo();
+ virtual ~BundleInfo();
+ virtual void setID(std::string name) = 0;
+ virtual std::string getID() = 0;
+ virtual void setPath(std::string path) = 0;
+ virtual std::string getPath() = 0;
+ virtual void setActivatorName(std::string activator) = 0;
+ virtual std::string getActivatorName() = 0;
+ virtual void setLibraryPath(std::string libpath) = 0;
+ virtual std::string getLibraryPath() = 0;
+ virtual void setVersion(std::string version) = 0;
+ virtual std::string getVersion() = 0;
+ static BundleInfo *build();
+ protected:
+ std::string m_ID, m_path, m_version;
};
}
}
#include "BundleInfo.h"
-using namespace std;
-
namespace OIC
{
namespace Service
{
class ResourceContainer
{
- public:
- ResourceContainer();
- virtual ~ResourceContainer();
- //virtual void initializeResourceContainer() = 0;
- virtual void startContainer(string configFile) = 0;
- virtual void stopContainer() = 0;
+ public:
+ ResourceContainer();
+ virtual ~ResourceContainer();
+ virtual void startContainer(std::string configFile) = 0;
+ virtual void stopContainer() = 0;
- // list of bundle ids
- virtual std::list<BundleInfo*> listBundles() = 0;
- virtual void startBundle(string bundleId) = 0;
- virtual void stopBundle(string bundleId) = 0;
+ // list of bundle ids
+ virtual std::list<BundleInfo *> listBundles() = 0;
+ virtual void startBundle(std::string bundleId) = 0;
+ virtual void stopBundle(std::string bundleId) = 0;
- // dynamic configuration
- virtual void addBundle(string bundleId, string bundleUri, string bundlePath, std::map<string, string> params) =0;
- virtual void removeBundle(string bundleId) = 0;
+ // dynamic configuration
+ virtual void addBundle(std::string bundleId, std::string bundleUri, std::string bundlePath,
+ std::map<std::string, std::string> params) = 0;
+ virtual void removeBundle(std::string bundleId) = 0;
- virtual void addResourceConfig(string bundleId, string resourceUri, std::map<string, string> params) = 0;
- virtual void removeResourceConfig(string bundleId, string resourceUri) = 0;
+ virtual void addResourceConfig(std::string bundleId, std::string resourceUri,
+ std::map<std::string, std::string> params) = 0;
+ virtual void removeResourceConfig(std::string bundleId, std::string resourceUri) = 0;
- virtual std::list<string> listBundleResources(string bundleId) = 0;
+ virtual std::list<std::string> listBundleResources(std::string bundleId) = 0;
- static ResourceContainer *getInstance();
+ static ResourceContainer *getInstance();
};
}
}
'include',
'bundle-api/include',
'src',
- '../serverBuilder/include',
- '../common/primitiveResource/include',
os.environ['JAVA_HOME']+'/include',
os.environ['JAVA_HOME']+'/include/linux'
])
virtual void setInputAttribute(SensorData inputs) = 0;
- int inputCount;
+ unsigned int inputCount;
vector<string> m_vecInputAttributes;
map< string, SensorData > m_mapStoredInputData;
SensorData m_outputs;
using namespace OIC::Service;
-HueLight::HueLight(){
+HueLight::HueLight()
+{
}
-HueLight::HueLight(HueConnector* connector, std::string address){
+HueLight::HueLight(HueConnector *connector, std::string address)
+{
m_address = address;
m_connector = connector;
initAttributes();
}
-HueLight::~HueLight(){
+HueLight::~HueLight()
+{
}
-string HueLight::getAttribute(string attributeName){
-
+string HueLight::getAttribute(string attributeName)
+{
+ return BundleResource::getAttribute(attributeName);
}
-void HueLight::initAttributes(){
+void HueLight::initAttributes()
+{
BundleResource::setAttribute("on-off", "false");
BundleResource::setAttribute("dim", "0");
BundleResource::setAttribute("color", "0");
m_mapAttributes.insert(std::pair<string, string>("color", "0"));*/
}
-void HueLight::setAttribute(string attributeName, string value){
+void HueLight::setAttribute(string attributeName, string value)
+{
cout << "HueLight::setAttribute setting " << attributeName << " to " << value << std::endl;
- if(attributeName == "on-off"){
+ if (attributeName == "on-off")
+ {
m_connector->transmit(this->m_address + "/state", "{\"on\":" + value + "}");
}
- if(attributeName == "dim"){
+ if (attributeName == "dim")
+ {
//m_connector->transmit(this->m_address + "/state", "{\"bri\":" + (value * 2.5) + "}");
m_connector->transmit(this->m_address + "/state", "{\"bri\":" + value + "}");
}
- if(attributeName == "color"){
+ if (attributeName == "color")
+ {
//m_connector->transmit(this->m_address+ "/state", "{\"hue\":" + (value * 650) + "}");
- m_connector->transmit(this->m_address+ "/state", "{\"hue\":" + value + "}");
+ m_connector->transmit(this->m_address + "/state", "{\"hue\":" + value + "}");
}
}
string DiscomfortIndexSensorResource::getAttribute(string attributeName)
{
cout << "DiscomfortIndexSensorResource::getAttribute called !!" << endl;
+ return BundleResource::getAttribute(attributeName);
}
void DiscomfortIndexSensorResource::setAttribute(string attributeName, string value)
m_pDiscomfortIndexSensor->runLogic(inData);
m_outputs = m_pDiscomfortIndexSensor->m_output;
- for (int i = 0; i < m_outputs.data.size(); i++)
+ for (unsigned int i = 0; i < m_outputs.data.size(); i++)
{
if (!m_outputs.data.at(i)["name"].compare("temperature"))
- BundleResource::setAttribute("temperature",m_outputs.data.at(i)["value"]);
+ BundleResource::setAttribute("temperature", m_outputs.data.at(i)["value"]);
else if (!m_outputs.data.at(i)["name"].compare("humidity"))
- BundleResource::setAttribute("humidity",m_outputs.data.at(i)["value"]);
+ BundleResource::setAttribute("humidity", m_outputs.data.at(i)["value"]);
else if (!m_outputs.data.at(i)["name"].compare("discomfortIndex"))
- BundleResource::setAttribute("discomfortIndex",m_outputs.data.at(i)["value"]);
+ BundleResource::setAttribute("discomfortIndex", m_outputs.data.at(i)["value"]);
}
}
}
#include "ResourceContainerBundleAPI.h"
#include "BundleInfoInternal.h"
-#include "PrimitiveRequest.h"
-#include "PrimitiveResponse.h"
+#include "RCSRequest.h"
+#include "RCSResponse.h"
#include "ResourceObject.h"
#include "jni.h"
void getResourceConfiguration(std::string bundleId,
std::vector< resourceInfo > *configOutput);
- PrimitiveGetResponse getRequestHandler(const PrimitiveRequest &request,
- const ResourceAttributes &attributes);
- PrimitiveSetResponse setRequestHandler(const PrimitiveRequest &request,
- const ResourceAttributes &attributes);
+ RCSGetResponse getRequestHandler(const RCSRequest &request,
+ const ResourceAttributes &attributes);
+ RCSSetResponse setRequestHandler(const RCSRequest &request,
+ const ResourceAttributes &attributes);
void onNotificationReceived(std::string strResourceUri);
#include "oc_logger.hpp"
#include <iostream>
+using namespace std;
using namespace OIC::Service;
using OC::oc_log_stream;
ResourceContainer *container = ResourceContainer::getInstance();
container->startContainer("examples/ResourceContainerConfig.xml");
- std::list<BundleInfo*> bundles = container->listBundles();
- std::list<BundleInfo*>::iterator bundleIt;
+ std::list<BundleInfo *> bundles = container->listBundles();
+ std::list<BundleInfo *>::iterator bundleIt;
- for(bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++){
- BundleInfo* bi = *bundleIt;
+ for (bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++)
+ {
+ BundleInfo *bi = *bundleIt;
info_logger() << "Available bundle: " << bi->getID() << endl;
}
cout << "Press enter to stop all bundles " << endl;
getchar();
- for(bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++){
- BundleInfo* bi = *bundleIt;
+ for (bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++)
+ {
+ BundleInfo *bi = *bundleIt;
info_logger() << "Stopping bundle: " << bi->getID() << endl;
container->stopBundle(bi->getID());
}
cout << "Press enter to restart all bundles " << endl;
getchar();
- for(bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++){
- BundleInfo* bi = *bundleIt;
+ for (bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++)
+ {
+ BundleInfo *bi = *bundleIt;
info_logger() << "Starting bundle: " << bi->getID() << endl;
container->startBundle(bi->getID());
}
bool has_suffix(const std::string &str, const std::string &suffix)
{
return str.size() >= suffix.size()
- && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+ && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}
void ResourceContainerImpl::startContainer(string configFile)
configInfo bundles;
m_config->getConfiguredBundles(&bundles);
- for (int i = 0; i < bundles.size(); i++)
+ for (unsigned int i = 0; i < bundles.size(); i++)
{
BundleInfo *bundleInfo = BundleInfo::build();
bundleInfo->setPath(bundles[i]["path"]);
{
info_logger() << "Stopping resource container.";
for (std::map< std::string, BundleInfoInternal * >::iterator it = m_bundles.begin();
- it != m_bundles.end(); ++it)
+ it != m_bundles.end(); ++it)
{
BundleInfoInternal *bundleInfo = it->second;
deactivateBundle(bundleInfo);
void ResourceContainerImpl::unregisterBundle(BundleInfo *bundleInfo)
{
- BundleInfoInternal* bundleInfoInternal = (BundleInfoInternal*) bundleInfo;
+ BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) bundleInfo;
if (bundleInfoInternal->isLoaded() && !bundleInfoInternal->isActivated())
{
if (!bundleInfoInternal->getJavaBundle())
{
void *bundleHandle = m_bundles[id]->getBundleHandle();
info_logger() << "Unregister bundle: " << m_bundles[id]->getID() << ", "
- << m_bundles[id]->getID() << endl;
+ << m_bundles[id]->getID() << endl;
char *error;
dlclose(bundleHandle);
if ((error = dlerror()) != NULL)
void ResourceContainerImpl::unregisterBundleJava(string id)
{
info_logger() << "Unregister Java bundle: " << m_bundles[id]->getID() << ", "
- << m_bundles[id]->getID() << endl;
+ << m_bundles[id]->getID() << endl;
info_logger() << "Destroying JVM" << endl;
m_bundleVM[id]->DestroyJavaVM();
ResourceObject::Ptr server = nullptr;
info_logger() << "Registration of resource " << strUri << "," << strResourceType
- << endl;
+ << endl;
server = buildResourceObject(strUri, strResourceType);
resource->registerObserver(this);
server->setGetRequestHandler(
- std::bind(&ResourceContainerImpl::getRequestHandler, this,
- std::placeholders::_1, std::placeholders::_2));
+ std::bind(&ResourceContainerImpl::getRequestHandler, this,
+ std::placeholders::_1, std::placeholders::_2));
server->setSetRequestHandler(
- std::bind(&ResourceContainerImpl::setRequestHandler, this,
- std::placeholders::_1, std::placeholders::_2));
+ std::bind(&ResourceContainerImpl::setRequestHandler, this,
+ std::placeholders::_1, std::placeholders::_2));
info_logger() << "Registration finished " << strUri << "," << strResourceType
- << endl;
+ << endl;
}
}
m_config->getResourceConfiguration(bundleId, configOutput);
}
- PrimitiveGetResponse ResourceContainerImpl::getRequestHandler(
- const PrimitiveRequest &request, const ResourceAttributes &attributes)
+ RCSGetResponse ResourceContainerImpl::getRequestHandler(
+ const RCSRequest &request, const ResourceAttributes &attributes)
{
ResourceAttributes attr;
if (m_mapServers.find(request.getResourceUri()) != m_mapServers.end()
- && m_mapResources.find(request.getResourceUri()) != m_mapResources.end())
+ && m_mapResources.find(request.getResourceUri()) != m_mapResources.end())
{
for (string attrName : m_mapResources[request.getResourceUri()]->getAttributeNames())
{
attr[attrName] = m_mapResources[request.getResourceUri()]->getAttribute(
- attrName);
+ attrName);
}
}
- return PrimitiveGetResponse::create(attr);
+ return RCSGetResponse::create(attr);
}
- PrimitiveSetResponse ResourceContainerImpl::setRequestHandler(
- const PrimitiveRequest &request, const ResourceAttributes &attributes)
+ RCSSetResponse ResourceContainerImpl::setRequestHandler(
+ const RCSRequest &request, const ResourceAttributes &attributes)
{
ResourceAttributes attr = attributes;
if (m_mapServers.find(request.getResourceUri()) != m_mapServers.end()
- && m_mapResources.find(request.getResourceUri()) != m_mapResources.end())
+ && m_mapResources.find(request.getResourceUri()) != m_mapResources.end())
{
for (string attrName : m_mapResources[request.getResourceUri()]->getAttributeNames())
{
}
}
- return PrimitiveSetResponse::create(attr);
+ return RCSSetResponse::create(attr);
}
void ResourceContainerImpl::onNotificationReceived(std::string strResourceUri)
{
info_logger() << "ResourceContainerImpl::onNotificationReceived\n\tnotification from "
- << strResourceUri << ".\n";
+ << strResourceUri << ".\n";
if (m_mapServers.find(strResourceUri) != m_mapServers.end())
{
string strResourceType)
{
return ResourceObject::Builder(strUri, strResourceType, "DEFAULT_INTERFACE").setObservable(
- true).setDiscoverable(true).build();
+ true).setDiscoverable(true).build();
}
void ResourceContainerImpl::startBundle(string bundleId)
}
void ResourceContainerImpl::addBundle(string bundleId, string bundleUri, string bundlePath,
- std::map< string, string > params)
+ std::map< string, string > params)
{
// To be implemented
}
{
std::list< BundleInfo * > ret;
for (std::map< std::string, BundleInfoInternal * >::iterator it = m_bundles.begin();
- it != m_bundles.end(); ++it)
+ it != m_bundles.end(); ++it)
{
{
BundleInfo *bundleInfo = BundleInfo::build();
{
std::list< string > ret;
- if (m_mapBundleResources.find(bundleId) != m_mapBundleResources.end())
+ if (m_mapBundleResources.find(bundleId) != m_mapBundleResources.end())
{
ret = m_mapBundleResources[bundleId];
}
-
+
return ret;
}
void ResourceContainerImpl::registerJavaBundle(BundleInfo *bundleInfo)
{
info_logger() << "Registering Java bundle " << bundleInfo->getID() << endl;
- JavaVM * jvm;
- JNIEnv * env;
+ JavaVM *jvm;
+ JNIEnv *env;
JavaVMInitArgs vm_args;
JavaVMOption options[3];
BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) bundleInfo;
- if(FILE *file = fopen(bundleInfo->getPath().c_str(), "r")){
+ if (FILE *file = fopen(bundleInfo->getPath().c_str(), "r"))
+ {
fclose(file);
info_logger() << "Resource bundle " << bundleInfo->getPath() << " available." << endl;
//return true;
}
- else{
+ else
+ {
error_logger() << "Resource bundle " << bundleInfo->getPath() << " not available" << endl;
return;
}
- options[0].optionString = "-Djava.compiler=NONE";
+ char optionString[] = "-Djava.compiler=NONE";
+ options[0].optionString = optionString;
char classpath[1000];
strcpy(classpath, "-Djava.class.path=");
strcat(classpath, bundleInfo->getPath().c_str());
int res;
res = JNI_CreateJavaVM(&jvm, (void **) &env, &vm_args);
- if(res < 0){
+ if (res < 0)
+ {
error_logger() << " cannot create JavaVM." << endl;
return;
}
- else{
+ else
+ {
info_logger() << "JVM successfully created " << endl;
}
if (bundleActivatorClass == NULL)
{
error_logger() << "Cannot register bundle " << bundleInfoInternal->getID()
- << " bundle activator(" << bundleInfoInternal->getActivatorName()
- << ") not found " << endl;
+ << " bundle activator(" << bundleInfoInternal->getActivatorName()
+ << ") not found " << endl;
return;
}
jmethodID activateMethod = env->GetMethodID(bundleActivatorClass, "activateBundle",
- "()V");
+ "()V");
if (activateMethod == NULL)
{
error_logger() << "Cannot register bundle " << bundleInfoInternal->getID()
- << " activate bundle method not found " << endl;
+ << " activate bundle method not found " << endl;
return;
}
bundleInfoInternal->setJavaBundleActivatorMethod(activateMethod);
jmethodID deactivateMethod = env->GetMethodID(bundleActivatorClass, "deactivateBundle",
- "()V");
+ "()V");
if (deactivateMethod == NULL)
{
error_logger() << "Cannot register bundle " << bundleInfoInternal->getID()
- << " deactivate bundle method not found " << endl;
+ << " deactivate bundle method not found " << endl;
return;
}
{
bundleActivator = (activator_t *) dlsym(bundleHandle, "externalActivateBundle");
bundleDeactivator = (deactivator_t *) dlsym(bundleHandle,
- "externalDeactivateBundle");
+ "externalDeactivateBundle");
if ((error = dlerror()) != NULL)
{
error_logger() << error << endl;
info_logger() << "Activating java bundle" << endl;
JavaVM *vm = getJavaVM(bundleId);
BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) m_bundles[bundleId];
- JNIEnv * env;
+ JNIEnv *env;
int envStat = vm->GetEnv((void **) &env, JNI_VERSION_1_4);
if (envStat == JNI_EDETACHED)
}
env->CallVoidMethod(bundleInfoInternal->getJavaBundleActivatorObject(),
- bundleInfoInternal->getJavaBundleActivatorMethod());
+ bundleInfoInternal->getJavaBundleActivatorMethod());
m_bundles[bundleId]->setActivated(true);
}
info_logger() << "Deactivating java bundle" << endl;
JavaVM *vm = getJavaVM(bundleId);
BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) m_bundles[bundleId];
- JNIEnv * env;
+ JNIEnv *env;
int envStat = vm->GetEnv((void **) &env, JNI_VERSION_1_4);
if (envStat == JNI_EDETACHED)
}
env->CallVoidMethod(bundleInfoInternal->getJavaBundleActivatorObject(),
- bundleInfoInternal->getJavaBundleDeactivatorMethod());
+ bundleInfoInternal->getJavaBundleDeactivatorMethod());
m_bundles[bundleId]->setActivated(false);
}
/*Fake bundle resource class for testing*/
class TestBundleResource: public BundleResource
{
-public:
- string getAttribute(string attributeName)
- {
- return "test";
- }
- ;
- void setAttribute(string attributeName, string value)
- {
- }
- ;
- void initAttributes()
- {
- BundleResource::setAttribute("attri", "test");
- }
- ;
+ public:
+ string getAttribute(string attributeName)
+ {
+ return "test";
+ }
+ ;
+ void setAttribute(string attributeName, string value)
+ {
+ }
+ ;
+ void initAttributes()
+ {
+ BundleResource::setAttribute("attri", "test");
+ }
+ ;
};
class ResourceContainerTest: public Test
{
-public:
- ResourceContainer *m_pResourceContainer;
+ public:
+ ResourceContainer *m_pResourceContainer;
-protected:
- void SetUp() override
- {
- m_pResourceContainer = ResourceContainer::getInstance();
- }
+ protected:
+ void SetUp() override
+ {
+ m_pResourceContainer = ResourceContainer::getInstance();
+ }
};
TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
{
m_pResourceContainer->startContainer(CONFIG_FILE);
- EXPECT_GT(m_pResourceContainer->listBundles().size(), 0);
+ EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
EXPECT_STREQ("oic.bundle.test",
- (*m_pResourceContainer->listBundles().begin())->getID().c_str());
+ (*m_pResourceContainer->listBundles().begin())->getID().c_str());
EXPECT_STREQ("libTestBundle.so",
- (*m_pResourceContainer->listBundles().begin())->getPath().c_str());
+ (*m_pResourceContainer->listBundles().begin())->getPath().c_str());
EXPECT_STREQ("1.0.0", (*m_pResourceContainer->listBundles().begin())->getVersion().c_str());
m_pResourceContainer->stopContainer();
{
m_pResourceContainer->startContainer(CONFIG_FILE);
- EXPECT_GT(m_pResourceContainer->listBundles().size(), 0);
+ EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
EXPECT_TRUE(((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isLoaded());
EXPECT_NE(nullptr,
- ((BundleInfoInternal *)( *m_pResourceContainer->listBundles().begin()))->getBundleHandle());
+ ((BundleInfoInternal *)( *m_pResourceContainer->listBundles().begin()))->getBundleHandle());
m_pResourceContainer->stopContainer();
}
{
m_pResourceContainer->startContainer(CONFIG_FILE);
- EXPECT_GT(m_pResourceContainer->listBundles().size(), 0);
+ EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
EXPECT_TRUE(
- ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
+ ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
EXPECT_NE(nullptr,
- ((BundleInfoInternal *)( *m_pResourceContainer->listBundles().begin()))->getBundleActivator());
+ ((BundleInfoInternal *)( *m_pResourceContainer->listBundles().begin()))->getBundleActivator());
m_pResourceContainer->stopContainer();
}
{
m_pResourceContainer->startContainer("invalideConfig");
- EXPECT_EQ(0, m_pResourceContainer->listBundles().size());
+ EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
}
TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
m_pResourceContainer->startContainer(CONFIG_FILE);
m_pResourceContainer->stopContainer();
- EXPECT_EQ(0, m_pResourceContainer->listBundles().size());
+ EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
}
TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
m_pResourceContainer->stopBundle("oic.bundle.test");
EXPECT_FALSE(
- ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
+ ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
}
TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
m_pResourceContainer->startBundle("oic.bundle.test");
EXPECT_TRUE(
- ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
+ ((BundleInfoInternal *)(*m_pResourceContainer->listBundles().begin()))->isActivated());
}
class ResourceContainerBundleAPITest: public Test
{
-public:
- MockRepository mocks;
- ResourceObject *m_pResourceObject;
- ResourceContainerBundleAPI *m_pResourceContainer;
- TestBundleResource *m_pBundleResource;
-
-protected:
- void SetUp() override
- {
- m_pResourceObject = mocks.Mock<ResourceObject>();
- m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
-
- m_pBundleResource = new TestBundleResource();
- m_pBundleResource->m_bundleId = "oic.bundle.test";
- m_pBundleResource->m_uri = "/test_resource";
- m_pBundleResource->m_resourceType = "oic.test";
- }
+ public:
+ MockRepository mocks;
+ ResourceObject *m_pResourceObject;
+ ResourceContainerBundleAPI *m_pResourceContainer;
+ TestBundleResource *m_pBundleResource;
+
+ protected:
+ void SetUp() override
+ {
+ m_pResourceObject = mocks.Mock<ResourceObject>();
+ m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
+
+ m_pBundleResource = new TestBundleResource();
+ m_pBundleResource->m_bundleId = "oic.bundle.test";
+ m_pBundleResource->m_uri = "/test_resource";
+ m_pBundleResource->m_resourceType = "oic.test";
+ }
};
TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
{
mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
- ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
- {}));
+ ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
+ {}));
mocks.ExpectCall(m_pResourceObject, ResourceObject::setGetRequestHandler);
mocks.ExpectCall(m_pResourceObject, ResourceObject::setSetRequestHandler);
TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
{
mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
- ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
- {}));
+ ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
+ {}));
mocks.ExpectCall(m_pResourceObject, ResourceObject::setGetRequestHandler);
mocks.ExpectCall(m_pResourceObject, ResourceObject::setSetRequestHandler);
m_pResourceContainer->registerResource(m_pBundleResource);
m_pResourceContainer->unregisterResource(m_pBundleResource);
- EXPECT_EQ(0,
- ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources( m_pBundleResource->m_bundleId).size());
+ EXPECT_EQ((unsigned int) 0,
+ ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
+ m_pBundleResource->m_bundleId).size());
}
TEST_F(ResourceContainerBundleAPITest,
- ServerNotifiesToObserversWhenNotificationReceivedFromResource)
+ ServerNotifiesToObserversWhenNotificationReceivedFromResource)
{
mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
- ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
- {}));
+ ResourceObject::Ptr(m_pResourceObject, [](ResourceObject *)
+ {}));
mocks.ExpectCall(m_pResourceObject, ResourceObject::setGetRequestHandler);
mocks.ExpectCall(m_pResourceObject, ResourceObject::setSetRequestHandler);
class ResourceContainerImplTest: public Test
{
-public:
- MockRepository mocks;
- ResourceContainerImpl *m_pResourceContainer;
- BundleInfo *m_pBundleInfo;
-
-protected:
- void SetUp() override
- {
- m_pResourceContainer = ResourceContainerImpl::getImplInstance();
- m_pBundleInfo = BundleInfo::build();
- }
+ public:
+ MockRepository mocks;
+ ResourceContainerImpl *m_pResourceContainer;
+ BundleInfo *m_pBundleInfo;
+
+ protected:
+ void SetUp() override
+ {
+ m_pResourceContainer = ResourceContainerImpl::getImplInstance();
+ m_pBundleInfo = BundleInfo::build();
+ }
};
TEST_F(ResourceContainerImplTest, SoBundleLoadedWhenRegisteredWithRegisterBundleAPI)
//{
//}
-/* Test for Configuration */TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
+/* Test for Configuration */
+TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
{
Configuration *config = new Configuration(CONFIG_FILE);
'../../../include',
'../include/internal',
'../bundle-api/include',
- '../../serverBuilder/include',
- '../../common/primitiveResource/include',
os.environ['JAVA_HOME']+'/include',
os.environ['JAVA_HOME']+'/include/linux'
])
container_gtest_env.PrependUnique(CPPPATH = [env.get('SRC_DIR')+'/extlibs/hippomocks-master',
gtest_dir + '/include'])
-container_gtest_env.AppendUnique(LIBPATH = [os.environ['JAVA_HOME']+'/jre/lib/i386/server/'])
+container_gtest_env.AppendUnique(LIBPATH = [os.environ['JAVA_LIB']])
conf = Configure(container_gtest_env)
if not conf.CheckLib('jvm'):
projects / platform / upstream / iotivity.git / commitdiff