X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fstack%2Ftest%2Fstacktests.cpp;h=3e145ad61b54f6d27bceb30160e4b2251f049be7;hb=7f00f942c39b7bc27c7eeecf213a239c3fe4173c;hp=ae60c5b11010a177afe1a3f9b7dcc9244b9f8e61;hpb=c96e932067b534b2b294b092d4f87bb495aa6807;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/stack/test/stacktests.cpp b/resource/csdk/stack/test/stacktests.cpp old mode 100755 new mode 100644 index ae60c5b..3e145ad --- a/resource/csdk/stack/test/stacktests.cpp +++ b/resource/csdk/stack/test/stacktests.cpp @@ -21,10 +21,13 @@ extern "C" { + #include "ocpayload.h" #include "ocstack.h" #include "ocstackinternal.h" #include "logger.h" #include "oic_malloc.h" + #include "oic_string.h" + #include "oic_time.h" } #include "gtest/gtest.h" @@ -32,7 +35,9 @@ extern "C" #include #include #include +#ifdef HAVE_UNISTD_H #include +#endif #include //----------------------------------------------------------------------------- @@ -59,13 +64,12 @@ static const char TAG[] = "TestHarness"; char gDeviceUUID[] = "myDeviceUUID"; char gManufacturerName[] = "myName"; -char gTooLongManufacturerName[] = "extremelylongmanufacturername"; -char gManufacturerUrl[] = "www.foooooooooooooooo.baaaaaaaaaaaaar"; static OCPrm_t pmSel; static char pinNumber; static OCDPDev_t peer; std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5); +std::chrono::seconds const LONG_TEST_TIMEOUT = std::chrono::seconds(300); //----------------------------------------------------------------------------- // Callback functions @@ -85,10 +89,11 @@ extern "C" OCStackApplicationResult asyncDoResourcesCallback(void* ctx, return OC_STACK_KEEP_TRANSACTION; } -static void resultCallback(OCDPDev_t *UNUSED1, OCStackResult UNUSED2) +static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3) { (void) (UNUSED1); (void) (UNUSED2); + (void) (UNUSED3); } extern "C" OCStackApplicationResult discoveryCallback(void* ctx, @@ -108,7 +113,7 @@ extern "C" OCStackApplicationResult discoveryCallback(void* ctx, OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload); EXPECT_TRUE(discoveryPayload != NULL); OCResourcePayload *res = discoveryPayload->resources; - size_t count = 0; + int count = 0; for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next) { count++; @@ -171,6 +176,60 @@ uint8_t InitResourceIndex() return 0; #endif } + +class Callback +{ + public: + Callback(OCClientResponseHandler cb) : m_cb(cb), m_called(false) + { + m_cbData.cb = &Callback::handler; + m_cbData.cd = NULL; + m_cbData.context = this; + } + void Wait(long waitTime) + { + uint64_t startTime = OICGetCurrentTime(TIME_IN_MS); + while (!m_called) + { + uint64_t currTime = OICGetCurrentTime(TIME_IN_MS); + long elapsed = (long)((currTime - startTime) / MS_PER_SEC); + if (elapsed > waitTime) + { + m_called = true; + } + OCProcess(); + } + } + operator OCCallbackData *() + { + return &m_cbData; + } + private: + OCCallbackData m_cbData; + OCClientResponseHandler m_cb; + bool m_called; + static OCStackApplicationResult handler(void *ctx, OCDoHandle handle, OCClientResponse *clientResponse) + { + Callback *callback = (Callback *) ctx; + OCStackApplicationResult result = callback->m_cb(NULL, handle, clientResponse); + callback->m_called = true; + return result; + } +}; + +class OCDiscoverTests : public testing::Test +{ + protected: + virtual void SetUp() + { + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER)); + } + + virtual void TearDown() + { + OCStop(); + } +}; //----------------------------------------------------------------------------- // Tests //----------------------------------------------------------------------------- @@ -224,6 +283,24 @@ TEST(StackStart, StackStartSuccessClientServer) EXPECT_EQ(OC_STACK_OK, OCStop()); } +TEST(StackStart, StackStartSuccessServerThenClient) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCStop()); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT)); + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + +TEST(StackStart, StackStartSuccessClientThenServer) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT)); + EXPECT_EQ(OC_STACK_OK, OCStop()); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + TEST(StackStart, StackStartSuccessiveInits) { itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); @@ -258,7 +335,7 @@ TEST(StackStart, SetPlatformInfoWithClientMode) gManufacturerName, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; - EXPECT_EQ(OC_STACK_ERROR, OCSetPlatformInfo(info)); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info)); EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -313,7 +390,12 @@ TEST(StackStart, SetPlatformInfoWithTooLongManufacName) { itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); - + char gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+2]; + for (int i = 0; i <= MAX_PLATFORM_NAME_LENGTH; i++ ) + { + gTooLongManufacturerName[i] = 'a'; + } + gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0'; OCPlatformInfo info = { gDeviceUUID, @@ -329,6 +411,12 @@ TEST(StackStart, SetPlatformInfoWithTooLongManufacURL) { itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + char gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+2]; + for (int i = 0; i <= MAX_PLATFORM_URL_LENGTH; i++ ) + { + gManufacturerUrl[i] = 'a'; + } + gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0'; OCPlatformInfo info = { gDeviceUUID, @@ -341,6 +429,186 @@ TEST(StackStart, SetPlatformInfoWithTooLongManufacURL) EXPECT_EQ(OC_STACK_OK, OCStop()); } +TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, "")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value")); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, NULL, "")); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL)); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL)); + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + +TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, "")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value")); + + void *value = NULL; + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ(gDeviceUUID, (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ(gManufacturerName, (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("http://www.iotivity.org", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("S777", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("15 Nov, 2016", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("1.1", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("14", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("0.1", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("0.1", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("http://www.iotivity.org", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("value", (char *)value); + OICFree(value); + + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + +TEST(StackStart, SetDeviceInfoAPI) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value")); + OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version"); + EXPECT_TRUE(dataModelVersions != NULL); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions)); + OCFreeOCStringLL(dataModelVersions); + OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI); + EXPECT_TRUE(handle != NULL); + EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv")); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL)); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, "", NULL)); + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + +TEST(StackStart, GetDeviceInfoAPI) +{ + itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); + EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER)); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion")); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value")); + OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version"); + EXPECT_TRUE(dataModelVersions != NULL); + EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions)); + OCFreeOCStringLL(dataModelVersions); + OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI); + EXPECT_TRUE(handle != NULL); + EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv")); + + void *value = NULL; + EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("Sample", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("specVersion", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", &value)); + ASSERT_TRUE(value != NULL); + EXPECT_STREQ("value", (char *)value); + OICFree(value); + value = NULL; + + EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value)); + ASSERT_TRUE(value != NULL); + ASSERT_TRUE(((OCStringLL *)value)->value); + EXPECT_STREQ("Data Model Version", ((OCStringLL *)value)->value); + OCFreeOCStringLL((OCStringLL *) value); + value = NULL; + + EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0)); + EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1)); + + EXPECT_EQ(OC_STACK_OK, OCStop()); +} + TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery) { itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT); @@ -351,8 +619,8 @@ TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery) InitStack(OC_CLIENT); /* Start a discovery query*/ - char szQueryUri[64] = { 0 }; - strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI); + char szQueryUri[MAX_QUERY_LENGTH] = { 0 }; + OICStrcpy(szQueryUri, MAX_QUERY_LENGTH, OC_RSRVD_WELL_KNOWN_URI); cbData.cb = asyncDoResourcesCallback; cbData.context = (void*)DEFAULT_CONTEXT_VALUE; cbData.cd = NULL; @@ -393,8 +661,8 @@ TEST(StackResource, DISABLED_UpdateResourceNullURI) InitStack(OC_CLIENT); /* Start a discovery query*/ - char szQueryUri[64] = { 0 }; - strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI); + char szQueryUri[MAX_QUERY_LENGTH] = { 0 }; + OICStrcpy(szQueryUri, MAX_QUERY_LENGTH, OC_RSRVD_WELL_KNOWN_URI); cbData.cb = asyncDoResourcesCallback; cbData.context = (void*)DEFAULT_CONTEXT_VALUE; cbData.cd = NULL; @@ -442,7 +710,7 @@ TEST(StackResource, CreateResourceBadParams) "/a/led", 0, NULL, - 128));// invalid bitmask for OCResourceProperty + 255));// invalid bitmask for OCResourceProperty EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -453,7 +721,7 @@ TEST(StackResource, CreateResourceBadUri) OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test"); InitStack(OC_SERVER); - const char *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL"; + const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW"; OCResourceHandle handle; @@ -476,7 +744,7 @@ TEST(StackResource, CreateResourceBadUri) EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle, "core.led", "core.rw", - uri65, //"/a/led", + uri257, //"/a/led", 0, 0, OC_DISCOVERABLE|OC_OBSERVABLE)); @@ -731,12 +999,14 @@ TEST(StackResource, ResourceTypeInterface) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); - const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0); + EXPECT_EQ(2, numResourceInterfaces); + const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0); + EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1); + const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1); EXPECT_STREQ("core.rw", resourceInterfaceName); // try getting resource interface names with an invalid index - resourceInterfaceName = OCGetResourceInterfaceName(handle, 1); + resourceInterfaceName = OCGetResourceInterfaceName(handle, 2); EXPECT_STREQ(NULL, resourceInterfaceName); // try getting resource interface names with an invalid index resourceInterfaceName = OCGetResourceInterfaceName(handle, 10); @@ -832,7 +1102,7 @@ TEST(StackResource, ResourceDuplicateNonDefaultInterfaces) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); + EXPECT_EQ(2, numResourceInterfaces); EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -854,7 +1124,7 @@ TEST(StackResource, ResourceTypeInterfaceMethods) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); + EXPECT_EQ(2, numResourceInterfaces); EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -874,7 +1144,11 @@ TEST(StackResource, GetResourceProperties) NULL, OC_DISCOVERABLE|OC_OBSERVABLE)); +#ifdef MQ_PUBLISHER + EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle)); +#else EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle)); +#endif EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle)); EXPECT_EQ(OC_STACK_OK, OCStop()); @@ -1019,6 +1293,8 @@ TEST(StackBind, BindResourceTypeNameBad) EXPECT_STREQ("core.led", resourceTypeName); EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL)); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad")); + EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad")); EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -1056,6 +1332,12 @@ TEST(StackBind, BindResourceTypeNameGood) resourceTypeName = OCGetResourceTypeName(handle, 2); EXPECT_STREQ("core.reallybrightled", resourceTypeName); + EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED")); + EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes)); + EXPECT_EQ(4, numResourceTypes); + resourceTypeName = OCGetResourceTypeName(handle, 3); + EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName); + EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -1107,8 +1389,8 @@ TEST(StackBind, BindResourceInterfaceNameBad) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); - const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0); + EXPECT_EQ(2, numResourceInterfaces); + const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1); EXPECT_STREQ("core.rw", resourceInterfaceName); EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL)); @@ -1133,15 +1415,15 @@ TEST(StackBind, BindResourceInterfaceNameGood) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); - const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0); + EXPECT_EQ(2, numResourceInterfaces); + const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1); EXPECT_STREQ("core.rw", resourceInterfaceName); EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r")); EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(2, numResourceInterfaces); - resourceInterfaceName = OCGetResourceInterfaceName(handle, 1); + EXPECT_EQ(3, numResourceInterfaces); + resourceInterfaceName = OCGetResourceInterfaceName(handle, 2); EXPECT_STREQ("core.r", resourceInterfaceName); EXPECT_EQ(OC_STACK_OK, OCStop()); @@ -1164,7 +1446,7 @@ TEST(StackBind, BindResourceInterfaceMethodsBad) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); + EXPECT_EQ(2, numResourceInterfaces); EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0)); @@ -1188,12 +1470,12 @@ TEST(StackBind, BindResourceInterfaceMethodsGood) uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); + EXPECT_EQ(2, numResourceInterfaces); EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r")); EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces)); - EXPECT_EQ(2, numResourceInterfaces); + EXPECT_EQ(3, numResourceInterfaces); EXPECT_EQ(OC_STACK_OK, OCStop()); } @@ -1659,13 +1941,15 @@ TEST(StackResourceAccess, DeleteMiddleResource) // Make sure the resource elements are still correct uint8_t numResourceInterfaces; EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces)); - EXPECT_EQ(1, numResourceInterfaces); - const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0); + EXPECT_EQ(2, numResourceInterfaces); + const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1); EXPECT_STREQ("core.rw", resourceInterfaceName); EXPECT_EQ(OC_STACK_OK, OCStop()); } +// Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer. +#if !defined(_MSC_VER) || (_MSC_VER >= 1900) TEST(PODTests, OCHeaderOption) { EXPECT_TRUE(std::is_pod::value); @@ -1673,22 +1957,23 @@ TEST(PODTests, OCHeaderOption) TEST(PODTests, OCCallbackData) { - EXPECT_TRUE(std::is_pod::value); + EXPECT_TRUE(std::is_pod::value); } +#endif TEST(OCDoDirectPairingTests, Nullpeer) { - EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, pmSel, &pinNumber, &resultCallback)); + EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback)); } TEST(OCDoDirectPairingTests, NullCallback) { - EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(&peer, pmSel, &pinNumber, NULL)); + EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL)); } TEST(OCDoDirectPairingTests, NullpinNumber) { - EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, NULL, &resultCallback)); + EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback)); } TEST(StackResource, MultipleResourcesDiscovery) @@ -1723,7 +2008,7 @@ TEST(StackResource, MultipleResourcesDiscovery) NULL, OC_DISCOVERABLE|OC_OBSERVABLE)); /* Start a discovery query*/ - char szQueryUri[256] = "/oic/res?if=oic.if.ll"; + char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll"; OCCallbackData cbData; cbData.cb = discoveryCallback; cbData.context = (void*)DEFAULT_CONTEXT_VALUE; @@ -1743,3 +2028,508 @@ TEST(StackResource, MultipleResourcesDiscovery) EXPECT_EQ(OC_STACK_OK, OCStop()); } + +TEST(StackPayload, CloneByteString) +{ + uint8_t bytes[] = { 0, 1, 2, 3 }; + OCByteString byteString; + byteString.bytes = bytes; + byteString.len = sizeof(bytes); + + OCRepPayload *original = OCRepPayloadCreate(); + ASSERT_TRUE(original != NULL); + EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString)); + + OCRepPayload *clone = OCRepPayloadClone(original); + ASSERT_TRUE(clone != NULL); + + OCRepPayloadDestroy(original); + + OCByteString cloneByteString; + EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString)); + ASSERT_TRUE(cloneByteString.bytes != NULL); + EXPECT_EQ(sizeof(bytes), cloneByteString.len); + EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes))); + OICFree(cloneByteString.bytes); + + OCRepPayloadDestroy(clone); +} + +TEST(StackUri, Rfc6874_Noop_1) +{ + char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB"; + char bytes[100] = {0}; + strncpy(bytes, validIPv6Address, sizeof(bytes)); + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address); + + // No % sign, should do nothing + EXPECT_STREQ(bytes, validIPv6Address); + EXPECT_EQ(OC_STACK_OK, result); +} + +TEST(StackUri, Rfc6874_Noop_2) +{ + char validIPv6Address[] = "3812:a61::4:1"; + char bytes[100] = {0}; + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address); + + // No % sign, should do nothing + EXPECT_STREQ(bytes, validIPv6Address); + EXPECT_EQ(OC_STACK_OK, result); +} + +TEST(StackUri, Rfc6874_WithEncoding) +{ + char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0"; + char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0"; + char bytes[100] = ""; + strncpy(bytes, validIPv6Address, sizeof(bytes)); + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address); + + // Encoding should have occured + EXPECT_STREQ(bytes, validIPv6AddressEncoded); + EXPECT_EQ(OC_STACK_OK, result); +} + +TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent) +{ + char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0"; + char bytes[100] = {0}; + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address); + + // Encoding should have failed due to extra '%' character + EXPECT_STREQ(bytes, ""); + EXPECT_EQ(OC_STACK_ERROR, result); +} + +TEST(StackUri, Rfc6874_AlreadyEncoded) +{ + char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0"; + char bytes[100] = {0}; + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded); + + // Encoding should have failed due to extra '%' character + EXPECT_STREQ(bytes, ""); + EXPECT_EQ(OC_STACK_ERROR, result); +} + +TEST(StackUri, Rfc6874_NoOverflow) +{ + char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0"; + char addrBuffer[100]; + char bytes[100] = {0}; + memset(addrBuffer, sizeof(addrBuffer), '_'); + + // Just enough room to encode + addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0'; + strcat(addrBuffer, validIPv6Address); + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer); + + // Encoding should have succeeded + EXPECT_EQ(OC_STACK_OK, result); +} + +TEST(StackUri, Rfc6874_NoOverflow_2) +{ + char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0"; + char addrBuffer[100]; + char bytes[100] = {0}; + memset(addrBuffer, sizeof(addrBuffer), '_'); + + // Not enough room to encode + addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0'; + strcat(addrBuffer, validIPv6Address); + + OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer); + + // Encoding should have failed due to output size limitations + EXPECT_STREQ(bytes, ""); + EXPECT_EQ(OC_STACK_ERROR, result); +} + +TEST(StackHeaderOption, setHeaderOption) +{ + uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] = + { 1 }; + OCHeaderOption options[MAX_HEADER_OPTIONS] = + { + { OC_COAP_ID, 6, 8, optionValue1 }, }; + uint8_t optionData = 255; + size_t optionDataSize = sizeof(optionData); + size_t numOptions = 1; + uint16_t optionID = 2048; + EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options, + &numOptions, + optionID, + &optionData, + optionDataSize)); + EXPECT_EQ(options[1].optionID, optionID); + EXPECT_EQ(options[1].optionData[0], 255); +} + +TEST(StackHeaderOption, getHeaderOption) +{ + uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] = + { 1 }; + uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] = + { 255 }; + OCHeaderOption options[MAX_HEADER_OPTIONS] = + { + { OC_COAP_ID, 6, 8, optionValue1 }, + { OC_COAP_ID, 2048, 16, optionValue2 }, }; + uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH]; + size_t optionDataSize = sizeof(optionData); + size_t numOptions = 2; + uint16_t optionID = 6; + uint16_t actualDataSize = 0; + EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options, + numOptions, + optionID, + optionData, + optionDataSize, + &actualDataSize)); + EXPECT_EQ(optionData[0], 1); + EXPECT_EQ(actualDataSize, 8); +} + +static OCStackApplicationResult DiscoverBaslineResource(void *ctx, OCDoHandle handle, + OCClientResponse *response) +{ + OC_UNUSED(ctx); + OC_UNUSED(handle); + EXPECT_EQ(OC_STACK_OK, response->result); + EXPECT_TRUE(NULL != response->payload); + if (NULL != response->payload) + { + EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type); + + OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload; + EXPECT_TRUE(NULL != payload->sid); + if (payload->name) + { + EXPECT_STREQ("StackTest", payload->name); + } + EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_RES, payload->type->value); + EXPECT_STREQ(OC_RSRVD_INTERFACE_LL, payload->iface->value); + EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, payload->iface->next->value); + + for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next) + { + if (0 == strcmp("/a/light", resource->uri)) + { + EXPECT_STREQ("/a/light", resource->uri); + EXPECT_STREQ("core.light", resource->types->value); + EXPECT_EQ(NULL, resource->types->next); + EXPECT_STREQ("oic.if.baseline", resource->interfaces->value); + EXPECT_EQ(NULL, resource->interfaces->next); + EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE); + EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE); + EXPECT_FALSE(resource->secure); + EXPECT_EQ(0, resource->port); + EXPECT_EQ(NULL, resource->next); + } + } + } + + return OC_STACK_DELETE_TRANSACTION; +} + +static OCStackApplicationResult DiscoverLinkedListResource(void *ctx, OCDoHandle handle, + OCClientResponse *response) +{ + OC_UNUSED(ctx); + OC_UNUSED(handle); + EXPECT_EQ(OC_STACK_OK, response->result); + EXPECT_TRUE(NULL != response->payload); + if (NULL != response->payload) + { + EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type); + + OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload; + EXPECT_NE((char *)NULL, payload->sid); + EXPECT_EQ(NULL, payload->name); + EXPECT_EQ(NULL, payload->type); + EXPECT_EQ(NULL, payload->iface); + + for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next) + { + if (0 == strcmp("/a/light", resource->uri)) + { + EXPECT_STREQ("/a/light", resource->uri); + EXPECT_STREQ("core.light", resource->types->value); + EXPECT_EQ(NULL, resource->types->next); + EXPECT_STREQ("oic.if.baseline", resource->interfaces->value); + EXPECT_EQ(NULL, resource->interfaces->next); + EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE); + EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE); + EXPECT_FALSE(resource->secure); + EXPECT_EQ(0, resource->port); + EXPECT_EQ(NULL, resource->next); + } + } + } + return OC_STACK_DELETE_TRANSACTION; +} + + +static OCStackApplicationResult DiscoverResourceTypeResponse(void *ctx, OCDoHandle handle, + OCClientResponse *response) +{ + OC_UNUSED(ctx); + OC_UNUSED(handle); + EXPECT_EQ(OC_STACK_OK, response->result); + EXPECT_TRUE(NULL != response->payload); + if (NULL != response->payload) + { + EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type); + + OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload; + EXPECT_NE((char *)NULL, payload->sid); + EXPECT_EQ(NULL, payload->name); + EXPECT_EQ(NULL, payload->type); + EXPECT_EQ(NULL, payload->iface); + EXPECT_TRUE(NULL != payload->resources); + + OCResourcePayload *resource = payload->resources; + + if (0 == strcmp("/a/light", resource->uri)) + { + EXPECT_STREQ("/a/light", resource->uri); + EXPECT_STREQ("core.light", resource->types->value); + EXPECT_EQ(NULL, resource->types->next); + EXPECT_STREQ("oic.if.baseline", resource->interfaces->value); + EXPECT_EQ(NULL, resource->interfaces->next); + EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE); + EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE); + EXPECT_FALSE(resource->secure); + EXPECT_EQ(0, resource->port); + EXPECT_EQ(NULL, resource->next); + } + } + + return OC_STACK_DELETE_TRANSACTION; +} + +static OCStackApplicationResult DiscoverNoResource(void *ctx, OCDoHandle handle, + OCClientResponse *response) +{ + OC_UNUSED(ctx); + OC_UNUSED(handle); + EXPECT_EQ(OC_STACK_OK, response->result); + EXPECT_TRUE(NULL != response->payload); + if (NULL != response->payload) + { + EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type); + + OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload; + EXPECT_EQ(NULL, payload->sid); + EXPECT_EQ(NULL, payload->name); + EXPECT_EQ(NULL, payload->type); + EXPECT_EQ(NULL, payload->iface); + + bool resourceFound = false; + for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next) + { + if (0 == strcmp("/a/light", resource->uri)) + { + resourceFound = true; + } + } + + EXPECT_FALSE(resourceFound); + } + return OC_STACK_DELETE_TRANSACTION; +} + +static OCStackApplicationResult DiscoverUnicastErrorResponse(void *ctx, OCDoHandle handle, + OCClientResponse *response) +{ + OC_UNUSED(ctx); + OC_UNUSED(handle); + EXPECT_NE(OC_STACK_OK, response->result); + EXPECT_TRUE(NULL == response->payload); + + return OC_STACK_DELETE_TRANSACTION; +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceBaselineQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "StackTest"); + Callback discoverCB(&DiscoverBaslineResource); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.baseline", NULL, + 0, CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(100); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithoutAnyQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverLinkedListResource); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res", NULL, 0, CT_DEFAULT, + OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(100); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceLinkedListQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverLinkedListResource); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.ll", NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(100); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithResourceTypeQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverResourceTypeResponse); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=core.light", NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(100); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery_Unicast) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + char targetUri[MAX_URI_LENGTH * 2] ={ 0, }; + snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=invalid"); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(100); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery_Unicast) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + char targetUri[MAX_URI_LENGTH * 2] ={ 0, }; + snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if="); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT, + OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(10); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery_Unicast) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + char targetUri[MAX_URI_LENGTH * 2] ={ 0, }; + snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=invalid"); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(10); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery_Unicast) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + char targetUri[MAX_URI_LENGTH * 2] ={ 0, }; + snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt="); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT, + OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(10); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=invalid", NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(5); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverUnicastErrorResponse); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=", NULL, 0, CT_DEFAULT, + OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(5); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverNoResource); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=invalid", NULL, 0, + CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(5); +} + +TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery) +{ + itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT); + + OCResourceHandle handles; + EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light", + entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE))); + OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest"); + Callback discoverCB(&DiscoverNoResource); + EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=", NULL, 0, CT_DEFAULT, + OC_HIGH_QOS, discoverCB, NULL, 0)); + discoverCB.Wait(5); +}