From: Yu Date: Mon, 29 Jun 2020 05:00:15 +0000 (+0900) Subject: Add gtest to get coverage data X-Git-Tag: submit/tizen/20200713.070339^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F09%2F237309%2F5;p=platform%2Fcore%2Fapi%2Fnsd.git Add gtest to get coverage data Change-Id: I85dd3b4385be8237e6b57a4cdb19645767316108 Signed-off-by: Yu jiung --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 1487a9b..c3c6a7d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -97,3 +97,4 @@ ADD_SUBDIRECTORY(include) ADD_SUBDIRECTORY(src) ADD_SUBDIRECTORY(pkgconfig) ADD_SUBDIRECTORY(test) +ADD_SUBDIRECTORY(unittest) \ No newline at end of file diff --git a/packaging/capi-network-nsd.spec b/packaging/capi-network-nsd.spec index 827609a..c6de4c8 100644 --- a/packaging/capi-network-nsd.spec +++ b/packaging/capi-network-nsd.spec @@ -1,6 +1,6 @@ Name: capi-network-nsd Summary: A Network Service Discovery libraries in Native API -Version: 0.0.26 +Version: 0.1.0 Release: 1 Group: System/Network License: Apache-2.0 @@ -17,6 +17,7 @@ BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(dns_sd) BuildRequires: pkgconfig(gssdp-1.0) BuildRequires: pkgconfig(cynara-client) +BuildRequires: pkgconfig(gmock) %if 0%{?gcov:1} BuildRequires: tar BuildRequires: lcov @@ -92,7 +93,8 @@ MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` -DLOCAL_STATE_DIR:PATH=%{_localstatedir} \ -DDATA_ROOT_DIR:PATH=%{_datadir} \ -DFULLVER=%{version} \ - -DMAJORVER=${MAJORVER} + -DMAJORVER=${MAJORVER} \ + -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} make %{?_smp_mflags} %install @@ -104,6 +106,13 @@ install -d -m 755 %{buildroot}%{_datadir}/gcov/obj tar xf %{name}-gcov.tar -C %{buildroot}%{_datadir}/gcov/obj %endif +%check +LD_LIBRARY_PATH=./src/ssdp:./src/dns-sd unittest/tct-nsd-core +%if 0%{?gcov:1} +lcov -c --ignore-errors graph --no-external -b . -d . -o nsd.info +genhtml nsd.info -o out --legend --show-details +%endif + %post -n libnsd-dns-sd -p /sbin/ldconfig %postun -n libnsd-dns-sd -p /sbin/ldconfig diff --git a/src/dns-sd/dns-sd.c b/src/dns-sd/dns-sd.c index 66b0bc8..7b3a06a 100644 --- a/src/dns-sd/dns-sd.c +++ b/src/dns-sd/dns-sd.c @@ -1009,8 +1009,7 @@ static void __dnssd_getaddrinfo_reply_cb(DNSServiceRef sd_ref, /* Update interface and flags for any future use */ found->if_index = if_index; local_handle->flags = flags; - DNSSD_LOGD("Domain/Interface/Flags : %s/%d/0x%x", - local_handle->domain, + DNSSD_LOGD("Interface/Flags : %d/0x%x", found->if_index, local_handle->flags); @@ -1106,7 +1105,8 @@ static int __dnssd_getaddrinfo(dnssd_handle_s *dnssd_handle, unsigned int flags, local_handle->op_type = DNSSD_TYPE_FOUND; local_handle->service_handler = (uintptr_t)local_handle & 0xffffffff; - g_strlcpy(local_handle->domain, domain, sizeof(local_handle->domain)); + if (domain) + g_strlcpy(local_handle->domain, domain, sizeof(local_handle->domain)); g_free(name); found->if_index = if_index; @@ -1283,8 +1283,9 @@ static void __dnssd_browse_reply_cb(DNSServiceRef sd_ref, unsigned int flags, g_strlcpy(dnssd_handle->domain, domain, sizeof(dnssd_handle->domain)); dnssd_handle->flags = flags; - DNSSD_LOGD("Domain/Interface/Flags : %s/:x%x", + DNSSD_LOGD("Domain/Interface/Flags : %s/%x/%x", dnssd_handle->domain, + if_index, dnssd_handle->flags); if (flags & kDNSServiceFlagsAdd) { diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt new file mode 100644 index 0000000..d82efef --- /dev/null +++ b/unittest/CMakeLists.txt @@ -0,0 +1,30 @@ +SET(UNITTEST_NAME "tct-nsd-core") + +PKG_CHECK_MODULES(unittest_pkgs REQUIRED + gmock +) +INCLUDE_DIRECTORIES(${unittest_pkgs_INCLUDE_DIRS}) +LINK_DIRECTORIES(${unittest_pkgs_LIBRARY_DIRS}) + +INCLUDE_DIRECTORIES( + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/include +) + +FILE(GLOB NSD_MOCK_SRCS + mock/*.c +) + +SET(TC_SOURCES + utc-nsd-ssdp-register.c + utc-nsd-ssdp-browse.c + utc-nsd-dnssd-register.c + utc-nsd-dnssd-browse.c +) + +ADD_EXECUTABLE(${UNITTEST_NAME} ${UNITTEST_NAME}.cpp ${TC_SOURCES} ${NSD_MOCK_SRCS}) +TARGET_LINK_LIBRARIES(${UNITTEST_NAME} + ${unittest_pkgs_LIBRARIES} + ${TARGET_LIB_NSD_DNS_SD} + ${TARGET_LIB_NSD_SSDP} +) diff --git a/unittest/include/assert_local.h b/unittest/include/assert_local.h new file mode 100755 index 0000000..7c88a02 --- /dev/null +++ b/unittest/include/assert_local.h @@ -0,0 +1,118 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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. +// +#ifndef _ASSERT_H_ +#define _ASSERT_H_ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define assert(exp) \ + do { \ + if (!(exp)) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert Fail; Following expression is not true: %s\n", \ + __FILE__, __LINE__, #exp); \ + return 1; \ + } \ + } while (0) + +#define assert_eq(var, ref) \ + do { \ + if (var != ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are not equal\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#define assert_eq_no_return(var, ref) \ + do { \ + if (var != ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are not equal\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return ; \ + } \ + } while (0) + +#define assert_neq_no_return(var, ref) \ + do { \ + if (var == ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are equal\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return ; \ + } \ + } while (0) + +#define assert_neq(var, ref) \ + do { \ + if (var == ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are equal\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#define assert_gt(var, ref) \ + do { \ + if (var <= ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than (%s == 0x%x)\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#define assert_geq(var, ref) \ + do { \ + if (var < ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than or equal to (%s == 0x%x)\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#define assert_lt(var, ref) \ + do { \ + if (var >= ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than (%s == 0x%x)\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#define assert_leq(var, ref) \ + do { \ + if (var > ref) { \ + fprintf(stderr, \ + "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than or equal to (%s == 0x%x)\n", \ + __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ + return 1; \ + } \ + } while (0) + +#ifdef __cplusplus +} +#endif +#endif // _ASSERT_H_ diff --git a/unittest/include/nsd-mock-switch.h b/unittest/include/nsd-mock-switch.h new file mode 100644 index 0000000..1a47fbf --- /dev/null +++ b/unittest/include/nsd-mock-switch.h @@ -0,0 +1,29 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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. +// +#ifndef _NSD_MOCK_SWTICH_H_ +#define _NSD_MOCK_SWTICH_H_ + +#ifdef __cplusplus +extern "C" { +#endif +void nsd_mock_dnssd_register_set_g_dbus_get_sync_failure(gboolean failure); +gboolean nsd_mock_dnssd_register_get_g_dbus_get_sync_failure(void); +void nsd_mock_dnssd_register_set_g_dbus_connection_call_sync_failure(gboolean failure); +gboolean nsd_mock_dnssd_register_get_g_dbus_connection_call_sync_failure(void); +#ifdef __cplusplus +} +#endif +#endif // _ASSERT_H_ diff --git a/unittest/include/tct_common.h b/unittest/include/tct_common.h new file mode 100755 index 0000000..5617478 --- /dev/null +++ b/unittest/include/tct_common.h @@ -0,0 +1,216 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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. +// +#ifndef _TCT_COMMON_H_ +#define _TCT_COMMON_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "assert_local.h" + +#include +#include +#include +#include +#include +#include +#include + +#define CONFIG_LINE_LEN_MAX 2048 +#define CONFIG_VALUE_LEN_MAX 1024 + +#define UTC_LOG "utc.log" +#define ERR_UTC_LOG "utc_error.log" +#define TC_RESULT "tc_result.log" + +FILE *g_fpLog; +FILE *g_fpLogDump; +int g_Serr; + +int old_Serr; + +#define FPRINTF(...) {\ + g_fpLog = fopen(ERR_LOG, "a");\ + fprintf(g_fpLog, __VA_ARGS__);\ + fclose(g_fpLog);\ +} + +#define DUMP_UTC_ERRLOG() {\ + g_Serr = dup(fileno(stderr));\ + g_fpLogDump = freopen(ERR_UTC_LOG, "w", stderr);\ + fflush(stderr);\ +} + +#define CLOSE_UTC_ERRLOG() {\ + if(g_fpLogDump) \ + {\ + if (g_Serr != -1)\ + {\ + old_Serr = fileno(stderr);\ + if(old_Serr != -1)\ + {\ + dup2(g_Serr, old_Serr);\ + }\ + close(g_Serr);\ + }\ + fclose(g_fpLogDump);\ + }\ +} + +#define PRINT_TC_RESULT(...) {\ + g_fpLog = fopen(TC_RESULT, "w");\ + fprintf(g_fpLog, __VA_ARGS__);\ + fclose(g_fpLog);\ +} + + +#define FREE_MEMORY_TC(buffer) {\ + if ( buffer != NULL )\ +{\ + free(buffer);\ + buffer = NULL;\ +}\ +} + + +#define IS_FEATURE_SUPPORTED(feature_name, featureFlag, ModuleName)\ +{\ + if ( !(TCTCheckSystemInfoFeatureSupported(feature_name, ModuleName)) )\ +{\ + featureFlag = false;\ +}\ + else\ +{\ + featureFlag = true;\ +}\ +} + +#define PRINT_RESULT(eCompare, eRetVal, API, Error) {\ + if ( eRetVal == eCompare )\ +{\ + if ( DEBUG )\ +{\ + FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\ +}\ +}\ + else \ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\ + return 1;\ +}\ +} + +#define PRINT_RESULT_NORETURN(eCompare, eRetVal, API, Error) {\ + if ( eRetVal == eCompare )\ +{\ + if ( DEBUG )\ +{\ + FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\ +}\ +}\ + else \ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\ +}\ +} + +#define PRINT_RESULT_CLEANUP(eCompare, eRetVal, API, Error, FreeResource) {\ + if ( eRetVal == eCompare )\ +{\ + if ( DEBUG )\ +{\ + FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\ +}\ +}\ +else \ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\ + FreeResource;\ + return 1;\ +}\ +} + +#define CHECK_VALUE_STRING(StringVariable, API) {\ + if ( StringVariable == NULL )\ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = value returned is NULL\\n", __LINE__, API_NAMESPACE, API);\ + return 1;\ +}\ + else if ( DEBUG )\ +{\ + FPRINTF("[Line : %d][%s] value returned = %s\\n", __LINE__, API_NAMESPACE, StringVariable);\ +}\ + free(StringVariable);\ + StringVariable = NULL;\ +} + +#define CHECK_VALUE_INT(Variable, API) {\ + if ( Variable == 0 )\ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = value returned is Zero\\n", __LINE__, API_NAMESPACE, API);\ + return 1;\ +}\ + else if ( DEBUG )\ +{\ + FPRINTF("[Line : %d][%s] value returned = %d\\n", __LINE__, API_NAMESPACE, Variable);\ +}\ +} + +#define CHECK_HANDLE(Handle, API) {\ + if ( Handle == NULL )\ +{\ + FPRINTF("[Line : %d][%s] %s failed, error returned = Handle returned is NULL\\n", __LINE__, API_NAMESPACE, API);\ + return 1;\ +}\ +} + +#define FREE_MEMORY(buffer) {\ + if ( buffer != NULL )\ +{\ + free(buffer);\ + buffer = NULL;\ +}\ +} + +bool TCTCheckSystemInfoFeatureSupported(char* pszKey, char* pszModuleName){ + return false; +} +char* TCTSystemInfoGetError(int nRet){ + return NULL; +} +bool GetValueFromConfigFile(char* pstrKeyString, char* pstrValue, char* pstrModule){ + return false; +} +bool GetValueForTCTSetting(char* pstrKeyString, char* pstrValue, char* pstrModule){ + return false; +} + +#define dlog_print( type, tag, ...) do{ \ + fprintf(stdout, ##__VA_ARGS__ ); \ + fprintf(stdout, "\n" ); \ +} while(0) + +#define PRINT_UTC_LOG(...) do{ \ + fprintf(stdout, ##__VA_ARGS__ ); \ + fprintf(stdout, "\n" ); \ +} while(0) + +#ifdef __cplusplus +} +#endif + +#endif // _TCT_COMMON_H_ diff --git a/unittest/include/testcase.h b/unittest/include/testcase.h new file mode 100755 index 0000000..febac28 --- /dev/null +++ b/unittest/include/testcase.h @@ -0,0 +1,40 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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. +// +#ifndef _TESTCASE_H_ +#define _TESTCASE_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* pointer to startup/cleanup functions */ +typedef void (*void_fun_ptr)(void); + +/* pointer to testcase functions */ +typedef int (*tc_fun_ptr)(void); + +/* struct describing specific testcase */ +typedef struct testcase_s { + const char* name; + tc_fun_ptr function; + void_fun_ptr startup; + void_fun_ptr cleanup; +} testcase; + +#ifdef __cplusplus +} +#endif +#endif // _TESTCASE_H_ diff --git a/unittest/mock/nsd-mock-cynara.c b/unittest/mock/nsd-mock-cynara.c new file mode 100644 index 0000000..b7094b0 --- /dev/null +++ b/unittest/mock/nsd-mock-cynara.c @@ -0,0 +1,28 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +API int cynara_check(cynara *p_cynara, + const char *client, const char *client_session, + const char *user, const char *privilege) +{ + return CYNARA_API_ACCESS_ALLOWED; +} diff --git a/unittest/mock/nsd-mock-dns-sd.c b/unittest/mock/nsd-mock-dns-sd.c new file mode 100644 index 0000000..03907bf --- /dev/null +++ b/unittest/mock/nsd-mock-dns-sd.c @@ -0,0 +1,577 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 +#include +#include +#include +#include +#include +#include + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +/* dnssd_sock_t, ipc_msg_hdr and request_op_t are from dnssd_ipc.h */ + +# define dnssd_InvalidSocket -1 +# define dnssd_SocketValid(s) ((s) >= 0) + +typedef int dnssd_sock_t; + +typedef struct +{ + uint32_t op; // request_op_t or reply_op_t +} ipc_msg_hdr; + +typedef enum +{ + request_op_none = 0, // No request yet received on this connection + connection_request = 1, // connected socket via DNSServiceConnect() + reg_record_request, // reg/remove record only valid for connected sockets + remove_record_request, + enumeration_request, + reg_service_request, + browse_request, + resolve_request, + query_request, + reconfirm_record_request, + add_record_request, + update_record_request, + setdomain_request, // Up to here is in Tiger and B4W 1.0.3 + getproperty_request, // New in B4W 1.0.4 + port_mapping_request, // New in Leopard and B4W 2.0 + addrinfo_request, + send_bpf, // New in SL + getpid_request, + release_request, + connection_delegate_request, + + cancel_request = 63 +} request_op_t; + +typedef struct _DNSServiceRef_t DNSServiceOp; +typedef struct _DNSRecordRef_t DNSRecord; + +typedef struct +{ + ipc_msg_hdr ipc_hdr; + DNSServiceFlags cb_flags; + uint32_t cb_interface; + DNSServiceErrorType cb_err; +} CallbackHeader; + +// client stub callback to process message from server and deliver results to client application +typedef void (*ProcessReplyFn)(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *msg, const char *const end); + +#define ValidatorBits 0x12345678 +#define DNSServiceRefValid(X) (dnssd_SocketValid((X)->sockfd) && (((X)->sockfd ^ (X)->validator) == ValidatorBits)) + +/* The virtual #_DNSServiceRef_t structure for unittest */ +struct _DNSServiceRef_t +{ + dnssd_sock_t sockfd; // Connected socket between client and daemon + dnssd_sock_t validator; // Used to detect memory corruption, double disposals, etc. + uint32_t op; // request_op_t or reply_op_t + ProcessReplyFn ProcessReply; // Function pointer to the code to handle received messages + void *AppCallback; // Client callback function and context + void *AppContext; + DNSRecord *rec; +}; + +/* The virtual #_DNSRecordRef_t structure for unittest */ +struct _DNSRecordRef_t +{ + DNSRecord *recnext; + DNSServiceOp *sdr; +}; + +static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int SeparateReturnSocket, DNSServiceOp *ref) +{ + char *msg = NULL; + ipc_msg_hdr *hdr; + + *len += sizeof(ipc_msg_hdr); + + // Write message to buffer + msg = malloc(*len); + + memset(msg, 0, *len); + hdr = (ipc_msg_hdr *)msg; + hdr->op = op; + *data_start = msg + sizeof(ipc_msg_hdr); + + return hdr; +} + +static void FreeDNSRecords(DNSServiceOp *sdRef) +{ + DNSRecord *rec = sdRef->rec; + while (rec) + { + DNSRecord *next = rec->recnext; + free(rec); + rec = next; + } +} + +static void FreeDNSServiceOp(DNSServiceOp *x) +{ + // We don't use our DNSServiceRefValid macro here because if we're cleaning up after a socket() call failed + // then sockfd could legitimately contain a failing value (e.g. dnssd_InvalidSocket) + x->sockfd = dnssd_InvalidSocket; + x->validator = 0xDDDDDDDD; + x->op = request_op_none; + x->AppCallback = NULL; + FreeDNSRecords(x); + free(x); +} + +#define MOCK_DNSSD_SOCK_FD 5 + +// Return a connected service ref (deallocate with DNSServiceRefDeallocate) +static DNSServiceErrorType ConnectToServer(DNSServiceRef *ref, DNSServiceFlags flags, uint32_t op, ProcessReplyFn ProcessReply, void *AppCallback, void *AppContext) +{ + DNSServiceOp *sdr; + + if (!ref) + return kDNSServiceErr_BadParam; + + sdr = malloc(sizeof(DNSServiceOp)); + sdr->sockfd = dnssd_InvalidSocket; + sdr->validator = sdr->sockfd ^ ValidatorBits; + sdr->op = op; + sdr->AppCallback = AppCallback; + sdr->AppContext = AppContext; + sdr->rec = NULL; + + *ref = NULL; + sdr->sockfd = MOCK_DNSSD_SOCK_FD; + sdr->validator = sdr->sockfd ^ ValidatorBits; + + *ref = sdr; + return kDNSServiceErr_NoError; +} + +#define TIZEN_DNSSD_MOCK_SERVICE "TizenDnssdMock" +#define TIZEN_DNSSD_MOCK_TYPE "_tizen_dnssd_mock._mock" +#define TIZEN_DNSSD_MOCK_DOMAIN "tizen_dnssd_mock." +#define TIZEN_DNSSD_MOCK_INTERFACE 5 +#define TIZEN_DNSSD_MOCK_PORT 12345 +#define TIZEN_DNSSD_MOCK_TXT_RECORD "txt=Tizen DNSSD MOCK info" +#define TIZEN_DNSSD_MOCK_HOST_NAME "DNSSD Mock Host name" + +static DNSServiceErrorType deliver_request(ipc_msg_hdr *hdr, DNSServiceOp *sdr) +{ + if (!DNSServiceRefValid(sdr)) + return kDNSServiceErr_BadReference; + + free(hdr); + + return kDNSServiceErr_NoError; +} + +API dnssd_sock_t DNSServiceRefSockFD(DNSServiceRef sdRef) +{ + if (!sdRef) + return dnssd_InvalidSocket; + + if (!DNSServiceRefValid(sdRef)) + return dnssd_InvalidSocket; + + return sdRef->sockfd; +} + + +static void __nsd_mock_dnssd_process_result_reg_service_request(DNSServiceOp *const sdr) +{ + ((DNSServiceRegisterReply)sdr->AppCallback)(sdr, + 0, + kDNSServiceErr_NoError, + NULL, + NULL, + TIZEN_DNSSD_MOCK_DOMAIN, + sdr->AppContext); +} + +static DNSServiceOp *adhoc_browse_handle = NULL; +static void __nsd_mock_dnssd_process_result_browse_request(DNSServiceOp *const sdr) +{ + ((DNSServiceBrowseReply)sdr->AppCallback)(sdr, + kDNSServiceFlagsAdd, + TIZEN_DNSSD_MOCK_INTERFACE, + kDNSServiceErr_NoError, + TIZEN_DNSSD_MOCK_SERVICE, + TIZEN_DNSSD_MOCK_TYPE, + TIZEN_DNSSD_MOCK_DOMAIN, + sdr->AppContext); + adhoc_browse_handle = sdr; +} + +static void __nsd_mock_dnssd_process_result_resolve_request(DNSServiceOp *const sdr) +{ + ((DNSServiceResolveReply)sdr->AppCallback)(sdr, + kDNSServiceFlagsAdd, + TIZEN_DNSSD_MOCK_INTERFACE, + kDNSServiceErr_NoError, + TIZEN_DNSSD_MOCK_SERVICE, + TIZEN_DNSSD_MOCK_TYPE, + TIZEN_DNSSD_MOCK_PORT, + strlen(TIZEN_DNSSD_MOCK_TXT_RECORD), + (const unsigned char *)TIZEN_DNSSD_MOCK_TXT_RECORD, + sdr->AppContext); +} + +static void __nsd_mock_dnssd_process_result_addrinfo_request(DNSServiceOp *const sdr) +{ + + struct sockaddr_in sa_in4 = {0,}; + const struct sockaddr *const sa = (struct sockaddr*)&sa_in4; + sa_in4.sin_family = AF_INET; + ((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, + kDNSServiceFlagsAdd, + TIZEN_DNSSD_MOCK_INTERFACE, + kDNSServiceErr_NoError, + TIZEN_DNSSD_MOCK_HOST_NAME, + sa, + 64, + sdr->AppContext); + + /* Adhoc for unavailable service */ + ((DNSServiceBrowseReply)adhoc_browse_handle->AppCallback)(sdr, + 0, + TIZEN_DNSSD_MOCK_INTERFACE, + kDNSServiceErr_NoError, + TIZEN_DNSSD_MOCK_SERVICE, + TIZEN_DNSSD_MOCK_TYPE, + TIZEN_DNSSD_MOCK_DOMAIN, + adhoc_browse_handle->AppContext); + adhoc_browse_handle = NULL; +} + +// Handle reply from server, calling application client callback. If there is no reply +// from the daemon on the socket contained in sdRef, the call will block. +API DNSServiceErrorType DNSServiceProcessResult(DNSServiceRef sdRef) +{ + if (!sdRef) + return kDNSServiceErr_BadParam; + + if (!DNSServiceRefValid(sdRef)) + return kDNSServiceErr_BadReference; + + /* original flow: + * Read reply header + * check header validity + * read body + * call sdRef->ProcessReply(sdRef, &cbh, ptr, data + cbh.ipc_hdr.datalen); + */ + if (sdRef->op == reg_service_request) + __nsd_mock_dnssd_process_result_reg_service_request(sdRef); + else if (sdRef->op == browse_request) + __nsd_mock_dnssd_process_result_browse_request(sdRef); + else if (sdRef->op == resolve_request) + __nsd_mock_dnssd_process_result_resolve_request(sdRef); + else if (sdRef->op == addrinfo_request) + __nsd_mock_dnssd_process_result_addrinfo_request(sdRef); + + return kDNSServiceErr_NoError; +} + + +API void DNSServiceRefDeallocate(DNSServiceRef sdRef) +{ + if (!sdRef) + return; + + if (!DNSServiceRefValid(sdRef)) + return; + + FreeDNSServiceOp(sdRef); +} + +API DNSServiceErrorType DNSServiceResolve +( + DNSServiceRef *sdRef, + DNSServiceFlags flags, + uint32_t interfaceIndex, + const char *name, + const char *regtype, + const char *domain, + DNSServiceResolveReply callBack, + void *context +) +{ + char *ptr; + size_t len; + ipc_msg_hdr *hdr; + DNSServiceErrorType err; + + if (!sdRef || !name || !regtype || !domain || !callBack) + return kDNSServiceErr_BadParam; + + err = ConnectToServer(sdRef, flags, resolve_request, NULL, callBack, context); + if (err) + return err; // On error ConnectToServer leaves *sdRef set to NULL + + // Calculate total message length + len = 0; + + hdr = create_hdr(resolve_request, &len, &ptr, 0, *sdRef); + if (!hdr) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + return kDNSServiceErr_NoMemory; + } + + err = deliver_request(hdr, *sdRef); // Will free hdr for us + if (err) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + } + + return err; +} + +API DNSServiceErrorType DNSServiceRegister +( + DNSServiceRef *sdRef, + DNSServiceFlags flags, + uint32_t interfaceIndex, + const char *name, + const char *regtype, + const char *domain, + const char *host, + uint16_t PortInNetworkByteOrder, + uint16_t txtLen, + const void *txtRecord, + DNSServiceRegisterReply callBack, + void *context +) +{ + char *ptr; + size_t len; + ipc_msg_hdr *hdr; + DNSServiceErrorType err; + + if (!sdRef || !regtype) + return kDNSServiceErr_BadParam; + + // No callback must have auto-rename + if (!callBack && (flags & kDNSServiceFlagsNoAutoRename)) + return kDNSServiceErr_BadParam; + + err = ConnectToServer(sdRef, flags, reg_service_request, NULL, callBack, context); + if (err) + return err; + + len = 0; + hdr = create_hdr(reg_service_request, &len, &ptr, 0, *sdRef); + if (!hdr) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + return kDNSServiceErr_NoMemory; + } + + err = deliver_request(hdr, *sdRef); // Will free hdr for us + if (err) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + } + return err; +} + +API DNSServiceErrorType DNSServiceAddRecord +( + DNSServiceRef sdRef, + DNSRecordRef *RecordRef, + DNSServiceFlags flags, + uint16_t rrtype, + uint16_t rdlen, + const void *rdata, + uint32_t ttl +) +{ + ipc_msg_hdr *hdr; + size_t len = 0; + char *ptr; + DNSRecordRef rref; + DNSRecord **p; + + if (!sdRef || !RecordRef || (!rdata && rdlen)) + return kDNSServiceErr_BadParam; + + if (sdRef->op != reg_service_request) + return kDNSServiceErr_BadReference; + + if (!DNSServiceRefValid(sdRef)) + return kDNSServiceErr_BadReference; + + *RecordRef = NULL; + + hdr = create_hdr(add_record_request, &len, &ptr, 0, sdRef); + + rref = malloc(sizeof(DNSRecord)); + rref->sdr = sdRef; + rref->recnext = NULL; + + *RecordRef = rref; + + p = &(sdRef)->rec; + while (*p) p = &(*p)->recnext; + *p = rref; + + return deliver_request(hdr, sdRef);; +} + +API DNSServiceErrorType DNSServiceUpdateRecord +( + DNSServiceRef sdRef, + DNSRecordRef RecordRef, /* may be NULL */ + DNSServiceFlags flags, + uint16_t rdlen, + const void *rdata, + uint32_t ttl +) +{ + (void)sdRef; // Unused + (void)RecordRef; // Unused + (void)flags; // Unused + (void)rdlen; // Unused + (void)rdata; // Unused + (void)ttl; // Unused + return kDNSServiceErr_NoError; +} + +API DNSServiceErrorType DNSServiceRemoveRecord +( + DNSServiceRef sdRef, + DNSRecordRef RecordRef, + DNSServiceFlags flags +) +{ + ipc_msg_hdr *hdr; + size_t len = 0; + char *ptr; + DNSServiceErrorType err; + + if (!sdRef) + return kDNSServiceErr_BadParam; + if (!RecordRef) + return kDNSServiceErr_BadParam; + + if (!DNSServiceRefValid(sdRef)) + return kDNSServiceErr_BadReference; + + hdr = create_hdr(remove_record_request, &len, &ptr, 1, sdRef); + + err = deliver_request(hdr, sdRef); // Will free hdr for us + if (!err) { + // This RecordRef could have been allocated in DNSServiceRegisterRecord or DNSServiceAddRecord. + // If so, delink from the list before freeing + DNSRecord **p = &sdRef->rec; + while (*p && *p != RecordRef) + p = &(*p)->recnext; + if (*p) + *p = RecordRef->recnext; + + free(RecordRef); + } + return err; +} + +API DNSServiceErrorType DNSServiceGetAddrInfo +( + DNSServiceRef *sdRef, + DNSServiceFlags flags, + uint32_t interfaceIndex, + uint32_t protocol, + const char *hostname, + DNSServiceGetAddrInfoReply callBack, + void *context /* may be NULL */ +) +{ + char *ptr; + size_t len; + ipc_msg_hdr *hdr; + DNSServiceErrorType err; + + if (!sdRef || !hostname || !callBack) + return kDNSServiceErr_BadParam; + + err = ConnectToServer(sdRef, flags, addrinfo_request, NULL, callBack, context); + if (err) + return err; // On error ConnectToServer leaves *sdRef set to NULL + + // Calculate total message length + len = 0; + + hdr = create_hdr(addrinfo_request, &len, &ptr, 0, *sdRef); + if (!hdr) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + return kDNSServiceErr_NoMemory; + } + + err = deliver_request(hdr, *sdRef); // Will free hdr for us + if (err) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + } + return err; +} + +API DNSServiceErrorType DNSServiceBrowse +( + DNSServiceRef *sdRef, + DNSServiceFlags flags, + uint32_t interfaceIndex, + const char *regtype, + const char *domain, + DNSServiceBrowseReply callBack, + void *context +) +{ + char *ptr; + size_t len; + ipc_msg_hdr *hdr; + DNSServiceErrorType err; + + // NULL domain handled below + if (!sdRef || !regtype || !callBack) + return kDNSServiceErr_BadParam; + + + err = ConnectToServer(sdRef, flags, browse_request, NULL, callBack, context); + if (err) + return err; // On error ConnectToServer leaves *sdRef set to NULL + + len = 0; + + hdr = create_hdr(browse_request, &len, &ptr, 0, *sdRef); + if (!hdr) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + return kDNSServiceErr_NoMemory; + } + + err = deliver_request(hdr, *sdRef); // Will free hdr for us + if (err) { + DNSServiceRefDeallocate(*sdRef); + *sdRef = NULL; + } + + return err; +} diff --git a/unittest/mock/nsd-mock-gdbus.c b/unittest/mock/nsd-mock-gdbus.c new file mode 100644 index 0000000..1c0182e --- /dev/null +++ b/unittest/mock/nsd-mock-gdbus.c @@ -0,0 +1,67 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 +#include + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +const gchar *netconfig_mock_gdbus_unique_name = "temporal_name"; + +static GDBusConnection *get_uninitialized_connection(GBusType bus_type, + GCancellable *cancellable, + GError **error) +{ + GDBusConnection *ret; + ret = NULL; + + ret = g_object_new(G_TYPE_DBUS_CONNECTION, + "address", "temporal_address", + "flags", G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | + G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, + "exit-on-close", TRUE, + NULL); + + return ret; +} + +API GDBusConnection *g_bus_get_sync(GBusType bus_type, GCancellable *cancellable, GError **error) +{ + return get_uninitialized_connection(bus_type, cancellable, error); +} + +API const gchar *g_dbus_connection_get_unique_name(GDBusConnection *connection) +{ + return netconfig_mock_gdbus_unique_name; +} + +API GVariant *g_dbus_connection_call_sync(GDBusConnection *connection, + const gchar *bus_name, + const gchar *object_path, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + const GVariantType *reply_type, + GDBusCallFlags flags, + gint timeout_msec, + GCancellable *cancellable, + GError **error) +{ + *error = NULL; + return g_variant_new_string("Haha this is mockup\n"); +} diff --git a/unittest/mock/nsd-mock-gio.c b/unittest/mock/nsd-mock-gio.c new file mode 100644 index 0000000..5ee9f4f --- /dev/null +++ b/unittest/mock/nsd-mock-gio.c @@ -0,0 +1,99 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 +#include + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +#define TIZEN_MOCK_IO_CHANNEL_SOURCE 5 + +API GIOChannel *g_io_channel_unix_new(gint fd) +{ + return g_new(GIOChannel, 1); +} + +API GIOStatus g_io_channel_set_flags(GIOChannel *channel, + GIOFlags flags, + GError **error) +{ + return G_IO_STATUS_NORMAL; +} + + +API void g_io_channel_set_close_on_unref(GIOChannel *channel, + gboolean do_close) +{ + return; +} + +typedef struct { + GIOChannel *channel; + GIOFunc func; + gpointer user_data; + gboolean called_once; +} mock_gio_channel_cb_data_s; + +static gboolean __mock_gio_channel_cb(gpointer user_data) +{ + mock_gio_channel_cb_data_s *cb_data = (mock_gio_channel_cb_data_s *)user_data; + + if (!user_data) + return FALSE; + + if (cb_data->called_once) + return TRUE; + + cb_data->func(cb_data->channel, G_IO_IN, cb_data->user_data); + cb_data->called_once = TRUE; + + return TRUE; +} + +static void __remove_mock_gio_channel_cb(gpointer data) +{ + mock_gio_channel_cb_data_s *cb_data = (mock_gio_channel_cb_data_s *)data; + if (!cb_data) + return; + g_free(cb_data); +} + +API guint g_io_add_watch(GIOChannel *channel, + GIOCondition condition, + GIOFunc func, + gpointer user_data) +{ + mock_gio_channel_cb_data_s *cb_data = g_try_malloc0(sizeof(mock_gio_channel_cb_data_s)); + guint g_mock_gio_channel_cb_source = 0; + + cb_data->channel = channel; + cb_data->func = func; + cb_data->user_data = user_data; + cb_data->called_once = FALSE; + g_mock_gio_channel_cb_source = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, + __mock_gio_channel_cb, + (gpointer)cb_data, + __remove_mock_gio_channel_cb); + + return g_mock_gio_channel_cb_source; +} + +API void g_io_channel_unref(GIOChannel *channel) +{ + g_free(channel); +} diff --git a/unittest/mock/nsd-mock-gssdp.c b/unittest/mock/nsd-mock-gssdp.c new file mode 100644 index 0000000..52fbd97 --- /dev/null +++ b/unittest/mock/nsd-mock-gssdp.c @@ -0,0 +1,171 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +#define DEFAULT_MOCK_GSSDP_RESOURCE_ID 5 + +GType +gssdp_client_get_type (void) G_GNUC_CONST; + +#define GSSDP_TYPE_CLIENT \ + (gssdp_client_get_type ()) +#define GSSDP_CLIENT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GSSDP_TYPE_CLIENT, \ + GSSDPClient)) +#define GSSDP_CLIENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GSSDP_TYPE_CLIENT, \ + GSSDPClientClass)) +#define GSSDP_IS_CLIENT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GSSDP_TYPE_CLIENT)) +#define GSSDP_IS_CLIENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GSSDP_TYPE_CLIENT)) +#define GSSDP_CLIENT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), \ + GSSDP_TYPE_CLIENT, \ + GSSDPClientClass)) + +typedef struct _GSSDPClient GSSDPClient; +typedef struct _GSSDPClientClass GSSDPClientClass; + +struct _GSSDPClient { + GObject parent; +}; + +struct _GSSDPClientClass { + GObjectClass parent_class; +}; + +GType +gssdp_resource_group_get_type (void) G_GNUC_CONST; + +#define GSSDP_TYPE_RESOURCE_GROUP \ + (gssdp_resource_group_get_type ()) +#define GSSDP_RESOURCE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GSSDP_TYPE_RESOURCE_GROUP, \ + GSSDPResourceGroup)) +#define GSSDP_RESOURCE_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GSSDP_TYPE_RESOURCE_GROUP, \ + GSSDPResourceGroupClass)) +#define GSSDP_IS_RESOURCE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GSSDP_TYPE_RESOURCE_GROUP)) +#define GSSDP_IS_RESOURCE_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GSSDP_TYPE_RESOURCE_GROUP)) +#define GSSDP_RESOURCE_GROUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), \ + GSSDP_TYPE_RESOURCE_GROUP, \ + GSSDPResourceGroupClass)) + +typedef struct _GSSDPResourceGroup GSSDPResourceGroup; +typedef struct _GSSDPResourceGroupClass GSSDPResourceGroupClass; + +struct _GSSDPResourceGroup { + GObject parent; +}; + +struct _GSSDPResourceGroupClass { + GObjectClass parent_class; +}; + +GType +gssdp_resource_browser_get_type (void) G_GNUC_CONST; + +#define GSSDP_TYPE_RESOURCE_BROWSER \ + (gssdp_resource_browser_get_type ()) +#define GSSDP_RESOURCE_BROWSER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GSSDP_TYPE_RESOURCE_BROWSER, \ + GSSDPResourceBrowser)) +#define GSSDP_RESOURCE_BROWSER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GSSDP_TYPE_RESOURCE_BROWSER, \ + GSSDPResourceBrowserClass)) +#define GSSDP_IS_RESOURCE_BROWSER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GSSDP_TYPE_RESOURCE_BROWSER)) +#define GSSDP_IS_RESOURCE_BROWSER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GSSDP_TYPE_RESOURCE_BROWSER)) +#define GSSDP_RESOURCE_BROWSER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), \ + GSSDP_TYPE_RESOURCE_BROWSER, \ + GSSDPResourceBrowserClass)) + +typedef struct _GSSDPResourceBrowser GSSDPResourceBrowser; +typedef struct _GSSDPResourceBrowserClass GSSDPResourceBrowserClass; + +struct _GSSDPResourceBrowser { + GObject parent; +}; + +struct _GSSDPResourceBrowserClass { + GObjectClass parent_class; +}; + +API GSSDPClient *gssdp_client_new(GMainContext *main_context, + const char *iface, + GError **error) +{ + return g_object_new(GSSDP_TYPE_CLIENT, NULL); +} + +API GSSDPResourceGroup * gssdp_resource_group_new(GSSDPClient *client) +{ + return g_object_new (GSSDP_TYPE_RESOURCE_GROUP, + "client", client, + NULL); +} + +API guint gssdp_resource_group_add_resource_simple(GSSDPResourceGroup *resource_group, + const char *target, + const char *usn, + const char *location) +{ + return DEFAULT_MOCK_GSSDP_RESOURCE_ID; +} + +API void gssdp_resource_group_set_available(GSSDPResourceGroup *resource_group, + gboolean available) +{ + return; +} + +API GSSDPResourceBrowser *gssdp_resource_browser_new(GSSDPClient *client, + const char *target) +{ + return g_object_new (GSSDP_TYPE_RESOURCE_BROWSER, + "client", client, + "target", target, + NULL); +} + +API void gssdp_resource_browser_set_active (GSSDPResourceBrowser *resource_browser, + gboolean active) +{ + return; +} diff --git a/unittest/mock/nsd-mock.c b/unittest/mock/nsd-mock.c new file mode 100644 index 0000000..31b7da8 --- /dev/null +++ b/unittest/mock/nsd-mock.c @@ -0,0 +1,83 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 +#include +#include +#include +#include +#include + +#include + +#include +#include + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +#define DEFAULT_MOCK_GOBJECT_SIGNAL 5 + +typedef enum { + LOG_ID_INVALID = -1, + LOG_ID_MAIN, + LOG_ID_RADIO, + LOG_ID_SYSTEM, + LOG_ID_APPS, + LOG_ID_KMSG, + LOG_ID_SYSLOG, + LOG_ID_MAX +} log_id_t; + +API int __dlog_print(log_id_t log_id, int prio, const char *tag, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + printf("\n"); + + return 0; +} + +API int system_info_get_platform_bool(const char *key, bool *value) +{ + *value = true; + return 0; +} + +API unsigned int if_nametoindex(const char *ifname) +{ + if (!ifname) + return 0; + else + return 1; +} +API gulong g_signal_connect_data(gpointer instance, + const gchar *detailed_signal, + GCallback c_handler, + gpointer data, + GClosureNotify destroy_data, + GConnectFlags connect_flags) +{ + return DEFAULT_MOCK_GOBJECT_SIGNAL; +} + +API void g_signal_handler_disconnect (gpointer instance, + gulong handler_id) +{ + return; +} diff --git a/unittest/tct-nsd-core.cpp b/unittest/tct-nsd-core.cpp new file mode 100755 index 0000000..4468a42 --- /dev/null +++ b/unittest/tct-nsd-core.cpp @@ -0,0 +1,93 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 +#include +#include "tct_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#include "tct-nsd-core.h" + +#ifdef __cplusplus +} +#endif + +#include + +#include +#include +#include +#include +#include +#include + +TEST(nsd, nsd){ + char *pszGetTCName = NULL; + pszGetTCName = (char*)malloc( 256 ); + memset( pszGetTCName, 0x00, 256); + strcpy( pszGetTCName, "utc_nsd"); + int i=0, result=0; + + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Executing TC Name = %s", __FUNCTION__, __LINE__, pszGetTCName); + + int successCnt = 0; + int errorCnt = 0; + for ( i = 0; tc_array[i].name; i++ ) + { + if ( 0 == strncmp(pszGetTCName, tc_array[i].name, strlen(pszGetTCName)) ) + { + if ( tc_array[i].startup ) + { + tc_array[i].startup(); + } + + result = tc_array[i].function(); + + if( result == 0 ) { + successCnt++; + } else { + dlog_print(DLOG_INFO, "NativeTCT", "[Error][%d] %s returns value = %d", i, tc_array[i].name, result); + errorCnt++; + } + + EXPECT_EQ(result, 0); + + if ( tc_array[i].cleanup ) + { + tc_array[i].cleanup(); + } + } + else + { + dlog_print(DLOG_INFO, "NativeTCT", "Name check error! [%s][%s]", pszGetTCName, tc_array[i].name); + ASSERT_EQ(0, 1); + } + } + + dlog_print(DLOG_INFO, "NativeTCT", "=========================="); + dlog_print(DLOG_INFO, "NativeTCT", "Success [%4d / %4d]", successCnt, successCnt + errorCnt); + dlog_print(DLOG_INFO, "NativeTCT", "Error [%4d / %4d]", errorCnt, successCnt + errorCnt); + dlog_print(DLOG_INFO, "NativeTCT", "=========================="); + + FREE_MEMORY_TC(pszGetTCName); +} + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/unittest/tct-nsd-core.h b/unittest/tct-nsd-core.h new file mode 100755 index 0000000..54afc4f --- /dev/null +++ b/unittest/tct-nsd-core.h @@ -0,0 +1,232 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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. +// +#ifndef __TCT_NSD_NATIVE_H__ +#define __TCT_NSD_NATIVE_H__ + +#include "testcase.h" +#include "tct_common.h" + +extern void utc_nsd_ssdp_browse_startup(void); +extern void utc_nsd_ssdp_browse_cleanup(void); +extern void utc_nsd_ssdp_register_startup(void); +extern void utc_nsd_ssdp_register_cleanup(void); +extern void utc_nsd_dnssd_browse_startup(void); +extern void utc_nsd_dnssd_browse_cleanup(void); +extern void utc_nsd_dnssd_register_startup(void); +extern void utc_nsd_dnssd_register_cleanup(void); + +extern int utc_nsd_ssdp_start_browsing_service_p(void); +extern int utc_nsd_ssdp_start_browsing_service_n(void); +extern int utc_nsd_ssdp_stop_browsing_service_p(void); +extern int utc_nsd_ssdp_stop_browsing_service_n1(void); +extern int utc_nsd_ssdp_stop_browsing_service_n2(void); +extern int utc_nsd_ssdp_initialize_p(void); +extern int utc_nsd_ssdp_deinitialize_p(void); +extern int utc_nsd_ssdp_deinitialize_n(void); +extern int utc_nsd_ssdp_create_local_service_p(void); +extern int utc_nsd_ssdp_create_local_service_n(void); +extern int utc_nsd_ssdp_destroy_local_service_p(void); +extern int utc_nsd_ssdp_detroy_local_service_n(void); +extern int utc_nsd_ssdp_set_usn_p(void); +extern int utc_nsd_ssdp_set_usn_n1(void); +extern int utc_nsd_ssdp_set_usn_n2(void); +extern int utc_nsd_ssdp_set_url_p(void); +extern int utc_nsd_ssdp_set_url_n1(void); +extern int utc_nsd_ssdp_set_url_n2(void); +extern int utc_nsd_ssdp_get_target_p(void); +extern int utc_nsd_ssdp_get_target_n1(void); +extern int utc_nsd_ssdp_get_target_n2(void); +extern int utc_nsd_ssdp_get_usn_p(void); +extern int utc_nsd_ssdp_get_usn_n1(void); +extern int utc_nsd_ssdp_get_usn_n2(void); +extern int utc_nsd_ssdp_get_url_p(void); +extern int utc_nsd_ssdp_get_url_n1(void); +extern int utc_nsd_ssdp_get_url_n2(void); +extern int utc_nsd_ssdp_register_local_service_p(void); +extern int utc_nsd_ssdp_register_local_service_n1(void); +extern int utc_nsd_ssdp_register_local_service_n2(void); +extern int utc_nsd_ssdp_deregister_local_service_p(void); +extern int utc_nsd_ssdp_deregister_local_service_n(void); +extern int utc_nsd_dnssd_browsing_service_full_p(void); +extern int utc_nsd_dnssd_start_browsing_service_p(void); +extern int utc_nsd_dnssd_start_browsing_service_n(void); +extern int utc_nsd_dnssd_stop_browsing_service_p(void); +extern int utc_nsd_dnssd_stop_browsing_service_n(void); +extern int utc_nsd_dnssd_start_browsing_service_on_interface_p(void); +extern int utc_nsd_dnssd_start_browsing_service_on_interface_n1(void); +extern int utc_nsd_dnssd_start_browsing_service_on_interface_n2(void); +extern int utc_nsd_dnssd_start_browsing_service_on_interface_n3(void); +extern int utc_nsd_dnssd_service_get_ip_n1(void); +extern int utc_nsd_dnssd_service_get_ip_n2(void); +extern int utc_nsd_dnssd_initialize_p(void); +extern int utc_nsd_dnssd_initialize_n(void); +extern int utc_nsd_dnssd_deinitialize_p(void); +extern int utc_nsd_dnssd_deinitialize_n(void); +extern int utc_nsd_dnssd_create_local_service_p(void); +extern int utc_nsd_dnssd_create_local_service_n1(void); +extern int utc_nsd_dnssd_create_local_service_n2(void); +extern int utc_nsd_dnssd_destroy_local_service_p(void); +extern int utc_nsd_dnssd_detroy_local_service_n1(void); +extern int utc_nsd_dnssd_detroy_local_service_n2(void); +extern int utc_nsd_dnssd_set_name_p(void); +extern int utc_nsd_dnssd_set_name_n1(void); +extern int utc_nsd_dnssd_set_name_n2(void); +extern int utc_nsd_dnssd_set_name_n3(void); +extern int utc_nsd_dnssd_set_port_p(void); +extern int utc_nsd_dnssd_set_port_n1(void); +extern int utc_nsd_dnssd_set_port_n2(void); +extern int utc_nsd_dnssd_set_port_n3(void); +extern int utc_nsd_dnssd_set_interface_p(void); +extern int utc_nsd_dnssd_set_interface_n1(void); +extern int utc_nsd_dnssd_set_interface_n2(void); +extern int utc_nsd_dnssd_set_interface_n3(void); +extern int utc_nsd_dnssd_set_record_p(void); +extern int utc_nsd_dnssd_set_record_n1(void); +extern int utc_nsd_dnssd_set_record_n2(void); +extern int utc_nsd_dnssd_unset_record_p(void); +extern int utc_nsd_dnssd_unset_record_n1(void); +extern int utc_nsd_dnssd_unset_record_n2(void); +extern int utc_nsd_dnssd_unset_record_n3(void); +extern int utc_nsd_dnssd_add_txt_record_p(void); +extern int utc_nsd_dnssd_add_txt_record_n1(void); +extern int utc_nsd_dnssd_add_txt_record_n2(void); +extern int utc_nsd_dnssd_add_txt_record_n3(void); +extern int utc_nsd_dnssd_add_txt_record_n4(void); +extern int utc_nsd_dnssd_get_all_txt_record_p(void); +extern int utc_nsd_dnssd_get_all_txt_record_n1(void); +extern int utc_nsd_dnssd_get_all_txt_record_n2(void); +extern int utc_nsd_dnssd_get_all_txt_record_n3(void); +extern int utc_nsd_dnssd_remove_txt_record_p(void); +extern int utc_nsd_dnssd_remove_txt_record_n1(void); +extern int utc_nsd_dnssd_remove_txt_record_n2(void); +extern int utc_nsd_dnssd_get_type_p(void); +extern int utc_nsd_dnssd_get_type_n1(void); +extern int utc_nsd_dnssd_get_type_n2(void); +extern int utc_nsd_dnssd_get_type_n3(void); +extern int utc_nsd_dnssd_get_name_p(void); +extern int utc_nsd_dnssd_get_name_n1(void); +extern int utc_nsd_dnssd_get_name_n2(void); +extern int utc_nsd_dnssd_get_port_p(void); +extern int utc_nsd_dnssd_get_port_n1(void); +extern int utc_nsd_dnssd_get_port_n2(void); +extern int utc_nsd_dnssd_register_local_service_p(void); +extern int utc_nsd_dnssd_register_local_service_n(void); +extern int utc_nsd_dnssd_deregister_local_service_p(void); +extern int utc_nsd_dnssd_deregister_local_service_n(void); + +testcase tc_array[] = { + {"utc_nsd_ssdp_start_browsing_service_p",utc_nsd_ssdp_start_browsing_service_p,utc_nsd_ssdp_browse_startup,utc_nsd_ssdp_browse_cleanup}, + {"utc_nsd_ssdp_start_browsing_service_n",utc_nsd_ssdp_start_browsing_service_n,utc_nsd_ssdp_browse_startup,utc_nsd_ssdp_browse_cleanup}, + {"utc_nsd_ssdp_stop_browsing_service_p",utc_nsd_ssdp_stop_browsing_service_p,utc_nsd_ssdp_browse_startup,utc_nsd_ssdp_browse_cleanup}, + {"utc_nsd_ssdp_stop_browsing_service_n1",utc_nsd_ssdp_stop_browsing_service_n1,utc_nsd_ssdp_browse_startup,utc_nsd_ssdp_browse_cleanup}, + {"utc_nsd_ssdp_stop_browsing_service_n2",utc_nsd_ssdp_stop_browsing_service_n2,utc_nsd_ssdp_browse_startup,utc_nsd_ssdp_browse_cleanup}, + {"utc_nsd_ssdp_initialize_p",utc_nsd_ssdp_initialize_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_deinitialize_p",utc_nsd_ssdp_deinitialize_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_deinitialize_n",utc_nsd_ssdp_deinitialize_n,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_create_local_service_p",utc_nsd_ssdp_create_local_service_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_create_local_service_n",utc_nsd_ssdp_create_local_service_n,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_destroy_local_service_p",utc_nsd_ssdp_destroy_local_service_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_detroy_local_service_n",utc_nsd_ssdp_detroy_local_service_n,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_usn_p",utc_nsd_ssdp_set_usn_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_usn_n1",utc_nsd_ssdp_set_usn_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_usn_n2",utc_nsd_ssdp_set_usn_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_url_p",utc_nsd_ssdp_set_url_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_url_n1",utc_nsd_ssdp_set_url_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_set_url_n2",utc_nsd_ssdp_set_url_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_target_p",utc_nsd_ssdp_get_target_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_target_n1",utc_nsd_ssdp_get_target_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_target_n2",utc_nsd_ssdp_get_target_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_usn_p",utc_nsd_ssdp_get_usn_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_usn_n1",utc_nsd_ssdp_get_usn_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_usn_n2",utc_nsd_ssdp_get_usn_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_url_p",utc_nsd_ssdp_get_url_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_url_n1",utc_nsd_ssdp_get_url_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_get_url_n2",utc_nsd_ssdp_get_url_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_register_local_service_p",utc_nsd_ssdp_register_local_service_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_register_local_service_n1",utc_nsd_ssdp_register_local_service_n1,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_register_local_service_n2",utc_nsd_ssdp_register_local_service_n2,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_deregister_local_service_p",utc_nsd_ssdp_deregister_local_service_p,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_ssdp_deregister_local_service_n",utc_nsd_ssdp_deregister_local_service_n,utc_nsd_ssdp_register_startup,utc_nsd_ssdp_register_cleanup}, + {"utc_nsd_dnssd_browsing_service_full_p",utc_nsd_dnssd_browsing_service_full_p,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_p",utc_nsd_dnssd_start_browsing_service_p,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_n",utc_nsd_dnssd_start_browsing_service_n,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_stop_browsing_service_p",utc_nsd_dnssd_stop_browsing_service_p,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_stop_browsing_service_n",utc_nsd_dnssd_stop_browsing_service_n,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_on_interface_p",utc_nsd_dnssd_start_browsing_service_on_interface_p,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_on_interface_n1",utc_nsd_dnssd_start_browsing_service_on_interface_n1,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_on_interface_n2",utc_nsd_dnssd_start_browsing_service_on_interface_n2,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_start_browsing_service_on_interface_n3",utc_nsd_dnssd_start_browsing_service_on_interface_n3,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_service_get_ip_n1",utc_nsd_dnssd_service_get_ip_n1,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_service_get_ip_n2",utc_nsd_dnssd_service_get_ip_n2,utc_nsd_dnssd_browse_startup,utc_nsd_dnssd_browse_cleanup}, + {"utc_nsd_dnssd_initialize_p",utc_nsd_dnssd_initialize_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_initialize_n",utc_nsd_dnssd_initialize_n,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_deinitialize_p",utc_nsd_dnssd_deinitialize_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_deinitialize_n",utc_nsd_dnssd_deinitialize_n,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_create_local_service_p",utc_nsd_dnssd_create_local_service_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_create_local_service_n1",utc_nsd_dnssd_create_local_service_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_create_local_service_n2",utc_nsd_dnssd_create_local_service_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_destroy_local_service_p",utc_nsd_dnssd_destroy_local_service_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_detroy_local_service_n1",utc_nsd_dnssd_detroy_local_service_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_detroy_local_service_n2",utc_nsd_dnssd_detroy_local_service_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_name_p",utc_nsd_dnssd_set_name_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_name_n1",utc_nsd_dnssd_set_name_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_name_n2",utc_nsd_dnssd_set_name_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_name_n3",utc_nsd_dnssd_set_name_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_port_p",utc_nsd_dnssd_set_port_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_port_n1",utc_nsd_dnssd_set_port_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_port_n2",utc_nsd_dnssd_set_port_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_port_n3",utc_nsd_dnssd_set_port_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_interface_p",utc_nsd_dnssd_set_interface_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_interface_n1",utc_nsd_dnssd_set_interface_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_interface_n2",utc_nsd_dnssd_set_interface_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_interface_n3",utc_nsd_dnssd_set_interface_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_record_p",utc_nsd_dnssd_set_record_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_record_n1",utc_nsd_dnssd_set_record_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_set_record_n2",utc_nsd_dnssd_set_record_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_unset_record_p",utc_nsd_dnssd_unset_record_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_unset_record_n1",utc_nsd_dnssd_unset_record_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_unset_record_n2",utc_nsd_dnssd_unset_record_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_unset_record_n3",utc_nsd_dnssd_unset_record_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_add_txt_record_p",utc_nsd_dnssd_add_txt_record_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_add_txt_record_n1",utc_nsd_dnssd_add_txt_record_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_add_txt_record_n2",utc_nsd_dnssd_add_txt_record_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_add_txt_record_n3",utc_nsd_dnssd_add_txt_record_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_add_txt_record_n4",utc_nsd_dnssd_add_txt_record_n4,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_all_txt_record_p",utc_nsd_dnssd_get_all_txt_record_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_all_txt_record_n1",utc_nsd_dnssd_get_all_txt_record_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_all_txt_record_n2",utc_nsd_dnssd_get_all_txt_record_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_all_txt_record_n3",utc_nsd_dnssd_get_all_txt_record_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_remove_txt_record_p",utc_nsd_dnssd_remove_txt_record_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_remove_txt_record_n1",utc_nsd_dnssd_remove_txt_record_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_remove_txt_record_n2",utc_nsd_dnssd_remove_txt_record_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_type_p",utc_nsd_dnssd_get_type_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_type_n1",utc_nsd_dnssd_get_type_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_type_n2",utc_nsd_dnssd_get_type_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_type_n3",utc_nsd_dnssd_get_type_n3,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_name_p",utc_nsd_dnssd_get_name_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_name_n1",utc_nsd_dnssd_get_name_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_name_n2",utc_nsd_dnssd_get_name_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_port_p",utc_nsd_dnssd_get_port_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_port_n1",utc_nsd_dnssd_get_port_n1,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_get_port_n2",utc_nsd_dnssd_get_port_n2,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_register_local_service_p",utc_nsd_dnssd_register_local_service_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_register_local_service_n",utc_nsd_dnssd_register_local_service_n,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_deregister_local_service_p",utc_nsd_dnssd_deregister_local_service_p,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {"utc_nsd_dnssd_deregister_local_service_n",utc_nsd_dnssd_deregister_local_service_n,utc_nsd_dnssd_register_startup,utc_nsd_dnssd_register_cleanup}, + {NULL, NULL} +}; + +#endif // __TCT_NSD_NATIVE_H__ diff --git a/unittest/utc-nsd-dnssd-browse.c b/unittest/utc-nsd-dnssd-browse.c new file mode 100644 index 0000000..c2e9adf --- /dev/null +++ b/unittest/utc-nsd-dnssd-browse.c @@ -0,0 +1,407 @@ +// +// Copyright (c) 2014 Samsung Electronics Co., Ltd. +// +// 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 "assert_local.h" +#include +#include +#include + +#include +#include +#include +//& set: Nsd-dnssd-browse + +static bool g_feature = true; +#define TIZEN_DNSSD_MOCK_TYPE "_tizen_dnssd_mock._mock" + +dnssd_browser_h g_browser_id = 0; +static GMainLoop* loop = NULL; +static bool found_callback = false; + +static void __found_cb(dnssd_service_state_e state, dnssd_service_h dnssd_service, void *user_data) +{ + return; +} + +static gboolean browsing_timeout(gpointer data) +{ + g_main_loop_quit(loop); + g_main_loop_unref(loop); + loop = NULL; + return FALSE; +} + +static void dnssd_browsing_found(dnssd_service_state_e state, + dnssd_service_h remote_service, void *user_data) +{ + char *name = NULL; + char *type = NULL; + char *ip_v4_address = NULL; + char *ip_v6_address = NULL; + unsigned char *txt_record = NULL; + unsigned short txt_len = 0; + int port = 0; + + int ret; + + if (state == DNSSD_SERVICE_STATE_AVAILABLE) { + + ret = dnssd_service_get_name(remote_service, &name); + if (ret != DNSSD_ERROR_NONE) + goto out; + + ret = dnssd_service_get_type(remote_service, &type); + if (ret != DNSSD_ERROR_NONE) + goto out; + + ret = dnssd_service_get_ip(remote_service, &ip_v4_address, &ip_v6_address); + if (ret != DNSSD_ERROR_NONE) + goto out; + + ret = dnssd_service_get_port(remote_service, &port); + if (ret != DNSSD_ERROR_NONE) + goto out; + + ret = dnssd_service_get_all_txt_record(remote_service, &txt_len, + (void *)&txt_record); + if (ret != DNSSD_ERROR_NONE) + goto out; + + found_callback = true; + g_main_loop_quit(loop); + g_main_loop_unref(loop); + } +out: + g_free(ip_v4_address); + g_free(ip_v6_address); + g_free(txt_record); + g_free(name); + g_free(type); +} + +static int wait_for_browse_callback(dnssd_browser_h *browser_id) +{ + int timeout_testcase = 0; + int ret = 0; + + ret = dnssd_start_browsing_service(TIZEN_DNSSD_MOCK_TYPE, browser_id, dnssd_browsing_found, NULL); + + if (ret == DNSSD_ERROR_NONE) { + found_callback = false; + loop = g_main_loop_new(NULL, FALSE); + timeout_testcase = g_timeout_add(20000, browsing_timeout, loop); + g_main_loop_run(loop); + g_source_remove(timeout_testcase); + } + + if (!found_callback) + ret = -1; + + return ret; +} + +/** + * @function utc_nsd_dnssd_browse_startup + * @since_tizen 3.0 + * @description Initializes DNSSD. Called before each test + * @parameter NA + * @return NA + */ +void utc_nsd_dnssd_browse_startup(void) +{ + int ret = DNSSD_ERROR_NONE; + ret = system_info_get_platform_bool("http://tizen.org/feature/network.service_discovery.dnssd", &g_feature); + + if (SYSTEM_INFO_ERROR_NONE != ret) { + fprintf(stderr, "system_info_get_platform_bool() Fail(%d)\n", ret); + return; + } + + if (g_feature == true) { + ret = dnssd_initialize(); + if (ret != DNSSD_ERROR_NONE) { + fprintf(stderr, "dnssd_initialize() Fail(%d)", ret); + return; + } + } +} + +/** + * @function utc_nsd_dnssd_browse_cleanup + * @since_tizen 3.0 + * @description Deinitialize DNSSD. Called after each test + * @parameter NA + * @return NA + */ +void utc_nsd_dnssd_browse_cleanup(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == true) { + ret = dnssd_deinitialize(); + if (ret != DNSSD_ERROR_NONE) { + fprintf(stderr, "dnssd_deinitialize() Fail(%d)", ret); + return; + } + } +} + + +int utc_nsd_dnssd_browsing_service_full_p(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = wait_for_browse_callback(&browser_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_stop_browsing_service(browser_id); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_start_browsing_service_p + * @since_tizen 3.0 + * @type Positive + * @description Start browsing DNSSD services + * @scenario Start browsing DNSSD services with a service type + * Ensure no error + */ +int utc_nsd_dnssd_start_browsing_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service("_ftp._tcp", &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_stop_browsing_service(browser_id); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_start_browsing_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_start_browsing_service by passing invalid browser handle + * @scenario Pass NULL as a browser handle + * Return value should be DNSSD_ERROR_INVALID_PARAMETER + */ +int utc_nsd_dnssd_start_browsing_service_n(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service("_ftp._tcp", NULL, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_stop_browsing_service_p + * @since_tizen 3.0 + * @type Positive + * @description Stop browsing DNSSD services + * @scenario Start browsing DNSSD services with a service type + * Stop browsing with valid browser handle + * Ensure no error + */ +int utc_nsd_dnssd_stop_browsing_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_stop_browsing_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service("_ftp._tcp", &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_stop_browsing_service(browser_id); + assert_eq(ret, DNSSD_ERROR_NONE); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_stop_browsing_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_stop_browsing_service by passing invalid browser handle + * @scenario Start browsing DNSSD services with a service target + * Stop browsing by passing an invalid browser handle + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND + */ +int utc_nsd_dnssd_stop_browsing_service_n(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_stop_browsing_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service("_ftp._tcp", &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_stop_browsing_service(0); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_stop_browsing_service(browser_id); + + return 0; +} + +int utc_nsd_dnssd_start_browsing_service_on_interface_p(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_start_browsing_service_on_interface(NULL, NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service_on_interface("_ftp._tcp", "wlan0", &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_stop_browsing_service(browser_id); + assert_eq(ret, DNSSD_ERROR_NONE); + return 0; +} + +int utc_nsd_dnssd_start_browsing_service_on_interface_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_start_browsing_service_on_interface(NULL, NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_start_browsing_service_on_interface("_ftp._tcp", "wlan0", &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +int utc_nsd_dnssd_start_browsing_service_on_interface_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service_on_interface("_ftp._tcp", "wlan0", NULL, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + return 0; +} + +int utc_nsd_dnssd_start_browsing_service_on_interface_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_browser_h browser_id = 0; + + if (g_feature == false) { + ret = dnssd_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_start_browsing_service_on_interface("_ftp._tcp", NULL, &browser_id, &__found_cb, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + return 0; +} +/** + * @testcase utc_nsd_dnssd_service_get_ip_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_ip by passing invalid browser handle + * @scenario get IP address by invalid browser handle + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND + */ +int utc_nsd_dnssd_service_get_ip_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_service_h service_id = 0; + char *ip_v4_address = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_ip(service_id, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_service_get_ip(service_id, &ip_v4_address, NULL); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_service_get_ip_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_ip by passing invalid parameter + * @scenario get IP address by invalid parameter + * Return value should be DNSSD_ERROR_INVALID_PARAMETER + */ +int utc_nsd_dnssd_service_get_ip_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + dnssd_service_h service_id = 0; + + if (g_feature == false) { + ret = dnssd_service_get_ip(service_id, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_service_get_ip(service_id, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + return 0; +} diff --git a/unittest/utc-nsd-dnssd-register.c b/unittest/utc-nsd-dnssd-register.c new file mode 100644 index 0000000..e40bd55 --- /dev/null +++ b/unittest/utc-nsd-dnssd-register.c @@ -0,0 +1,1816 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 "assert_local.h" +#include +#include +#include + +#include +#include +#include + +static GMainLoop* loop = NULL; +static bool registered_callback = false; +static bool g_feature = true; + +static void __registered_cb(dnssd_error_e result, + dnssd_service_h dnssd_service, void *user_data) +{ + return; +} + +static gboolean register_timeout(gpointer data) +{ + registered_callback= false; + g_main_loop_quit(loop); + g_main_loop_unref(loop); + loop = NULL; + return FALSE; +} + +static void dnssd_register_reply(dnssd_error_e result, + dnssd_service_h local_service, void *user_data) +{ + if (result == DNSSD_ERROR_NONE) { + registered_callback = true; + g_main_loop_quit(loop); + g_main_loop_unref(loop); + } +} + +static int wait_for_registered_callback(dnssd_service_h local_service) +{ + int timeout_testcase = 0; + int ret; + + ret = dnssd_register_local_service(local_service, dnssd_register_reply, NULL); + + if (ret == DNSSD_ERROR_NONE) + { + registered_callback = false; + loop = g_main_loop_new(NULL, FALSE); + timeout_testcase = g_timeout_add(20000, register_timeout, loop); + g_main_loop_run(loop); + g_source_remove(timeout_testcase); + + if (!registered_callback) + { + ret = -1; + } + } + return ret; +} + +/** + * @function utc_nsd_dnssd_register_startup + * @since_tizen 3.0 + * @description Initializes DNSSD. Called before each test + * @parameter NA + * @return NA + */ +void utc_nsd_dnssd_register_startup(void) +{ + int ret = DNSSD_ERROR_NONE; + ret = system_info_get_platform_bool("http://tizen.org/feature/network.service_discovery.dnssd", &g_feature); + + if (SYSTEM_INFO_ERROR_NONE != ret) { + fprintf(stderr, "system_info_get_platform_bool() Fail(%d)\n", ret); + return; + } + + if (g_feature == true) { + ret = dnssd_initialize(); + if (ret != DNSSD_ERROR_NONE) { + fprintf(stderr, "dnssd_initialize() Fail(%d)", ret); + return; + } + } +} + +/** + * @function utc_nsd_dnssd_register_cleanup + * @since_tizen 3.0 + * @description Deinitialize DNSSD. Called after each test + * @parameter NA + * @return NA + */ +void utc_nsd_dnssd_register_cleanup(void) +{ + if (g_feature == true) { + dnssd_deinitialize(); + } +} + +/** + * @testcase utc_nsd_dnssd_initialize_p + * @since_tizen 3.0 + * @type Positive + * @description Initialize DNSSD. + * @scenario Initialize DNSSD. + * Ensure no error + */ +int utc_nsd_dnssd_initialize_p(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_initialize(); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + dnssd_deinitialize(); + + ret = dnssd_initialize(); + assert_eq(ret, DNSSD_ERROR_NONE); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_initialize_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_deinitialize after DNSSD is initialized. + * @scenario initialize again. + * Return value should be DNSSD_ERROR_INVALID_OPERATION. + */ +int utc_nsd_dnssd_initialize_n(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_initialize(); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_initialize(); + assert_eq(ret, DNSSD_ERROR_INVALID_OPERATION); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_deinitialize_p + * @since_tizen 3.0 + * @type Positive + * @description Deinitialize DNSSD. + * @scenario Deinitialize DNSSD. + * Ensure no error + */ +int utc_nsd_dnssd_deinitialize_p(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_deinitialize(); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + ret = dnssd_deinitialize(); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_deinitialize_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_deinitialize before DNSSD is initialized. + * @scenario Deinitialize DNSSD and deinitialize again. + * Return value should be DNSSD_ERROR_NOT_INITIALIZED. + */ +int utc_nsd_dnssd_deinitialize_n(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_deinitialize(); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + dnssd_deinitialize(); + + ret = dnssd_deinitialize(); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_create_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Create a DNSSD local service handle. + * @scenario Create and Destroy a DNSSD local service handle. + * Ensure no error + */ +int utc_nsd_dnssd_create_local_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_create_local_service(NULL, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_create_local_service_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_create_local_service(NULL, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_create_local_service_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_create_local_service by passing an invalid parameter. + * @scenario Pass NULL as a service handle parameter. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_create_local_service_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_create_local_service(NULL, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_create_local_service("_ftp._tcp", NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_destroy_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Destroy a DNSSD local service handle. + * @scenario Create and Destroy a DNSSD local service handle. + * Ensure no error + */ +int utc_nsd_dnssd_destroy_local_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_destroy_local_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_destroy_local_service(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + return 0; +} + +int utc_nsd_dnssd_detroy_local_service_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id = 0; + + if (g_feature == false) { + ret = dnssd_create_local_service(NULL, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_destroy_local_service(serv_id); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_destroy_local_service_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_destroy_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_detroy_local_service_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_destroy_local_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_destroy_local_service(serv_id + 1); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; + +} +/** + * @testcase utc_nsd_dnssd_set_name_p + * @since_tizen 3.0 + * @type Positive + * @description Set the service name of a DNSSD local service. + * @scenario Create a DNSSD local service and set the service name of the service. + * Ensure no error + */ +int utc_nsd_dnssd_set_name_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_name(serv_id, "test-ftp"); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_name_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_name by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_set_name_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_name(serv_id + 1, "test-ftp"); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_name_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_name by passing invalid service name. + * @scenario Create a DNSSD service and set a service name. + * Create another DNSSD service and set the same service name as NULL. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_set_name_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_set_name(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_set_name_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_set_name(serv_id, "test-ftp"); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_port_p + * @since_tizen 3.0 + * @type Positive + * @description Set the port number of a DNSSD local service. + * @scenario Create a DNSSD local service and set the port number of the service. + * Ensure no error + */ +int utc_nsd_dnssd_set_port_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_port(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_port_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_port by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_set_port_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_port(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_port(serv_id + 1, 1234); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_port_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_port by passing an invalid port number + * @scenario Create a DNSSD service and set a port number as an invalid value. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_set_port_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_port(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_set_port(serv_id, -1234); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + return 0; +} + +int utc_nsd_dnssd_set_port_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_port(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +int utc_nsd_dnssd_set_interface_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_interface(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_interface(serv_id, "wlan0"); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_set_interface_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_interface(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_interface(serv_id + 1, "wlan0"); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_set_interface_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_interface(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_set_interface(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + return 0; +} + +int utc_nsd_dnssd_set_interface_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_set_interface(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_set_interface(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_record_p + * @since_tizen 3.0 + * @type Positive + * @description Verify dnssd_service_set_record by setting dns resource record + * @scenario Create a DNSSD service and set a dns resource record. + * Ensure no error. + */ +int utc_nsd_dnssd_set_record_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char buff[32] = {0,}; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_set_record(0, 0, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + g_strlcpy(buff + 1, value, sizeof(buff)); + buff[0] = strlen(value); + ret = dnssd_service_set_record(serv_id, 16, buff[0] + 1, (void *)buff); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_record(serv_id, 16, buff[0] + 1, (void *)buff); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_service_unset_record(serv_id, 16); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_set_record_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_record by setting dns resource record + * @scenario Create a DNSSD service and pass invalid service ID. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_set_record_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char buff[32] = {0,}; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_set_record(0, 0, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + g_strlcpy(buff + 1, value, sizeof(buff)); + buff[0] = strlen(value); + + ret = dnssd_service_set_record(serv_id + 1, 16, buff[0], (void *)buff); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_service_unset_record(serv_id, 16); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_set_record_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char buff[32] = {0,}; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_set_record(0, 0, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + g_strlcpy(buff + 1, value, sizeof(buff)); + buff[0] = strlen(value); + + ret = dnssd_service_set_record(serv_id, 16, buff[0], (void *)buff); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} +/** + * @testcase utc_nsd_dnssd_unset_record_p + * @since_tizen 3.0 + * @type Positive + * @description Verify dnssd_service_unset_record by removing dns resource record + * @scenario Unset DNS resource record after creating & setting a dns resource record. + * Ensure no error. + */ +int utc_nsd_dnssd_unset_record_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char buff[32] = {0,}; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_unset_record(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + g_strlcpy(buff + 1, value, sizeof(buff)); + buff[0] = strlen(value); + + ret = dnssd_service_set_record(serv_id, 16, buff[0] + 1, (void *)buff); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_unset_record(serv_id, 16); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_unset_record_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_set_record by setting dns resource record + * @scenario Create a DNSSD service, set resource record and pass invalid service ID. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_unset_record_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char buff[32] = {0,}; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_unset_record(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + g_strlcpy(buff + 1, value, sizeof(buff)); + buff[0] = strlen(value); + + ret = dnssd_service_set_record(serv_id, 16, buff[0] + 1, (void *)buff); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_unset_record(serv_id + 1, 16); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_service_unset_record(serv_id, 16); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_unset_record_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_unset_record(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_unset_record(serv_id, 16); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_service_unset_record(serv_id, 16); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_unset_record_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_unset_record(0, 0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_unset_record(serv_id, 16); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_add_txt_record_p + * @since_tizen 3.0 + * @type Positive + * @description Verify dnssd_add_txt_record by setting txt record + * @scenario Create a DNSSD service and set a dns txt record. + * Ensure no error. + */ +int utc_nsd_dnssd_add_txt_record_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_add_txt_record(0, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_remove_txt_record(serv_id, key); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_add_txt_record_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd__add_txt_record by setting txt record + * @scenario Create a DNSSD service and pass invalid service ID. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_add_txt_record_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_add_txt_record(0, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id + 1, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_add_txt_record_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_add_txt_record by setting txt record + * @scenario Create a DNSSD service and pass NULL key and NULL value. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_add_txt_record_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_add_txt_record(0, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_add_txt_record_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_add_txt_record(0, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, 300, value); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_add_txt_record_n4(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_add_txt_record(0, NULL, 0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_add_txt_record(serv_id, key, 300, value); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} +/** + * @testcase utc_nsd_dnssd_get_all_txt_record_p + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_get_all_txt_record + * @scenario Get txt resource record after creating & setting a txt record. + * Ensure no error. + */ +int utc_nsd_dnssd_get_all_txt_record_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + void *txt_record = NULL; + unsigned short length = 0; + + if (g_feature == false) { + ret = dnssd_service_get_all_txt_record(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_get_all_txt_record(serv_id, &length, &txt_record); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_remove_txt_record(serv_id, key); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_all_txt_record_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_get_all_txt_record + * @scenario Get txt resource record with invalid service ID after creating & setting a txt record. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_get_all_txt_record_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + void *txt_record = NULL; + unsigned short length = 0; + + if (g_feature == false) { + ret = dnssd_service_get_all_txt_record(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_get_all_txt_record(serv_id + 1, &length, &txt_record); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + ret = dnssd_service_remove_txt_record(serv_id, key); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_all_txt_record_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_get_all_txt_record + * @scenario Get txt resource record with NULL key after creating & setting a txt record. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_get_all_txt_record_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + unsigned short length = 0; + + if (g_feature == false) { + ret = dnssd_service_get_all_txt_record(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_get_all_txt_record(serv_id, &length, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + ret = dnssd_service_remove_txt_record(serv_id, key); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_get_all_txt_record_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + unsigned short length = 0; + + if (g_feature == false) { + ret = dnssd_service_get_all_txt_record(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + dnssd_deinitialize(); + + ret = dnssd_service_get_all_txt_record(serv_id, &length, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} +/** + * @testcase utc_nsd_dnssd_remove_txt_record_p + * @since_tizen 3.0 + * @type Positive + * @description Verify dnssd_service_remove_txt_record by removing txt record + * @scenario Unset DNS txt record after creating & setting a txt record. + * Ensure no error. + */ +int utc_nsd_dnssd_remove_txt_record_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_remove_txt_record(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_remove_txt_record(serv_id, key); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_remove_txt_record_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_remove_unset_txt_record by removing txt record + * @scenario Unset DNS resource record with invalid service ID after creating & setting a txt record. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_remove_txt_record_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_remove_txt_record(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_remove_txt_record(serv_id + 1, key); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_service_remove_txt_record(serv_id, NULL); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_remove_txt_record_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_remove_unset_txt_record by removing txt record + * @scenario Unset DNS resource record with NULL key after creating & setting a txt record. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_remove_txt_record_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *key = "path"; + char *value = "http://www.tizen.org"; + + if (g_feature == false) { + ret = dnssd_service_remove_txt_record(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_add_txt_record(serv_id, key, strlen(value), value); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_remove_txt_record(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_service_remove_txt_record(serv_id, NULL); + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_type_p + * @since_tizen 3.0 + * @type Positive + * @description Get the type of a DNSSD service. + * @scenario Create a DNSSD local service and get the type of a DNSSD service. + * Ensure no error + */ +int utc_nsd_dnssd_get_type_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *type = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_type(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_get_type(serv_id, &type); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + g_free(type); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_type_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_type by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_get_type_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *type = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_type(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_get_type(serv_id + 1, &type); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_type_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_type by passing an invalid parameter. + * @scenario Pass NULL as a service_type parameter for getting the type of a DNSSD service. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_get_type_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_get_type(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_get_type(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +int utc_nsd_dnssd_get_type_n3(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *type = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_type(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_deinitialize(); + + ret = dnssd_service_get_type(serv_id, &type); + assert_eq(ret, DNSSD_ERROR_NOT_INITIALIZED); + + dnssd_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_name_p + * @since_tizen 3.0 + * @type Positive + * @description Get the service name of a DNSSD service. + * @scenario Create a DNSSD local service and get the service name of a DNSSD service. + * Ensure no error + */ +int utc_nsd_dnssd_get_name_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *name = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_name(serv_id, "test-ftp"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_get_name(serv_id, &name); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + g_free(name); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_name_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_name by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_get_name_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + char *name = NULL; + + if (g_feature == false) { + ret = dnssd_service_get_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_get_name(serv_id + 1, &name); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_name_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_name by passing an invalid parameter + * @scenario Pass NULL as a target parameter for getting the service name of a DNSSD service. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_get_name_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_get_name(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_get_name(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_port_p + * @since_tizen 3.0 + * @type Positive + * @description Get the port number of a DNSSD service. + * @scenario Create a DNSSD local service and get the port number of a DNSSD service. + * Ensure no error + */ +int utc_nsd_dnssd_get_port_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + int port = 0; + + if (g_feature == false) { + ret = dnssd_service_get_port(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_get_port(serv_id, &port); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_get_port_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_port by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_get_port_n1(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + int port = 0; + + if (g_feature == false) { + ret = dnssd_service_get_port(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_service_get_port(serv_id + 1, &port); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + + +/** + * @testcase utc_nsd_dnssd_get_port_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_service_get_port by passing an invalid parameter + * @scenario Pass NULL as a target parameter for getting the port number of a DNSSD service. + * Return value should be DNSSD_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_dnssd_get_port_n2(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_service_get_port(0, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + ret = dnssd_service_get_port(serv_id, NULL); + assert_eq(ret, DNSSD_ERROR_INVALID_PARAMETER); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_register_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Register a DNSSD local service handle. + * @scenario Create a DNSSD service and set a service name and a port number for the service. + * Register, Deregister and Destroy the DNSSD service. + * Ensure no error + */ +int utc_nsd_dnssd_register_local_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_register_local_service(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_deregister_local_service(serv_id); + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_register_local_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_register_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_register_local_service_n(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_register_local_service(0, NULL, NULL); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + + ret = dnssd_register_local_service(serv_id + 1, &__registered_cb, NULL); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_deregister_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Deregister a DNSSD local service handle. + * @scenario Create a DNSSD service and Register + * Deregister and Destroy the DNSSD service. + * Ensure no error + */ +int utc_nsd_dnssd_deregister_local_service_p(void) +{ + int ret = DNSSD_ERROR_NONE; + static dnssd_service_h serv_id; + + if (g_feature == false) { + ret = dnssd_deregister_local_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + dnssd_create_local_service("_ftp._tcp", &serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_name(serv_id, "Tizen"); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_service_set_port(serv_id, 12345); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = wait_for_registered_callback(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + ret = dnssd_deregister_local_service(serv_id); + assert_eq(ret, DNSSD_ERROR_NONE); + + dnssd_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_dnssd_deregister_local_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify dnssd_deregister_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be DNSSD_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_dnssd_deregister_local_service_n(void) +{ + int ret = DNSSD_ERROR_NONE; + + if (g_feature == false) { + ret = dnssd_deregister_local_service(0); + assert_eq(ret, DNSSD_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = dnssd_deregister_local_service(0); + assert_eq(ret, DNSSD_ERROR_SERVICE_NOT_FOUND); + + return 0; +} diff --git a/unittest/utc-nsd-ssdp-browse.c b/unittest/utc-nsd-ssdp-browse.c new file mode 100644 index 0000000..0cc47be --- /dev/null +++ b/unittest/utc-nsd-ssdp-browse.c @@ -0,0 +1,215 @@ +// +// Copyright (c) 2014 Samsung Electronics Co., Ltd. +// +// 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 "assert_local.h" +#include +#include +#include +#include + +//& set: Nsd-ssdp-browse + +static GMainLoop* g_loop = NULL; +static bool g_feature = true; + +static void __found_cb(ssdp_service_state_e state, ssdp_service_h ssdp_service, void *user_data) +{ + return; +} + +/** + * @function utc_nsd_ssdp_browse_startup + * @since_tizen 3.0 + * @description Initializes SSDP. Called before each test + * @parameter NA + * @return NA + */ +void utc_nsd_ssdp_browse_startup(void) +{ + int ret = SSDP_ERROR_NONE; + ret = system_info_get_platform_bool("http://tizen.org/feature/network.service_discovery.ssdp", &g_feature); + + if (SYSTEM_INFO_ERROR_NONE != ret) { + fprintf(stderr, "system_info_get_platform_bool() Fail(%d)\n", ret); + return; + } + + if (g_feature == true) { + ret = ssdp_initialize(); + if (ret != SSDP_ERROR_NONE) { + fprintf(stderr, "dnssd_initialize() Fail(%d)", ret); + return; + } + g_loop = g_main_loop_new(NULL, FALSE); + } +} + +/** + * @function utc_nsd_ssdp_browse_cleanup + * @since_tizen 3.0 + * @description Deinitialize SSDP. Called after each test + * @parameter NA + * @return NA + */ +void utc_nsd_ssdp_browse_cleanup(void) +{ + if (g_feature == true) { + ssdp_deinitialize(); + g_main_loop_unref(g_loop); + g_loop = NULL; + } +} + +/** + * @testcase utc_nsd_ssdp_start_browsing_service_p + * @since_tizen 3.0 + * @type Positive + * @description Start browsing SSDP services + * @scenario Start browsing SSDP services with a service target + * Ensure no error + */ +int utc_nsd_ssdp_start_browsing_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + ssdp_browser_h browser_id = 0; + + if (g_feature == false) { + ret = ssdp_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_start_browsing_service("upnp:rootdevice", &browser_id, &__found_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_stop_browsing_service(browser_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_start_browsing_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_start_browsing_service by passing invalid browser handle + * @scenario Pass NULL as a browser handle + * Return value should be SSDP_ERROR_INVALID_PARAMETER + */ +int utc_nsd_ssdp_start_browsing_service_n(void) +{ + int ret = SSDP_ERROR_NONE; + + if (g_feature == false) { + ret = ssdp_start_browsing_service(NULL, NULL, NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_start_browsing_service("upnp:rootdevice", NULL, &__found_cb, NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_stop_browsing_service_p + * @since_tizen 3.0 + * @type Positive + * @description Stop browsing SSDP services + * @scenario Start browsing SSDP services with a service target + * Stop browsing with valid browser handle + * Ensure no error + */ +int utc_nsd_ssdp_stop_browsing_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + ssdp_browser_h browser_id = 0; + + if (g_feature == false) { + ret = ssdp_stop_browsing_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_start_browsing_service("upnp:rootdevice", &browser_id, &__found_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_stop_browsing_service(browser_id); + assert_eq(ret, SSDP_ERROR_NONE); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_stop_browsing_service_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_stop_browsing_service by passing invalid browser handle + * @scenario Start browsing SSDP services with a service target + * Stop browsing by passing an invalid browser handle + * Return value should be SSDP_ERROR_INVALID_PARAMETER + */ +int utc_nsd_ssdp_stop_browsing_service_n1(void) +{ + int ret = SSDP_ERROR_NONE; + ssdp_browser_h browser_id = 0; + + if (g_feature == false) { + ret = ssdp_stop_browsing_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_start_browsing_service("upnp:rootdevice", &browser_id, &__found_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_stop_browsing_service(0); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_stop_browsing_service(browser_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_stop_browsing_service_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_stop_browsing_service by passing invalid browser handle + * @scenario Start browsing SSDP services with a service target + * Stop browsing by passing an invalid browser handle which has not been created before + * Return value should be SSDP_SERVICE_NOT_FOUND + */ +int utc_nsd_ssdp_stop_browsing_service_n2(void) +{ + int ret = SSDP_ERROR_NONE; + ssdp_browser_h browser_id = 0; + + if (g_feature == false) { + ret = ssdp_stop_browsing_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_start_browsing_service("upnp:rootdevice", &browser_id, &__found_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_stop_browsing_service(browser_id + 1); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_stop_browsing_service(browser_id); + + return 0; +} diff --git a/unittest/utc-nsd-ssdp-register.c b/unittest/utc-nsd-ssdp-register.c new file mode 100644 index 0000000..fbd1f01 --- /dev/null +++ b/unittest/utc-nsd-ssdp-register.c @@ -0,0 +1,923 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// 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 "assert_local.h" +#include +#include +#include +#include +#include + +//& set: Nsd-ssdp-register + +static GMainLoop* g_loop = NULL; +static bool g_feature = true; + +static void __registered_cb(ssdp_error_e result, ssdp_service_h ssdp_service, void *user_data) +{ + return; +} + + +/** + * @function utc_nsd_ssdp_register_startup + * @since_tizen 3.0 + * @description Initializes SSDP. Called before each test + * @parameter NA + * @return NA + */ +void utc_nsd_ssdp_register_startup(void) +{ + int ret = SSDP_ERROR_NONE; + ret = system_info_get_platform_bool("http://tizen.org/feature/network.service_discovery.ssdp", &g_feature); + + if (SYSTEM_INFO_ERROR_NONE != ret) { + fprintf(stderr, "system_info_get_platform_bool() Fail(%d)\n", ret); + return; + } + + if (g_feature == true) { + ret = ssdp_initialize(); + if (ret != SSDP_ERROR_NONE) { + fprintf(stderr, "dnssd_initialize() Fail(%d)", ret); + return; + } + g_loop = g_main_loop_new(NULL, FALSE); + } +} + +/** + * @function utc_nsd_ssdp_register_cleanup + * @since_tizen 3.0 + * @description Deinitialize SSDP. Called after each test + * @parameter NA + * @return NA + */ +void utc_nsd_ssdp_register_cleanup(void) +{ + if (g_feature == true) { + ssdp_deinitialize(); + g_main_loop_unref(g_loop); + g_loop = NULL; + } +} + +/** + * @testcase utc_nsd_ssdp_initialize_p + * @since_tizen 3.0 + * @type Positive + * @description Initialize SSDP. + * @scenario Initialize SSDP. + * Ensure no error + */ +int utc_nsd_ssdp_initialize_p(void) +{ + int ret = SSDP_ERROR_NONE; + + if (g_feature == false) { + ret = ssdp_initialize(); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + ssdp_deinitialize(); + + ret = ssdp_initialize(); + assert_eq(ret, SSDP_ERROR_NONE); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_deinitialize_p + * @since_tizen 3.0 + * @type Positive + * @description Deinitialize SSDP. + * @scenario Deinitialize SSDP. + * Ensure no error + */ +int utc_nsd_ssdp_deinitialize_p(void) +{ + int ret = SSDP_ERROR_NONE; + + if (g_feature == false) { + ret = ssdp_deinitialize(); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + ret = ssdp_deinitialize(); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_deinitialize_n + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_deinitialize before SSDP is initialized. + * @scenario Deinitialize SSDP and deinitialize again. + * Return value should be SSDP_ERROR_NOT_INITIALIZED. + */ +int utc_nsd_ssdp_deinitialize_n(void) +{ + int ret = SSDP_ERROR_NONE; + + if (g_feature == false) { + ret = ssdp_deinitialize(); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + ssdp_deinitialize(); + + ret = ssdp_deinitialize(); + assert_eq(ret, SSDP_ERROR_NOT_INITIALIZED); + + ssdp_initialize(); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_create_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Create a SSDP local service handle. + * @scenario Create and Destroy a SSDP local service handle. + * Ensure no error + */ +int utc_nsd_ssdp_create_local_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_create_local_service(NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_create_local_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_create_local_service by passing an invalid parameter. + * @scenario Pass NULL as a service handle parameter. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_create_local_service_n(void) +{ + int ret = SSDP_ERROR_NONE; + + if (g_feature == false) { + ret = ssdp_create_local_service(NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_destroy_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Destroy a SSDP local service handle. + * @scenario Create and Destroy a SSDP local service handle. + * Ensure no error + */ +int utc_nsd_ssdp_destroy_local_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_destroy_local_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_destroy_local_service(serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_destroy_local_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_destroy_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_detroy_local_service_n(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_destroy_local_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_destroy_local_service(serv_id + 1); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(serv_id); + + return 0; + +} + +/** + * @testcase utc_nsd_ssdp_set_usn_p + * @since_tizen 3.0 + * @type Positive + * @description Set the USN of a SSDP local service. + * @scenario Create a SSDP local service and set the USN of the service. + * Ensure no error + */ +int utc_nsd_ssdp_set_usn_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_set_usn_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_set_usn by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_set_usn_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + static ssdp_service_h other_serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_usn(serv_id + 1, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(other_serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_set_usn_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_set_usn by passing a duplicate USN. + * @scenario Create a SSDP service and set a USN. + * Create another SSDP service and set the same USN as that of the first SSDP service. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_set_usn_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + static ssdp_service_h other_serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + ssdp_service_set_usn(serv_id, "uuid:1234abce"); + + ssdp_create_local_service("upnp:rootdevice", &other_serv_id); + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_destroy_local_service(other_serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_set_url_p + * @since_tizen 3.0 + * @type Positive + * @description Set the URL of a SSDP local service. + * @scenario Create a SSDP local service and set the URL of the service. + * Ensure no error + */ +int utc_nsd_ssdp_set_url_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_set_url_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_set_url by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_set_url_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + static ssdp_service_h other_serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_url(serv_id + 1, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(other_serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_set_url_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_set_usn by passing a duplicate URL. + * @scenario Create a SSDP service and set a URL. + * Create another SSDP service and set the same URL as that of the first SSDP service. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_set_url_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + static ssdp_service_h other_serv_id; + + if (g_feature == false) { + ret = ssdp_service_set_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + ssdp_service_set_url(serv_id, "192.168.0.1"); + + ssdp_create_local_service("upnp:rootdevice", &other_serv_id); + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_destroy_local_service(other_serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_target_p + * @since_tizen 3.0 + * @type Positive + * @description Get the target of a SSDP service. + * @scenario Create a SSDP local service and get the target of a SSDP service. + * Ensure no error + */ +int utc_nsd_ssdp_get_target_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *target = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_target(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_target(serv_id, &target); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + g_free(target); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_target_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_target by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_get_target_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *target = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_target(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_target(serv_id + 1, &target); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_target_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_target by passing an invalid parameter. + * @scenario Pass NULL as a target parameter for getting the target of a SSDP service. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_get_target_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_service_get_target(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_target(serv_id, NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_usn_p + * @since_tizen 3.0 + * @type Positive + * @description Get the USN of a SSDP service. + * @scenario Create a SSDP local service and get the USN of a SSDP service. + * Ensure no error + */ +int utc_nsd_ssdp_get_usn_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *usn = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_get_usn(serv_id, &usn); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + g_free(usn); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_usn_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_usn by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_get_usn_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *usn = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_usn(serv_id + 1, &usn); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_usn_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_usn by passing an invalid parameter + * @scenario Pass NULL as a target parameter for getting the USN of a SSDP service. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_get_usn_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_service_get_usn(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_usn(serv_id, NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_url_p + * @since_tizen 3.0 + * @type Positive + * @description Get the URL of a SSDP service. + * @scenario Create a SSDP local service and get the URL of a SSDP service. + * Ensure no error + */ +int utc_nsd_ssdp_get_url_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *url = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_get_url(serv_id, &url); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + g_free(url); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_url_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_url by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_get_url_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + char *url = NULL; + + if (g_feature == false) { + ret = ssdp_service_get_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_url(serv_id + 1, &url); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_get_url_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_service_get_url by passing an invalid parameter + * @scenario Pass NULL as a target parameter for getting the URL of a SSDP service. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_get_url_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_service_get_url(0, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + + ret = ssdp_service_get_url(serv_id, NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_register_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Register a SSDP local service handle. + * @scenario Create a SSDP service and set a USN and a URL for the service. + * Register, Deregister and Destroy the SSDP service. + * Ensure no error + */ +int utc_nsd_ssdp_register_local_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_register_local_service(0, NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_deregister_local_service(serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_register_local_service_n1 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_register_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_register_local_service_n1(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_register_local_service(0, NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id + 1, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_register_local_service_n2 + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_register_local_service by registering the duplcate service + * @scenario Create and Register a SSDP service. + * Register the service already registered again. + * Return value should be SSDP_ERROR_INVALID_PARAMETER. + */ +int utc_nsd_ssdp_register_local_service_n2(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_register_local_service(0, NULL, NULL); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_INVALID_PARAMETER); + + ssdp_deregister_local_service(serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_deregister_local_service_p + * @since_tizen 3.0 + * @type Positive + * @description Deregister a SSDP local service handle. + * @scenario Create a SSDP service and Register + * Deregister and Destroy the SSDP service. + * Ensure no error + */ +int utc_nsd_ssdp_deregister_local_service_p(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_deregister_local_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_deregister_local_service(serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ssdp_destroy_local_service(serv_id); + + return 0; +} + +/** + * @testcase utc_nsd_ssdp_deregister_local_service_n + * @since_tizen 3.0 + * @type Negative + * @description Verify ssdp_deregister_local_service by passing invalid service handle. + * @scenario Pass an invalid service handle which has not been created before. + * Return value should be SSDP_ERROR_SERVICE_NOT_FOUND. + */ +int utc_nsd_ssdp_deregister_local_service_n(void) +{ + int ret = SSDP_ERROR_NONE; + static ssdp_service_h serv_id; + + if (g_feature == false) { + ret = ssdp_deregister_local_service(0); + assert_eq(ret, SSDP_ERROR_NOT_SUPPORTED); + return 0; + } + + ret = ssdp_create_local_service("upnp:rootdevice", &serv_id); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_usn(serv_id, "uuid:1234abce"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_service_set_url(serv_id, "192.168.0.1"); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_register_local_service(serv_id, &__registered_cb, NULL); + assert_eq(ret, SSDP_ERROR_NONE); + + ret = ssdp_deregister_local_service(serv_id + 1); + assert_eq(ret, SSDP_ERROR_SERVICE_NOT_FOUND); + + ssdp_deregister_local_service(serv_id); + ssdp_destroy_local_service(serv_id); + + return 0; +} +