INCLUDE_DIRECTORIES(${DPL_3RDPARTY_INCLUDE_DIR})
# Add system include files
-INCLUDE_DIRECTORIES(${SYS_3RDPARTY_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_3RDPARTY_INCLUDE_DIRS})
LINK_DIRECTORIES(${SYS_3RDPARTY_LIBRARY_DIRS})
# Build shared library
+#include <stddef.h>\r
#include <stdio.h>\r
#include "FastDelegate.h"\r
// Demonstrate the syntax for FastDelegates.\r
# @brief
#
-#
# Check minimum CMake version
-#
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-#
# Project name
-#
PROJECT(dpl)
-#
-# Logs
-#
+STRING(REGEX MATCH "([^.]*)" API_VERSION "${VERSION}")
+ADD_DEFINITIONS("-DAPI_VERSION=\"$(API_VERSION)\"")
+# Comment this to disable control of global settings with environment variable
+ADD_DEFINITIONS("-DGLOBAL_SETTINGS_CONTROL")
-OPTION(DPL_LOG "DPL logs status" OFF)
+# Build type
+IF(NOT CMAKE_BUILD_TYPE)
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF(NOT CMAKE_BUILD_TYPE)
-IF(DPL_LOG)
+# Options
+OPTION(DPL_LOG "DPL logs status" OFF)
+IF(DPL_LOG AND NOT CMAKE_BUILD_TYPE MATCHES "profiling")
MESSAGE(STATUS "Logging enabled for DPL")
ADD_DEFINITIONS("-DDPL_LOGS_ENABLED")
-ELSE(DPL_LOG)
+ELSE(DPL_LOG AND NOT CMAKE_BUILD_TYPE MATCHES "profiling")
MESSAGE(STATUS "Logging disabled for DPL")
-ENDIF(DPL_LOG)
-ADD_DEFINITIONS("-DSEPARATED_SINGLETON_IMPLEMENTATION")
+ENDIF(DPL_LOG AND NOT CMAKE_BUILD_TYPE MATCHES "profiling")
-# Gtk
-OPTION(DISABLE_GTK "Disable GTK stuff" ON)
-
-#
-# Build type
-#
+OPTION(WITH_TESTS "Build tests" OFF)
-SET(CMAKE_BUILD_TYPE "Release")
+# Compiler flags
+SET(CMAKE_C_FLAGS_PROFILING "-O2")
+SET(CMAKE_CXX_FLAGS_PROFILING "-O2 -std=c++0x")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -std=c++0x -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2 -g")
+SET(CMAKE_CXX_FLAGS_RELEASE "-O2 -std=c++0x -g")
+SET(CMAKE_CXX_FLAGS_CCOV "-O0 -std=c++0x -g --coverage")
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
-SET(CMAKE_CXX_FLAGS "-O2 -g -fPIC -D_FORTIFY_SOURCE=0")
+ADD_DEFINITIONS("-fPIC") # If supported for the target machine, emit position-independent code, suitable for dynamic linking and avoiding any limit on the size of the global offset table. This option makes a difference on the m68k, PowerPC and SPARC. (BJ: our ARM too?)
-#
# CMake settings
-#
MESSAGE(STATUS "========================================")
MESSAGE(STATUS "CMAKE_BINARY_DIR: " ${CMAKE_BINARY_DIR})
MESSAGE(STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR})
MESSAGE(STATUS "CMAKE_COMPILER_IS_GNUCXX : " ${CMAKE_COMPILER_IS_GNUCXX})
MESSAGE(STATUS "CMAKE_AR: " ${CMAKE_AR})
MESSAGE(STATUS "CMAKE_RANLIB: " ${CMAKE_RANLIB})
+MESSAGE(STATUS "WITH_TESTS: " ${WITH_TESTS})
MESSAGE(STATUS "========================================")
-#
# Build 3rd party libraries first
-#
ADD_SUBDIRECTORY(3rdparty)
-#
# Compiler flags
-#
-
ADD_DEFINITIONS("-fvisibility=default") # mark all exported symbols as visible
# Warnings mode
SET(TARGET_DPL_RPC_EFL "lib${PROJECT_NAME}-rpc-efl")
SET(TARGET_DPL_TEST_ENGINE_EFL "lib${PROJECT_NAME}-test-efl")
SET(TARGET_DPL_LOG_EFL "lib${PROJECT_NAME}-log-efl")
-SET(TARGET_DPL_POPUP "lib${PROJECT_NAME}-popup-efl")
SET(TARGET_WRT_DAO_RW_LIB "dpl-wrt-dao-rw")
SET(TARGET_WRT_DAO_RO_LIB "dpl-wrt-dao-ro")
+SET(TARGET_AUTO_SAVE_DAO_LIB "wrt-commons-auto-save-dao")
+SET(TARGET_AUTO_SAVE_DAO_RW_LIB "wrt-commons-auto-save-dao-rw")
+SET(TARGET_AUTO_SAVE_DAO_RO_LIB "wrt-commons-auto-save-dao-ro")
+SET(TARGET_CUSTOM_HANDLER_DAO_RW_LIB "wrt-commons-custom-handler-dao-rw")
+SET(TARGET_CUSTOM_HANDLER_DAO_RO_LIB "wrt-commons-custom-handler-dao-ro")
+SET(TARGET_SECURITY_ORIGIN_DAO_LIB "wrt-commons-security-origin-dao")
SET(TARGET_DPL_UTILS_EFL "lib${PROJECT_NAME}-utils-efl")
-SET(TARGET_ACE_DAO_RO_LIB "dpl-ace-dao-ro")
-SET(TARGET_ACE_DAO_RW_LIB "dpl-ace-dao-rw")
-SET(TARGET_ACE_LIB "dpl-ace")
-SET(TARGET_VCORE_LIB "dpl-vcore")
+SET(TARGET_DPL_ENCRYPTION "lib${PROJECT_NAME}-encryption")
+
+macro(configure_and_install_pkg PKG_FILE)
+ CONFIGURE_FILE(${PKG_FILE}.in ${PKG_FILE} @ONLY)
+ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PKG_FILE} DESTINATION lib/pkgconfig)
+endmacro(configure_and_install_pkg)
ADD_SUBDIRECTORY(modules)
ADD_SUBDIRECTORY(build)
-ADD_SUBDIRECTORY(tests)
ADD_SUBDIRECTORY(etc)
+IF(WITH_TESTS)
+ ADD_SUBDIRECTORY(tests)
+ENDIF(WITH_TESTS)
ADD_SUBDIRECTORY(rpc)
ADD_SUBDIRECTORY(test)
#ADD_SUBDIRECTORY(log)
-ADD_SUBDIRECTORY(vcore)
-ADD_SUBDIRECTORY(ace)
ADD_SUBDIRECTORY(widget_dao)
-ADD_SUBDIRECTORY(popup)
+ADD_SUBDIRECTORY(auto_save_dao)
+ADD_SUBDIRECTORY(security_origin_dao)
+ADD_SUBDIRECTORY(custom_handler_dao)
ADD_SUBDIRECTORY(utils)
+ADD_SUBDIRECTORY(support)
+ADD_SUBDIRECTORY(encryption)
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Jihoon Chung (jihoon.chung@samsung.com)
+# @brief
+#
+
+configure_and_install_pkg(wrt-commons-auto-save-dao.pc)
+configure_and_install_pkg(wrt-commons-auto-save-dao-ro.pc)
+configure_and_install_pkg(wrt-commons-auto-save-dao-rw.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-auto-save-dao-ro
+Description: wrt-commons-auto-save-dao-ro
+
+Version: @VERSION@
+Requires: dpl-efl wrt-commons-auto-save-dao libxml-2.0
+Libs: -lwrt-commons-auto-save-dao-ro -lwrt-commons-auto-save-dao -L${libdir}
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-auto-save-dao-rw
+Description: wrt-commons-auto-save-dao-rw
+
+Version: @VERSION@
+Requires: dpl-efl wrt-commons-auto-save-dao wrt-commons-auto-save-dao-ro libxml-2.0
+Libs: -lwrt-commons-auto-save-dao-rw -lwrt-commons-auto-save-dao-ro -lwrt-commons-auto-save-dao -L${libdir}
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-auto-save-dao
+Description: wrt-commons-auto-save-dao
+
+Version: @VERSION@
+Requires: dpl-efl libxml-2.0
+Libs: -lwrt-commons-auto-save-dao -L${libdir}
+Cflags: -I${includedir}/dpl-efl
${DPL_LOG_INCLUDE_DIR}
${DPL_CORE_INCLUDE_DIR}
${DPL_3RDPARTY_INCLUDE_DIR}
- ${SYS_EFL_INCLUDE_DIRS}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_INCLUDE_DIRS})
+
LINK_DIRECTORIES(${SYS_EFL_LIBRARY_DIRS})
# Base EFL based DPL library
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_CORE_EFL_DETAIL_HEADERS}
DESTINATION include/dpl-efl/dpl/3rdparty/fastdelegate)
# Install pkgconfig script
-INSTALL(FILES dpl-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-efl
+Description: DPL - EFL based
+Version: @VERSION@
+Requires: ecore appcore-efl openssl dlog vconf
+Libs: -L${libdir} -ldpl-efl
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+# Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @brief
+#
+
+configure_and_install_pkg(wrt-commons-custom-handler-dao-ro.pc)
+configure_and_install_pkg(wrt-commons-custom-handler-dao-rw.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-custom-handler-dao-ro
+Description: wrt-commons-custom-handler-dao-ro
+
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -lwrt-commons-custom-handler-dao-ro -L${libdir}
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-custom-handler-dao-rw
+Description: wrt-commons-custom-handler-dao-rw
+
+Version: @VERSION@
+Requires: dpl-efl wrt-commons-custom-handler-dao-ro
+Libs: -lwrt-commons-custom-handler-dao-rw -lwrt-commons-custom-handler-dao-ro -L${libdir}
+Cflags: -I${includedir}/dpl-efl
${DPL_LOG_INCLUDE_DIR}
${DPL_CORE_INCLUDE_DIR}
${DPL_DB_INCLUDE_DIR}
- ${SYS_EFL_INCLUDE_DIRS})
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_DB_INCLUDE_DIRS})
LINK_DIRECTORIES(
${SYS_EFL_DB_LIBRARY_DIRS}
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_DB_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_DB_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_DB_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_DB_HEADERS}
DESTINATION include/dpl-efl/dpl/db)
# Install pkgconfig script
-INSTALL(FILES dpl-db-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-db-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-db-efl
+Description: DPL DB - EFL based
+Version: @VERSION@
+Requires: dpl-efl sqlite3 db-util
+Libs: -L${libdir} -ldpl-db-efl
+Cflags: -I${includedir}/dpl-efl
INCLUDE(FindPkgConfig)
PKG_CHECK_MODULES(SYS_EFL_DBUS
dbus-1
+ gio-2.0
REQUIRED)
# Add core include directories
${DPL_CORE_INCLUDE_DIR}
${DPL_DBUS_INCLUDE_DIR}
${DPL_EVENT_INCLUDE_DIR}
- ${SYS_EFL_INCLUDE_DIRS})
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_DBUS_INCLUDE_DIRS})
LINK_DIRECTORIES(
${SYS_EFL_DBUS_LIBRARY_DIRS}
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_DBUS_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_DBUS_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_DBUS_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_DBUS_HEADERS}
DESTINATION include/dpl-efl/dpl/dbus)
# Install pkgconfig script
-INSTALL(FILES dpl-dbus-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-dbus-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-dbus-efl
+Description: DPL DBus - EFL based
+Version: @VERSION@
+Requires: dbus-1 dpl-efl dpl-event-efl
+Libs: -L${libdir} -ldpl-dbus-efl
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Soyoung Kim (sy037.kim@samsung.com)
+# @version 1.0
+# @brief
+#
+
+# Check required modules
+INCLUDE(FindPkgConfig)
+PKG_CHECK_MODULES(SYS_ENCRYPTION
+ dlog
+ openssl
+ REQUIRED
+)
+
+# Add core include directories
+INCLUDE_DIRECTORIES(
+ ${DPL_LOG_INCLUDE_DIR}
+ ${DPL_CORE_INCLUDE_DIR}
+ ${DPL_DB_INCLUDE_DIR}
+ ${DPL_ENCRYPTION_INCLUDE_DIR}
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_ENCRYPTION_INCLUDE_DIRS})
+
+LINK_DIRECTORIES(
+ ${SYS_ENCRYPTION_LIBRARY_DIRS}
+)
+
+# Base EFL based DPL library
+SET(DPL_ENCRYPTION_LIBRARY "${PROJECT_NAME}-encryption")
+
+# Build shared library
+
+ADD_LIBRARY(${TARGET_DPL_ENCRYPTION} SHARED
+ ${DPL_ENCRYPTION_SOURCES}
+)
+
+TARGET_LINK_LIBRARIES(${TARGET_DPL_ENCRYPTION}
+ ${SYS_ENCRYPTION_LIBRARIES}
+ ${TARGET_DPL_EFL}
+)
+
+TARGET_LINK_LIBRARIES(${TARGET_DPL_ENCRYPTION} -L./libs -lcal)
+
+# Target library properties
+SET_TARGET_PROPERTIES(${TARGET_DPL_ENCRYPTION} PROPERTIES
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
+ CLEAN_DIRECT_OUTPUT 1
+ OUTPUT_NAME ${DPL_ENCRYPTION_LIBRARY})
+
+# Install libraries
+INSTALL(TARGETS ${TARGET_DPL_ENCRYPTION}
+ DESTINATION lib)
+
+# Install detail headers
+
+INSTALL(FILES ${DPL_ENCRYPTION_HEADERS}
+ DESTINATION include/dpl-efl/dpl/encryption)
+
+# Install pkgconfig script
+configure_and_install_pkg(dpl-encryption.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-encryption
+Description: DPL UTILS - EFL based
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -L${libdir} -ldpl-encryption
+Cflags: -I${includedir}/dpl-efl
ecore
appcore-efl
vconf
- heynoti
REQUIRED
)
${DPL_LOG_INCLUDE_DIR}
${DPL_CORE_INCLUDE_DIR}
${DPL_EVENT_INCLUDE_DIR}
- ${SYS_EFL_EVENT_INCLUDE_DIRS})
+ ${DPL_EVENT_INCLUDE_DIR}
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_EVENT_INCLUDE_DIRS})
LINK_DIRECTORIES(
${SYS_EFL_EVENT_LIBRARY_DIRS}
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_EVENT_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_EVENT_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_EVENT_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_EVENT_HEADERS}
DESTINATION include/dpl-efl/dpl/event)
# Install pkgconfig script
-INSTALL(FILES dpl-event-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-event-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-event-efl
+Description: DPL Event - EFL based
+Version: @VERSION@
+Requires: dpl-efl ecore appcore-efl vconf
+Libs: -L${libdir} -ldpl-event-efl
+Cflags: -I${includedir}/dpl-efl
# Add core include directories
INCLUDE_DIRECTORIES(
${DPL_LOG_INCLUDE_DIR}
- ${SYS_EFL_LOG_INCLUDE_DIRS}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_LOG_INCLUDE_DIRS})
+
LINK_DIRECTORIES(
${SYS_EFL_LOG_LIBRARY_DIRS}
)
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_LOG_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_LOG_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_LOG_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
INSTALL(FILES ${DPL_LOG_HEADERS}
DESTINATION include/dpl-efl/dpl/log)
# Install pkgconfig script
-INSTALL(FILES dpl-log-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-log-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-log-efl
+Description: DPL Log Engine - EFL based
+Version: @VERSION@
+Requires: dpl-efl dlog
+Libs: -L${libdir} -ldpl-log-efl
+Cflags: -I${includedir}/dpl-efl
+
# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
${DPL_SOCKET_INCLUDE_DIR}
${DPL_EVENT_INCLUDE_DIR}
${DPL_RPC_INCLUDE_DIR}
- ${SYS_EFL_RPC_INCLUDE_DIRS}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_RPC_INCLUDE_DIRS})
+
LINK_DIRECTORIES(
${SYS_EFL_RPC_LIBRARY_DIRS}
)
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_RPC_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_RPC_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_RPC_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_RPC_HEADERS}
DESTINATION include/dpl-efl/dpl/rpc)
# Install pkgconfig script
-INSTALL(FILES dpl-rpc-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-rpc-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-rpc-efl
+Description: DPL RPC - EFL based
+Version: @VERSION@
+Requires: dpl-efl dpl-event-efl dpl-socket-efl
+Libs: -L${libdir} -ldpl-rpc-efl
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Jihoon Chung (jihoon.chung@samsung.com)
+# @brief
+#
+
+configure_and_install_pkg(wrt-commons-security-origin-dao.pc)
+
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-security-origin-dao
+Description: wrt-commons-security-origin-dao
+
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -lwrt-commons-security-origin-dao -L${libdir}
+Cflags: -I${includedir}/dpl-efl
${DPL_CORE_INCLUDE_DIR}
${DPL_SOCKET_INCLUDE_DIR}
${DPL_EVENT_INCLUDE_DIR}
- ${SYS_EFL_SOCKET_INCLUDE_DIRS}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_SOCKET_INCLUDE_DIRS})
+
LINK_DIRECTORIES(
${SYS_EFL_SOCKET_LIBRARY_DIRS}
)
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_SOCKET_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_SOCKET_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_SOCKET_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_SOCKET_HEADERS}
DESTINATION include/dpl-efl/dpl/socket)
# Install pkgconfig script
-INSTALL(FILES dpl-socket-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-socket-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-socket-efl
+Description: DPL Socket - EFL based
+Version: @VERSION@
+Requires: dpl-efl dpl-event-efl
+Libs: -L${libdir} -ldpl-socket-efl
+Cflags: -I${includedir}/dpl-efl
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Lukasz Marek (l.marek@samsung.com)
+# @version 1.0
+# @brief
+#
+
+# Install headers
+INSTALL(FILES ${DPL_WRT_ENGINE_HEADERS}
+ DESTINATION include/dpl-efl/wrt-commons)
+
+# Install pkgconfig script
+configure_and_install_pkg(wrt-plugins-types.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: wrt-plugins-types
+Description: Header for plugins types
+Version: @VERSION@
+Requires:
+Libs:
+Cflags: -I${includedir}/dpl-efl/wrt-commons
${DPL_LOG_INCLUDE_DIR}
${DPL_CORE_INCLUDE_DIR}
${DPL_TEST_ENGINE_INCLUDE_DIR}
- ${SYS_EFL_TEST_ENGINE_INCLUDE_DIRS}
+ ${DPL_UTILS_INCLUDE_DIR}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_TEST_ENGINE_INCLUDE_DIRS})
+
LINK_DIRECTORIES(
${SYS_EFL_TEST_ENGINE_LIBRARY_DIRS}
)
TARGET_LINK_LIBRARIES(${TARGET_DPL_TEST_ENGINE_EFL}
${TARGET_DPL_EFL}
+ ${TARGET_DPL_UTILS_EFL}
)
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_TEST_ENGINE_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_TEST_ENGINE_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_TEST_ENGINE_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_TEST_ENGINE_HEADERS}
DESTINATION include/dpl-efl/dpl/test)
# Install pkgconfig script
-INSTALL(FILES dpl-test-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-test-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-test-efl
+Description: DPL Test Engine - EFL based
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -L${libdir} -ldpl-test-efl
+Cflags: -I${includedir}/dpl-efl
${DPL_LOG_INCLUDE_DIR}
${DPL_CORE_INCLUDE_DIR}
${DPL_DB_INCLUDE_DIR}
- ${SYS_EFL_UTILS_INCLUDE_DIRS}
${DPL_UTILS_INCLUDE_DIR}
${DPL_LOCALIZATION_INCLUDE_DIR}
)
+INCLUDE_DIRECTORIES(SYSTEM ${SYS_EFL_UTILS_INCLUDE_DIRS})
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/modules/widget_dao/include)
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/modules/vcore/src/vcore)
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_UTILS_EFL} PROPERTIES
- SOVERSION ${VERSION}
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${DPL_EFL_UTILS_LIBRARY})
# Install libraries
INSTALL(TARGETS ${TARGET_DPL_UTILS_EFL}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+ DESTINATION lib)
# Install detail headers
INSTALL(FILES ${DPL_UTILS_HEADERS}
DESTINATION include/dpl-efl/dpl/localization)
# Install pkgconfig script
-INSTALL(FILES dpl-utils-efl.pc
- DESTINATION lib/pkgconfig)
+configure_and_install_pkg(dpl-utils-efl.pc)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: dpl-utils-efl
+Description: DPL UTILS - EFL based
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -L${libdir} -ldpl-utils-efl
+Cflags: -I${includedir}/dpl-efl
# @brief
#
-CONFIGURE_FILE(dpl-wrt-dao-ro.pc.in dpl-wrt-dao-ro.pc @ONLY)
-CONFIGURE_FILE(dpl-wrt-dao-rw.pc.in dpl-wrt-dao-rw.pc @ONLY)
-INSTALL(FILES
- ${CMAKE_BINARY_DIR}/build/widget_dao/dpl-wrt-dao-ro.pc
- ${CMAKE_BINARY_DIR}/build/widget_dao/dpl-wrt-dao-rw.pc
- DESTINATION
- lib/pkgconfig)
+configure_and_install_pkg(dpl-wrt-dao-ro.pc)
+configure_and_install_pkg(dpl-wrt-dao-rw.pc)
+wrt-commons (0.2.93) unstable; urgency=low
+
+ * Change DPL::WaitableHandleWatchSupport's destructor not to call DPL:Aassert explicitly.
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Sat, 02 Feb 2013 17:25:09 +0900
+
+wrt-commons (0.2.92) unstable; urgency=low
+
+ * Removal of popup implementation
+ * Clean up unnecessary cmake log
+ * Improve XML test results collector
+ * Add method for reset crossEventCallHandler
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 16 Jan 2013 10:49:45 +0900
+
+wrt-commons (0.2.91) unstable; urgency=low
+
+ * Fix issue Prevent Defect -17677
+ * Fixing issues: 17677
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.91
+
+ -- leerang <leerang.song@samsung.com> Wed, 09 Jan 2013 18:03:04 +0900
+
+wrt-commons (0.2.90) unstable; urgency=low
+
+ * Changed PkgName type from DPL::Optional<DPL::String> to DPL::String. PART 4
+ * User agent database update
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 08 Jan 2013 11:12:49 +0900
+
+wrt-commons (0.2.89) unstable; urgency=low
+
+ * Handle return value from pthread_setspecific
+ * Deleted array to 0 comparison
+ * Deleted unreachable code
+ * Add vconf key for memory saving mode
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.89
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 02 Jan 2013 11:00:02 +0900
+
+wrt-commons (0.2.88) unstable; urgency=low
+
+ * Add path builder for vconf key
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.88
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Sat, 29 Dec 2012 14:02:18 +0900
+
+wrt-commons (0.2.87) unstable; urgency=low
+
+ * changed to get encryption/decryption key from device unique key
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.87
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 28 Dec 2012 20:47:21 +0900
+
+wrt-commons (0.2.86) unstable; urgency=low
+
+ * Revert "Modify get encryption/decryption key from device unique key"
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.86
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 28 Dec 2012 17:42:06 +0900
+
+wrt-commons (0.2.85) unstable; urgency=low
+
+ * For livebox configuration
+ * livebox configuration valuables have been changed
+ * Modify get encryption/decryption key from device unique key
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.85
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 28 Dec 2012 14:05:27 +0900
+
+wrt-commons (0.2.83) unstable; urgency=low
+
+ * Replacing widget handle with tizenid in property DAO
+
+ -- KEONGEUN <lke01.lee@samsung.com> Fri, 21 Dec 2012 17:03:54 +0900
+
+wrt-commons (0.2.82) unstable; urgency=low
+
+ * CustomHandlersDB API updated to handle new functionalities.
+ * Add tests - DAO, DPL
+ * Custom Handlers DAO extended with new api
+ * registerWidgetSecuritySettings - nested transaction removal. New widget dao testcase
+ * Unit test for custom handler dao stub
+ * CustomHandlersDAO test
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.82
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 20 Dec 2012 09:04:59 +0900
+
+wrt-commons (0.2.81) unstable; urgency=low
+
+ * Fix dependencies in DAO modules
+ * Missing boilerplate added
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.81
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Sun, 16 Dec 2012 09:09:42 +0900
+
+wrt-commons (0.2.80) unstable; urgency=low
+
+ * Implement privilege database table
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.80
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 14 Dec 2012 10:30:48 +0900
+
+wrt-commons (0.2.79) unstable; urgency=low
+
+ * Replacing DbWidgetHandle with WidgetPkgName in SecurityOriginDAO
+ * Handle remove() return value
+ * Delete unreachable code
+ * Handle chmod return value
+ * CustomHandlerDAO implementation
+ * Unhandled isWidgetInstalled return value
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.79
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 13 Dec 2012 11:15:24 +0900
+
+wrt-commons (0.2.78) unstable; urgency=low
+
+ * Removing copy&paste code, part 2
+ * Changed SharedPtr to std:shared_ptr
+ * Changed ScopedPtr to std::unique_ptr
+ * Klocwork analysis related fix
+ * SharedFromTHis replace by STL C++0x ones
+ * Overload methods to run with tizen id instead of widgetHandle
+ * Changed PkgName type from DPL::Optional<DPL::String> to DPL::String
+ * Default "en" language tag removed from provider
+ * CustomHandlers DAO libraries stubs added
+ * Replacing widget handle with tizenid in property DAO
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.78
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 10 Dec 2012 10:11:26 +0900
+
+wrt-commons (0.2.76) unstable; urgency=low
+
+ * Add share directory
+ * Add category element for manifest.xml
+ * Modify installed path for preload widget.
+ * Updated widget resources path in wrt_reset_all.sh
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.76
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 30 Nov 2012 17:47:24 +0900
+
+wrt-commons (0.2.75) unstable; urgency=low
+
+ * Throw an exception when pthread_key_create fails
+ * Symbolic link pointed by GetVCoreDatabaseFilePath will be removed.
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.75
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Fri, 23 Nov 2012 22:01:00 +0900
+
+wrt-commons (0.2.74) unstable; urgency=low
+
+ * Removing copy&paste code, part 1
+ * Removal of factory_widget attribute and related functions
+ * Implement security origin dao for allow,deny one time
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.74
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 23 Nov 2012 10:09:27 +0900
+
+wrt-commons (0.2.73) unstable; urgency=low
+
+ * Distinguish between system headers and project headers
+ * Implement security origin dao for setting menu
+ * Implement security settings in the widgetDAO
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.73
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 22 Nov 2012 20:46:40 +0900
+
+wrt-commons (0.2.72) unstable; urgency=low
+
+ * Change widget installed path request by app fw
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.72
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Tue, 13 Nov 2012 17:16:16 +0900
+
+wrt-commons (0.2.71) unstable; urgency=low
+
+ * Implement Security origin database
+ * hidden symbol for enhancement shared library loading time (orm.h)
+ * Default widget locale adding to language tags
+ * WrtDAO clean up - unused function with widget handle usage
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.71
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 12 Nov 2012 16:55:19 +0900
+
+wrt-commons (0.2.70) unstable; urgency=low
+
+ * Additional Include: stddef.h
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.70
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 05 Nov 2012 17:43:04 +0900
+
+wrt-commons (0.2.69) unstable; urgency=low
+
+ * [Commons] Modify package type
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.69
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Mon, 05 Nov 2012 16:46:34 +0900
+
+wrt-commons (0.2.68) unstable; urgency=low
+
+ * Change profiling build
+ * Removing unused WtrUtilStringToLower
+ * Fix for localization URI ended with '/'
+ * Code refactoring and removal of factory_widget attribute
+ * WidgetDAO from WidgetHandle construction depracated
+ * WrtDAO - getPkgnameList
+ * Removal of compilation warnings
+ * W3c file localization - from pkgname construction
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.68
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 02 Nov 2012 11:20:52 +0900
+
+wrt-commons (0.2.67) unstable; urgency=low
+
+ * Localization cleaning from unused API (restore)
+ * Removing old, unused _WrtUtil* functions
+ * Database reset affects security-server
+ * Removing FileUtils
+ * Replacing recursive opendir with fts
+
+ * Release wrt-commons_0.2.67
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.67
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Wed, 24 Oct 2012 17:02:50 +0900
+
+wrt-commons (0.2.66) unstable; urgency=low
+
+ * Release wrt-commons_0.2.66
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.66
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Thu, 18 Oct 2012 11:33:54 +0900
+
+wrt-commons (0.2.65) unstable; urgency=low
+
+ * [Engine] Add method to get widget list
+ * [Commons] New utility functions in wrt_utility
+ * [Commons] Escaping bash sequences in argument programs
+ * [Engine] Allow to call methods using dao pointer
+ * [Engine] Remove mutex from log system.
+ * [Engine] Support for authors certificates (part 4).
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.65
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Wed, 17 Oct 2012 22:08:33 +0900
+
+wrt-commons (0.2.64) unstable; urgency=low
+
+ * Revert "Localization cleaning from unused API"
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.64
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 12 Oct 2012 14:21:43 +0900
+
+wrt-commons (0.2.63) unstable; urgency=low
+
+ * Support for authors certificate
+ * WidgetDAO new CTOR (based on TizenID)
+ * Localization related cleanup
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.63
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 11 Oct 2012 12:53:19 +0200
+
+wrt-commons (0.2.62) unstable; urgency=low
+
+ * [Engine] Add license installing
+ * [Engine] clean up .gitignore
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.62
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 11 Oct 2012 08:02:04 +0900
+
+wrt-commons (0.2.61) unstable; urgency=low
+
+ * [Commons] Support for Debug and Release build configuration
+ * Deprecated localization API removal
+ * Localization refactoring and cleaning
+ * [Commons] Refactoring featureDAO, pluginDAO table
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.61
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 05 Oct 2012 07:29:49 +0900
+
+wrt-commons (0.2.60) unstable; urgency=low
+
+ * for SEL verification
+ * [Commons] POWDER remains removed
+ * [Commons] Fixed PLM P120926-3287
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.60
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 28 Sep 2012 15:27:25 +0900
+
+wrt-commons (0.2.59) unstalbe; urgency=low
+
+ * Add smack manifest
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.59
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Thu, 20 Sep 2012 20:08:44 +0900
+
+wrt-commons (0.2.58) unstalbe; urgency=low
+
+ * for SEL verification
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.58
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Thu, 20 Sep 2012 12:02:41 +0900
+
+wrt-commons (0.2.57) unstalbe; urgency=low
+
+ * Proper list support in LanguageTagsProvider
+ * User Agent Database update
+ * Language tags providing class added
+ * Add a feature dao function giving requested features' data
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.57
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Wed, 19 Sep 2012 12:03:09 +0900
+
+wrt-commons (0.2.56) unstalbe; urgency=low
+
+ * [Commons] Test mode environment variable changed
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.56
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 12 Sep 2012 15:46:28 +0900
+
+wrt-commons (0.2.55) unstable; urgency=low
+
+ * [Commons] Table ExternalFiles renamed to ExternalLocations
+ * [Commons] Fix in base path removal in localization module.
+ * [Commons] Add multiple output types in test framework
+ * [Commons] Slash added to global config paths
+ * [Commons] Background page support in WidgetModel
+ * [Commons] New table - WidgetExternalFiles
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.55
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Thu, 06 Sep 2012 00:34:12 +0900
+
+wrt-commons (0.2.54) unstable; urgency=low
+
+ * [common] Add XML test collector
+ * [common] Add encryption api
+ * [Engine] Fix for wrt-popup
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.54
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 29 Aug 2012 13:37:28 +0900
+
+wrt-commons (0.2.53) unstable; urgency=low
+
+ * Added new build type for code coverage
+ * User Agent Database update
+ * Added new SQLConnection flag - CRW and null query check
+ * Remove "auto" for fixed build break
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.53
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 09 Aug 2012 15:16:30 +0900
+
+wrt-commons (0.2.52) unstable; urgency=low
+
+ * Re-upload package
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.52
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 31 Jul 2012 11:15:58 +0900
+
+wrt-commons (0.2.51) unstable; urgency=low
+
+ * Re-upload package
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.51
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 30 Jul 2012 10:06:49 +0900
+
+wrt-commons (0.2.50) unstable; urgency=low
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.50
+
+ -- Leerang Song <leerang.song@samsung.com> Fri, 27 Jul 2012 12:02:06 +0900
+
+wrt-commons (0.2.49) unstable; urgency=low
+
+ * Add splash screen
+ * Fix circular dependency to cert-svc
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.49
+
+ -- Zbigniew Kostrzewa <z.kostrzewa@samsung.com> Wed, 25 Jul 2012 14:36:40 +0200
+
+wrt-commons (0.2.48) unstable; urgency=low
+
+ * Fixed CCR(#N_SE-3620)
+ * FeatureDAOReadOnly - performance improvement
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.48
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 25 Jul 2012 09:58:22 +0900
+
+wrt-commons (0.2.47) unstable; urgency=low
+
+ * Change installed resource path & Add PackageType
+ * support tizen extension requirement regarding application id / required version
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.47
+
+ -- Leerang Song <leerang.song@samsung.com> Thu, 19 Jul 2012 19:19:39 +0900
+
+wrt-commons (0.2.46-1) unstable; urgency=low
+
+ * Add tag for auto SR
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.46-1
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 12 Jul 2012 15:25:36 +0900
+
+wrt-commons (0.2.46) unstable; urgency=low
+
+ * Remove auto save for WK1
+ * Support auto save id/password for WK2
+ * Multiple INVALID_WIDGET_HANDLE definition
+ * Wrt DB DefferedWidgetPackageInstallation clean up
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.46
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 12 Jul 2012 10:56:48 +0900
+
+wrt-commons (0.2.45) unstable; urgency=low
+
+ * Fingerprint list should not contain empty strings
+ * Add frame load and unload callback
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.45
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 28 Jun 2012 16:30:53 +0900
+
+wrt-commons (0.2.44) unstable; urgency=low
+
+ * Move create directory("/opt/apps/widget/")
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.44
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 21 Jun 2012 11:13:38 +0900
+
+wrt-commons (0.2.43) unstable; urgency=low
+
+ * Remove WK1
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.43
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 19 Jun 2012 09:46:13 +0900
+
+wrt-commons (0.2.42) unstable; urgency=low
+
+ * Fix build break in wrt-security
+ * Remove warning when reset .wrt.db
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.42
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 15 Jun 2012 10:31:34 +0900
+
+wrt-commons (0.2.41) unstable; urgency=low
+
+ * Clean up unused api in FeatureDAO
+ * Nested loop removal
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.41
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 31 May 2012 11:40:41 +0900
+
+wrt-commons (0.2.40) unstable; urgency=low
+
+ * Unused code removal
+ * wrt_reset_all.sh changed to remove all widgets files
+ * Modify desktop default icon path for installer
+ * Add wrt-client prefix for wk2
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.40
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 24 May 2012 18:04:34 +0900
+
+wrt-commons (0.2.39) unstable; urgency=low
+
+ * Separated singleton implementation removal
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.39
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 21 May 2012 15:26:54 +0200
+
+wrt-commons (0.2.38) unstable; urgency=low
+
+ * Refactoring common_dao for auto_save
+ * ZipInput simplified
+ * Nested loop removall
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.38
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 21 May 2012 17:13:15 +0900
+
+wrt-commons (0.2.37) unstable; urgency=low
+
+ * Tests leftovers removal
+ * Remove unused DPL::MultiTaskDecl
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.37
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 17 May 2012 19:49:51 +0900
+
+wrt-commons (0.2.36) unstable; urgency=low
+
+ * Script to reset wrt (wrt_reset_all.sh)
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.36
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 14 May 2012 18:28:43 +0900
+
+wrt-commons (0.2.35) unstable; urgency=low
+
+ * Prepare widgetDAO to get different widget IDs
+ * depends on "add recovery mechanism.." commit
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.35
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 07 May 2012 17:35:10 +0900
+
+wrt-commons (0.2.34) unstable; urgency=low
+
+ * Patch for compliance test widget-api/NoInterfaceObject
+ * TLV pthread reference issue
+ * Changing WidgetDAO rw to ro permissions where appropriate
+ * JIL and WAC1.0 leftovers removal
+ * Widget StartFile localizedPath fix
+ * Switching to the TestModeFlag - final step
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.34
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 03 May 2012 10:11:41 +0900
+
+wrt-commons (0.2.33) unstable; urgency=low
+
+ * UserAgent locales removed
+ * Deprecated api removed
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.33
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 23 Apr 2012 14:10:21 +0900
+
+wrt-commons (0.2.32) unstable; urgency=low
+
+ * Language changed callback move to WRT engine
+ * Modify the access rights for Semaphore method
+ * Ultimate solution to test mode flag
+ * Web App data sharing From orange requirement
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.32
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 16 Apr 2012 09:48:09 +0900
+
+wrt-commons (0.2.31) unstable; urgency=low
+
+ * Mapping from features to device caps is obtained from .so
+ * Exposed pc file for wrt-plugin-export header
+ * Common environment test flag
+ * getUserAgentLocales added to WidgetDAOReadOnly
+ * TAP tests results collector
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.31
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 09 Apr 2012 10:25:57 +0900
+
+wrt-commons (0.2.30) unstable; urgency=low
+
+ * clean-up powder, parental mode
+ * Revert "[wrt-commons] Added global config API and desktop_file_name_field in wrt_db"
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.30
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 28 Mar 2012 18:25:06 +0900
+
+wrt-commons (0.2.29) unstable; urgency=low
+
+ * Change user name to user id
+ * Adding cookie sharing mode field
+ * Added global config API and desktop_file_name_field in wrt_db
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.29
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 27 Mar 2012 17:05:15 +0900
+
+wrt-commons (0.2.28) unstable; urgency=low
+
+ * Optimize OBS
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.28
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 23 Mar 2012 10:10:42 +0900
+
+wrt-commons (0.2.27) unstable; urgency=low
+
+ * add libxml2-dev to 'Depends' of wrt-commons-dev package
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.27
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Mon, 19 Mar 2012 19:01:09 +0900
+
+wrt-commons (0.2.26) unstable; urgency=low
+
+ * Create ".wrt_autosave.db"
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.26
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 19 Mar 2012 13:31:14 +0900
+
+wrt-commons (0.2.25-1) unstable; urgency=low
+
+ * Apply changed EFL APIs
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.25-1
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Wed, 14 Mar 2012 10:04:41 +0900
+
+wrt-commons (0.2.25) unstable; urgency=low
+
+ * Support OBS, SMACK
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.25
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Tue, 13 Mar 2012 19:51:25 +0900
+
+wrt-commons (0.2.24) unstable; urgency=low
+
+ * Clean-up heynoti depedency
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.24
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 06 Mar 2012 21:12:40 +0900
+
+wrt-commons (0.2.23) unstable; urgency=low
+
+ * Move certificates and finterprint settings from wrt-commons repository into wrt-security
+ * Add exception for "create directory"
+ * Clean-up unused event source
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.23
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 06 Mar 2012 20:29:32 +0900
+
+wrt-commons (0.2.22) unstable; urgency=low
+
+ * Modified libraries' names
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.22
+
+ -- Grzegorz Krawczyk <g.krawczyk@samsung.com> Tue, 28 Feb 2012 17:01:07 +0100
+
+wrt-commons (0.2.21) unstable; urgency=low
+
+ * Vcore and ACE removed
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.21
+
+ -- Grzegorz Krawczyk <g.krawczyk@samsung.com> Fri, 24 Feb 2012 16:51:27 +0100
+
+wrt-commons (0.2.20) unstable; urgency=low
+
+ * User Agent lists update
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.20
+
+ -- Hoseon LEE <hoseon46.lee@samsung.com> Fri, 24 Feb 2012 09:28:47 +0100
+
+wrt-commons (0.2.19) unstable; urgency=low
+
+ * WAC Compliance test WL-3240 fix.
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.19
+
+ -- Zbigniew Kostrzewa <z.kostrzewa@samsung.com> Wed, 22 Feb 2012 09:28:47 +0100
+
wrt-commons (0.2.18) unstable; urgency=low
- * Boilerplate update
+ * Fixed static dev cap setting.
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.18
+
+ -- Zbigniew Kostrzewa <z.kostrzewa@samsung.com> Wed, 22 Feb 2012 07:59:18 +0100
+
+wrt-commons (0.2.17) unstable; urgency=low
+
+ * WAC policy test suite bugfix.
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.17
+
+ -- Zbigniew Kostrzewa <z.kostrzewa@samsung.com> Mon, 20 Feb 2012 14:05:41 +0100
+
+wrt-commons (0.2.16) unstable; urgency=low
+
+ * Localization API minor change
+ * test package reenabled
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.16
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 13 Feb 2012 16:04:58 +0100
+
+wrt-commons (0.2.15) unstable; urgency=low
+
+ * Tapi dependency added
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.15
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 13 Feb 2012 12:53:12 +0100
+
+wrt-commons (0.2.14) unstable; urgency=low
+
+ * MEID check added
+ * Added safe singleton implementation, that prevents dubletons.
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.14
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 13 Feb 2012 12:29:16 +0100
+
+wrt-commons (0.2.13) unstable; urgency=low
+
+ * Removing SLP, Bada ... strings for Source Open
+ * Update User-agent
+ * Popup manage initialization flag fixed
+ * Add weather widget is installed by package name
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.13
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 13 Feb 2012 10:46:30 +0100
+
+wrt-commons (0.2.12) unstable; urgency=low
+
+ * disabling test package to be build
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.12
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Wed, 08 Feb 2012 17:45:57 +0100
+
+wrt-commons (0.2.11) unstable; urgency=low
+
+ * Ace and Vcore tests moved to wrt-commons
+ * "efl" suffic removed
+ * certificate names changes
+ * bugfix:
+ ** undetermined attributes
+ ** Attributes sorting algorithm
+ ** Vcore init
+ * New tests added (to OCSP)
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.11
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Wed, 08 Feb 2012 17:10:30 +0100
+
+wrt-commons (0.2.10) unstable; urgency=low
+
+ * Files access with FILE API bug fix
+ * Add global dao APIs for operation of white document list
+ * fixed WidgetDAO for ugid
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.10
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 02 Feb 2012 15:43:01 +0900
+
+wrt-commons (0.2.9) unstable; urgency=low
+
+ * Refactoring Phase2
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.9
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Tue, 31 Jan 2012 12:56:00 +0900
+
+wrt-commons (0.2.8) unstable; urgency=low
+
+ * documentation included to repository
+ * dbus fix (crash issue with bool type)
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.8
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Wed, 25 Jan 2012 14:47:21 +0100
+
+wrt-commons (0.2.7) unstable; urgency=low
+
+ * Debianize latest source
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.7
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Wed, 25 Jan 2012 10:30:05 +0900
+
+wrt-commons (0.2.6) unstable; urgency=low
+
+ * Wrt-commons split into several libraries
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.6
+
+ -- Grzegorz Krawczyk <g.krawczyk@samsung.com> Fri, 20 Jan 2012 16:20:27 +0100
+
+wrt-commons (0.2.5) unstable; urgency=low
+
+ * DBUS module moved from wrt
+ * Dir structure has been changed (modules extracted)
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.5
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 17 Jan 2012 18:20:27 +0100
+
+wrt-commons (0.2.4) unstable; urgency=low
+
+ * Webkit2(Refactoring) branch merged
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.4
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 16 Jan 2012 15:57:06 +0900
+
+wrt-commons (0.2.3) unstable; urgency=low
+
+ * Webkit2(Refactoring) branch merged
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.3
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Mon, 16 Jan 2012 15:30:07 +0900
+
+wrt-commons (0.2.2) unstable; urgency=low
+
+ * Master and Webkit2 branch merged (ORM change merged)
+ * Mechanisms moved from wrt: NestedLoop, ScopedGPointer
+
+ * Git : slp/pkgs/w/wrt-commons
+ * Tag : wrt-commons_0.2.2
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 12 Jan 2012 11:19:00 +0100
+
+wrt-commons (0.2.1) unstable; urgency=low
+
+ * ORM interface changed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : wrt-commons_0.2.1
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 12 Dec 2011 11:33:07 +0100
+
+wrt-commons (0.2.0) unstable; urgency=low
+
+ * Debianize for changing package name (wrt-commons)
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : wrt-commons_0.2.0
+
+ -- Hoseon LEE <hoseon46.lee@samsung.com> Thu, 08 Dec 2011 10:51:40 +0900
+
+wrt-commons (0.1.65) unstable; urgency=low
+
+ * Debianize latest source
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.65
+
+ -- Hoseon LEE <hoseon46.lee@samsung.com> Wed, 07 Dec 2011 12:11:02 +0900
+
+wrt-commons (0.1.64) unstable; urgency=low
+
+ * Fixes, FakeRPC connection added
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.64
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 29 Nov 2011 12:20:39 +0100
+
+dpl (0.1.63) unstable; urgency=low
+
+ * ThreadDatabase Support moved to dpl
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.63
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 22 Nov 2011 16:48:43 +0100
+
+dpl (0.1.62) unstable; urgency=low
+
+ * ICDelegate, apply, caller functions extended
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.62
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 17 Nov 2011 17:19:13 +0100
+
+dpl (0.1.61) unstable; urgency=low
+
+ * Adding ORM, Apply, ICD mechanism to DPL
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.61
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Wed, 09 Nov 2011 13:33:16 +0100
+
+dpl (0.1.60) unstable; urgency=low
+
+ * debianization due to icu upversioning
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.60
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 25 Oct 2011 10:40:26 +0200
+
+dpl (0.1.59) unstable; urgency=low
+
+ * modification of build option to build only EFL DPL package
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.59
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Wed, 07 Sep 2011 13:42:54 +0900
+
+dpl (0.1.58) unstable; urgency=low
+
+ * Debianized for open source
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.58
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Tue, 06 Sep 2011 13:52:05 +0900
+
+dpl (0.1.57) unstable; urgency=low
+
+ * Waitables reloaded after HandleWatcher is called
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.57
+
+ -- Zbigniew Kostrzewa <z.kostrzewa@samsung.com> Thu, 28 Jul 2011 11:35:42 +0200
+
+dpl (0.1.56) unstable; urgency=low
+
+ * add policyClass as template param, genericsocket fixed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.56
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 27 Jun 2011 11:55:42 +0200
+
+dpl (0.1.55) unstable; urgency=low
+
+ * once, automatic listeners cleaning, property fix
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.55
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 14 Jun 2011 10:50:56 +0200
+
+dpl (0.1.54) unstable; urgency=low
+
+ * fix build dep
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.54
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 09 Jun 2011 14:12:31 +0200
+
+dpl (0.1.53) unstable; urgency=low
+
+ * scoped patterns extended, StringCompare with ICU
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.53
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 09 Jun 2011 12:50:44 +0200
+
+dpl (0.1.52) unstable; urgency=low
+
+ * scoped patterns extanded
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.52
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 06 Jun 2011 15:59:44 +0200
+
+dpl (0.1.51) unstable; urgency=low
+
+ * string errno, get/set virtual for property
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.51
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 06 Jun 2011 14:43:48 +0200
+
+dpl (0.1.50) unstable; urgency=low
+
+ * fix namespace, fix network change message publishing,
+ * size functionality added int TypeLists
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.50
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 19 May 2011 15:06:39 +0200
+
+dpl (0.1.49) unstable; urgency=low
+
+ * license cleanup, small bug fixes
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.49
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 12 May 2011 12:57:54 +0200
+
+dpl (0.1.48) unstable; urgency=low
+
+ * MessageQueue, static remove for semaphores
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.48
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 22 Apr 2011 11:32:15 +0200
+
+dpl (0.1.47) unstable; urgency=low
+
+ * model/property system, TLS fixed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.47
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 14 Apr 2011 14:35:38 +0200
+
+dpl (0.1.46) unstable; urgency=low
+
+ * delegate mechanism, sql connection, test runner fix
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.46
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 31 Mar 2011 10:18:22 +0200
+
+dpl (0.1.45) unstable; urgency=low
+
+ * ThreadLocal variables, named semaphore, Waitable fix,
+ * symbols visibility fix
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.45
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 21 Mar 2011 16:57:31 +0100
+
+dpl (0.1.44) unstable; urgency=low
+
+ * Disable Werror flag, bb fixed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.44
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 10 Mar 2011 21:06:51 +0900
+
+dpl (0.1.43) unstable; urgency=low
+
+ * ecore_main_loop_select_func_get return type changed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.43
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 08 Mar 2011 11:05:54 +0900
+
+dpl (0.1.42) unstable; urgency=low
+
+ * MultiTask added. union_cast, lexical_cast
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.42
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 04 Mar 2011 14:05:23 +0100
+
+dpl (0.1.41) unstable; urgency=low
+
+ * klocwork fixes, release method added to scoped array
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.41
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 01 Mar 2011 09:38:53 +0100
+
+dpl (0.1.40) unstable; urgency=low
+
+ * Zip-input fixed.
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.40
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 28 Feb 2011 10:42:44 +0100
+
+dpl (0.1.39-1) unstable; urgency=low
+
+ * redebianized
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.39-1
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 25 Feb 2011 09:33:12 +0100
+
+dpl (0.1.39) unstable; urgency=low
+
+ * Semaphore added, Mutex fixed, Zip enhanced
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.39
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 22 Feb 2011 09:54:11 +0100
+
+dpl (0.1.38) unstable; urgency=low
+
+ * GetCurrentTask, EventDispatcher fix, Append for DPL::String
+ * Zip file support
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.38
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 15 Feb 2011 17:52:24 +0100
+
+dpl (0.1.37-1) unstable; urgency=low
+
+ * redebianize
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.37-1
- * Git : tizen2/pkgs/w/wrt-commons
- * Tag : wrt-commons_0.2.18
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 04 Feb 2011 11:11:13 +0100
- -- Tae-Jeong Lee <taejeong.lee@samsung.com> Thu, 23 Feb 2012 16:12:49 +0900
+dpl (0.1.37) unstable; urgency=low
-wrt-commons (0.2.17) unstable; urgency=low
+ * EventSupport fixes.
- * debianize
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.37
- * Git : tizen2/pkgs/w/wrt-commons
- * Tag : wrt-commons_0.2.17
+ -- Pawel Sikorski <p.sikorski@samsung.com> Thu, 03 Feb 2011 17:44:49 +0100
- -- Yunchan Cho <yunchan.cho@samsung.com> Wed, 22 Feb 2012 16:57:31 +0900
+dpl (0.1.36) unstable; urgency=low
-wrt-commons (0.2.16) unstable; urgency=low
+ * header fix.
- * Init changelog
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.36
- * Git : tizen2/pkgs/w/wrt-commons
- * Tag : wrt-commons_0.2.16
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 01 Feb 2011 12:19:53 +0100
+
+dpl (0.1.35-1) unstable; urgency=low
+
+ * debianization fix.
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.35-1
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 01 Feb 2011 09:58:40 +0100
+
+dpl (0.1.35) unstable; urgency=low
+
+ * DPL::CharTraits fixed
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.35
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 01 Feb 2011 09:46:04 +0100
+
+dpl (0.1.34) unstable; urgency=low
+
+ * bundled value usage added.
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.34
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 28 Jan 2011 14:13:03 +0100
+
+dpl (0.1.33) unstable; urgency=low
+
+ * Synchronized events support.
+ * FOREACH macro.
+ * BinaryQueue reimplementation
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.33
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 21 Jan 2011 10:43:38 +0100
+
+dpl (0.1.32-3) unstable; urgency=low
+
+ * dpl path fix
+
+ * Git : 165.213.180.234:slp/pkgs/d/dpl
+ * Tag : dpl_0.1.32-3
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 11 Jan 2011 18:19:25 +0100
+
+dpl (0.1.32-2) unstable; urgency=low
+
+ * build break fixed
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.32-2
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 11 Jan 2011 17:29:55 +0100
+
+dpl (0.1.32-1) unstable; urgency=low
+
+ * redebianizing
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.32-1
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 11 Jan 2011 12:46:19 +0100
+
+dpl (0.1.32) unstable; urgency=low
+
+ * moving vconf header to dirty headers
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.32
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 10 Jan 2011 10:13:07 +0100
+
+dpl (0.1.31) unstable; urgency=low
+
+ * debianized - 0.1.31
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.31
+
+ -- Koeun Choi <koeun.choi@samsung.com> Wed, 08 Dec 2010 20:22:25 +0900
+
+dpl (0.1.30-2) unstable; urgency=low
+
+ * debianized - 0.1.30-2
+ * Ignored category for test runner
+ * TypeListGenerator to TypeListDecl
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.30-2
+
+ -- Koeun Choi <koeun.choi@samsung.com> Mon, 15 Nov 2010 16:00:52 +0900
+
+dpl (0.1.30) unstable; urgency=low
+
+ * Ignored category for test runner
+
+ -- Przemyslaw Dobrowolski <p.dobrowolsk@samsung.com> Fri, 12 Nov 2010 14:55:15 +0100
+
+dpl (0.1.29) unstable; urgency=low
+
+ * Renamed TypeListGenerator to TypeListDecl
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.29
+
+ -- Przemyslaw Dobrowolski <p.dobrowolsk@samsung.com> Fri, 12 Nov 2010 14:14:54 +0100
+
+dpl (0.1.28) unstable; urgency=low
+
+ * New controller mechanism
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.28
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Fri, 12 Nov 2010 12:22:01 +0100
+
+dpl (0.1.27) unstable; urgency=low
+
+ * Added threads' guarded singletons
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.27
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 09 Nov 2010 10:13:16 +0100
+
+dpl (0.1.26) unstable; urgency=low
+
+ * Bug fixes
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.26
+
+ -- Koeun Choi <koeun.choi@samsung.com> Mon, 08 Nov 2010 14:43:15 +0100
+
+ dpl (0.1.25-1) unstable; urgency=low
+
+ * Redebianized.
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.25-1
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 28 Oct 2010 12:12:45 +0900
+
+dpl (0.1.25) unstable; urgency=low
+
+ * Fixed exception handing while parsing RPC protocol
+ * commit : a19efed5a210fb1f8f91de18009b0d86e03326db
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.25
+
+ -- Koeun Choi <koeun.choi@samsung.com> Mon, 25 Oct 2010 15:21:48 +0900
+
+
+dpl (0.1.24) unstable; urgency=low
+
+ * Added 21 Controler support
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.24
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Wed, 20 Oct 2010 16:15:42 +0200
+
+dpl (0.1.23) unstable; urgency=low
+
+ * Reverted: main event dispatcher fix
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.23
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Wed, 13 Oct 2010 11:09:48 +0200
+
+dpl (0.1.22-1) unstable; urgency=low
+
+ * Main event dispatcher fix
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.22-1
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Fri, 08 Oct 2010 16:17:51 +0200
+
+dpl (0.1.22) unstable; urgency=low
+
+ * Main event dispatcher fix
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.22
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Fri, 08 Oct 2010 14:45:45 +0200
+
+dpl (0.1.21) unstable; urgency=low
+
+ * Fixed RPC bug which caused white screen
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.21
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Thu, 07 Oct 2010 12:17:18 +0200
+
+dpl (0.1.20-1) unstable; urgency=low
+
+ * Reupload to fix debianization error (again)
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.20-1
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Wed, 06 Oct 2010 15:07:32 +0200
+
+dpl (0.1.19) unstable; urgency=low
+
+ * Fixed bug in generic RPC protocol parser & package name is changed(svn is removed)
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.19
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 30 Sep 2010 19:17:20 +0900
+
+dpl (0.1.18) unstable; urgency=low
+
+ * support string conversion (i18n) and char traits
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.18
+
+ -- Ming Jin <ming79.jin@samsung.com> Fri, 17 Sep 2010 14:32:23 +0900
+
+dpl (0.1.17) unstable; urgency=low
+
+ * Upgrade to EFL1.0 alpha
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.17
+
+ -- Piotr Fatyga <p.fatyga@samsung.com> Fri, 10 Sep 2010 17:41:55 +0200
+
+dpl (0.1.16) unstable; urgency=low
+
+ * changed assert routine. Building changed to Release.
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.16
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Wed, 01 Sep 2010 11:39:41 +0200
+
+dpl (0.1.15) unstable; urgency=low
+
+ * Hibernation fixed
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.15
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 31 Aug 2010 19:00:52 +0200
+
+dpl (0.1.14) unstable; urgency=low
+
+ * Improvements in shared ptr, logging mechanism and unit testing
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.14
+
+ -- Pawel Sikorski <p.sikorski@samsung.com> Tue, 24 Aug 2010 09:59:48 +0200
+
+dpl (0.1.12) unstable; urgency=low
+
+ * Fixed problem with bool operator in smart pointers
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.12
+
+ -- Przemyslaw Dobrowolski <p.dobrowolsk@samsung.com> Wed, 18 Aug 2010 11:01:52 +0200
+
+dpl (0.1.11) unstable; urgency=low
+
+ * appcore updated
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.11
+
+ -- Koeun Choi <koeun.choi@samsung.com> Fri, 06 Aug 2010 10:28:44 +0900
+
+dpl (0.1.10) unstable; urgency=low
+
+ * Added support for handling late EFL events
+
+ * Git : 165.213.180.234:/git/slp/pkgs/dpl
+ * Tag : dpl_0.1.10
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 03 Aug 2010 19:34:53 +0900
+
+dpl (0.1.9) unstable; urgency=low
+
+ * Fixed bug in shared pointer copy operator
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.9
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Mon, 12 Jul 2010 13:54:01 +0900
+
+dpl (0.1.8) unstable; urgency=low
+
+ * Fixed prevent defects
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.8
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Tue, 22 Jun 2010 12:14:32 +0900
+
+dpl (0.1.7) unstable; urgency=low
+
+ * DLOG API change update
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.7
+
+ -- Ming Jin <ming79.jin@samsung.com> Wed, 16 Jun 2010 17:00:00 +0900
+
+dpl (0.1.6-1) unstable; urgency=low
+
+ * Strange tag verification error.
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.6-1
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Fri, 11 Jun 2010 11:37:41 +0900
+
+dpl (0.1.6) unstable; urgency=low
+
+ * Repackaging due to efl update.
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.6
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Fri, 11 Jun 2010 09:38:01 +0900
+
+dpl (0.1.5) unstable; urgency=low
+
+ * Changed usage of deprecated appfwk to appcore-efl
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.5
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Tue, 08 Jun 2010 19:11:38 +0900
+
+dpl (0.1.4) unstable; urgency=low
+
+ * appfwk api removed
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.4
+
+ -- Andrew Lee <hyunchul2.lee@samsung.com> Fri, 04 Jun 2010 11:22:28 +0900
+
+dpl (0.1.3) unstable; urgency=low
+
+ * single instance locking mechanism supported
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.3
+
+ -- Koeun Choi <koeun.choi@samsung.com> Wed, 19 May 2010 20:19:00 +0900
+
+dpl (0.1.2) unstable; urgency=low
+
+ * HIBERNATION_LEAVE_BEFORE_WS added
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.2
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 18 May 2010 08:27:14 +0900
+
+dpl (0.1.1) unstable; urgency=low
+
+ * permission changed by new SLP security guideline
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.1
+
+ -- Koeun Choi <koeun.choi@samsung.com> Fri, 14 May 2010 14:07:16 +0900
+
+dpl (0.1.0) unstable; urgency=medium
+
+ * below details are written by Przemek. :)
+
+ * Added main window visibility optional flag to application class.
+
+ * Removed debug logs from application (switched to pedantic ones)
+ Fixed close sequence in RPC example
+
+ * Fixed critical leak in rpc connection related to acquisition of abstract waitable input/output.
+
+ * Added RPC Client/Server example
+
+ * Removed useParam from ConnectionEstablished event in RPC Server/Client
+ Added ConnectionID to ConnectionEstablishedEvent in RPC Server/Client
+ Added convience Open methods to (Tcp/Unix)SocketRPC(Server/Client)
+
+ * Removed purpose-specific static call code.
+
+ * Added implementation of GenericSocketRPCServer, TcpSocketRPCServer, UnixSocketRPCServer.
+
+ * Implementation in progress: Client/Server architecture for RPC - client and connection part.
+
+ * Temporary fix to build break caused by problems with in DLOG include files
+
+ * Fixed unregister global noti signal routine
+
+ * Added dedicated RPCFunction include file
+ All current RPC mechanisms marked as deprecated
+ Added RPC Client/Server/Connection stub files
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.1.0
+
+ -- Koeun Choi <koeun.choi@samsung.com> Fri, 07 May 2010 11:10:09 +0200
+
+dpl (0.0.9) unstable; urgency=low
+
+ * HibernationEnter and HibernationLeave system events added to EventDeliverySystem
+
+ * Added support for old style pedantic logs
+
+ * Added initial support (i386,gcc) for dynamically created static methods (static interception)
+
+ * Added protocol argument size checks in RPC
+
+ * Fixed non-reentrant version of serialized string parser in EventDeliverySystem
+
+ * Fixed multiple event handling routines to return all signaled handles list (starvation related fix)
+
+ * Workaround definition file added. Moved GLIB-loop-intergration workaround to workaround definition file.
+
+ * Fixed typo in exception messages
+
+ * Workaround for SLP select
+
+ * Added postinstallation scripts for EFL and GTL version of DPL
+
+ * Fixed bug related to improper reinitialization of socket descriptor after Close/Open sequence
+
+ * Added GenericSocketRPC
+ Added TcpSocketRPC
+ Implementation of UnixSocketRPC rebased to GenericSocketRPC
+ Fixed template-based problems with declaring nested generic exceptions
+
+ * Added support for old style plain logs (export DPL_USE_OLD_STYLE_LOGS=1)
+
+ * Fixed bug in WaitableInputOutputExecutionContextSupport related to continous event insisting
+ Fixed bug in WaitableHandle related to improper handling of Read/Write events
+ Added support for retrieving other errors in WatableHandle
+ Added runtime-check for invalid WaitableHandles
+
+ * Fixed DPL debug package name
+
+ * More DPL doxygen documentation added.
+
+ * Added more tests for BinaryQueue (21)
+ Added doxygen documentation for BinaryQueue
+
+ * BinaryQueue basic unit tests added (13)
+
+ * Added generic framework for unit-testing for DPL
+
+ * Added support for handling manipulations with waitable handle watcher/listeners lists during event handling
+ Added TcpSocket
+ Added tcpsock example
+ Added support for defining maximum number of bytes to read in AbstractInput
+ Added support for DNS resolve for tcp Address
+
+ * Added support for retrieving doubles from database in SqlConnection.
+ Added exceptions on retrieving column out of bounds.
+
+ * Added support for retrieveing last insert row ID in SqlConnnection (reported by b.grzelewski)
+
+ * Fixed bug in GenericRPC related to inproper interpretation of incoming data stream (reported by p.sikorski)
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.0.8
+
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 29 Apr 2010 17:41:02 +0200
+
+dpl (0.0.8) unstable; urgency=medium
+
+ * debianized : commit 210d5f7ecd396ff9aeeafcb0d34272a4c4e6c77d
+
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.0.8
+
+ -- Koeun Choi <koeun.choi@samsung.com> Fri, 23 Apr 2010 00:51:27 +0900
+
+dpl (0.0.7) unstable; urgency=low
+
+ * debianized
+ * Git : 165.213.180.234:/git/slp2.0/slp2.0-pkgs/dpl-0
+ * Tag : dpl_0.0.7
+
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 20 Apr 2010 14:16:18 +0900
+
+dpl (0.0.6) unstable; urgency=medium
+
+ * LogSystem switched to DLOG
+
+ * Initial support for Application in gtk version added
+
+ * Fixed link problems in example projects build scripts
+
+ * Added missing sender in events from GenericSocket
+
+ * Added missing dependencies to db-util in pkgconfig files
+
+ * Fixed memory leak in MainEventDispatcher for EFL, related to timed events (reported by valgrind)
+
+ * Fixed memory leak in Thread event list (reported by valgrind)
+
+ * Minimum version of libslp-setting-0 defined (reported by p.misiak)
+
+ * Fixed bug in UnixSocketRPC in scenario when cannot connect (reported by p.sikorski)
+
+ -- Koeun Choi <koeun.choi@samsung.com> Fri, 16 Apr 2010 11:08:46 +0200
+
+dpl (0.0.5) unstable; urgency=high
+
+ * Minimum required version od db-util changed to 0.1.0-23 due to link problems
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 15 Apr 2010 08:28:08 +0200
+
+dpl (0.0.4) unstable; urgency=medium
+
+ * SQLConnection: Added support for Lucene indexer
+
+ * Replaced deprecated API from vconf and util in EventDeliveryDetail for EFL
+
+ * Added doxygen configuration file
+ Added deprecated DPL declarator file
+ Added support for handling broken connections in GenericSocket and RPC
+
+ * DLOG: dlog_init/dlog_deinit is not needed and deprecated. Removed.
+
+ * Fixed bug related to multiple close/connect on socket (reported by p.sikorski)
+
+ * Reference manual stub added
+
+ * Added WaitableInputOutputExecutionContextSupport
+ Various bugfixes related to WaitableHandleSupport
+ Added RPC ClosedEvent support
+
+ -- Koeun Choi <koeun.choi@samsung.com> Wed, 14 Apr 2010 14:27:54 +0200
+
+dpl (0.0.3) unstable; urgency=low
+
+ * Experimental RPC over unix-sockets added.
+
+ * Fixed bug in Main. Various bugfixes in UnixSocket and GenericSocket. GenericRPC implementation in progress
+
+ * Removed NamedPipeRPCCall
+ Added UnixSocketRPC
+ Renaming RPCCall -> RPC
+
+ * GenericSocket implementation finished
+
+ * Generic socket implementation in progress.
+ Added DPL debug package
+
+ * Added Main
+
+ * Fixed DPL-GTK library dependency problem
+
+ * Added WaitableHandleWatchSupport
+
+ * Fixed BUG in EFL-MainEventDispatcher, regarding too late deinitialization
+
+ * Fixed bug in controller touch check assertions.
+ Generic socket implementation in progress.
+
+ * Added support for mode in waitable handle wait procedures.
+ Added support for multi-mode watchers in thread.
+ Added UnixSocket implementation.
+ Added GenericSocket implementation.
+ Added AbstractSocket.
+ Added Address concept.
+ Added example socket test program.
+
+ * Controller extended to handle maximum of 20 events
+
+ * Added WaitableHandle
+
+ * Added AbstractWaitableInput, AbstractWaitableOutput, AbstractWaitableInputOutput,
+ NamedBasePipe, NamedInputPipe, NamedOutputPipe, partial implementation of GenericRPCCall,
+ full implementation of NamedPipeRPCCall
+
+ * Added NamedPipe (blocking mode)
+
+ * Added AbstractInput, AbstractOutput, AbstractInputOutput, NamedPipe stub, GenericRPCCall stub
+
+ * Added RecursiveMutex.
+ Added support for waitable event watchers in Thread.
+
+ * Added BinaryQueue
+
+ * Debian/changelog updated
+
+ * Fixed build-depends
+
+ * Package build dependencies defined properly
+
+ -- Koeun Choi <koeun.choi@samsung.com> Thu, 08 Apr 2010 15:54:02 +0200
+
+dpl (0.0.2) unstable; urgency=low
+
+ * Toolchain upgrades and fixes
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 23 Mar 2010 11:40:32 +0100
+
+dpl (0.0.1) unstable; urgency=low
+
+ * Initial release
+
+ -- Koeun Choi <koeun.choi@samsung.com> Tue, 23 Mar 2010 11:40:32 +0100
- -- Pawel Sikorski <p.sikorski@samsung.com> Mon, 13 Feb 2012 16:04:58 +0100
Maintainer: Lukasz Wrzosek<l.wrzosek@samsung.com>, Taejeong.lee <taejeong.lee@samsung.com>
Standards-Version: 3.7.2
Uploaders: Yunchan Cho <yunchan.cho@samsung.com>,Przemyslaw Dobrowolski <p.dobrowolsk@samsung.com>, Pawel Sikorski <p.sikorski@samsung.com>, Zbigniew Kostrzewa <z.kostrzewa@samsung.com>
-Build-Depends: debhelper (>= 5), libecore-dev, libslp-setting-dev (>=0.2.5-2), libheynoti-dev, libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libglib2.0-dev, libslp-db-util-dev (>= 0.1.0-23), zlib1g-dev, libpcre-dev, libicu-dev, libxmlsec1-dev, openssl, libxml2-dev, libsoup2.4-dev, libcert-svc-dev, libiri-dev, libidn11-dev, libslp-tapi-dev
+Build-Depends: debhelper (>= 5), libecore-dev, libslp-setting-dev (>=0.2.5-2), libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libglib2.0-dev, libslp-db-util-dev (>= 0.1.0-23), zlib1g-dev, libpcre-dev, libicu-dev, libxmlsec1-dev, openssl, libxml2-dev, libsoup2.4-dev, libiri-dev, libidn11-dev
# If you want to build version of gtk, comment out above one live and use the following one line
-#Build-Depends: debhelper (>= 5), libecore-dev, libslp-setting-dev (>=0.2.5-2), libheynoti-dev, libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libglib2.0-dev, libslp-db-util-dev (>= 0.1.0-23), libgtk2.0-dev, zlib1g-dev, libpcre-dev, libicu-dev
+#Build-Depends: debhelper (>= 5), libecore-dev, libslp-setting-dev (>=0.2.5-2), libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libglib2.0-dev, libslp-db-util-dev (>= 0.1.0-23), libgtk2.0-dev, zlib1g-dev, libpcre-dev, libicu-dev
Package: wrt-commons
Section: libs
Conflicts: dpl-efl-dev
Replaces: dpl-efl-dev
Architecture: any
-Depends: wrt-commons (= ${Source-Version}), libecore-dev, libslp-setting-dev (>=0.2.5-2), libheynoti-dev, libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libslp-db-util-dev (>= 0.1.0-23), zlib1g-dev, libpcre-dev
+Depends: wrt-commons (= ${Source-Version}), libecore-dev, libslp-setting-dev (>=0.2.5-2), libappcore-efl-dev, libssl-dev, libsqlite3-dev, dlog-dev (>= 0.2.14-0), libslp-db-util-dev (>= 0.1.0-23), zlib1g-dev, libpcre-dev, libxml2-dev
Description: Design patterns library - EFL based developer files
Design patterns library is a collection of useful C++ utilities
to easily develop window applications. The most important part of
#!/usr/bin/make -f
#export DH_VERBOSE=1
-PACKAGE_VERSION ?= $(shell sed -n "1 p" debian/changelog | sed 's/.*([0-9]*.\([0-9]*\).*).*/\1/')
-CFLAGS = -Wall -g
-LDFLAGS = -Wl,--as-needed -Wl,--hash-style=both
+PACKAGE_VERSION ?= $(shell dpkg-parsechangelog | sed -n 's/^Version: // p')
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
- CFLAGS += -O0
+ifneq (,$(findstring yes,$(DPL_LOGS)))
+DPL_LOGS_STATUS = "ON"
else
- CFLAGS += -O2
-endif
-
-ifneq (,$(findstring yes,$(DPL_LOG)))
- DPL_LOGS_STATUS = "ON"
-else
- DPL_LOGS_STATUS = "OFF"
+DPL_LOGS_STATUS = "OFF"
endif
BUILD_DIR = cmake-build
configure: configure-stamp
configure-stamp:
- dh_testdir
+ dh_testdir
rm -rf $(BUILD_DIR)
mkdir $(BUILD_DIR)
- ( cd $(BUILD_DIR); cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DDPL_LOG=$(DPL_LOGS_STATUS) -DVERSION=${PACKAGE_VERSION}; )
+ ( cd $(BUILD_DIR); cmake .. \
+ -DCMAKE_INSTALL_PREFIX=/usr \
+ -DDPL_LOG=$(DPL_LOGS_STATUS) \
+ -DVERSION=${PACKAGE_VERSION};)
+
touch configure-stamp
build: build-stamp
usr/lib/*.so*
/usr/share/wrt-engine/*
-/usr/bin/wrt_reset_db.sh
-/usr/bin/wrt_create_clean_db.sh
-/usr/etc/ace/config*
-/usr/etc/ace/bondixml*
-/usr/etc/ace/demo.*
-/usr/etc/ace/WACPolicy.xml
-/usr/etc/ace/UnrestrictedPolicy.xml
-/opt/share/cert-svc/certs/code-signing/wac/*
+/usr/bin/wrt_commons_reset_db.sh
+/usr/bin/wrt_commons_create_clean_db.sh
if [ -z ${2} ]; then
echo "This is new install of wrt-commons"
- echo "Calling /usr/bin/wrt_reset_db.sh"
- /usr/bin/wrt_reset_db.sh
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
else
# Find out old and new version of databases
WRT_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.wrt.db ".tables" | grep "DB_VERSION_"`
WRT_NEW_DB_VERSION=`cat /usr/share/wrt-engine/wrt_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
- ACE_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.ace.db ".tables" | grep "DB_VERSION_"`
- ACE_NEW_DB_VERSION=`cat /usr/share/wrt-engine/ace_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
- VCORE_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.vcore.db ".tables" | grep "DB_VERSION_"`
- VCORE_NEW_DB_VERSION=`cat /usr/share/wrt-engine/vcore_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
+ AUTOSAVE_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.wrt_autosave.db ".tables" | grep "DB_VERSION_"`
+ AUTOSAVE_NEW_DB_VERSION=`cat /usr/share/wrt-engine/wrt_autosave_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
+ CUSTOM_HANDLER_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.wrt_custom_handler.db ".tables" | grep "DB_VERSION_"`
+ CUSTOM_HANDLER_NEW_DB_VERSION=`cat /usr/share/wrt-engine/wrt_custom_handler_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
echo "OLD wrt database version ${WRT_OLD_DB_VERSION}"
echo "NEW wrt database version ${WRT_NEW_DB_VERSION}"
- echo "OLD ace database version ${ACE_OLD_DB_VERSION}"
- echo "NEW ace database version ${ACE_NEW_DB_VERSION}"
- echo "OLD vcore database version ${VCORE_OLD_DB_VERSION}"
- echo "NEW vcore database version ${VCORE_NEW_DB_VERSION}"
+ echo "OLD wrt_autosave database version ${AUTOSAVE_OLD_DB_VERSION}"
+ echo "NEW wrt_autosave database version ${AUTOSAVE_NEW_DB_VERSION}"
+ echo "OLD wrt_custom_handler database version ${CUSTOM_HANDLER_OLD_DB_VERSION}"
+ echo "NEW wrt_custom_handler database version ${CUSTOM_HANDLER_NEW_DB_VERSION}"
-
- if [ ${WRT_OLD_DB_VERSION} -a ${WRT_NEW_DB_VERSION} -a ${ACE_OLD_DB_VERSION} -a ${ACE_NEW_DB_VERSION} -a ${VCORE_OLD_DB_VERSION} -a ${VCORE_NEW_DB_VERSION} ]
+ if [ ${WRT_OLD_DB_VERSION} -a ${WRT_NEW_DB_VERSION} -a ${AUTOSAVE_OLD_DB_VERSION} -a ${AUTOSAVE_NEW_DB_VERSION} -a ${CUSTOM_HANDLER_OLD_DB_VERSION} -a ${CUSTOM_HANDLER_NEW_DB_VERSION}]
then
- if [ ${WRT_NEW_DB_VERSION} = ${WRT_OLD_DB_VERSION} -a ${ACE_NEW_DB_VERSION} = ${ACE_OLD_DB_VERSION} -a ${VCORE_OLD_DB_VERSION} = ${VCORE_NEW_DB_VERSION} ]
+ if [ ${WRT_NEW_DB_VERSION} = ${WRT_OLD_DB_VERSION} -a ${AUTOSAVE_NEW_DB_VERSION} = ${AUTOSAVE_OLD_DB_VERSION} -a ${CUSTOM_HANDLER_NEW_DB_VERSION} = ${CUSTOM_HANDLER_OLD_DB_VERSION}]
then
echo "Equal database detected so db installation ignored"
else
- echo "Calling /usr/bin/wrt_reset_db.sh"
- /usr/bin/wrt_reset_db.sh
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
fi
else
- echo "Calling /usr/bin/wrt_reset_db.sh"
- /usr/bin/wrt_reset_db.sh
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
fi
fi
mkdir -p /usr/etc/ace
mkdir -p /usr/apps/org.tizen.policy
-# 3. configurations
-chown root:root /usr/etc/ace/config.xml
-
# DBUS services fix
# WARNING: THIS IS TEMPORARY SOLUTION, AS THIS SHOULD NOT BE OUR
# RESPONSIBILITY!!! WE HAVE TO CONTACT TO DBUS MAINAINERS
#!/usr/bin/env python
+# Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
import os
import re
SET(ETC_DIR ${PROJECT_SOURCE_DIR}/etc)
INSTALL(FILES
- ${ETC_DIR}/wrt_reset_db.sh
- ${ETC_DIR}/wrt_create_clean_db.sh
+ ${ETC_DIR}/wrt_commons_reset_db.sh
+ ${ETC_DIR}/wrt_commons_create_clean_db.sh
DESTINATION /usr/bin
)
-
-INSTALL(FILES
- ${ETC_DIR}/schema.xsd
- DESTINATION share/wrt-engine
- )
-
-INSTALL(FILES
- ${ETC_DIR}/fingerprint_list.xsd
- DESTINATION share/wrt-engine/
- )
-
-INSTALL(FILES
- ${ETC_DIR}/fingerprint_list.xml
- DESTINATION share/wrt-engine/
- )
-
-ADD_SUBDIRECTORY(certificates)
--- /dev/null
+#!/bin/sh
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+
+for name in wrt wrt_autosave wrt_custom_handler
+do
+ rm -f /opt/dbspace/.$name.db
+ rm -f /opt/dbspace/.$name.db-journal
+ SQL="PRAGMA journal_mode = PERSIST;"
+ sqlite3 /opt/dbspace/.$name.db "$SQL"
+ SQL=".read /usr/share/wrt-engine/"$name"_db.sql"
+ sqlite3 /opt/dbspace/.$name.db "$SQL"
+ touch /opt/dbspace/.$name.db-journal
+ chown 0:6026 /opt/dbspace/.$name.db
+ chown 0:6026 /opt/dbspace/.$name.db-journal
+ chmod 660 /opt/dbspace/.$name.db
+ chmod 660 /opt/dbspace/.$name.db-journal
+ pkill -9 security-serv
+done
+
+
--- /dev/null
+#!/bin/sh
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+
+rm -rf /opt/share/widget/system/*
+
+#Removing of widget desktop icons
+WIDGET_EXEC_PATH=/opt/usr/apps/
+WIDGET_DESKTOP_PATH=/opt/share/applications/
+WRT_DB=/opt/dbspace/.wrt.db
+PLUGINS_INSTALLATION_REQUIRED_PATH=/opt/share/widget/
+PLUGINS_INSTALLATION_REQUIRED=plugin-installation-required
+
+if [ -f ${WRT_DB} ]
+then
+ PKG_NAME_SET=$(sqlite3 $WRT_DB 'select pkgname from WidgetInfo;')
+ for pkgname in $PKG_NAME_SET
+ do
+ rm -rf ${WIDGET_EXEC_PATH}${pkgname}
+ widget_desktop_file="${WIDGET_DESKTOP_PATH}${pkgname}.desktop";
+ if [ -f ${widget_desktop_file} ]; then
+ rm -f $widget_desktop_file;
+ fi
+ done
+else
+ echo "${WRT_DB} doesn't exist"
+fi
+
+wrt_commons_create_clean_db.sh
+if [ -e ${PLUGINS_INSTALLATION_REQUIRED_PATH} ] && [ -d ${PLUGINS_INSTALLATION_REQUIRED_PATH} ]
+then
+ touch ${PLUGINS_INSTALLATION_REQUIRED_PATH}${PLUGINS_INSTALLATION_REQUIRED}
+fi
ADD_SUBDIRECTORY(timed_event)
ADD_SUBDIRECTORY(single_instance)
ADD_SUBDIRECTORY(crypto_hash)
-ADD_SUBDIRECTORY(event_delivery_test)
ADD_SUBDIRECTORY(metronome)
ADD_SUBDIRECTORY(copy)
* @version 1.0
* @brief This file is the implementation file of binary queue example
*/
+#include <stddef.h>
#include <dpl/binary_queue.h>
#include <dpl/exception.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of copy example
*/
+#include <stddef.h>
#include <dpl/file_input.h>
#include <dpl/file_output.h>
#include <dpl/copy.h>
* @version 1.0
* @brief This file is the implementation file of crypto hash example
*/
+#include <stddef.h>
#include <dpl/crypto_hash.h>
#include <iostream>
#include <string>
* @version 1.0
* @brief Implementation for simple echo service DBus client.
*/
-
+#include <stddef.h>
#include <iostream>
#include <string>
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
+#include <stddef.h>
#include <memory>
#include <iostream>
#include <gio/gio.h>
* @version 1.0
* @brief This file is the implementation file of RPC example
*/
-
+#include <stddef.h>
#include <dpl/unix_socket_rpc_client.h>
#include <dpl/unix_socket_rpc_server.h>
#include <dpl/unix_socket_rpc_connection.h>
#include <dpl/fake_rpc_connection.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
#include <dpl/application.h>
#include <dpl/controller.h>
#include <dpl/thread.h>
int m_sentData;
int m_receivedData;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcUnixConnection;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcFakeConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcUnixConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcFakeConnection;
virtual void OnEventReceived(const AsyncCallEvent &event)
{
if (dynamic_cast<DPL::FakeRpcConnection *>(event.GetArg1())){
++m_connections;
LogInfo("CLIENT: Acquiring new fake connection");
- m_rpcFakeConnection.Reset(event.GetArg1());
+ m_rpcFakeConnection.reset(event.GetArg1());
//this is not used on this side
// m_rpcFakeConnection->DPL::EventSupport<AsyncCallEvent>::AddListener(this);
}
else{
++m_connections;
LogInfo("CLIENT: Acquiring new unix connection");
- m_rpcUnixConnection.Reset(event.GetArg1());
+ m_rpcUnixConnection.reset(event.GetArg1());
m_rpcUnixConnection->DPL::EventSupport<AsyncCallEvent>::AddListener(this);
}
if(m_connections == 2){
LogInfo("CLIENT: Starting thread event loop");
int ret = Exec();
- if (m_rpcUnixConnection.Get()){
+ if (m_rpcUnixConnection.get()){
LogInfo("CLIENT: Removing Unix connection");
m_rpcUnixConnection->DPL::EventSupport<AsyncCallEvent>::RemoveListener(this);
- m_rpcUnixConnection.Reset();
+ m_rpcUnixConnection.reset();
}
LogInfo("CLIENT: Closing");
- if (m_rpcFakeConnection.Get()){
+ if (m_rpcFakeConnection.get()){
LogInfo("CLIENT: Removing Fake connection");
//this is not used on this side
// m_rpcFakeConnection->DPL::EventSupport<AsyncCallEvent>::RemoveListener(this);
- m_rpcFakeConnection.Reset();
+ m_rpcFakeConnection.reset();
}
// Detach RPC client listener
DPL::UnixSocketRPCServer m_rpcUnixServer;
DPL::FakeRpcServer m_rpcFakeServer;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcUnixConnection;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcFakeConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcUnixConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcFakeConnection;
MyThread m_thread;
LogInfo("SERVER: Closing RPC connection...");
// Detach RPC connection listeners
- if (m_rpcUnixConnection.Get()) {
+ if (m_rpcUnixConnection.get()) {
//this is not used on this side
// m_rpcUnixConnection->DPL::EventSupport<AsyncCallEvent>::RemoveListener(this);
- m_rpcUnixConnection.Reset();
+ m_rpcUnixConnection.reset();
}
- if (m_rpcFakeConnection.Get()) {
+ if (m_rpcFakeConnection.get()) {
m_rpcFakeConnection->DPL::EventSupport<AsyncCallEvent>::RemoveListener(this);
- m_rpcFakeConnection.Reset();
+ m_rpcFakeConnection.reset();
}
LogInfo("SERVER: Closing Server");
// Save connection pointer
if (dynamic_cast<DPL::FakeRpcConnection *>(event.GetArg1())){
LogInfo("SERVER: Acquiring Fake RPC connection");
- m_rpcFakeConnection.Reset(event.GetArg1());
+ m_rpcFakeConnection.reset(event.GetArg1());
m_rpcFakeConnection->DPL::EventSupport<AsyncCallEvent>::AddListener(this);
}
else{
LogInfo("SERVER: Acquiring Unix RPC connection");
- m_rpcUnixConnection.Reset(event.GetArg1());
+ m_rpcUnixConnection.reset(event.GetArg1());
//this is not used on this side
// m_rpcUnixConnection->DPL::EventSupport<AsyncCallEvent>::AddListener(this);
}
* @version 1.0
* @brief This file is the implementation file of metronome client example
*/
+#include <stddef.h>
#include <dpl/tcp_socket_rpc_client.h>
#include <dpl/tcp_socket_rpc_connection.h>
#include <dpl/application.h>
{
private:
DPL::TcpSocketRPCClient m_rpcClient;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcConnection;
virtual void OnEventReceived(const DPL::AbstractRPCConnectionEvents::AsyncCallEvent &event)
{
{
// Save connection pointer
LogInfo("Connected to metronome server");
- m_rpcConnection.Reset(event.GetArg1());
+ m_rpcConnection.reset(event.GetArg1());
// Attach event listeners
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::AsyncCallEvent>::AddListener(this);
virtual ~MetronomeClientApplication()
{
// Delete all RPC connections
- if (m_rpcConnection.Get())
+ if (m_rpcConnection.get())
{
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::AsyncCallEvent>::RemoveListener(this);
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::ConnectionClosedEvent>::RemoveListener(this);
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::ConnectionBrokenEvent>::RemoveListener(this);
- m_rpcConnection.Reset();
+ m_rpcConnection.reset();
}
// Close RPC server
* @version 1.0
* @brief This file is the implementation file of metronome server example
*/
+#include <stddef.h>
#include <dpl/tcp_socket_rpc_server.h>
#include <dpl/tcp_socket_rpc_connection.h>
#include <dpl/controller.h>
* @version 1.0
* @brief This file is the implementation file of RPC example
*/
+#include <stddef.h>
#include <dpl/unix_socket_rpc_client.h>
#include <dpl/unix_socket_rpc_server.h>
#include <dpl/unix_socket_rpc_connection.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
#include <dpl/application.h>
#include <dpl/controller.h>
#include <dpl/thread.h>
{
private:
DPL::UnixSocketRPCClient m_rpcClient;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcConnection;
virtual void OnEventReceived(const DPL::AbstractRPCConnectionEvents::AsyncCallEvent &event)
{
{
// Save connection pointer
LogInfo("CLIENT: Acquiring new connection");
- m_rpcConnection.Reset(event.GetArg1());
+ m_rpcConnection.reset(event.GetArg1());
// Attach listener to new connection
LogInfo("CLIENT: Attaching connection event listeners");
int ret = Exec();
// Detach RPC listeners
- if (m_rpcConnection.Get())
+ if (m_rpcConnection.get())
{
LogInfo("CLIENT: Detaching RPC connection events");
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::AsyncCallEvent>::RemoveListener(this);
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::ConnectionBrokenEvent>::RemoveListener(this);
LogInfo("CLIENT: Resetting connection");
- m_rpcConnection.Reset();
+ m_rpcConnection.reset();
}
// Detach RPC client listener
{
private:
DPL::UnixSocketRPCServer m_rpcServer;
- DPL::ScopedPtr<DPL::AbstractRPCConnection> m_rpcConnection;
+ std::unique_ptr<DPL::AbstractRPCConnection> m_rpcConnection;
MyThread m_thread;
LogInfo("SERVER: Closing RPC connection on event...");
// Detach RPC connection listeners
- if (m_rpcConnection.Get())
+ if (m_rpcConnection.get())
{
LogInfo("SERVER: Detaching connection events");
m_rpcConnection->DPL::EventSupport<DPL::AbstractRPCConnectionEvents::AsyncCallEvent>::RemoveListener(this);
{
// Save connection pointer
LogInfo("SERVER: Acquiring RPC connection");
- m_rpcConnection.Reset(event.GetArg1());
+ m_rpcConnection.reset(event.GetArg1());
// Attach event listeners
LogInfo("SERVER: Attaching connection listeners");
* @version 1.0
* @brief This file is the implementation file of simple example
*/
+#include <stddef.h>
#include <dpl/log/log.h>
int main(int argc, char *argv[])
* @version 1.0
* @brief This file is the implementation file of single instance example
*/
+#include <stddef.h>
#include <dpl/single_instance.h>
#include <iostream>
* @version 1.0
* @brief This file is the implementation file of socket example
*/
+#include <stddef.h>
#include <dpl/unix_socket.h>
#include <dpl/abstract_socket.h>
#include <dpl/application.h>
* @version 1.0
* @brief This file is the implementation file of tcpsock example
*/
+#include <stddef.h>
#include <dpl/tcp_socket.h>
#include <dpl/abstract_socket.h>
#include <dpl/application.h>
* @version 1.0
* @brief This file is the implementation file of timed event example
*/
+#include <stddef.h>
#include <dpl/generic_event.h>
#include <dpl/application.h>
#include <dpl/controller.h>
include(rpc/config.cmake)
include(test/config.cmake)
include(log/config.cmake)
-ADD_SUBDIRECTORY(vcore)
-ADD_SUBDIRECTORY(ace)
ADD_SUBDIRECTORY(widget_dao)
-include(popup/config.cmake)
+ADD_SUBDIRECTORY(auto_save_dao)
+ADD_SUBDIRECTORY(security_origin_dao)
+ADD_SUBDIRECTORY(custom_handler_dao)
include(utils/config.cmake)
include(localization/config.cmake)
+include(support/config.cmake)
+include(encryption/config.cmake)
--- /dev/null
+SET(TARGET_AUTO_SAVE_DAO_DB "Sqlite3DbAutoSave")
+
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h
+ COMMAND ${CMAKE_SOURCE_DIR}/modules/auto_save_dao/orm/gen_db_md5.sh
+ ARGS ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h
+ ${CMAKE_SOURCE_DIR}/modules/auto_save_dao/orm/autosave_db
+ DEPENDS ${CMAKE_SOURCE_DIR}/modules/auto_save_dao/orm/autosave_db
+ ${CMAKE_SOURCE_DIR}/modules/auto_save_dao/orm/gen_db_md5.sh
+ COMMENT "Generating WRT auto save database checksum"
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .wrt_autosave.db
+ COMMAND rm -f ${CMAKE_CURRENT_BINARY_DIR}/.wrt_autosave.db
+ COMMAND gcc -Wall -include ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h -I${PROJECT_SOURCE_DIR}/modules/db/include -I${PROJECT_SOURCE_DIR}/modules/auto_save_dao/orm -E ${PROJECT_SOURCE_DIR}/modules/auto_save_dao/orm/autosave_db_sql_generator.h | grep --invert-match "^#" > ${CMAKE_CURRENT_BINARY_DIR}/wrt_autosave_db.sql
+ COMMAND sqlite3 ${CMAKE_CURRENT_BINARY_DIR}/.wrt_autosave.db ".read ${CMAKE_CURRENT_BINARY_DIR}/wrt_autosave_db.sql" || rm -f ${CMAKE_CURRENT_BINARY_DIR}/.wrt_autosave.db
+ DEPENDS ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h ${PROJECT_SOURCE_DIR}/modules/auto_save_dao/orm/autosave_db_sql_generator.h ${PROJECT_SOURCE_DIR}/modules/auto_save_dao/orm/autosave_db
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .wrt_autosave.db-journal
+ COMMAND touch
+ ARGS ${CMAKE_CURRENT_BINARY_DIR}/.wrt_autosave.db-journal
+ )
+
+ADD_CUSTOM_TARGET(${TARGET_AUTO_SAVE_DAO_DB} ALL DEPENDS .wrt_autosave.db .wrt_autosave.db-journal)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/wrt_autosave_db.sql DESTINATION share/wrt-engine/)
+
+###############################################################################
+
+INCLUDE(FindPkgConfig)
+
+PKG_CHECK_MODULES(AUTO_SAVE_DAO_DEPS
+ glib-2.0
+ REQUIRED)
+
+SET(AUTO_SAVE_DAO_INCLUDE_DIRS
+ ${PROJECT_SOURCE_DIR}/modules/auto_save_dao/include
+ ${PROJECT_SOURCE_DIR}/modules/auto_save_dao/orm
+ ${PROJECT_SOURCE_DIR}/modules/core/include
+ ${PROJECT_SOURCE_DIR}/modules/db/include
+ ${PROJECT_SOURCE_DIR}/modules/log/include
+)
+
+
+SET(AUTO_SAVE_DAO_SOURCES
+ dao/common_dao_types.cpp
+ dao/AutoSaveDatabase.cpp
+)
+
+SET(AUTO_SAVE_DAO_RO_SOURCES
+ dao/auto_save_dao_read_only.cpp
+)
+
+SET(AUTO_SAVE_DAO_RW_SOURCES
+ dao/auto_save_dao.cpp
+)
+
+
+INCLUDE_DIRECTORIES(${AUTO_SAVE_DAO_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${AUTO_SAVE_DAO_DEPS_INCLUDE_DIRS})
+
+ADD_LIBRARY(${TARGET_AUTO_SAVE_DAO_LIB} SHARED ${AUTO_SAVE_DAO_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_LIB} PROPERTIES COMPILE_FLAGS "-include ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h")
+TARGET_LINK_LIBRARIES(${TARGET_AUTO_SAVE_DAO_LIB} ${TARGET_DPL_EFL} ${TARGET_DPL_DB_EFL} ${AUTO_SAVE_DAO_DEPS_LIBRARIES})
+ADD_DEPENDENCIES(${TARGET_AUTO_SAVE_DAO_LIB} ${TARGET_AUTO_SAVE_DAO_DB})
+
+ADD_LIBRARY(${TARGET_AUTO_SAVE_DAO_RO_LIB} SHARED ${AUTO_SAVE_DAO_RO_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_RO_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_RO_LIB} PROPERTIES COMPILE_FLAGS "-include ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h")
+TARGET_LINK_LIBRARIES(${TARGET_AUTO_SAVE_DAO_RO_LIB} ${TARGET_AUTO_SAVE_DAO_LIB})
+ADD_DEPENDENCIES(${TARGET_AUTO_SAVE_DAO_RO_LIB} ${TARGET_AUTO_SAVE_DAO_DB})
+
+ADD_LIBRARY(${TARGET_AUTO_SAVE_DAO_RW_LIB} SHARED ${AUTO_SAVE_DAO_RW_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_RW_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+SET_TARGET_PROPERTIES(${TARGET_AUTO_SAVE_DAO_RW_LIB} PROPERTIES COMPILE_FLAGS "-include ${CMAKE_BINARY_DIR}/modules/auto_save_dao/database_checksum_autosave.h")
+TARGET_LINK_LIBRARIES(${TARGET_AUTO_SAVE_DAO_RW_LIB} ${TARGET_AUTO_SAVE_DAO_RO_LIB})
+ADD_DEPENDENCIES(${TARGET_AUTO_SAVE_DAO_RW_LIB} ${TARGET_AUTO_SAVE_DAO_DB})
+
+INSTALL(TARGETS ${TARGET_AUTO_SAVE_DAO_LIB} DESTINATION lib)
+INSTALL(TARGETS ${TARGET_AUTO_SAVE_DAO_RO_LIB} DESTINATION lib)
+INSTALL(TARGETS ${TARGET_AUTO_SAVE_DAO_RW_LIB} DESTINATION lib)
+
+INSTALL(FILES
+ include/wrt-commons/auto-save-dao/common_dao_types.h
+ include/wrt-commons/auto-save-dao/AutoSaveDatabase.h
+ DESTINATION include/dpl-efl/wrt-commons/auto-save-dao
+)
+
+INSTALL(FILES
+ include/wrt-commons/auto-save-dao-ro/auto_save_dao_read_only.h
+ DESTINATION include/dpl-efl/wrt-commons/auto-save-dao-ro
+)
+
+INSTALL(FILES
+ include/wrt-commons/auto-save-dao-rw/auto_save_dao.h
+ DESTINATION include/dpl-efl/wrt-commons/auto-save-dao-rw
+)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <stddef.h>
+#include <wrt-commons/auto-save-dao/AutoSaveDatabase.h>
+
+using namespace AutoSaveDB;
+
+namespace {
+const char* AUTOSAVE_DB_DATABASE = "/opt/dbspace/.wrt_autosave.db";
+DPL::DB::SqlConnection::Flag::Type AUTOSAVE_DB_FLAGS =
+ DPL::DB::SqlConnection::Flag::UseLucene;
+}
+
+DPL::Mutex g_autoSaveDbQueriesMutex;
+DPL::DB::ThreadDatabaseSupport Interface::m_autoSavedbInterface(
+ AUTOSAVE_DB_DATABASE, AUTOSAVE_DB_FLAGS);
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file auto_save_dao.cpp
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the definition of auto save dao class.
+ */
+#include <stddef.h>
+#include <wrt-commons/auto-save-dao-rw/auto_save_dao.h>
+#include <wrt-commons/auto-save-dao/AutoSaveDatabase.h>
+#include <orm_generator_autosave.h>
+#include <dpl/foreach.h>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::autosave;
+using namespace AutoSaveDB::Interface;
+
+namespace AutoSaveDB {
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
+ Catch(DPL::DB::SqlConnection::Exception::Base) { \
+ LogError(message); \
+ ReThrowMsg(AutoSaveDAO::Exception::DatabaseError, \
+ message); \
+ }
+
+AutoSaveDAO::AutoSaveDAO() :
+ AutoSaveDAOReadOnly()
+{
+}
+
+AutoSaveDAO::~AutoSaveDAO()
+{
+}
+
+void AutoSaveDAO::attachDatabaseRW(void)
+{
+ m_autoSavedbInterface.AttachToThread(
+ DPL::DB::SqlConnection::Flag::RW);
+}
+
+void AutoSaveDAO::detachDatabase(void)
+{
+ m_autoSavedbInterface.DetachFromThread();
+}
+
+void AutoSaveDAO::setAutoSaveSubmitFormData(const DPL::String &url,
+ const SubmitFormData &submitFormData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_autoSavedbInterface);
+
+ SubmitFormData submitData = getAutoSaveSubmitFormData(url);
+ if (!submitData.empty()) {
+ AUTOSAVE_DB_DELETE(del,
+ AutoSaveSubmitFormElement,
+ &m_autoSavedbInterface)
+ del->Where(Equals<AutoSaveSubmitFormElement::address>(url));
+ del->Execute();
+ }
+
+ FOREACH(pSubmitFormData, submitFormData) {
+ AutoSaveSubmitFormElement::Row row;
+ row.Set_address(url);
+ row.Set_key(pSubmitFormData->key);
+ row.Set_value(pSubmitFormData->value);
+
+ AUTOSAVE_DB_INSERT(
+ insert, AutoSaveSubmitFormElement, &m_autoSavedbInterface);
+ insert->Values(row);
+ insert->Execute();
+ }
+
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END(
+ "Fail to register id, passwd for autosave")
+}
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
+
+} // namespace AutoSaveDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of auto save dao class.
+ *
+ * @file auto_save_dao_read_only.cpp
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of auto save dao
+ */
+#include <stddef.h>
+#include <wrt-commons/auto-save-dao-ro/auto_save_dao_read_only.h>
+#include <wrt-commons/auto-save-dao/AutoSaveDatabase.h>
+#include <orm_generator_autosave.h>
+#include <dpl/foreach.h>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::autosave;
+using namespace AutoSaveDB::Interface;
+
+
+namespace AutoSaveDB {
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
+ Catch(DPL::DB::SqlConnection::Exception::Base) { \
+ LogError(message); \
+ ReThrowMsg(AutoSaveDAOReadOnly::Exception::DatabaseError, \
+ message); \
+ }
+
+AutoSaveDAOReadOnly::AutoSaveDAOReadOnly()
+{
+}
+
+AutoSaveDAOReadOnly::~AutoSaveDAOReadOnly()
+{
+}
+
+void AutoSaveDAOReadOnly::attachDatabaseRO(void)
+{
+ m_autoSavedbInterface.AttachToThread(
+ DPL::DB::SqlConnection::Flag::RO);
+}
+
+void AutoSaveDAOReadOnly::detachDatabase(void)
+{
+ m_autoSavedbInterface.DetachFromThread();
+}
+
+SubmitFormData AutoSaveDAOReadOnly::getAutoSaveSubmitFormData(
+ const DPL::String &url)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ AUTOSAVE_DB_SELECT(select, AutoSaveSubmitFormElement, &m_autoSavedbInterface);
+ select->Where(Equals<AutoSaveSubmitFormElement::address>(url));
+ AutoSaveSubmitFormElement::Select::RowList rows = select->GetRowList();
+
+ SubmitFormData submitFormData;
+ FOREACH(it, rows) {
+ SubmitFormElement element;
+ element.key = it->Get_key();
+ element.value = it->Get_value();
+ submitFormData.push_back(element);
+ }
+ return submitFormData;
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get autosave data string")
+}
+
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
+
+} // namespace AutoSaveDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file common_dao_types.cpp
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the implementation of
+ * common data types for autoSavedb
+ */
+#include <stddef.h>
+#include <wrt-commons/auto-save-dao/common_dao_types.h>
+#include <dpl/log/log.h>
+
+namespace AutoSaveDB {
+} // namespace AutoSaveDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of auto save dao class.
+ *
+ * @file auto_save_dao_read_only.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of auto save dao
+ */
+
+#ifndef _AUTO_SAVE_DAO_READ_ONLY_H_
+#define _AUTO_SAVE_DAO_READ_ONLY_H_
+
+#include <dpl/string.h>
+#include <dpl/exception.h>
+#include <dpl/optional.h>
+#include <wrt-commons/auto-save-dao/common_dao_types.h>
+
+namespace AutoSaveDB {
+
+class AutoSaveDAOReadOnly
+{
+ public:
+ /**
+ * AutoSaveDAOReadOnly Exception classes
+ */
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
+ };
+
+ public:
+
+ AutoSaveDAOReadOnly();
+ virtual ~AutoSaveDAOReadOnly();
+
+ static void attachDatabaseRO(void);
+ static void detachDatabase(void);
+
+ /**
+ * This method gets Autofill for Webkit
+ */
+ static SubmitFormData getAutoSaveSubmitFormData(
+ const DPL::String &url);
+
+};
+
+} // namespace AutoSaveDB
+
+#endif // _AUTO_SAVE_DAO_READ_ONLY_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of auto save dao class.
+ *
+ * @file auto_save_dao.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of auto save dao
+ */
+#ifndef _AUTO_SAVE_DAO_H_
+#define _AUTO_SAVE_DAO_H_
+
+#include <wrt-commons/auto-save-dao-ro/auto_save_dao_read_only.h>
+
+namespace AutoSaveDB {
+
+class AutoSaveDAO : public AutoSaveDAOReadOnly
+{
+ public:
+
+ AutoSaveDAO();
+ virtual ~AutoSaveDAO();
+
+ static void attachDatabaseRW(void);
+ static void detachDatabase(void);
+
+ /**
+ * This method sets Autofill for Webkit
+ */
+ static void setAutoSaveSubmitFormData(
+ const DPL::String& url, const SubmitFormData &submitFormData);
+};
+
+} // namespace AutoSaveDB
+
+#endif // _AUTO_SAVE_DAO_H_
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _AUTOSAVEDATABASE_H_
+#define _AUTOSAVEDATABASE_H_
+
+#include <dpl/thread.h>
+#include <dpl/mutex.h>
+#include <dpl/db/thread_database_support.h>
+
+extern DPL::Mutex g_autoSaveDbQueriesMutex;
+
+#define AUTOSAVE_DB_INTERNAL(tlsCommand, InternalType, interface) \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ { \
+ DPL::Mutex::ScopedLock lock(&g_autoSaveDbQueriesMutex); \
+ if (!tlsCommand ## Ptr) { \
+ static DPL::ThreadLocalVariable<InternalType> tmp; \
+ tlsCommand ## Ptr = &tmp; \
+ } \
+ } \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
+
+#define AUTOSAVE_DB_SELECT(name, type, interface) \
+ AUTOSAVE_DB_INTERNAL(name, type::Select, interface)
+
+#define AUTOSAVE_DB_INSERT(name, type, interface) \
+ AUTOSAVE_DB_INTERNAL(name, type::Insert, interface)
+
+#define AUTOSAVE_DB_UPDATE(name, type, interface) \
+ AUTOSAVE_DB_INTERNAL(name, type::Update, interface)
+
+#define AUTOSAVE_DB_DELETE(name, type, interface) \
+ AUTOSAVE_DB_INTERNAL(name, type::Delete, interface)
+
+namespace AutoSaveDB {
+namespace Interface {
+
+extern DPL::DB::ThreadDatabaseSupport m_autoSavedbInterface;
+
+} // namespace Interface
+} // namespace AutoSaveDB
+
+#endif /* _AUTOSAVEDATABASE_H_ */
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file common_dao_types.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of
+ * common data types for auto save database.
+ */
+#ifndef SHARE_COMMON_DAO_TYPES_H_
+#define SHARE_COMMON_DAO_TYPES_H_
+
+#include <list>
+#include <dpl/string.h>
+
+namespace AutoSaveDB {
+
+struct SubmitFormElement
+{
+ DPL::String key;
+ DPL::String value;
+
+ SubmitFormElement()
+ {
+ }
+
+ SubmitFormElement(
+ const DPL::String& keyData,
+ const DPL::String& valueData) :
+ key(keyData),
+ value(valueData)
+ {
+ }
+
+ bool operator== (const SubmitFormElement& other) const
+ {
+ return (!DPL::StringCompare(key, other.key) &&
+ !DPL::StringCompare(value, other.value));
+ }
+
+ bool operator!= (const SubmitFormElement& other) const
+ {
+ return !(*this == other);
+ }
+};
+typedef std::list<SubmitFormElement> SubmitFormData;
+
+} // namespace AutoSaveDB
+
+#endif /* SHARE_COMMON_DAO_TYPES_H_ */
--- /dev/null
+SQL(
+ BEGIN TRANSACTION;
+)
+
+CREATE_TABLE(AutoSaveSubmitFormElement)
+ COLUMN_NOT_NULL(address, VARCHAR(256),)
+ COLUMN_NOT_NULL(key, TEXT,)
+ COLUMN_NOT_NULL(value, TEXT,)
+CREATE_TABLE_END()
+
+SQL(
+ COMMIT;
+)
--- /dev/null
+DATABASE_START(autosave)
+
+#include "autosave_db"
+#include "version_db"
+
+DATABASE_END()
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file autosave_db_sql_generator.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief Macro definitions for generating the SQL
+ * input file from database definition.
+ */
+
+//Do not include this file directly! It is used only for SQL code generation.
+#include <dpl/db/orm_macros.h>
+
+#include "autosave_db_definitions"
--- /dev/null
+#!/bin/sh
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+CHECKSUM=`cat ${2} ${3} 2>/dev/null | md5sum 2>/dev/null | cut -d\ -f1 2>/dev/null`
+echo "#define DB_CHECKSUM DB_VERSION_${CHECKSUM}" > ${1}
+echo "#define DB_CHECKSUM_STR \"DB_VERSION_${CHECKSUM}\"" >> ${1}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _ORM_GENERATOR_AUTOSAVE_H_
+#define _ORM_GENERATOR_AUTOSAVE_H_
+
+#define ORM_GENERATOR_DATABASE_NAME autosave_db_definitions
+#include <dpl/db/orm_generator.h>
+#undef ORM_GENERATOR_DATABASE_NAME
+
+#endif // _ORM_GENERATOR_AUTOSAVE_H_
--- /dev/null
+SQL(
+ BEGIN TRANSACTION;
+ CREATE TABLE DB_CHECKSUM (version INT);
+ COMMIT;
+)
${PROJECT_SOURCE_DIR}/modules/core/src/exception.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/fast_delegate.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/file_input.cpp
- ${PROJECT_SOURCE_DIR}/modules/core/src/file_input_mapping.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/file_output.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/lexical_cast.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/mutex.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/named_base_pipe.cpp
- ${PROJECT_SOURCE_DIR}/modules/core/src/named_input_pipe.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/named_output_pipe.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/noncopyable.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/once.cpp
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/apply.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/assert.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/atomic.h
+ ${PROJECT_SOURCE_DIR}/modules/core/include/dpl/auto_ptr.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/binary_queue.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/bool_operator.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/char_traits.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/exception.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/fast_delegate.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/file_input.h
- ${PROJECT_SOURCE_DIR}/modules/core/include/dpl/file_input_mapping.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/file_output.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/foreach.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/generic_event.h
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file auto_ptr.h
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @author Tomasz Swierczek (t.swierczek@samsung.com)
+ * @version 1.0
+ * @brief This file contais definictions of specific AutoPtr class.
+ */
+#ifndef _AUTO_PTR_H_
+#define _AUTO_PTR_H_
+
+#include <list>
+#include <set>
+#include <string>
+
+namespace DPL {
+/*
+ * base deleter func
+ */
+template <typename T>
+struct UniversalFree {};
+
+// Template Specialization
+#define DECLARE_DELETER(type, function) \
+ template <> \
+ struct UniversalFree <type> { \
+ void universal_free(type *ptr){ \
+ if (ptr) { \
+ function(ptr); } \
+ } \
+ };
+
+template <typename T>
+class AutoPtr
+{
+ public:
+ AutoPtr(T *ptr) :
+ m_data(ptr)
+ {
+ }
+
+ AutoPtr(const AutoPtr<T> &second)
+ {
+ m_data = second.m_data;
+ second.m_data = 0;
+ }
+
+ AutoPtr & operator=(const AutoPtr &second)
+ {
+ if (this != &second) {
+ UniversalFree<T> deleter;
+ deleter.universal_free(m_data);
+ m_data = second.m_data;
+ second.m_data = 0;
+ }
+ return *this;
+ }
+
+ /**
+ * overloaded -> operator, so smart ptr could act as ordinary ptr
+ */
+ T* operator->()
+ {
+ return m_data;
+ }
+
+ ~AutoPtr()
+ {
+ UniversalFree<T> deleter;
+ deleter.universal_free(m_data);
+ }
+
+ /**
+ * get internal pointer
+ */
+ T* get(void)
+ {
+ return m_data;
+ }
+
+ private:
+ mutable T *m_data;
+};
+} // namespace DPL
+
+#endif // AUTO_PTR
#ifndef DPL_NAMED_PIPE_H
#define DPL_NAMED_PIPE_H
-#include <dpl/noncopyable.h>
#include <dpl/exception.h>
-#include <dpl/abstract_waitable_input.h>
#include <dpl/named_base_pipe.h>
+#include <dpl/file_input.h>
namespace DPL
{
class NamedInputPipe
- : private Noncopyable,
- public NamedBasePipe,
- public AbstractWaitableInput
-{
-public:
- class Exception
- {
- public:
- DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
- DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
- DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
- };
-
-protected:
- int m_fifo;
-
-public:
- NamedInputPipe();
- virtual ~NamedInputPipe();
-
- void Open(const std::string &fileName);
- void Close();
-
- // AbstractInput
- virtual BinaryQueueAutoPtr Read(size_t size);
-
- // AbstractWaitableInput
- virtual WaitableHandle WaitableReadHandle() const;
-};
+ : public NamedBasePipe,
+ public FileInput
+{};
} // namespace DPL
#endif // DPL_NAMED_PIPE_H
sem_t *InternalGet() const;
void InternalDestroy();
+public:
+ /**
+ * decrement the semaphore counter
+ */
void Lock() const;
- void Unlock() const;
-public:
/**
+ * increment the semaphore counter
+ */
+ void Unlock() const;
+
+ /**
* Remove a named semaphore
*
* @param fileName Name of the semaphore
#include <dpl/noncopyable.h>
#include <dpl/atomic.h>
#include <dpl/bool_operator.h>
-#include <cstddef>
+#include <stddef.h>
#include <dpl/assert.h>
namespace DPL
static void ResetThreadGuard();
};
-//This is needed for backward compatibility
-#ifndef SEPARATED_SINGLETON_IMPLEMENTATION
-template<typename Class>
-Singleton<Class>& Singleton<Class>::InternalInstance()
-{
- static Singleton<Class> instance;
- return instance;
-}
-
-template<typename Class>
-Class &Singleton<Class>::Instance()
-{
- Singleton<Class>& instance = Singleton<Class>::InternalInstance();
-
- if (!!instance.m_guard)
- {
- Assert(Thread::GetCurrentThread() == *instance.m_guard &&
- "Singleton thread guard failed. A forbidden call from foreign thread was detected!");
- }
-
- return instance;
-}
-
-// Thread guarding
-template<typename Class>
-void Singleton<Class>::SetThreadGuard(Thread *thread)
-{
- Singleton<Class>& instance = Singleton<Class>::InternalInstance();
- instance.m_guard = OptionalThreadPtr(thread);
-}
-
-template<typename Class>
-void Singleton<Class>::ResetThreadGuard()
-{
- Singleton<Class>& instance = Singleton<Class>::InternalInstance();
- instance.m_guard = OptionalThreadPtr::Null;
-}
-
-#endif
-
} // namespace DPL
#endif // DPL_SINGLETON_H
#ifndef DPL_TASK_H
#define DPL_TASK_H
-#include <dpl/scoped_array.h>
#include <dpl/noncopyable.h>
-#include <dpl/union_cast.h>
-#include <dpl/semaphore.h>
#include <dpl/foreach.h>
-#include <dpl/mutex.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
#include <algorithm>
-#include <sstream>
-#include <iomanip>
#include <list>
-#include <stack>
-#include <cctype>
namespace DPL
{
return static_cast<size_t>(m_steps.size());
}
};
-
-template<typename ImplementationType>
-class MultiTaskDecl
- : public Task
-{
-protected:
- typedef void (ImplementationType::*Step)();
- typedef std::list<Step> StepList;
- typedef std::stack<Step> StepStack;
-
-private:
- static std::string StepToString(Step step)
- {
- std::ostringstream pseudoAddressStream;
- pseudoAddressStream << std::hex << union_cast<size_t>(step);
-
- std::string pseudoAddress = pseudoAddressStream.str();
-
- std::transform(pseudoAddress.begin(), pseudoAddress.end(),
- pseudoAddress.begin(), ::toupper);
-
- return std::string("0x") + pseudoAddress;
- }
-
- struct ConditionalStep
- {
- Step step;
-
- // Depencency lists
- StepList unsatisfiedDependencies;
- StepList satisfiedDependencies;
-
- ConditionalStep()
- : step(NULL)
- {
- }
-
- ConditionalStep(Step stepArg,
- StepList dependenciesArg)
- : step(stepArg),
- unsatisfiedDependencies(dependenciesArg)
- {
- }
- };
-
- typedef std::list<ConditionalStep> ConditionalStepList;
-
- // Synchronization
- Semaphore m_activeStepsSemaphore;
- mutable Mutex m_dependencyListMutex;
-
- // Those steps that have their dependency lists satified and are ready
- // to be executed
- // Current step is defined to be the front of satisfied list
- ConditionalStepList m_satisfiedSteps;
-
- // Those steps that are going to be executed but their dependency
- // lists have not been satified
- ConditionalStepList m_unsatisfiedSteps;
-
- // Those steps that have their dependency lists satified and are currently
- // being executed
- ConditionalStepList m_executingSteps;
-
- // Those steps that have been executed with their dependency lists
- // satisfied
- ConditionalStepList m_historicSteps;
-
- ///< Growing list of submitted abort steps
- StepStack m_abortSteps;
-
- // Deriving implementation
- ImplementationType *m_implementation;
-
- // Max parallel steps
- size_t m_maxParallelCount;
-
- ///< Valid in dependency list mutex only
- void SatisfyDependencies(const ConditionalStep &conditionalStep)
- {
- LogPedantic("Satisfying steps with dependecy to step: "
- << StepToString(conditionalStep.step));
-
- // Can satisfy conditional steps if and only if there are no more
- // satisfied, unsatisfied or running same steps
- // There is at least one historic step - this one
- if (IsContainingStep(conditionalStep.step, m_unsatisfiedSteps) ||
- IsContainingStep(conditionalStep.step, m_satisfiedSteps) ||
- IsContainingStep(conditionalStep.step, m_executingSteps))
- {
- LogPedantic("Step " << StepToString(conditionalStep.step)
- << " cannot satify other steps yet");
-
- return;
- }
-
- LogPedantic("Step " << StepToString(conditionalStep.step)
- << " can satify other steps");
-
- // Do satisfy
- typename ConditionalStepList::iterator unsatisfiedStepIterator =
- m_unsatisfiedSteps.begin();;
-
- while (unsatisfiedStepIterator != m_unsatisfiedSteps.end())
- {
- typename StepList::iterator iterator =
- std::find(
- unsatisfiedStepIterator->unsatisfiedDependencies.begin(),
- unsatisfiedStepIterator->unsatisfiedDependencies.end(),
- conditionalStep.step);
-
- // Does this conditional step need to be satisfied ?
- if (iterator ==
- unsatisfiedStepIterator->unsatisfiedDependencies.end())
- {
- continue;
- }
-
- LogPedantic("Satisfying step "
- << StepToString(unsatisfiedStepIterator->step)
- << " dependency to step "
- << StepToString(conditionalStep.step));
-
- // Satisfy dependency
- unsatisfiedStepIterator->unsatisfiedDependencies.erase(
- iterator);
-
- unsatisfiedStepIterator->satisfiedDependencies.push_back(
- conditionalStep.step);
-
- // If step is fully satisfied, transfer it to the satisfied
- // steps list
- if (unsatisfiedStepIterator->unsatisfiedDependencies.empty())
- {
- LogPedantic("Step "
- << StepToString(unsatisfiedStepIterator->step)
- << " is fully satisfied");
-
- // Move step
- m_satisfiedSteps.push_back(*unsatisfiedStepIterator);
-
- unsatisfiedStepIterator =
- m_unsatisfiedSteps.erase(unsatisfiedStepIterator);
-
- continue;
- }
-
- // Check next unsatisfied step
- ++unsatisfiedStepIterator;
- }
- }
-
- ///< Valid in dependency list mutex only
- bool IsContainingStep(Step step, const ConditionalStepList &dependencies) const
- {
- FOREACH (iterator, dependencies)
- if (iterator->step == step)
- return true;
-
- return false;
- }
-
- ///< Valid in dependency list mutex only
- bool IsStepDependecyListSatisfied(
- const StepList &dependencies) const
- {
- // All dependant step must be historic
- FOREACH (iterator, dependencies)
- if (!IsContainingStep(*iterator, m_historicSteps))
- return false;
-
- // Also, none dependant step can exist in
- // unsatisfied/satisfied/inProgress lists
- FOREACH (iterator, dependencies)
- {
- if (IsContainingStep(*iterator, m_unsatisfiedSteps) ||
- IsContainingStep(*iterator, m_satisfiedSteps) ||
- IsContainingStep(*iterator, m_executingSteps))
- {
- return false;
- }
- }
-
- return true;
- }
-
- bool AbortInternal()
- {
- // Clear all steps and construct
- // a single-dependency list of abort steps
- m_unsatisfiedSteps.clear();
- m_satisfiedSteps.clear();
- m_executingSteps.clear();
- m_historicSteps.clear();
-
- if (m_abortSteps.empty())
- return false;
-
- // Register last abort step as satisfied
- m_satisfiedSteps.push_back(
- ConditionalStep(
- m_abortSteps.top(),
- StepList()));
-
- Step lastStep = m_abortSteps.top();
- m_abortSteps.pop();
-
- // Create abort step list
- while (!m_abortSteps.empty())
- {
- // Add next unsatisfied step
- StepList dependencies;
- dependencies.push_back(lastStep);
-
- m_unsatisfiedSteps.push_back(
- ConditionalStep(
- m_abortSteps.top(),
- dependencies));
-
- // Remove top abort step
- lastStep = m_abortSteps.top();
- m_abortSteps.pop();
- }
-
- return true;
- }
-
-protected:
- void AddStep(Step step,
- const StepList &dependencies)
- {
- Mutex::ScopedLock lock(&m_dependencyListMutex);
-
- LogPedantic("Adding step: " << StepToString(step));
-
- FOREACH (iterator, dependencies)
- LogPedantic(" Dependency: " << StepToString(*iterator));
-
- // Add step to proper list
- if (IsStepDependecyListSatisfied(dependencies))
- {
- m_satisfiedSteps.push_back(ConditionalStep(step, dependencies));
-
- LogPedantic("Step " << StepToString(step) << " is satisfied");
- }
- else
- {
- m_unsatisfiedSteps.push_back(ConditionalStep(step, dependencies));
-
- LogPedantic("Step " << StepToString(step) << " is unsatisfied");
- }
-
- LogPedantic("Satisfied step count: " << m_satisfiedSteps.size());
- LogPedantic("Unsatisfied step count: " << m_unsatisfiedSteps.size());
- }
-
- void AddAbortStep(Step step)
- {
- Mutex::ScopedLock lock(&m_dependencyListMutex);
-
- m_abortSteps.push_front(step);
-
- LogPedantic("Abort step count: " << m_abortSteps.size());
- }
-
-public:
- MultiTaskDecl(ImplementationType *implementation,
- size_t maxParallelCount)
- : m_activeStepsSemaphore(maxParallelCount),
- m_implementation(implementation),
- m_maxParallelCount(maxParallelCount)
- {
- }
-
- bool NextStep()
- {
- ConditionalStep stepToExecute;
- typename ConditionalStepList::iterator executingStepIterator;
-
- // Take the main semaphore lock
- Semaphore::ScopedLock semaphoreLock(&m_activeStepsSemaphore);
-
- // Take the dependency list lock
- {
- Mutex::ScopedLock listLock(&m_dependencyListMutex);
-
- // Get next step to execute
- if (m_satisfiedSteps.empty())
- {
- LogPedantic("No more satisfied steps to execute");
- return false;
- }
-
- // Get next satisfied step to execute
- stepToExecute = m_satisfiedSteps.front();
- m_satisfiedSteps.pop_front();
-
- // Register it in executing step list
- m_executingSteps.push_back(stepToExecute);
- executingStepIterator = --m_executingSteps.end();
-
- // Leave the dependency list lock
- }
-
- // Execute step
- (*m_implementation.*stepToExecute.step)();
-
- // Take a lock again
- {
- Mutex::ScopedLock listLock(&m_dependencyListMutex);
-
- // Unregister executing step
- m_executingSteps.erase(executingStepIterator);
-
- // Add historic step
- m_historicSteps.push_back(stepToExecute);
-
- // Satisfy dependencies
- SatisfyDependencies(stepToExecute);
-
- // Leave lock
- }
-
- // Done
- return true;
- }
-
- bool Abort()
- {
- // Wait until all active steps are done
- // This is achieved by taking all semaphore slots
- ScopedArray<Semaphore::ScopedLock *> semaphoreLocks(
- new Semaphore::ScopedLock *[m_maxParallelCount]);
-
- for (size_t i = 0; i < m_maxParallelCount; ++i)
- semaphoreLocks[i] = new Semaphore::ScopedLock(
- &m_activeStepsSemaphore);
-
- // Result
- bool result;
-
- // Take step lists lock
- {
- Mutex::ScopedLock mutexLock(&m_dependencyListMutex);
-
- // Do internal abort
- result = AbortInternal();
-
- // Leave steps list lock
- }
-
- // Leave semaphore locks
- for (size_t i = 0; i < m_maxParallelCount; ++i)
- delete semaphoreLocks[i];
-
- // Return result
- return result;
- }
-
- size_t GetStepCount() const
- {
- // Return sum of sizes of all lists
- Mutex::ScopedLock lock(&m_dependencyListMutex);
-
- return static_cast<size_t>(
- m_unsatisfiedSteps.size() +
- m_satisfiedSteps.size() +
- m_executingSteps.size() +
- m_historicSteps.size());
- }
-};
} // namespace DPL
#endif // DPL_TASK_H
void Quit();
/**
+ * Checks if current thread is main one
+ * Returns true if it is main program thread, false otherwise
+ */
+ static bool IsMainThread();
+
+ /**
* Current thread retrieval
* Returns DPL thread handle or NULL if it is main program thread
*/
public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, NullReference)
+ DECLARE_EXCEPTION_TYPE(Base, KeyCreateFailed)
};
private:
// If yes, pthread_exit(NULL) is required
if (!g_TLSforMainCreated)
{
- if (Thread::GetCurrentThread() == NULL)
+ if (Thread::IsMainThread())
{
g_TLSforMainCreated = true;
atexit(&MainThreadExitClean);
ThreadLocalVariable()
{
int result = pthread_key_create(&m_key, &InternalDestroy);
-
- Assert(result == 0 &&
- "Failed to allocate thread local variable");
+ if (result != 0) {
+ ThrowMsg(typename Exception::KeyCreateFailed,
+ "Failed to allocate thread local variable: " << result);
+ }
}
~ThreadLocalVariable()
typedef std::pair<size_t, size_t> FileHandle;
- struct FileDateTime
- {
- unsigned int second; //< seconds after the minute - [0,59]
- unsigned int minute; //< minutes after the hour - [0,59]
- unsigned int hour; //< hours since midnight - [0,23]
- unsigned int day; //< day of the month - [1,31]
- unsigned int month; //< months since January - [0,11]
- unsigned int year; //< years - [1980..2044]
-
- FileDateTime()
- : second(0),
- minute(0),
- hour(0),
- day(0),
- month(0),
- year(0)
- {
- }
-
- FileDateTime(unsigned int secondArg,
- unsigned int minuteArg,
- unsigned int hourArg,
- unsigned int dayArg,
- unsigned int monthArg,
- unsigned int yearArg)
- : second(secondArg),
- minute(minuteArg),
- hour(hourArg),
- day(dayArg),
- month(monthArg),
- year(yearArg)
- {
- }
- };
-
struct FileInfo
{
// File handle
std::string comment;
// File information
- unsigned long version; //< version made by
- unsigned long versionNeeded; //< version needed to extract
- unsigned long flag; //< general purpose bit flag
- unsigned long compressionMethod; //< compression method
- unsigned long dosDate; //< last mod file date in Dos fmt
- unsigned long crc; //< crc-32
off64_t compressedSize; //< compressed size
off64_t uncompressedSize; //< uncompressed size
- unsigned long diskNumberStart; //< disk number start
- unsigned long internalFileAttributes; //< internal file attributes
- unsigned long externalFileAttributes; //< external file attributes
-
- FileDateTime dateTime;
FileInfo()
: handle(),
name(),
comment(),
- version(0),
- versionNeeded(0),
- flag(0),
- compressionMethod(0),
- dosDate(0),
- crc(0),
compressedSize(0),
- uncompressedSize(0),
- diskNumberStart(0),
- internalFileAttributes(0),
- externalFileAttributes(0),
- dateTime()
+ uncompressedSize(0)
{
}
FileInfo(const FileHandle &handleArg,
const std::string &nameArg,
const std::string &commentArg,
- unsigned long versionArg,
- unsigned long versionNeededArg,
- unsigned long flagArg,
- unsigned long compressionMethodArg,
- unsigned long dosDateArg,
- unsigned long crcArg,
const off64_t &compressedSizeArg,
- const off64_t &uncompressedSizeArg,
- unsigned long diskNumberStartArg,
- unsigned long internalFileAttributesArg,
- unsigned long externalFileAttributesArg,
- const FileDateTime &dateTimeArg)
+ const off64_t &uncompressedSizeArg)
: handle(handleArg),
name(nameArg),
comment(commentArg),
- version(versionArg),
- versionNeeded(versionNeededArg),
- flag(flagArg),
- compressionMethod(compressionMethodArg),
- dosDate(dosDateArg),
- crc(crcArg),
compressedSize(compressedSizeArg),
- uncompressedSize(uncompressedSizeArg),
- diskNumberStart(diskNumberStartArg),
- internalFileAttributes(internalFileAttributesArg),
- externalFileAttributes(externalFileAttributesArg),
- dateTime(dateTimeArg)
+ uncompressedSize(uncompressedSizeArg)
{
}
};
bool empty() const;
/**
- * Open a binary file for given file handle
- *
- * @return file object
- * @param[in] handle Zip file handle to open
- * @exception std::bad_alloc Cannot allocate memory to hold additional data
- * @exception SteamOpenFailed Cannot find file with given handle
- * @see BinaryQueue::BufferDeleterFree
- */
- File *OpenFile(FileHandle handle);
-
- /**
* Open a binary file for given file name
*
* @return file object
* @version 1.0
* @brief This file is the implementation file of abstract waitable input adapter
*/
+#include <stddef.h>
#include <dpl/abstract_waitable_input_adapter.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of abstract waitable input output adapter
*/
+#include <stddef.h>
#include <dpl/abstract_waitable_input_output_adapter.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of abstract waitable output adapter
*/
+#include <stddef.h>
#include <dpl/abstract_waitable_output_adapter.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of address
*/
+#include <stddef.h>
#include <dpl/address.h>
#include <sstream>
#include <dpl/assert.h>
* @version 1.0
* @brief This file is the implementation file of MVC application support
*/
+#include <stddef.h>
#include <dpl/application.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of apply functionality
*/
+#include <stddef.h>
#include <dpl/apply.h>
//
* @version 1.0
* @brief This file is the implementation file of assert
*/
+#include <stddef.h>
#include <dpl/assert.h>
#include <dpl/colors.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of atomic
*/
+#include <stddef.h>
#include <dpl/atomic.h>
namespace DPL
Atomic::ValueType Atomic::ExchangeAndAdd(ValueType value)
{
- return g_atomic_int_exchange_and_add(&m_value, value);
+ return g_atomic_int_exchange_and_add(const_cast<gint* >(&m_value), value);
}
bool Atomic::CompareAndExchange(ValueType oldValue, ValueType newValue)
{
- return g_atomic_int_compare_and_exchange(&m_value, oldValue, newValue);
+ return g_atomic_int_compare_and_exchange(const_cast<gint* >(&m_value), oldValue, newValue);
}
bool Atomic::operator--()
{
- return g_atomic_int_dec_and_test(&m_value) != TRUE;
+ return g_atomic_int_dec_and_test(const_cast<gint* >(&m_value)) != TRUE;
}
void Atomic::operator++()
{
- g_atomic_int_inc(&m_value);
+ g_atomic_int_inc(const_cast<gint* >(&m_value));
}
Atomic::operator ValueType() const
{
- return g_atomic_int_get(&m_value);
+ return g_atomic_int_get(const_cast<gint* >(&m_value));
}
} // namespace DPL
* @version 1.0
* @brief This file is the implementation file of binary queue
*/
+#include <stddef.h>
#include <dpl/binary_queue.h>
#include <dpl/assert.h>
#include <dpl/scoped_free.h>
* @biref Char traits are used to create basic_string extended with additional features
* Current char traits could be extended in feature to boost performance
*/
+#include <stddef.h>
#include <dpl/char_traits.h>
//
* @brief Some constants with definition of colors for Console
* and html output
*/
-
+#include <stddef.h>
#include <dpl/colors.h>
* @version 1.0
* @brief This file is the implementation file of copy
*/
+#include <stddef.h>
#include <dpl/copy.h>
#include <dpl/waitable_handle.h>
#include <dpl/binary_queue.h>
* @version 1.0
* @brief This file is the implementation file of errno string
*/
+#include <stddef.h>
#include <dpl/errno_string.h>
#include <dpl/assert.h>
#include <dpl/exception.h>
* @version 1.0
* @brief This file is the implementation of exception system
*/
+#include <stddef.h>
#include <dpl/exception.h>
#include <dpl/log/log.h>
#include <cstdio>
* @version 1.0
* @brief This file is the implementation file of fast delegate
*/
+#include <stddef.h>
#include <dpl/fast_delegate.h>
* limitations under the License.
*/
/*
- * @file named_input_pipe.cpp
+ * @file file_input.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
* @brief This file is the implementation file of named input pipe
*/
+#include <stddef.h>
#include <dpl/file_input.h>
#include <dpl/binary_queue.h>
#include <dpl/log/log.h>
namespace DPL
{
+
namespace // anonymous
{
const size_t DEFAULT_READ_BUFFER_SIZE = 4096;
* @version 1.0
* @brief This file is the implementation file of file output
*/
+#include <stddef.h>
#include <dpl/file_output.h>
#include <dpl/binary_queue.h>
#include <dpl/scoped_free.h>
* @version 1.0
* @brief This file is the implementation file of MVC generic event
*/
+#include <stddef.h>
#include <dpl/generic_event.h>
//
* @version 1.0
* @brief Implementation file for lexical cast
*/
+#include <stddef.h>
#include <dpl/lexical_cast.h>
//
* @version 1.0
* @brief This file is the implementation file of main for EFL
*/
+#include <stddef.h>
#include <dpl/main.h>
#include <dpl/log/log.h>
#include <sys/select.h>
ecore_main_fd_handler_del(m_invokerHandler);
m_invokerHandler = NULL;
+ //set old ecore select function, because after ecore_shutdown() call,
+ //it is being called once again and it may crash.
+ ecore_main_loop_select_func_set(m_oldEcoreSelect);
// Decrement ECORE init count
// We do not need ecore routines any more
ecore_shutdown();
// GLIB loop intergration workaround
int Main::EcoreSelectInterceptor(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
-#if 0
- // Check each descriptor to see if it is valid
- for (int i = 0; i < nfds; i++)
- {
- if (FD_ISSET(i, readfds) || FD_ISSET(i, writefds) || FD_ISSET(i, exceptfds))
- {
- // Try to get descriptor flags
- int result = fcntl(i, F_GETFL);
-
- if (result == -1)
- {
- if (errno == EBADF)
- {
- // This a bad descriptor. Remove all occurrences of it.
- if (FD_ISSET(i, readfds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad read descriptor: " << i);
- FD_CLR(i, readfds);
- }
-
- if (FD_ISSET(i, writefds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad write descriptor: " << i);
- FD_CLR(i, writefds);
- }
-
- if (FD_ISSET(i, exceptfds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad exception descriptor: " << i);
- FD_CLR(i, exceptfds);
- }
- }
- else
- {
- // Unexpected error
- Assert(0);
- }
- }
- }
- }
-
- // Find out new maximum
- int newNfds = 0;
-
- for (int i = 0; i < nfds; i++)
- {
- if (FD_ISSET(i, readfds) || FD_ISSET(i, writefds) || FD_ISSET(i, exceptfds))
- newNfds = i;
- }
-
- return MainSingleton::Instance().m_oldEcoreSelect(newNfds + 1, readfds, writefds, exceptfds, timeout);
-
-#else
-
// We have to check error code here and make another try because of some glib error's.
fd_set rfds, wfds, efds;
memcpy(&rfds, readfds, sizeof(fd_set));
}
return ret;
-#endif
}
#endif // DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
} // namespace DPL
* @version 1.0
* @brief This file is the implementation file of mutex
*/
+#include <stddef.h>
#include <dpl/mutex.h>
#include <dpl/assert.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of named base pipe
*/
+#include <stddef.h>
#include <dpl/named_base_pipe.h>
#include <sys/types.h>
#include <sys/stat.h>
* @version 1.0
* @brief This file is the implementation file of named output pipe
*/
+#include <stddef.h>
#include <dpl/named_output_pipe.h>
#include <dpl/binary_queue.h>
#include <dpl/scoped_free.h>
* @version 1.0
* @brief This file is the implementation file of noncopyable
*/
+#include <stddef.h>
#include <dpl/noncopyable.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of once
*/
+#include <stddef.h>
#include <dpl/once.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of read write mutex
*/
+#include <stddef.h>
#include <dpl/read_write_mutex.h>
#include <dpl/assert.h>
* @version 1.0
* @brief This file is the implementation file of recursive mutex
*/
+#include <stddef.h>
#include <dpl/recursive_mutex.h>
#include <dpl/assert.h>
* @version 1.0
* @brief This file is the implementation file of semaphore
*/
+#include <stddef.h>
#include <dpl/semaphore.h>
#include <dpl/assert.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of data serialization.
*/
+#include <stddef.h>
#include <dpl/serialization.h>
//
* @version 1.0
* @brief This file is the implementation file of single instance
*/
+#include <stddef.h>
#include <dpl/single_instance.h>
#include <dpl/log/log.h>
#include <unistd.h>
* @version 1.0
* @brief This file is the implementation file of singleton
*/
+#include <stddef.h>
#include <dpl/singleton.h>
//
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
*/
+#include <stddef.h>
#include <dpl/string.h>
#include <dpl/char_traits.h>
#include <dpl/errno_string.h>
ThrowMsg(StringException::IconvConvertErrorUTF8ToUTF32,
"iconv failed for " << "UTF-32 <- UTF-8" << "error: "
<< GetErrnoString());
- return String();
}
// Ignore BOM in front of UTF-32
ThrowMsg(StringException::IconvInitErrorUTF32ToUTF8,
"iconv_open failed for " << "UTF-8 <- UTF-32"
<< "error: " << GetErrnoString());
- return std::string();
}
size_t iconvRet = iconv(iconvHandle, &inbuf, &inbytes, &outbuf, &outbytesleft);
ThrowMsg(StringException::IconvConvertErrorUTF32ToUTF8,
"iconv failed for " << "UTF-8 <- UTF-32"
<< "error: " << GetErrnoString());
- return std::string();
}
return &output[0];
* @version 1.0
* @brief Implementation file for abstaract task definition
*/
+#include <stddef.h>
#include <dpl/task.h>
//
* @version 1.0
* @brief Implementation file for task list
*/
+#include <stddef.h>
#include <dpl/task_list.h>
#include <dpl/assert.h>
* @version 1.0
* @brief This file is the implementation file of thread
*/
+#include <stddef.h>
#include <dpl/thread.h>
#include <dpl/log/log.h>
#include <sys/time.h>
#include <dpl/assert.h>
#include <errno.h>
#include <time.h>
+#include <string.h>
namespace // anonymous
{
m_eventList.clear();
}
+bool Thread::IsMainThread()
+{
+ return (pthread_equal(pthread_self(), g_mainThread));
+}
+
Thread *Thread::GetCurrentThread()
{
if (pthread_equal(pthread_self(), g_mainThread))
Assert(This != NULL);
// Set thread specific
- pthread_setspecific(g_threadSpecific.threadSpecific, This);
+ int result = pthread_setspecific(g_threadSpecific.threadSpecific, This);
+
+ if (result!=0)
+ {
+ LogError("Failed to set threadSpecific. Error: " << strerror(result));
+ }
// Enter thread proc
// Do not allow exceptions to hit pthread core
* @version 1.0
* @brief Generic type list template
*/
+#include <stddef.h>
#include <dpl/type_list.h>
//
* @version 1.0
* @brief Implementation file for union cast
*/
+#include <stddef.h>
#include <dpl/union_cast.h>
//
* @version 1.0
* @brief This file is the implementation file of waitable event
*/
+#include <stddef.h>
#include <dpl/waitable_event.h>
#include <sys/select.h>
#include <unistd.h>
* @version 1.0
* @brief This file is the implementation file of waitable handle
*/
+#include <stddef.h>
#include <dpl/waitable_event.h>
#include <dpl/workaround.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of waitable handle watch support
*/
+#include <stddef.h>
#include <dpl/waitable_handle_watch_support.h>
#include <dpl/thread.h>
#include <dpl/main.h>
// Developer assertions
if (!m_watchersMap.empty())
{
- LogPedantic("### Leaked watchers map dump ###");
+ LogWarning("### Leaked watchers map dump ###");
for (WaitableHandleWatchersMap::const_iterator iterator = m_watchersMap.begin();
iterator != m_watchersMap.end();
++iterator)
{
- LogPedantic("### Waitable handle: " << iterator->first);
+ LogWarning("### Waitable handle: " << iterator->first);
- LogPedantic("### Read listeners: " << iterator->second.readListenersCount);
- LogPedantic("### Write listeners: " << iterator->second.writeListenersCount);
+ LogWarning("### Read listeners: " << iterator->second.readListenersCount);
+ LogWarning("### Write listeners: " << iterator->second.writeListenersCount);
for (WaitableHandleListenerList::const_iterator listenersIterator = iterator->second.listeners.begin();
listenersIterator != iterator->second.listeners.end();
++listenersIterator)
{
- LogPedantic("### Mode: " << listenersIterator->mode << ". Listener: 0x" << std::hex << listenersIterator->listener);
+ LogWarning("### Mode: " << listenersIterator->mode << ". Listener: 0x" << std::hex << listenersIterator->listener);
}
}
}
-
- Assert(m_watchersMap.empty() == true);
}
WaitableHandle WaitableHandleWatchSupport::WaitableInvokerHandle() const
* @version 1.0
* @brief This file is the implementation file of zip input
*/
+#include <stddef.h>
+#include <iomanip>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
#include <dpl/zip_input.h>
-#include <dpl/file_input_mapping.h>
+#include <dpl/scoped_close.h>
#include <dpl/binary_queue.h>
#include <dpl/scoped_free.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
#include <dpl/scoped_array.h>
#include <dpl/foreach.h>
#include <dpl/log/log.h>
class Device
{
private:
- DPL::ScopedPtr<FileInputMapping> m_fileMapping;
+ int m_handle;
+ off64_t m_size; // file mapping size
+ unsigned char *m_address; // mapping base address
struct File
{
public:
Device(const std::string &fileName)
{
- Try
+ LogPedantic("Creating file mapping");
+ // Open device and map it to user space
+ int file = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_RDONLY));
+
+ if (file == -1)
+ {
+ int error = errno;
+ ThrowMsg(ZipInput::Exception::OpenFailed,
+ "Failed to open file. errno = " << error);
+ }
+
+ // Scoped close on file
+ ScopedClose scopedClose(file);
+
+ // Calculate file size
+ off64_t size = lseek64(file, 0, SEEK_END);
+
+ if (size == static_cast<off64_t>(-1))
{
- LogPedantic("Creating file mapping");
- m_fileMapping.Reset(new FileInputMapping(fileName));
+ int error = errno;
+ ThrowMsg(ZipInput::Exception::OpenFailed,
+ "Failed to seek file. errno = " << error);
}
- Catch (FileInputMapping::Exception::Base)
+
+ // Map file to usespace
+ void *address = mmap(0, static_cast<size_t>(size),
+ PROT_READ, MAP_SHARED, file, 0);
+
+ if (address == MAP_FAILED)
{
- LogPedantic("Failed to create file mapping");
+ int error = errno;
+ ThrowMsg(ZipInput::Exception::OpenFailed,
+ "Failed to map file. errno = " << error);
+ }
+
+ // Release scoped close
+ m_handle = scopedClose.Release();
+
+ // Save mapped up address
+ m_size = size;
+ m_address = static_cast<unsigned char *>(address);
+
+ LogPedantic("Created file mapping: " << fileName <<
+ " of size: " << m_size <<
+ " at address: " << std::hex << static_cast<void *>(m_address));
+ }
- ReThrowMsg(ZipInput::Exception::OpenFailed,
- "Failed to open zip file mapping");
+ ~Device()
+ {
+ // Close mapping
+ if (munmap(m_address, static_cast<size_t>(m_size)) == -1)
+ {
+ int error = errno;
+ LogPedantic("Failed to munmap file. errno = " << error);
}
- LogPedantic("File mapping created");
+ // Close file descriptor
+ if (close(m_handle) == -1)
+ {
+ int error = errno;
+ LogPedantic("Failed to close file. errno = " << error);
+ }
}
// zlib_filefunc64_def interface: files
static voidpf ZCALLBACK open64_file(voidpf opaque,
- const void* filename,
- int mode)
+ const void* /*filename*/,
+ int /*mode*/)
{
- (void)filename;
- (void)mode;
-
Device *device = static_cast<Device *>(opaque);
// Open file for master device
File *deviceFile = static_cast<File *>(pstream);
// Check if offset is out of bounds
- if (deviceFile->offset >= device->m_fileMapping->GetSize())
+ if (deviceFile->offset >= device->m_size)
{
LogPedantic("Device: read offset out of bounds");
return -1;
}
- off64_t bytesLeft = device->m_fileMapping->GetSize() -
+ off64_t bytesLeft = device->m_size -
deviceFile->offset;
off64_t bytesToRead;
// Do copy
memcpy(buf,
- device->m_fileMapping->GetAddress() + deviceFile->offset,
+ device->m_address + deviceFile->offset,
static_cast<size_t>(bytesToRead));
// Increment file offset
return static_cast<uLong>(bytesToRead);
}
- static uLong ZCALLBACK write_file(voidpf opaque,
- voidpf stream,
- const void* buf,
- uLong size)
+ static uLong ZCALLBACK write_file(voidpf /*opaque*/,
+ voidpf /*stream*/,
+ const void* /*buf*/,
+ uLong /*size*/)
{
- (void)opaque;
- (void)stream;
- (void)buf;
- (void)size;
-
// Not supported by device
LogPedantic("Unsupported function called!");
return -1;
}
- static int ZCALLBACK close_file(voidpf opaque,
- voidpf stream)
+ static int ZCALLBACK close_file(voidpf /*opaque*/, voidpf stream)
{
- (void)opaque;
File *deviceFile = static_cast<File *>(stream);
// Delete file
return 0;
}
- static int ZCALLBACK testerror_file(voidpf opaque,
- voidpf stream)
+ static int ZCALLBACK testerror_file(voidpf /*opaque*/, voidpf /*stream*/)
{
- (void)opaque;
- (void)stream;
-
// No errors
return 0;
}
- static ZPOS64_T ZCALLBACK tell64_file(voidpf opaque,
- voidpf stream)
+ static ZPOS64_T ZCALLBACK tell64_file(voidpf /*opaque*/, voidpf stream)
{
- (void)opaque;
File *deviceFile = static_cast<File *>(stream);
return static_cast<ZPOS64_T>(deviceFile->offset);
case ZLIB_FILEFUNC_SEEK_END:
deviceFile->offset =
- device->m_fileMapping->GetSize() -
+ device->m_size -
static_cast<off64_t>(offset);
break;
// Create master device
LogPedantic("Creating master device");
- ScopedPtr<Device> device(new Device(fileName));
+ std::unique_ptr<Device> device(new Device(fileName));
// Open master file
zlib_filefunc64_def interface;
interface.zseek64_file = &Device::seek64_file;
interface.zclose_file = &Device::close_file;
interface.zerror_file = &Device::testerror_file;
- interface.opaque = device.Get();
+ interface.opaque = device.get();
LogPedantic("Opening zip file");
unzFile file = unzOpen2_64(NULL, &interface);
// Release scoped unz close
m_masterFile = scopedUnzClose.Release();
- m_device = device.Release();
+ m_device = device.release();
LogPedantic("Zip file opened");
}
),
std::string(fileName.Get()),
std::string(fileComment.Get()),
- static_cast<unsigned long>(fileInfo.version),
- static_cast<unsigned long>(fileInfo.version_needed),
- static_cast<unsigned long>(fileInfo.flag),
- static_cast<unsigned long>(fileInfo.compression_method),
- static_cast<unsigned long>(fileInfo.dosDate),
- static_cast<unsigned long>(fileInfo.crc),
static_cast<off64_t>(fileInfo.compressed_size),
- static_cast<off64_t>(fileInfo.uncompressed_size),
- static_cast<unsigned long>(fileInfo.disk_num_start),
- static_cast<unsigned long>(fileInfo.internal_fa),
- static_cast<unsigned long>(fileInfo.external_fa),
- FileDateTime(
- fileInfo.tmu_date.tm_sec,
- fileInfo.tmu_date.tm_min,
- fileInfo.tmu_date.tm_hour,
- fileInfo.tmu_date.tm_mday,
- fileInfo.tmu_date.tm_mon,
- fileInfo.tmu_date.tm_year
- )
+ static_cast<off64_t>(fileInfo.uncompressed_size)
)
);
return m_fileInfos.size();
}
-ZipInput::File *ZipInput::OpenFile(FileHandle handle)
-{
- return new File(m_device, handle);
-}
-
ZipInput::File *ZipInput::OpenFile(const std::string &fileName)
{
FOREACH(iterator, m_fileInfos)
--- /dev/null
+SET(TARGET_CUSTOM_HANDLER_DAO_DB "Sqlite3DbCustomHandler")
+
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h
+ COMMAND ${CMAKE_SOURCE_DIR}/modules/custom_handler_dao/orm/gen_db_md5.sh
+ ARGS ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h
+ ${CMAKE_SOURCE_DIR}/modules/custom_handler_dao/orm/custom_handler_db
+ DEPENDS ${CMAKE_SOURCE_DIR}/modules/custom_handler_dao/orm/custom_handler_db
+ ${CMAKE_SOURCE_DIR}/modules/custom_handler_dao/orm/gen_db_md5.sh
+ COMMENT "Generating WRT custom handlers database checksum"
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .wrt_custom_handler.db
+ COMMAND rm -f ${CMAKE_CURRENT_BINARY_DIR}/.wrt_custom_handler.db
+ COMMAND gcc -Wall -include ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h -I${PROJECT_SOURCE_DIR}/modules/db/include -I${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/orm -E ${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/orm/custom_handler_db_sql_generator.h | grep --invert-match "^#" > ${CMAKE_CURRENT_BINARY_DIR}/wrt_custom_handler_db.sql
+ COMMAND sqlite3 ${CMAKE_CURRENT_BINARY_DIR}/.wrt_custom_handler.db ".read ${CMAKE_CURRENT_BINARY_DIR}/wrt_custom_handler_db.sql" || rm -f ${CMAKE_CURRENT_BINARY_DIR}/.wrt_custom_handler.db
+ DEPENDS ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h ${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/orm/custom_handler_db_sql_generator.h ${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/orm/custom_handler_db
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .wrt_custom_handler.db-journal
+ COMMAND touch
+ ARGS ${CMAKE_CURRENT_BINARY_DIR}/.wrt_custom_handler.db-journal
+ )
+
+ADD_CUSTOM_TARGET(${TARGET_CUSTOM_HANDLER_DAO_DB} ALL DEPENDS .wrt_custom_handler.db .wrt_custom_handler.db-journal)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/wrt_custom_handler_db.sql DESTINATION share/wrt-engine/)
+
+###############################################################################
+
+INCLUDE(FindPkgConfig)
+
+PKG_CHECK_MODULES(CUSTOM_HANDLER_DAO_DEPS
+ glib-2.0
+ REQUIRED)
+
+SET(CUSTOM_HANDLER_DAO_INCLUDE_DIRS
+ ${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/include
+ ${PROJECT_SOURCE_DIR}/modules/custom_handler_dao/orm
+ ${PROJECT_SOURCE_DIR}/modules/core/include
+ ${PROJECT_SOURCE_DIR}/modules/db/include
+ ${PROJECT_SOURCE_DIR}/modules/log/include
+)
+
+
+SET(CUSTOM_HANDLER_DAO_RO_SOURCES
+ dao/CustomHandlerDatabase.cpp
+ dao/custom_handler_dao_read_only.cpp
+)
+
+SET(CUSTOM_HANDLER_DAO_RW_SOURCES
+ dao/custom_handler_dao.cpp
+)
+
+
+INCLUDE_DIRECTORIES(${CUSTOM_HANDLER_DAO_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${CUSTOM_HANDLER_DAO_DEPS_INCLUDE_DIRS})
+
+ADD_LIBRARY(${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} SHARED ${CUSTOM_HANDLER_DAO_RO_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+SET_TARGET_PROPERTIES(${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} PROPERTIES COMPILE_FLAGS "-include ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h")
+TARGET_LINK_LIBRARIES(${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} ${TARGET_CUSTOM_HANDLER_DAO_LIB})
+ADD_DEPENDENCIES(${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} ${TARGET_CUSTOM_HANDLER_DAO_DB})
+
+ADD_LIBRARY(${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} SHARED ${CUSTOM_HANDLER_DAO_RW_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+SET_TARGET_PROPERTIES(${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} PROPERTIES COMPILE_FLAGS "-include ${CMAKE_BINARY_DIR}/modules/custom_handler_dao/database_checksum_custom_handler.h")
+TARGET_LINK_LIBRARIES(${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} ${TARGET_CUSTOM_HANDLER_DAO_RO_LIB})
+ADD_DEPENDENCIES(${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} ${TARGET_CUSTOM_HANDLER_DAO_DB})
+
+INSTALL(TARGETS ${TARGET_CUSTOM_HANDLER_DAO_RO_LIB} DESTINATION lib)
+INSTALL(TARGETS ${TARGET_CUSTOM_HANDLER_DAO_RW_LIB} DESTINATION lib)
+
+INSTALL(FILES
+ include/wrt-commons/custom-handler-dao-ro/common_dao_types.h
+ include/wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h
+ include/wrt-commons/custom-handler-dao-ro/custom_handler_dao_read_only.h
+ DESTINATION include/dpl-efl/wrt-commons/custom-handler-dao-ro
+)
+
+INSTALL(FILES
+ include/wrt-commons/custom-handler-dao-rw/custom_handler_dao.h
+ DESTINATION include/dpl-efl/wrt-commons/custom-handler-dao-rw
+)
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h>
+
+namespace CustomHandlerDB {
+namespace Interface {
+
+namespace {
+const char* CustomHandler_DB_DATABASE = "/opt/dbspace/.wrt_custom_handler.db";
+DPL::DB::SqlConnection::Flag::Type CustomHandler_DB_FLAGS =
+ DPL::DB::SqlConnection::Flag::UseLucene;
+}
+
+DPL::Mutex g_dbQueriesMutex;
+DPL::DB::ThreadDatabaseSupport g_dbInterface(CustomHandler_DB_DATABASE,
+ CustomHandler_DB_FLAGS);
+
+void attachDatabaseRO()
+{
+ g_dbInterface.AttachToThread(DPL::DB::SqlConnection::Flag::RO);
+}
+
+void attachDatabaseRW()
+{
+ g_dbInterface.AttachToThread(DPL::DB::SqlConnection::Flag::RW);
+}
+
+void detachDatabase()
+{
+ g_dbInterface.DetachFromThread();
+}
+
+} //namespace Interface
+} //namespace CustomHandlerDB
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file custom_handler_dao.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains the definition of custom handler dao class.
+ */
+
+#include <wrt-commons/custom-handler-dao-rw/custom_handler_dao.h>
+#include <wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h>
+#include <orm_generator_custom_handler.h>
+#include <wrt-commons/custom-handler-dao-ro/custom_handler_dao_read_only.h>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::custom_handler;
+
+namespace CustomHandlerDB {
+
+namespace {
+
+template <typename T>
+void fillRow(T& row, const CustomHandler& handler, const DPL::String& pkgName)
+{
+ row.Set_app_id(pkgName);
+ row.Set_target(handler.target);
+ row.Set_base_url(handler.base_url);
+ row.Set_url(handler.url);
+ row.Set_title(handler.title);
+ row.Set_user_allowed(handler.user_decision);
+}
+
+} // namespace
+
+CustomHandlerDAO::CustomHandlerDAO(const DPL::String& pkgName) :
+ CustomHandlerDAOReadOnly(pkgName)
+{
+}
+
+CustomHandlerDAO::~CustomHandlerDAO()
+{
+}
+
+void CustomHandlerDAO::registerContentHandler(const CustomHandler& handler)
+{
+ LogDebug("Registering content handler " << handler.target << " " <<
+ handler.base_url);
+ Try {
+ if (handler.user_decision & Agreed) {
+ //need to disable all previous, agreed entries
+ CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
+ select->Where(And(Equals<ContentHandlers::target>(handler.target),
+ Or(Equals<ContentHandlers::user_allowed>(Agreed),
+ Equals<ContentHandlers::user_allowed>(AgreedPermanently))
+ ));
+ ContentHandlers::Select::RowList rows = select->GetRowList();
+ if (rows.size() > 1) {
+ //more than one activ content handler - not good. Remove all.
+ //this should never happen
+ LogError("Database data incoherent.");
+ CUSTOM_HANDLER_DB_DELETE(deleteContent, ContentHandlers);
+ deleteContent->Where(And(Equals<ContentHandlers::target>(handler.target),
+ Or(Equals<ContentHandlers::user_allowed>(Agreed),
+ Equals<ContentHandlers::user_allowed>(AgreedPermanently))));
+ deleteContent->Execute();
+ //all content handlers removed. New one can be inserted
+ } else if (!rows.empty()) {
+ //one active handler. Can be updaed
+ LogDebug("Activ content handler exist. Update");
+ CUSTOM_HANDLER_DB_UPDATE(update, ContentHandlers);
+ update->Where(And(Equals<ContentHandlers::target>(handler.target),
+ Or(Equals<ContentHandlers::user_allowed>(Agreed),
+ Equals<ContentHandlers::user_allowed>(AgreedPermanently))
+ ));
+ ContentHandlers::Row rowToUpdate = rows.front();
+
+ if (handler.user_decision & DecisionSaved) {
+ //do not ask about previous one
+ rowToUpdate.Set_user_allowed(DeclinedPermanently);
+ } else {
+ //ask for next time
+ rowToUpdate.Set_user_allowed(Declined);
+ }
+ update->Values(rowToUpdate);
+ update->Execute();
+ }
+ }
+ LogDebug("Inserting new content handler");
+ ContentHandlers::Row row;
+ fillRow(row, handler, m_pkgName);
+ if (getContentHandler(handler.target, handler.url, handler.base_url)) {
+ LogDebug("Content handler exist. Update its state");
+ CUSTOM_HANDLER_DB_UPDATE(updateRow, ContentHandlers);
+ updateRow->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(handler.target),
+ And(Equals<ContentHandlers::url>(handler.url),
+ Equals<ContentHandlers::base_url>(handler.base_url)))));
+ updateRow->Values(row);
+ updateRow->Execute();
+ LogDebug("updated");
+ return;
+ }
+ CUSTOM_HANDLER_DB_INSERT(insert, ContentHandlers);
+ insert->Values(row);
+ insert->Execute();
+ LogDebug("insterted");
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to register custom handler");
+ }
+}
+
+void CustomHandlerDAO::registerProtocolHandler(const CustomHandler& handler)
+{
+ LogDebug("Registering protocol handler " << handler.target << " " <<
+ handler.base_url);
+ Try {
+
+ if (handler.user_decision & Agreed) {
+ //need to disable all previous, agreed entries
+ CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
+ select->Where(And(Equals<ProtocolHandlers::target>(handler.target),
+ Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
+ Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))
+ ));
+ ProtocolHandlers::Select::RowList rows = select->GetRowList();
+ if (rows.size() > 1) {
+ //more than one activ protocol handler - not good. Remove all.
+ //this should never happen
+ LogError("Database data incoherent.");
+ CUSTOM_HANDLER_DB_DELETE(deleteProtocol, ProtocolHandlers);
+ deleteProtocol->Where(And(Equals<ProtocolHandlers::target>(handler.target),
+ Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
+ Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))));
+ deleteProtocol->Execute();
+ //all protocol handlers removed. New one can be inserted
+ } else if (!rows.empty()) {
+ //one active handler. Can be updaed
+ CUSTOM_HANDLER_DB_UPDATE(update, ProtocolHandlers);
+ update->Where(And(Equals<ProtocolHandlers::target>(handler.target),
+ Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
+ Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))
+ ));
+ ProtocolHandlers::Row rowToUpdate = rows.front();
+
+ if (handler.user_decision & DecisionSaved) {
+ //do not ask about previous one
+ rowToUpdate.Set_user_allowed(DeclinedPermanently);
+ } else {
+ //ask for next time
+ rowToUpdate.Set_user_allowed(Declined);
+ }
+ update->Values(rowToUpdate);
+ update->Execute();
+ }
+ }
+ LogDebug("Inserting new protocol handler");
+ ProtocolHandlers::Row row;
+ fillRow(row, handler, m_pkgName);
+ if (getProtocolHandler(handler.target, handler.url, handler.base_url)) {
+ LogDebug("Protocol handler exist. Update its state");
+ CUSTOM_HANDLER_DB_UPDATE(updateRow, ProtocolHandlers);
+ updateRow->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(handler.target),
+ And(Equals<ProtocolHandlers::url>(handler.url),
+ Equals<ProtocolHandlers::base_url>(handler.base_url)))));
+ updateRow->Values(row);
+ updateRow->Execute();
+ LogDebug("updated");
+ return;
+ }
+ CUSTOM_HANDLER_DB_INSERT(insert, ProtocolHandlers);
+ insert->Values(row);
+ insert->Execute();
+ LogDebug("insterted");
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to register custom handler");
+ }
+}
+
+void CustomHandlerDAO::unregisterContentHandler(const DPL::String& target,
+ const DPL::String& url)
+{
+ LogDebug("Removing content handler " << target << " " << url);
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
+ deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(target),
+ Equals<ContentHandlers::url>(url))));
+ deleteFrom->Execute();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
+ }
+}
+
+void CustomHandlerDAO::unregisterProtocolHandler(const DPL::String& target,
+ const DPL::String& url)
+{
+ LogDebug("Removing protocol handler " << target << " " << url);
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
+ deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(target),
+ Equals<ProtocolHandlers::url>(url))));
+ deleteFrom->Execute();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
+ }
+
+}
+
+void CustomHandlerDAO::unregisterContentHandler(const DPL::String& target,
+ const DPL::String& url,
+ const DPL::String& baseURL)
+{
+ LogDebug("Removing content handler " << target << " " << url);
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
+ deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(target),
+ And(Equals<ContentHandlers::url>(url),
+ Equals<ContentHandlers::base_url>(baseURL)))));
+ deleteFrom->Execute();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
+ }
+}
+
+void CustomHandlerDAO::unregisterProtocolHandler(const DPL::String& target,
+ const DPL::String& url,
+ const DPL::String& baseURL)
+{
+ LogDebug("Removing protocol handler " << target << " " << url);
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
+ deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(target),
+ And(Equals<ProtocolHandlers::url>(url),
+ Equals<ProtocolHandlers::base_url>(baseURL)))));
+ deleteFrom->Execute();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
+ }
+
+}
+
+void CustomHandlerDAO::removeWidgetProtocolHandlers()
+{
+ LogDebug("ente");
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteProtocol, ProtocolHandlers);
+ deleteProtocol->Where(Equals<ProtocolHandlers::app_id>(m_pkgName));
+ deleteProtocol->Execute();
+
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove widget protoc");
+ }
+}
+
+void CustomHandlerDAO::removeWidgetContentHandlers()
+{
+ LogDebug("ente");
+ Try {
+ CUSTOM_HANDLER_DB_DELETE(deleteContent, ContentHandlers);
+ deleteContent->Where(Equals<ContentHandlers::app_id>(m_pkgName));
+ deleteContent->Execute();
+
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove widget entries");
+ }
+}
+
+
+} // namespace CustomHandlerDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of custom handler dao class.
+ *
+ * @file custom_handler_dao_read_only.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of custom handler dao
+ */
+
+#include <wrt-commons/custom-handler-dao-ro/custom_handler_dao_read_only.h>
+#include <wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h>
+
+#include <orm_generator_custom_handler.h>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::custom_handler;
+
+namespace CustomHandlerDB {
+
+namespace {
+
+template <typename T>
+CustomHandlerPtr getSingleHandler(std::list<T> row)
+{
+ CustomHandlerPtr handler;
+ if (!row.empty()) {
+ // There should be only one
+ if (row.size() > 1) {
+ ThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "More than one handler registered");
+ }
+
+ handler.reset(new CustomHandler());
+ handler->target = row.front().Get_target();
+ handler->base_url = row.front().Get_base_url();
+ handler->url = row.front().Get_url();
+ handler->title = row.front().Get_title();
+ handler->user_allowed = static_cast<bool>(row.front().Get_user_allowed());
+ handler->user_decision =
+ static_cast<HandlerState>(row.front().Get_user_allowed());
+ }
+ return handler;
+}
+
+} // namespace
+
+CustomHandlerDAOReadOnly::CustomHandlerDAOReadOnly(const DPL::String& pkgName) :
+ m_pkgName(pkgName)
+{
+}
+
+CustomHandlerDAOReadOnly::~CustomHandlerDAOReadOnly()
+{
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getProtocolHandler(
+ const DPL::String& protocol,
+ const DPL::String& url)
+{
+ LogDebug("Getting protocol handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
+
+ select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(protocol),
+ Equals<ProtocolHandlers::url>(url))));
+
+ std::list<ProtocolHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get protocol handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getContentHandler(
+ const DPL::String& content,
+ const DPL::String& url)
+{
+ LogDebug("Getting content handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
+
+ select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(content),
+ Equals<ContentHandlers::url>(url))));
+
+ std::list<ContentHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get content handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getActivProtocolHandler(
+ const DPL::String& protocol)
+{
+ LogDebug("Getting active protocol handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
+
+ select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ Equals<ProtocolHandlers::target>(protocol)));
+
+ std::list<ProtocolHandlers::Row> list = select->GetRowList();
+ CustomHandlerPtr handler;
+
+ FOREACH(it, list) {
+ if (it->Get_user_allowed() & Agreed) {
+ handler.reset(new CustomHandler());
+ handler->base_url = it->Get_base_url();
+ handler->target = it->Get_target();
+ handler->title = it->Get_title();
+ handler->url = it->Get_url();
+ handler->user_allowed =
+ static_cast<bool>(it->Get_user_allowed());
+ handler->user_decision =
+ static_cast<HandlerState>(it->Get_user_allowed());
+ }
+ }
+ return handler;
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get protocol handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getProtocolHandler(
+ const DPL::String& protocol,
+ const DPL::String& url,
+ const DPL::String& baseURL)
+{
+ LogDebug("Check if protocol is registered");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
+
+ select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(protocol),
+ And(Equals<ProtocolHandlers::url>(url),
+ Equals<ProtocolHandlers::base_url>(baseURL)
+ )
+ )
+ )
+ );
+
+ std::list<ProtocolHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get content handler");
+ }
+}
+
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getActivContentHandler(
+ const DPL::String& content)
+{
+ LogDebug("Getting active content handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
+
+ select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ Equals<ContentHandlers::target>(content)));
+
+ std::list<ContentHandlers::Row> list = select->GetRowList();
+ CustomHandlerPtr handler;
+
+ FOREACH(it, list) {
+ if (it->Get_user_allowed() & Agreed) {
+ handler.reset(new CustomHandler());
+ handler->base_url = it->Get_base_url();
+ handler->target = it->Get_target();
+ handler->title = it->Get_title();
+ handler->url = it->Get_url();
+ handler->user_allowed =
+ static_cast<bool>(it->Get_user_allowed());
+ handler->user_decision =
+ static_cast<HandlerState>(it->Get_user_allowed());
+ }
+ }
+ return handler;
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get protocol handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getContentHandler(
+ const DPL::String& content,
+ const DPL::String& url,
+ const DPL::String& baseURL)
+{
+ LogDebug("Check if content is registered");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
+
+ select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(content),
+ And(Equals<ContentHandlers::url>(url),
+ Equals<ContentHandlers::base_url>(baseURL)))));
+
+ std::list<ContentHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get content handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getAllowedProtocolHandler(
+ const DPL::String& protocol)
+{
+ LogDebug("Getting allowed protocol handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
+
+ select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(protocol),
+ Equals<ProtocolHandlers::user_allowed>(true))));
+
+ std::list<ProtocolHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get content handler");
+ }
+}
+
+CustomHandlerPtr CustomHandlerDAOReadOnly::getAllowedContentHandler(
+ const DPL::String& protocol)
+{
+ LogDebug("Getting allowed content handler");
+ Try{
+ CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers)
+
+ select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(protocol),
+ Equals<ContentHandlers::user_allowed>(true))));
+
+ std::list<ContentHandlers::Row> list = select->GetRowList();
+ return getSingleHandler(list);
+ } Catch(DPL::DB::SqlConnection::Exception::Base) {
+ ReThrowMsg(CustomHandlerDAOReadOnly::Exception::DatabaseError,
+ "Failed to get content handler");
+ }
+}
+
+} // namespace CustomHandlerDB
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _CUSTOM_HANDLER_DATABASE_H_
+#define _CUSTOM_HANDLER_DATABASE_H_
+
+#include <dpl/thread.h>
+#include <dpl/mutex.h>
+#include <dpl/db/thread_database_support.h>
+
+namespace CustomHandlerDB {
+namespace Interface {
+
+void attachDatabaseRO();
+void attachDatabaseRW();
+void detachDatabase();
+
+extern DPL::Mutex g_dbQueriesMutex;
+extern DPL::DB::ThreadDatabaseSupport g_dbInterface;
+
+} // namespace Interface
+} // namespace CustomHandlerDB
+
+#define CUSTOM_HANDLER_DB_INTERNAL(tlsCommand, InternalType) \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ { \
+ DPL::Mutex::ScopedLock lock( \
+ &CustomHandlerDB::Interface::g_dbQueriesMutex); \
+ if (!tlsCommand ## Ptr) { \
+ static DPL::ThreadLocalVariable<InternalType> tmp; \
+ tlsCommand ## Ptr = &tmp; \
+ } \
+ } \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ if (tlsCommand.IsNull()) \
+ { \
+ tlsCommand = InternalType(&CustomHandlerDB::Interface::g_dbInterface); \
+ }
+
+#define CUSTOM_HANDLER_DB_SELECT(name, type) \
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Select)
+
+#define CUSTOM_HANDLER_DB_INSERT(name, type) \
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Insert)
+
+#define CUSTOM_HANDLER_DB_UPDATE(name, type) \
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Update)
+
+#define CUSTOM_HANDLER_DB_DELETE(name, type) \
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Delete)
+
+#endif /* _CUSTOM_HANDLER_DATABASE_H_ */
+
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file common_dao_types.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of
+ * common data types for custom handler database.
+ */
+#ifndef SRC_MODULES_CUSTOM_HANDLERS_DAO_COMMON_DAO_TYPES_H_
+#define SRC_MODULES_CUSTOM_HANDLERS_DAO_COMMON_DAO_TYPES_H_
+
+#include <list>
+#include <memory>
+#include <dpl/string.h>
+
+namespace CustomHandlerDB {
+
+/**
+ * @brief Custom Handler struct
+ *
+ * Describes custom handler for protocol and content.
+ */
+enum HandlerState {
+ Agreed = 0x01, //user agreed to use protocol only,
+ //but want to ask in next occurence
+ Declined = 0x02, //user declined to use protocol,
+ //but want to ask in next occurence
+ //in fact it is used when user wants to cover saved agreed
+ //decision by agreeing to another one without save.
+ DecisionSaved = 0x04, //user dont want to ask again
+ AgreedPermanently = Agreed | DecisionSaved,
+ DeclinedPermanently = Declined | DecisionSaved
+};
+
+struct CustomHandler
+{
+ DPL::String target; // protocol/content ("mailto"/"application/x-soup")
+ DPL::String base_url; // base url of registered page
+ DPL::String url; // url used for protocol/content handling
+ DPL::String title; // user friendly handler name
+ bool user_allowed; // true if user has allowed the handler
+ HandlerState user_decision;
+};
+
+typedef std::shared_ptr<CustomHandler> CustomHandlerPtr;
+typedef std::list <CustomHandlerPtr> CustomHandlersList;
+
+} // namespace CustomHandlerDB
+
+#endif /* SRC_MODULES_CUSTOM_HANDLERS_DAO_COMMON_DAO_TYPES_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of custom handler dao class.
+ *
+ * @file custom_handler_dao_read_only.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of custom handler dao
+ */
+
+#ifndef _CUSTOM_HANDLER_DAO_READ_ONLY_H_
+#define _CUSTOM_HANDLER_DAO_READ_ONLY_H_
+
+#include <dpl/string.h>
+#include <dpl/exception.h>
+#include "common_dao_types.h"
+
+namespace CustomHandlerDB {
+
+class CustomHandlerDAOReadOnly
+{
+ public:
+ /**
+ * CustomHandlerDAOReadOnly Exception classes
+ */
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
+ };
+
+ public:
+ explicit CustomHandlerDAOReadOnly(const DPL::String& pkgName);
+ virtual ~CustomHandlerDAOReadOnly();
+
+ /**
+ * Returns protocol handler
+ */
+ CustomHandlerPtr getProtocolHandler(const DPL::String& protocol,
+ const DPL::String& url);
+ CustomHandlerPtr getProtocolHandler(const DPL::String& protocol,
+ const DPL::String& url,
+ const DPL::String& baseURL);
+
+ /**
+ * Returns protocol handler that is agreed or agreed and saved and match tizenID
+ */
+ CustomHandlerPtr getActivProtocolHandler(const DPL::String& protocol);
+
+
+
+ /**
+ * Returns content handler
+ */
+ CustomHandlerPtr getContentHandler(const DPL::String& content,
+ const DPL::String& url);
+ CustomHandlerPtr getContentHandler(const DPL::String& protocol,
+ const DPL::String& url,
+ const DPL::String& baseURL);
+
+ /**
+ * Returns content handler that is agreed or agreed and saved and match tizenID
+ */
+ CustomHandlerPtr getActivContentHandler(const DPL::String& content);
+
+ /**
+ * Returns allowed handler for given protocol
+ */
+ CustomHandlerPtr getAllowedProtocolHandler(const DPL::String& protocol);
+
+ /**
+ * Returns allowed handler for given content
+ */
+ CustomHandlerPtr getAllowedContentHandler(const DPL::String& protocol);
+
+ protected:
+ DPL::String m_pkgName;
+};
+
+} // namespace CustomHandlerDB
+
+#endif // _CUSTOM_HANDLER_DAO_READ_ONLY_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of custom handler dao class.
+ *
+ * @file custom_handler_dao.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of custom handler dao
+ */
+#ifndef _CUSTOM_HANDLER_DAO_H_
+#define _CUSTOM_HANDLER_DAO_H_
+
+#include <wrt-commons/custom-handler-dao-ro/custom_handler_dao_read_only.h>
+
+namespace CustomHandlerDB {
+
+class CustomHandlerDAO : public CustomHandlerDAOReadOnly
+{
+ public:
+ explicit CustomHandlerDAO(const DPL::String& pkgName);
+ virtual ~CustomHandlerDAO();
+
+ /**
+ * Registers custom content handler
+ */
+ void registerContentHandler(const CustomHandler& handler);
+
+ /**
+ * Registers custom protocol handler
+ */
+ void registerProtocolHandler(const CustomHandler& handler);
+
+ /**
+ * Unregisters custom content handler
+ */
+ void unregisterContentHandler(const DPL::String& target,
+ const DPL::String& burl);
+ /**
+ * Unregisters custom protocol handler
+ */
+ void unregisterProtocolHandler(const DPL::String& target,
+ const DPL::String& url);
+
+ void unregisterContentHandler(const DPL::String& target,
+ const DPL::String& url,
+ const DPL::String& baseURL);
+
+ void unregisterProtocolHandler(const DPL::String& target,
+ const DPL::String& url,
+ const DPL::String& baseURL);
+
+ /**
+ * Removes all widget entries connected to given ID
+ */
+ void removeWidgetProtocolHandlers();
+ void removeWidgetContentHandlers();
+};
+
+} // namespace CustomHandlerDB
+
+#endif // _CUSTOM_HANDLER_DAO_H_
--- /dev/null
+SQL(
+ BEGIN TRANSACTION;
+)
+
+CREATE_TABLE(ProtocolHandlers)
+ COLUMN_NOT_NULL(app_id, TEXT,)
+ COLUMN_NOT_NULL(target, TEXT,)
+ COLUMN_NOT_NULL(base_url, TEXT,)
+ COLUMN_NOT_NULL(url, TEXT,)
+ COLUMN_NOT_NULL(title, TEXT,)
+ COLUMN_NOT_NULL(user_allowed, INT,)
+
+ TABLE_CONSTRAINTS(
+ PRIMARY KEY (app_id, target, base_url, url)
+ )
+CREATE_TABLE_END()
+
+CREATE_TABLE(ContentHandlers)
+ COLUMN_NOT_NULL(app_id, TEXT,)
+ COLUMN_NOT_NULL(target, TEXT,)
+ COLUMN_NOT_NULL(base_url, TEXT,)
+ COLUMN_NOT_NULL(url, TEXT,)
+ COLUMN_NOT_NULL(title, TEXT,)
+ COLUMN_NOT_NULL(user_allowed, INT,)
+
+ TABLE_CONSTRAINTS(
+ PRIMARY KEY (app_id, target, base_url, url)
+ )
+CREATE_TABLE_END()
+
+SQL(
+ COMMIT;
+)
+
--- /dev/null
+DATABASE_START(custom_handler)
+
+#include "custom_handler_db"
+#include "version_db"
+
+DATABASE_END()
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file custom_handler_db_sql_generator.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief Macro definitions for generating the SQL
+ * input file from database definition.
+ */
+
+//Do not include this file directly! It is used only for SQL code generation.
+#include <dpl/db/orm_macros.h>
+
+#include "custom_handler_db_definitions"
--- /dev/null
+#!/bin/sh
+# Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+CHECKSUM=`cat ${2} ${3} 2>/dev/null | md5sum 2>/dev/null | cut -d\ -f1 2>/dev/null`
+echo "#define DB_CHECKSUM DB_VERSION_${CHECKSUM}" > ${1}
+echo "#define DB_CHECKSUM_STR \"DB_VERSION_${CHECKSUM}\"" >> ${1}
+
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _ORM_GENERATOR_CUSTOM_HANDLER_H_
+#define _ORM_GENERATOR_CUSTOM_HANDLER_H_
+
+#define ORM_GENERATOR_DATABASE_NAME custom_handler_db_definitions
+#include <dpl/db/orm_generator.h>
+#undef ORM_GENERATOR_DATABASE_NAME
+
+#endif // _ORM_GENERATOR_CUSTOM_HANDLER_H_
--- /dev/null
+SQL(
+ BEGIN TRANSACTION;
+ CREATE TABLE DB_CHECKSUM (version INT);
+ COMMIT;
+)
#include <string>
#include <typeinfo>
#include <utility>
+#include <set>
+#include <memory>
#include <dpl/db/sql_connection.h>
#include <dpl/db/orm_interface.h>
#include <dpl/string.h>
#include <dpl/optional.h>
-#include <dpl/shared_ptr.h>
#include <dpl/type_list.h>
#include <dpl/assert.h>
+#include <dpl/foreach.h>
#ifndef DPL_ORM_H
#define DPL_ORM_H
(void)_ignored_; \
}
+#define DECLARE_COLUMN_TYPE_LIST() typedef DPL::TypeListDecl<
+#define SELECTED_COLUMN(table_name, column_name) table_name::column_name,
+#define DECLARE_COLUMN_TYPE_LIST_END(name) DPL::TypeListGuard>::Type name;
+
typedef size_t ColumnIndex;
typedef size_t ArgumentIndex;
typedef DPL::Optional<DPL::String> OptionalString;
extern const char And[];
extern const char Or[];
extern const char Is[];
+ extern const char In[];
//TODO define more relation types
}
void BindArgument(DataCommand *command, ArgumentIndex index, const DPL::String& argument);
void BindArgument(DataCommand *command, ArgumentIndex index, const OptionalString& argument);
}
-class Expression {
+class __attribute__ ((visibility("hidden"))) Expression {
public:
virtual ~Expression() {}
virtual std::string GetString() const = 0;
virtual ArgumentIndex BindTo(DataCommand *command, ArgumentIndex index) = 0;
};
-typedef DPL::SharedPtr<Expression> ExpressionPtr;
+typedef std::shared_ptr<Expression> ExpressionPtr;
template<const char* Operator, typename LeftExpression, typename RightExpression>
-class BinaryExpression : public Expression {
+class __attribute__ ((visibility("hidden"))) BinaryExpression : public Expression {
protected:
LeftExpression m_leftExpression;
RightExpression m_rightExpression;
(leftExpression, rightExpression);
}
+template<typename LeftExpression, typename RightExpression>
+BinaryExpression<RelationTypes::Or, LeftExpression, RightExpression>
+ Or(const LeftExpression& leftExpression, const RightExpression& rightExpression)
+{
+ return BinaryExpression<RelationTypes::Or, LeftExpression, RightExpression>
+ (leftExpression, rightExpression);
+}
+
template<typename ArgumentType>
-class ExpressionWithArgument : public Expression {
+class __attribute__ ((visibility("hidden"))) ExpressionWithArgument : public Expression {
protected:
ArgumentType argument;
}
};
-
template<typename ColumnData, const char* Relation>
-class Compare : public ExpressionWithArgument<typename ColumnData::ColumnType> {
+class __attribute__ ((visibility("hidden"))) Compare : public ExpressionWithArgument<typename ColumnData::ColumnType> {
public:
explicit Compare(typename ColumnData::ColumnType column) :
ExpressionWithArgument<typename ColumnData::ColumnType>(column)
virtual std::string GetString() const
{
std::string statement;
+ statement += ColumnData::GetTableName();
+ statement += ".";
statement += ColumnData::GetColumnName();
statement += " ";
statement += Relation;
};
#define ORM_DEFINE_COMPARE_EXPRESSION(name, relationType) \
template<typename ColumnData> \
- class name : public Compare<ColumnData, RelationTypes::relationType> { \
+ class __attribute__ ((visibility("hidden"))) name : public Compare<ColumnData, RelationTypes::relationType> { \
public: \
name(typename ColumnData::ColumnType column) : \
Compare<ColumnData, RelationTypes::relationType>(column) \
ORM_DEFINE_COMPARE_EXPRESSION(Equals, Equal)
ORM_DEFINE_COMPARE_EXPRESSION(Is, Is)
+template<typename ColumnData1, typename ColumnData2>
+class __attribute__ ((visibility("hidden"))) CompareBinaryColumn {
+private:
+ std::string m_relation;
+public:
+ CompareBinaryColumn(const char* Relation) :
+ m_relation(Relation)
+ {}
+
+ virtual ~CompareBinaryColumn() {}
+
+ virtual std::string GetString() const
+ {
+ std::string statement;
+ statement += ColumnData1::GetTableName();
+ statement += ".";
+ statement += ColumnData1::GetColumnName();
+ statement += " ";
+ statement += m_relation;
+ statement += " ";
+ statement += ColumnData2::GetTableName();
+ statement += ".";
+ statement += ColumnData2::GetColumnName();
+
+ return statement;
+ }
+};
+
+template<typename ColumnData1, typename ColumnData2>
+CompareBinaryColumn<ColumnData1, ColumnData2>
+ Equal()
+{
+ return CompareBinaryColumn<ColumnData1, ColumnData2>(RelationTypes::Equal);
+}
+
+template<typename ColumnData, const char* Relation>
+class __attribute__ ((visibility("hidden"))) NumerousArguments : public Expression {
+protected:
+ std::set<typename ColumnData::ColumnType> m_argumentList;
+public:
+ NumerousArguments(const std::set<typename ColumnData::ColumnType>& argumentList) : m_argumentList(argumentList) {}
+
+ virtual std::string GetString() const
+ {
+ std::string statement;
+ statement += ColumnData::GetColumnName();
+ statement += " ";
+ statement += Relation;
+ statement += " ( ";
+
+ int argumentCount = m_argumentList.size();
+ while(argumentCount)
+ {
+ statement += "?";
+ argumentCount--;
+ if (argumentCount)
+ {
+ statement += ", ";
+ }
+ }
+
+ statement += " )";
+
+ return statement;
+ }
+
+ virtual ArgumentIndex BindTo(DataCommand *command, ArgumentIndex index)
+ {
+ ArgumentIndex argumentIndex = index;
+ FOREACH(argumentIt, m_argumentList)
+ {
+ DataCommandUtils::BindArgument(command, argumentIndex, *argumentIt);
+ argumentIndex++;
+ }
+ return argumentIndex + 1;
+ }
+
+ template<typename TableDefinition>
+ struct ValidForTable {
+ typedef typename TableDefinition::ColumnList::template Contains<ColumnData> Yes;
+ };
+};
+
+#define ORM_DEFINE_COMPARE_EXPRESSION_NUMEROUS_ARGUMENTS(name, relationType) \
+ template<typename ColumnData> \
+ class __attribute__ ((visibility("hidden"))) name : public NumerousArguments<ColumnData, RelationTypes::relationType> { \
+ public: \
+ name(std::set<typename ColumnData::ColumnType> column) : \
+ NumerousArguments<ColumnData, RelationTypes::relationType>(column) \
+ {} \
+ };
+
+ORM_DEFINE_COMPARE_EXPRESSION_NUMEROUS_ARGUMENTS(In, In)
+
template<typename ColumnType>
ColumnType GetColumnFromCommand(ColumnIndex columnIndex, DataCommand *command);
+class __attribute__ ((visibility("hidden"))) CustomColumnBase {
+public:
+ CustomColumnBase() {}
+ virtual ~CustomColumnBase() {}
+};
+
+template<typename ColumnType>
+class __attribute__ ((visibility("hidden"))) CustomColumn : public CustomColumnBase {
+private:
+ ColumnType m_columnData;
+
+public:
+ CustomColumn() {}
+ CustomColumn(ColumnType data)
+ {
+ m_columnData = data;
+ }
+
+ void SetColumnData(ColumnType data)
+ {
+ m_columnData = data;
+ }
+
+ ColumnType GetColumnData() const
+ {
+ return m_columnData;
+ }
+};
+
+template<typename ColumnList>
+class __attribute__ ((visibility("hidden"))) CustomRowUtil {
+public:
+ static void MakeColumnList(std::vector<CustomColumnBase*>& columnList)
+ {
+ typedef CustomColumn<typename ColumnList::Head::ColumnType> Type;
+ Type* pColumn = new Type();
+ columnList.push_back(pColumn);
+ CustomRowUtil<typename ColumnList::Tail>::MakeColumnList(columnList);
+ }
+
+ static void CopyColumnList(const std::vector<CustomColumnBase*>& srcList, std::vector<CustomColumnBase*>& dstList)
+ {
+ CopyColumnList(srcList, dstList, 0);
+ }
+
+ static ColumnIndex GetColumnIndex(const std::string& columnName)
+ {
+ return GetColumnIndex(columnName, 0);
+ }
+
+private:
+ static void CopyColumnList(const std::vector<CustomColumnBase*>& srcList, std::vector<CustomColumnBase*>& dstList, ColumnIndex index)
+ {
+ typedef CustomColumn<typename ColumnList::Head::ColumnType> Type;
+ Type* pColumn = new Type(((Type*)(srcList.at(index)))->GetColumnData());
+ dstList.push_back(pColumn);
+ CustomRowUtil<typename ColumnList::Tail>::CopyColumnList(srcList, dstList, index + 1);
+ }
+
+ static ColumnIndex GetColumnIndex(const std::string& columnName, ColumnIndex index)
+ {
+ if (ColumnList::Head::GetColumnName() == columnName)
+ return index;
+
+ return CustomRowUtil<typename ColumnList::Tail>::GetColumnIndex(columnName, index + 1);
+ }
+
+template<typename Other>
+friend class CustomRowUtil;
+};
+
+template<>
+class __attribute__ ((visibility("hidden"))) CustomRowUtil<DPL::TypeListGuard> {
+public:
+ static void MakeColumnList(std::vector<CustomColumnBase*>&) {}
+private:
+ static void CopyColumnList(const std::vector<CustomColumnBase*>&, std::vector<CustomColumnBase*>&, ColumnIndex) {}
+ static ColumnIndex GetColumnIndex(const std::string&, ColumnIndex) { return -1; }
+
+template<typename Other>
+friend class CustomRowUtil;
+};
+
+template<typename ColumnList>
+class __attribute__ ((visibility("hidden"))) CustomRow {
+private:
+ std::vector<CustomColumnBase*> m_columns;
+
+public:
+ CustomRow()
+ {
+ CustomRowUtil<ColumnList>::MakeColumnList(m_columns);
+ }
+
+ CustomRow(const CustomRow& r)
+ {
+ CustomRowUtil<ColumnList>::CopyColumnList(r.m_columns, m_columns);
+ }
+
+ virtual ~CustomRow()
+ {
+ while (!m_columns.empty())
+ {
+ CustomColumnBase* pCustomColumn = m_columns.back();
+ m_columns.pop_back();
+ if (pCustomColumn)
+ delete pCustomColumn;
+ }
+ }
+
+ template<typename ColumnType>
+ void SetColumnData(ColumnIndex columnIndex, ColumnType data)
+ {
+ typedef CustomColumn<ColumnType> Type;
+ Assert(columnIndex < m_columns.size());
+ Type* pColumn = dynamic_cast<Type*>(m_columns.at(columnIndex));
+ Assert(pColumn);
+ pColumn->SetColumnData(data);
+ }
+
+ template<typename ColumnData>
+ typename ColumnData::ColumnType GetColumnData()
+ {
+ typedef CustomColumn<typename ColumnData::ColumnType> Type;
+ ColumnIndex index = CustomRowUtil<ColumnList>::GetColumnIndex(ColumnData::GetColumnName());
+ Assert(index < m_columns.size());
+ Type* pColumn = dynamic_cast<Type*>(m_columns.at(index));
+ Assert(pColumn);
+ return pColumn->GetColumnData();
+ }
+};
+
+template<typename CustomRow, typename ColumnType>
+void SetColumnData(CustomRow& row, ColumnType columnData, ColumnIndex columnIndex)
+{
+ row.SetColumnData<ColumnType>(columnIndex, columnData);
+}
+
+template<typename ColumnList, typename CustomRow>
+class __attribute__ ((visibility("hidden"))) FillCustomRowUtil {
+public:
+ static void FillCustomRow(CustomRow& row, DataCommand* command)
+ {
+ FillCustomRow(row, 0, command);
+ }
+
+private:
+ static void FillCustomRow(CustomRow& row, ColumnIndex columnIndex, DataCommand* command)
+ {
+ typename ColumnList::Head::ColumnType columnData;
+ columnData = GetColumnFromCommand<typename ColumnList::Head::ColumnType>(columnIndex, command);
+ SetColumnData<CustomRow, typename ColumnList::Head::ColumnType>(row, columnData, columnIndex);
+ FillCustomRowUtil<typename ColumnList::Tail, CustomRow>::FillCustomRow(row, columnIndex + 1, command);
+ }
+
+template<typename Other, typename OtherRow>
+friend class FillCustomRowUtil;
+};
+
+template<typename CustomRow>
+class __attribute__ ((visibility("hidden"))) FillCustomRowUtil<DPL::TypeListGuard, CustomRow> {
+private:
+ static void FillCustomRow(CustomRow&, ColumnIndex, DataCommand *)
+ { /* do nothing, we're past the last element of column list */ }
+
+template<typename Other, typename OtherRow>
+friend class FillCustomRowUtil;
+};
+
template<typename ColumnList, typename Row>
-class FillRowUtil {
+class __attribute__ ((visibility("hidden"))) FillRowUtil {
public:
+ static void FillRow(Row& row, DataCommand *command)
+ {
+ FillRow(row, 0, command);
+ }
+
+private:
static void FillRow(Row& row, ColumnIndex columnIndex, DataCommand *command)
{
typename ColumnList::Head::ColumnType rowField;
ColumnList::Head::SetRowField(row, rowField);
FillRowUtil<typename ColumnList::Tail, Row>::FillRow(row, columnIndex + 1, command);
}
+
+template<typename Other, typename OtherRow>
+friend class FillRowUtil;
};
template<typename Row>
-class FillRowUtil<DPL::TypeListGuard, Row> {
-public:
+class __attribute__ ((visibility("hidden"))) FillRowUtil<DPL::TypeListGuard, Row> {
+private:
static void FillRow(Row&, ColumnIndex, DataCommand *)
{ /* do nothing, we're past the last element of column list */ }
+
+template<typename Other, typename OtherRow>
+friend class FillRowUtil;
+};
+
+template<typename ColumnList>
+class __attribute__ ((visibility("hidden"))) JoinUtil {
+public:
+ static std::string GetColumnNames()
+ {
+ std::string result;
+ result = ColumnList::Head::GetTableName();
+ result += ".";
+ result += ColumnList::Head::GetColumnName();
+ if (ColumnList::Tail::Size > 0)
+ result += ", ";
+
+ return result += JoinUtil<typename ColumnList::Tail>::GetColumnNames();
+ }
+
+ static std::string GetJoinTableName(const std::string& tableName)
+ {
+ std::string joinTableName = ColumnList::Head::GetTableName();
+ if (tableName.find(joinTableName) == std::string::npos)
+ return joinTableName;
+
+ return JoinUtil<typename ColumnList::Tail>::GetJoinTableName(tableName);
+ }
+};
+
+template<>
+class __attribute__ ((visibility("hidden"))) JoinUtil<DPL::TypeListGuard> {
+public:
+ static std::string GetColumnNames() { return ""; }
+ static std::string GetJoinTableName(std::string) { return ""; }
};
class Exception {
};
template<typename TableDefinition>
-class Query
+class __attribute__ ((visibility("hidden"))) Query
{
protected:
explicit Query(IOrmInterface* interface) :
};
template<typename TableDefinition>
-class QueryWithWhereClause : public Query<TableDefinition>
+class
__attribute__ ((visibility("hidden"))) QueryWithWhereClause : public Query<TableDefinition>
{
protected:
ExpressionPtr m_whereExpression;
str.str());
}
//TODO maybe don't make a copy here but just generate the string part of the query.
- m_whereExpression.Reset(new Expression(expression));
+ m_whereExpression.reset(new Expression(expression));
}
};
template<typename TableDefinition>
-class Delete : public QueryWithWhereClause<TableDefinition>
+class
__attribute__ ((visibility("hidden"))) Delete : public QueryWithWhereClause<TableDefinition>
{
protected:
void Prepare()
}
};
+namespace {
+class BindVisitor {
+private:
+ DataCommand *m_command;
+public:
+ ArgumentIndex m_bindArgumentIndex;
+
+ BindVisitor(DataCommand *command) :
+ m_command(command),
+ m_bindArgumentIndex(1)
+ {}
+
+ template<typename ColumnType>
+ void Visit(const char*, const ColumnType& value, bool isSet)
+ {
+ if ( isSet )
+ {
+ DataCommandUtils::BindArgument(m_command, m_bindArgumentIndex, value);
+ m_bindArgumentIndex++;
+ }
+ }
+};
+} //anonymous namespace
template<typename TableDefinition>
-class Insert : public Query<TableDefinition>
+class
__attribute__ ((visibility("hidden"))) Insert : public Query<TableDefinition>
{
public:
typedef typename TableDefinition::Row Row;
}
}
- class BindVisitor {
- private:
- DataCommand *m_command;
- ArgumentIndex m_bindArgumentIndex;
- public:
- BindVisitor(DataCommand *command) :
- m_command(command),
- m_bindArgumentIndex(1)
- {}
-
- template<typename ColumnType>
- void Visit(const char*, const ColumnType& value, bool isSet)
- {
- if ( isSet )
- {
- DataCommandUtils::BindArgument(m_command, m_bindArgumentIndex, value);
- m_bindArgumentIndex++;
- }
- }
- };
-
void Bind()
{
BindVisitor visitor(this->m_command);
};
template<typename TableDefinition>
-class Select : public QueryWithWhereClause<TableDefinition>
+class
__attribute__ ((visibility("hidden"))) Select : public QueryWithWhereClause<TableDefinition>
{
public:
typedef typename TableDefinition::ColumnList ColumnList;
typedef std::list<Row> RowList;
protected:
DPL::Optional<std::string> m_orderBy;
+ std::string m_JoinClause;
bool m_distinctResults;
void Prepare(const char* selectColumnName)
this->m_commandString += " FROM ";
this->m_commandString += TableDefinition::GetName();
+ this->m_commandString += m_JoinClause;
+
QueryWithWhereClause<TableDefinition>::Prepare();
if ( !m_orderBy.IsNull() )
Row GetRow()
{
Row row;
- FillRowUtil<ColumnList, Row>::FillRow(row, 0, this->m_command);
+ FillRowUtil<ColumnList, Row>::FillRow(row, this->m_command);
+ return row;
+ }
+
+ template<typename ColumnList, typename CustomRow>
+ CustomRow GetCustomRow()
+ {
+ CustomRow row;
+ FillCustomRowUtil<ColumnList, CustomRow>::FillCustomRow(row, this->m_command);
return row;
}
m_orderBy = orderBy;
}
+ template<typename ColumnList, typename Expression>
+ void Join(const Expression& expression) {
+ std::string usedTableNames = TableDefinition::GetName();
+ if (!m_JoinClause.empty())
+ usedTableNames += m_JoinClause;
+
+ this->m_JoinClause += " JOIN ";
+ this->m_JoinClause += JoinUtil<ColumnList>::GetJoinTableName(usedTableNames);
+ this->m_JoinClause += " ON ";
+ this->m_JoinClause += expression.GetString();
+ }
+
template<typename ColumnData>
typename ColumnData::ColumnType GetSingleValue()
{
this->m_command->Reset();
return resultList;
}
+
+ template<typename ColumnList, typename CustomRow>
+ CustomRow GetCustomSingleRow()
+ {
+ Prepare(JoinUtil<ColumnList>::GetColumnNames().c_str());
+ Bind();
+ this->m_command->Step();
+
+ CustomRow result = GetCustomRow<ColumnList, CustomRow>();
+
+ this->m_command->Reset();
+ return result;
+ }
+
+ template<typename ColumnList, typename CustomRow>
+ std::list<CustomRow> GetCustomRowList()
+ {
+ Prepare(JoinUtil<ColumnList>::GetColumnNames().c_str());
+ Bind();
+
+ std::list<CustomRow> resultList;
+
+ while (this->m_command->Step())
+ resultList.push_back(GetCustomRow<ColumnList, CustomRow>());
+
+ this->m_command->Reset();
+ return resultList;
+ }
};
template<typename TableDefinition>
-class Update : public QueryWithWhereClause<TableDefinition> {
+class
__attribute__ ((visibility("hidden"))) Update : public QueryWithWhereClause<TableDefinition> {
public:
typedef typename TableDefinition::Row Row;
}
}
- class BindVisitor {
- private:
- DataCommand *m_command;
-
- public:
- ArgumentIndex m_bindArgumentIndex;
-
- BindVisitor(DataCommand *command) :
- m_command(command),
- m_bindArgumentIndex(1)
- {}
-
- template<typename ColumnType>
- void Visit(const char*, const ColumnType& value, bool isSet)
- {
- if ( isSet )
- {
- DataCommandUtils::BindArgument(m_command, m_bindArgumentIndex, value);
- m_bindArgumentIndex++;
- }
- }
- };
-
void Bind()
{
BindVisitor visitor(this->m_command);
#define DECLARE_COLUMN(FIELD, TYPE) \
struct FIELD { \
typedef TYPE ColumnType; \
+ static const char* GetTableName() { return GetName(); } \
static const char* GetColumnName() { return STRINGIFY(FIELD); } \
- static void SetRowField(Row& row, const TYPE& value) { row.Set_##FIELD(value);} \
+ static void SetRowField(Row& row, const TYPE& _value) { row.Set_##FIELD(_value);} \
};
#define INT int
#define VARCHAR(x) DPL::String
#define TEXT DPL::String
-#define SQL(args...)
-#define TABLE_CONSTRAINTS(args...)
+#define SQL(...)
+#define TABLE_CONSTRAINTS(...)
#define OPTIONAL(type) DPL::Optional< type >
#define DATABASE_START(db_name) \
namespace db_name \
class RowBase; \
inline std::ostream& operator<<(std::ostream& ostr, const RowBase& row); \
}
-#define COLUMN_NOT_NULL(name, type, args...)
-#define COLUMN(name, type, args...)
+#define COLUMN_NOT_NULL(name, type, ...)
+#define COLUMN(name, type, ...)
#define CREATE_TABLE_END()
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class RowBase { \
public: friend std::ostream& operator<<(std::ostream&, const RowBase&);
-#define COLUMN_NOT_NULL(name, type, args...) \
+#define COLUMN_NOT_NULL(name, type, ...) \
protected: type name; bool m_##name##_set; \
- public: void Set_##name(const type& value) { \
+ public: void Set_##name(const type& _value) { \
m_##name##_set = true; \
- this->name = value; \
+ this->name = _value; \
} \
public: type Get_##name() const { \
if ( !m_##name##_set ) { \
return name; \
}
-#define COLUMN(name, type, args...) \
+#define COLUMN(name, type, ...) \
protected: OPTIONAL(type) name; bool m_##name##_set; \
- public: void Set_##name(const OPTIONAL(type)& value) { \
+ public: void Set_##name(const OPTIONAL(type)& _value) { \
m_##name##_set = true; \
- this->name = value; \
+ this->name = _value; \
} \
public: OPTIONAL(type) Get_##name() const { \
if ( !m_##name##_set ) { \
// RowBase ostream operator<<
#define CREATE_TABLE(name) std::ostream& name::operator<<(std::ostream& ostr, const RowBase& row) { using ::operator<< ; ostr << STRINGIFY(name) << " (";
-#define COLUMN_NOT_NULL(name, type, args...) ostr << " '" << row.name << "'" ;
-#define COLUMN(name, type, args...) ostr << " '" << row.name << "'" ;
+#define COLUMN_NOT_NULL(name, type, ...) ostr << " '" << row.name << "'" ;
+#define COLUMN(name, type, ...) ostr << " '" << row.name << "'" ;
#define CREATE_TABLE_END() ostr << " )" ; return ostr; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class RowBase2 : public RowBase { \
public: bool operator==(const RowBase2& row) const { return true
-#define COLUMN_NOT_NULL(name, type, args...) && (this->name == row.name)
-#define COLUMN(name, type, args...) && (this->name == row.name)
+#define COLUMN_NOT_NULL(name, type, ...) && (this->name == row.name)
+#define COLUMN(name, type, ...) && (this->name == row.name)
#define CREATE_TABLE_END() ; } }; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class RowBase3 : public RowBase2 { \
public: bool operator<(const RowBase3& row) const {
-#define COLUMN_NOT_NULL(name, type, args...) if (this->name < row.name) { return true; } if (this->name > row.name) { return false; }
-#define COLUMN(name, type, args...) if (this->name < row.name) { return true; } if (this->name > row.name) { return false; }
+#define COLUMN_NOT_NULL(name, type, ...) if (this->name < row.name) { return true; } if (this->name > row.name) { return false; }
+#define COLUMN(name, type, ...) if (this->name < row.name) { return true; } if (this->name > row.name) { return false; }
#define CREATE_TABLE_END() return false; } }; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class RowBase4 : public RowBase3 { \
public: bool IsSignatureMatching(const RowBase4& row) const { return true
-#define COLUMN_NOT_NULL(name, type, args...) && (this->m_##name##_set == row.m_##name##_set)
-#define COLUMN(name, type, args...) && (this->m_##name##_set == row.m_##name##_set)
+#define COLUMN_NOT_NULL(name, type, ...) && (this->m_##name##_set == row.m_##name##_set)
+#define COLUMN(name, type, ...) && (this->m_##name##_set == row.m_##name##_set)
#define CREATE_TABLE_END() ; } }; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class RowBase5 : public RowBase4 { \
public: RowBase5() {
-#define COLUMN_NOT_NULL(name, type, args...) m_##name##_set = false;
-#define COLUMN(name, type, args...) m_##name##_set = false;
+#define COLUMN_NOT_NULL(name, type, ...) m_##name##_set = false;
+#define COLUMN(name, type, ...) m_##name##_set = false;
#define CREATE_TABLE_END() } }; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
#define CREATE_TABLE(name) namespace name { class Row : public RowBase5 { \
public: template<typename Visitor> \
void VisitColumns(Visitor& visitor) const {
-#define COLUMN_NOT_NULL(name, type, args...) visitor.Visit(STRINGIFY(name), this->name, this->m_##name##_set);
-#define COLUMN(name, type, args...) visitor.Visit(STRINGIFY(name), this->name, this->m_##name##_set);
+#define COLUMN_NOT_NULL(name, type, ...) visitor.Visit(STRINGIFY(name), this->name, this->m_##name##_set);
+#define COLUMN(name, type, ...) visitor.Visit(STRINGIFY(name), this->name, this->m_##name##_set);
#define CREATE_TABLE_END() } }; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
// Field structure declarations
-#define CREATE_TABLE(name) namespace name {
-#define COLUMN_NOT_NULL(name, type, args...) DECLARE_COLUMN(name, type)
-#define COLUMN(name, type, args...) DECLARE_COLUMN(name, OPTIONAL(type))
+#define CREATE_TABLE(name) namespace name { \
+ static const char* GetName() { return STRINGIFY(name); }
+#define COLUMN_NOT_NULL(name, type, ...) DECLARE_COLUMN(name, type)
+#define COLUMN(name, type, ...) DECLARE_COLUMN(name, OPTIONAL(type))
#define CREATE_TABLE_END() }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
// ColumnList typedef
#define CREATE_TABLE(name) namespace name { typedef DPL::TypeListDecl<
-#define COLUMN_NOT_NULL(name, type, args...) name,
-#define COLUMN(name, type, args...) name,
+#define COLUMN_NOT_NULL(name, type, ...) name,
+#define COLUMN(name, type, ...) name,
#define CREATE_TABLE_END() DPL::TypeListGuard>::Type ColumnList; }
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
}; \
}
-#define COLUMN_NOT_NULL(name, type, args...)
-#define COLUMN(name, type, args...)
+#define COLUMN_NOT_NULL(name, type, ...)
+#define COLUMN(name, type, ...)
#define CREATE_TABLE_END()
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
typedef Delete<TableDefinition> Delete; \
typedef Update<TableDefinition> Update; \
}
-#define COLUMN_NOT_NULL(name, type, args...)
-#define COLUMN(name, type, args...)
+#define COLUMN_NOT_NULL(name, type, ...)
+#define COLUMN(name, type, ...)
#define CREATE_TABLE_END()
#include ORM_GENERATOR_DATABASE_NAME_LOCAL
//Do not include this file directly! It is used only for SQL code generation.
#define CREATE_TABLE(name) CREATE TABLE name (
-#define COLUMN(name, type, args...) name type args ,
-#define COLUMN_NOT_NULL(name, type, args...) name type args not null,
-#define SQL(args...) args
-#define TABLE_CONSTRAINTS(args...) args ,
+#define COLUMN(name, type, ...) name type __VA_ARGS__ ,
+#define COLUMN_NOT_NULL(name, type, ...) name type __VA_ARGS__ not null,
+#define SQL(...) __VA_ARGS__
+#define TABLE_CONSTRAINTS(...) __VA_ARGS__ ,
#define CREATE_TABLE_END() CHECK(1) );
#define DATABASE_START(db_name)
#define DATABASE_END()
#include <dpl/noncopyable.h>
#include <dpl/exception.h>
#include <dpl/optional.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
#include <dpl/string.h>
#include <dpl/log/log.h>
#include <sqlite3.h>
None = 1<<0,
UseLucene = 1<<1
};
+
+ enum Option
+ {
+ RO = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READONLY,
+ /**
+ *TODO: please remove CREATE option from RW flag when all places
+ * that need that switched do CRW
+ */
+ RW = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+ CRW = RW | SQLITE_OPEN_CREATE
+ };
};
// RowID
int m_dataCommandsCount;
// Synchronization object
- ScopedPtr<SynchronizationObject> m_synchronizationObject;
+ std::unique_ptr<SynchronizationObject> m_synchronizationObject;
- virtual void Connect(const std::string &address, Flag::Type = Flag::None);
+ virtual void Connect(const std::string &address,
+ Flag::Type = Flag::None, Flag::Option = Flag::RO);
virtual void Disconnect();
void TurnOnForeignKeys();
*/
explicit SqlConnection(const std::string &address = std::string(),
Flag::Type flags = Flag::None,
+ Flag::Option options = Flag::RO,
SynchronizationObject *synchronizationObject =
AllocDefaultSynchronizationObject());
{
}
- void AttachToThread()
+ void AttachToThread(
+ DPL::DB::SqlConnection::Flag::Option options =
+ DPL::DB::SqlConnection::Flag::RO)
{
Linger() = false;
// Initialize SQL connection described in traits
LogInfo("Attaching thread database connection: " << m_address);
- Connection() = new DPL::DB::SqlConnection(m_address.c_str(), m_flags);
+ Connection() = new DPL::DB::SqlConnection(m_address.c_str(), m_flags, options);
RefCounter() = 0;
* @version 1.0
* @brief This file is the implementation file of SQL naive synchronization object
*/
+#include <stddef.h>
#include <dpl/db/naive_synchronization_object.h>
#include <dpl/thread.h>
* @version 1.0
* @brief Static definitions and function template specialziations of DPL-ORM.
*/
-
+#include <stddef.h>
#include <dpl/db/orm.h>
namespace DPL {
const char And[] = "AND";
const char Or[] = "OR";
const char Is[] = "IS";
+const char In[] = "IN";
}
template<>
}
}
-}
\ No newline at end of file
+}
* @version 1.0
* @brief This file is the implementation file of SQL connection
*/
+#include <stddef.h>
#include <dpl/db/sql_connection.h>
#include <dpl/db/naive_synchronization_object.h>
#include <dpl/scoped_free.h>
Assert(connection != NULL);
// Notify all after potentially synchronized database connection access
- ScopedNotifyAll notifyAll(connection->m_synchronizationObject.Get());
+ ScopedNotifyAll notifyAll(connection->m_synchronizationObject.get());
for (;;)
{
{
// Notify all after potentially synchronized database connection access
ScopedNotifyAll notifyAll(
- m_masterConnection->m_synchronizationObject.Get());
+ m_masterConnection->m_synchronizationObject.get());
for (;;)
{
return Optional<String>(s);
}
-void SqlConnection::Connect(const std::string &address, Flag::Type flag)
+void SqlConnection::Connect(const std::string &address,
+ Flag::Type type,
+ Flag::Option flag)
{
- if (m_connection != NULL)
- {
+ if (m_connection != NULL) {
LogPedantic("Already connected.");
return;
}
-
LogPedantic("Connecting to DB: " << address << "...");
// Connect to database
int result;
-
- if (flag & Flag::UseLucene)
- {
+ if (type & Flag::UseLucene) {
result = db_util_open_with_options(
address.c_str(),
&m_connection,
- SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+ flag,
NULL);
m_usingLucene = true;
LogPedantic("Lucene index enabled");
- }
- else
- {
+ } else {
result = sqlite3_open_v2(
address.c_str(),
&m_connection,
- SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+ flag,
NULL);
m_usingLucene = false;
LogPedantic("Lucene index disabled");
}
- if (result == SQLITE_OK)
- {
+ if (result == SQLITE_OK) {
LogPedantic("Connected to DB");
- }
- else
- {
+ } else {
LogPedantic("Failed to connect to DB!");
ThrowMsg(Exception::ConnectionBroken, address);
}
SqlConnection::SqlConnection(const std::string &address,
Flag::Type flag,
+ Flag::Option option,
SynchronizationObject *synchronizationObject)
: m_connection(NULL),
m_usingLucene(false),
LogPedantic("Opening database connection to: " << address);
// Connect to DB
- SqlConnection::Connect(address, flag);
+ SqlConnection::Connect(address, flag, option);
if (!m_synchronizationObject)
{
return;
}
+ if (format == NULL)
+ {
+ LogPedantic("Null query!");
+ ThrowMsg(Exception::SyntaxError, "Null statement");
+ }
+
char *rawBuffer;
va_list args;
LogPedantic("Executing SQL command: " << buffer.Get());
// Notify all after potentially synchronized database connection access
- ScopedNotifyAll notifyAll(m_synchronizationObject.Get());
+ ScopedNotifyAll notifyAll(m_synchronizationObject.get());
for (;;)
{
* @version 1.0
* @brief This file contains the definition of thread database support
*/
-
+#include <stddef.h>
#include <dpl/db/thread_database_support.h>
\ No newline at end of file
struct ObjectRegistration
{
- ObjectRegistration(guint registrationId, const ObjectPtr& object)
- : registrationId(registrationId),
- object(object)
+ ObjectRegistration(guint _registrationId, const ObjectPtr& _object)
+ : registrationId(_registrationId),
+ object(_object)
{
}
* @version 1.0
* @brief
*/
-
+#include <stddef.h>
#include <dpl/log/log.h>
#include <dpl/dbus/connection.h>
#include <dpl/dbus/exception.h>
* @version 1.0
* @brief
*/
-
+#include <stddef.h>
#include <dpl/dbus/dispatcher.h>
namespace DPL
* @version 1.0
* @brief
*/
+#include <stddef.h>
#include <dpl/log/log.h>
#include <dpl/assert.h>
#include <dpl/exception.h>
* @version 1.0
* @brief
*/
-
+#include <stddef.h>
#include <dpl/dbus/object.h>
namespace DPL {
* @version 1.0
* @brief
*/
-
+#include <stddef.h>
#include <dpl/dbus/object_proxy.h>
namespace DPL {
* @version 1.0
* @brief
*/
-
+#include <stddef.h>
#include <dpl/assert.h>
#include <dpl/log/log.h>
#include <dpl/dbus/server.h>
}
}
-}
\ No newline at end of file
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+#
+# @file config.cmake
+# @author Soyoung Kim(sy037.kim@samsung.com)
+# @version 1.0
+# @brief
+#
+
+SET(DPL_ENCRYPTION_SOURCES
+ ${PROJECT_SOURCE_DIR}/modules/encryption/src/resource_encryption.cpp
+ ${PROJECT_SOURCE_DIR}/modules/encryption/src/resource_decryption.cpp
+ PARENT_SCOPE
+)
+
+
+SET(DPL_ENCRYPTION_HEADERS
+ ${PROJECT_SOURCE_DIR}/modules/encryption/include/dpl/encryption/resource_encryption.h
+ ${PROJECT_SOURCE_DIR}/modules/encryption/include/dpl/encryption/resource_decryption.h
+ PARENT_SCOPE
+)
+
+SET(DPL_ENCRYPTION_INCLUDE_DIR
+ ${PROJECT_SOURCE_DIR}/modules/encryption/include
+ PARENT_SCOPE
+)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file resource_decryption.h
+ * @author Soyoung Kim (sy037.kim@samsung.com)
+ * @version 1.0
+ * @brief Header file for resource decryption
+ */
+#ifndef RESOURCE_DECRYPTION_H
+#define RESOURCE_DECRYPTION_H
+
+#include <string.h>
+#include <string>
+#include <openssl/aes.h>
+#include <openssl/sha.h>
+#include <dpl/exception.h>
+
+extern char** calculate(char*pappId, int idLen, int keyLen);
+
+namespace WRTDecryptor{
+class ResourceDecryptor
+{
+ public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, GetDecKeyFailed)
+ DECLARE_EXCEPTION_TYPE(Base, EncryptionFailed)
+ };
+
+ ResourceDecryptor();
+ ResourceDecryptor(std::string userKey);
+ virtual ~ResourceDecryptor();
+
+ void SetDecryptionKey(std::string userKey);
+ void GetDecryptedChunk(unsigned char* inBuf, unsigned char* decBuf, size_t chunkSize);
+
+ private:
+ AES_KEY* GetDecryptionKey();
+ AES_KEY m_decKey;
+
+};
+} //namespace WRTDecryptor
+
+#endif /* RESOURCE_DECRYPTION_H */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file resource_encryption.h
+ * @author Soyoung Kim (sy037.kim@samsung.com)
+ * @version 1.0
+ * @brief Header file for resource encryption
+ */
+#ifndef RESOURCE_ENCRYPTION_H
+#define RESOURCE_ENCRYPTION_H
+
+#include <string.h>
+#include <string>
+#include <openssl/aes.h>
+#include <openssl/sha.h>
+#include <dpl/exception.h>
+
+extern char** calculate(char*pappId, int idLen, int keyLen);
+
+namespace WRTEncryptor{
+class ResourceEncryptor
+{
+ public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFileFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFileFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, EncryptionFailed)
+ };
+
+ ResourceEncryptor();
+ virtual ~ResourceEncryptor();
+
+ int GetBlockSize(int inSize);
+ void CreateEncryptionKey(std::string userKey);
+ void EncryptChunk(unsigned char* inputBuf, unsigned char* encBuf, size_t
+ chunkSize);
+
+ private:
+ AES_KEY GetEncryptionkey();
+ AES_KEY m_encKey;
+};
+} //namespace WRTEncryptor
+
+#endif /* RESOURCE_DECRYPTION_H */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file resource_decryption.cpp
+ * @author Soyoung Kim (sy037.kim@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for resource decryption
+ */
+#include <stddef.h>
+#include <dpl/encryption/resource_decryption.h>
+
+#include <fcntl.h>
+#include <string>
+#include <dpl/log/log.h>
+#include <dpl/exception.h>
+
+namespace {
+#define BITS_SIZE 128
+#define KEY_SIZE 16
+}
+namespace WRTDecryptor{
+ResourceDecryptor::ResourceDecryptor()
+{
+ LogDebug("Started Decryption");
+}
+
+ResourceDecryptor::ResourceDecryptor(std::string userKey)
+{
+ LogDebug("Finished Decryption");
+ SetDecryptionKey(userKey);
+}
+
+ResourceDecryptor::~ResourceDecryptor()
+{
+}
+
+void ResourceDecryptor::SetDecryptionKey(std::string userKey)
+{
+ if (userKey.empty()) {
+ return;
+ }
+
+ char **duk = calculate(const_cast<char*>(userKey.c_str()), userKey.size(), KEY_SIZE);
+ unsigned char *key = reinterpret_cast<unsigned char*>(*duk);
+
+ if ( 0 > AES_set_decrypt_key(key, BITS_SIZE, &m_decKey)) {
+ ThrowMsg(ResourceDecryptor::Exception::GetDecKeyFailed,
+ "Failed to create decryption key");
+ }
+}
+
+AES_KEY* ResourceDecryptor::GetDecryptionKey()
+{
+ return &m_decKey;
+}
+
+void ResourceDecryptor::GetDecryptedChunk(unsigned char*
+ inBuf, unsigned char* decBuf, size_t inBufSize)
+{
+ Assert(decBuf);
+ if (decBuf == NULL) {
+ ThrowMsg(ResourceDecryptor::Exception::EncryptionFailed,
+ "Failed to Get Decryption Chunk");
+ }
+ unsigned char ivec[16] = {0, };
+
+ AES_cbc_encrypt(inBuf, decBuf, inBufSize, &m_decKey, ivec, AES_DECRYPT);
+ LogDebug("Success decryption");
+}
+
+} //namespace WRTDecryptor
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file resource_encryption.cpp
+ * @author Soyoung Kim (sy037.kim@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for resource encryption
+ */
+#include <stddef.h>
+#include <dpl/encryption/resource_encryption.h>
+
+#include <fcntl.h>
+#include <dpl/log/log.h>
+
+namespace {
+#define BITS_SIZE 128
+#define KEY_SIZE 16
+}
+namespace WRTEncryptor{
+ResourceEncryptor::ResourceEncryptor()
+{
+ LogDebug("Started Encrytion");
+}
+
+ResourceEncryptor::~ResourceEncryptor()
+{
+ LogDebug("Finished Encrytion");
+}
+
+int ResourceEncryptor::GetBlockSize(int inSize)
+{
+ if ((inSize % AES_BLOCK_SIZE) != 0) {
+ return (( inSize/ AES_BLOCK_SIZE) +1) * AES_BLOCK_SIZE;
+ }
+ return inSize;
+}
+
+void ResourceEncryptor::CreateEncryptionKey(std::string userKey)
+{
+ if (userKey.empty()) {
+ return;
+ }
+
+ char **duk = calculate(const_cast<char*>(userKey.c_str()), userKey.size(), KEY_SIZE);
+ unsigned char *key = reinterpret_cast<unsigned char*>(*duk);
+
+ if ( 0 > AES_set_encrypt_key(key, BITS_SIZE, &m_encKey)) {
+ ThrowMsg(ResourceEncryptor::Exception::CreateEncKeyFailed,
+ "Failed to create encryption key");
+ }
+ LogDebug("Success to create ecryption and decryption key");
+}
+
+AES_KEY ResourceEncryptor::GetEncryptionkey()
+{
+ return m_encKey;
+}
+
+void ResourceEncryptor::EncryptChunk(unsigned char*
+ inputBuf, unsigned char* encBuf, size_t chunkSize)
+{
+ Assert(inputBuf);
+ Assert(encBuf);
+
+ unsigned char ivec[16] = {0, };
+
+ AES_cbc_encrypt(inputBuf, encBuf, chunkSize, &m_encKey, ivec, AES_ENCRYPT);
+}
+} //namespace ResourceEnc
${PROJECT_SOURCE_DIR}/modules/event/src/abstract_event_call.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/abstract_event_dispatcher.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/controller.cpp
- ${PROJECT_SOURCE_DIR}/modules/event/src/event_delivery.cpp
- ${PROJECT_SOURCE_DIR}/modules/event/src/event_delivery_detail.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/event_listener.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/event_support.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/generic_event_call.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/main_event_dispatcher.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/thread_event_dispatcher.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/inter_context_delegate.cpp
- ${PROJECT_SOURCE_DIR}/modules/event/src/nested_loop.cpp
${PROJECT_SOURCE_DIR}/modules/event/src/model.cpp
PARENT_SCOPE
)
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/abstract_event_call.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/abstract_event_dispatcher.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/controller.h
- ${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_delivery_detail.h
- ${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_delivery.h
- ${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_delivery_injector.h
- ${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_delivery_messages.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_listener.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/event_support.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/generic_event_call.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/main_event_dispatcher.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/thread_event_dispatcher.h
- ${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/nested_loop.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/inter_context_delegate.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/model.h
${PROJECT_SOURCE_DIR}/modules/event/include/dpl/event/property.h
#include <dpl/event/generic_event_call.h>
#include <dpl/waitable_event.h>
#include <dpl/fast_delegate.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
#include <dpl/exception.h>
#include <dpl/thread.h>
#include <dpl/assert.h>
double dueTime = 0.0)
{
// Emit event, and retrieve later in current context to dispatch
- ScopedPtr<Mutex::ScopedLock> lock(
+ std::unique_ptr<Mutex::ScopedLock> lock(
new Mutex::ScopedLock(&m_listenerDelegateMutex));
// Show some info
if (!synchronizationBarrier.empty())
{
LogPedantic("Leaving lock due to existing barrier");
- lock.Reset();
+ lock.reset();
}
LogPedantic("Size of barrier: " << synchronizationBarrier.size());
#include <dpl/event/thread_event_dispatcher.h>
#include <dpl/event/main_event_dispatcher.h>
#include <dpl/fast_delegate.h>
-#include <dpl/shared_ptr.h>
-#include <dpl/enable_shared_from_this.h>
#include <dpl/generic_event.h>
#include <dpl/foreach.h>
#include <dpl/recursive_mutex.h>
#include <dpl/apply.h>
#include <tuple>
#include <list>
+#include <memory>
/*
* - Created ICDelegate can be passed freely to other threads.
class ICDSharedDataBase
{
public:
- typedef DPL::SharedPtr<ICDSharedDataBase> ICDSharedDataBasePtr;
+ typedef std::shared_ptr<ICDSharedDataBase> ICDSharedDataBasePtr;
typedef std::list<ICDSharedDataBasePtr> ICDSharedDataBaseList;
class ScopedLock : DPL::Noncopyable
}
virtual void Call()
{
- m_helperBase.Reset();
+ m_helperBase.reset();
}
private:
ICD::Reuse reuse)
{
ICDSharedData* hlp = new ICDSharedData(base, outerDelegate, reuse);
- m_helper.Reset(hlp);
+ m_helper.reset(hlp);
}
// Calling operator will pass all args passed to it to correct context and
{
Assert(m_helper);
ICDPrivate::ICDSharedDataBase::ScopedLock lock(
- DPL::StaticPointerCast<ICDPrivate::ICDSharedDataBase>(m_helper));
+ std::static_pointer_cast<ICDPrivate::ICDSharedDataBase>(m_helper));
m_helper->CallDelegate(args ...);
}
{
Assert(m_helper);
ICDPrivate::ICDSharedDataBase::ScopedLock lock(
- DPL::StaticPointerCast<ICDPrivate::ICDSharedDataBase>(m_helper));
+ std::static_pointer_cast<ICDPrivate::ICDSharedDataBase>(m_helper));
m_helper->disable();
}
ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr
getRelatedICDSharedData() const
{
- return DPL::StaticPointerCast<ICDPrivate::ICDSharedDataBase>(m_helper);
+ return std::static_pointer_cast<ICDPrivate::ICDSharedDataBase>(m_helper);
}
private:
template<typename ThisType>
friend class ICDelegateSupport;
class ICDSharedData;
- typedef DPL::SharedPtr<ICDSharedData> ICDSharedDataPtr;
+ typedef std::shared_ptr<ICDSharedData> ICDSharedDataPtr;
struct PrivateEvent
{
typedef DPL::FastDelegate<void (const PrivateEvent&)>
ICDSharedDataDelegateType;
class ICDSharedData : private DPL::Event::EventSupport<PrivateEvent>,
- private DPL::EnableSharedFromThis<ICDSharedData>,
+ public std::enable_shared_from_this<ICDSharedData>,
public ICDPrivate::ICDSharedDataBase
{
public:
void CallDelegate(ArgTypesList ... args)
{
ICDPrivate::ICDSharedDataBase::ScopedLock lock(
- DPL::StaticPointerCast<ICDPrivate::ICDSharedDataBase>(
- this->SharedFromThis()));
+ std::static_pointer_cast<ICDPrivate::ICDSharedDataBase>(
+ this->shared_from_this()));
if (!isDisabled()) {
- EmitEvent(PrivateEvent(this->SharedFromThis(),
+ EmitEvent(PrivateEvent(this->shared_from_this(),
args ...));
}
}
virtual void disable()
{
ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr ptr(
- DPL::StaticPointerCast<ICDSharedDataBase>(
- this->SharedFromThis()));
+ std::static_pointer_cast<ICDSharedDataBase>(
+ this->shared_from_this()));
ICDPrivate::ICDSharedDataBase::ScopedLock lock(ptr);
if (!isDisabled()) {
ICDPrivate::ICDSharedDataBase::disable();
}
private:
- friend class DPL::SharedPtr<ICDSharedData>;
+ friend class std::shared_ptr<ICDSharedData>;
ICDSharedDataDelegateType m_subDelegate;
ICDPrivate::ICDelegateSupportInterface* m_base;
DPL::FastDelegate<void (ArgTypesList ...)> m_outerDelegate;
void delegateForwarder(const PrivateEvent& event)
{
ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr ptr(
- DPL::StaticPointerCast<ICDSharedDataBase>(event.helper));
+ std::static_pointer_cast<ICDSharedDataBase>(event.helper));
ICDPrivate::ICDSharedDataBase::ScopedLock lock(ptr);
Assert(!m_outerDelegate.empty());
m_ICDSharedDatas;
FOREACH(helper, list) {
ICDPrivate::ICDSharedDataBase::ScopedLock lock(
- DPL::StaticPointerCast<ICDPrivate::ICDSharedDataBase>(*helper));
+ std::static_pointer_cast<ICDPrivate::ICDSharedDataBase>(*helper));
(*helper)->disable();
}
m_ICDSharedDatas.clear();
// Cross thread send support
WrappedEventCallList m_wrappedCrossEventCallList;
Mutex m_crossEventCallMutex;
- WaitableEvent m_crossEventCallInvoker;
+ WaitableEvent* m_crossEventCallInvoker;
Ecore_Event_Handler *m_eventCallHandler;
Ecore_Fd_Handler *m_crossEventCallHandler;
virtual void AddEventCall(AbstractEventCall *abstractEventCall);
virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime);
+ virtual void ResetCrossEventCallHandler();
};
MainEventDispatcher& GetMainEventDispatcherInstance();
EmitEvent(PropertyEvent<Type>(value, this->m_model),
EmitMode::Auto);
}
+
+ void SetWithoutLock(const Type &value)
+ {
+ if (this->m_storage.Get() == value)
+ return;
+
+ this->m_storage.Set(value);
+ }
};
}
* @version 1.0
* @brief This file is the implementation file of abstract event call
*/
+#include <stddef.h>
#include <dpl/event/abstract_event_call.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of abstract event dispatcher
*/
+#include <stddef.h>
#include <dpl/event/abstract_event_dispatcher.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of MVC controller
*/
+#include <stddef.h>
#include <dpl/event/controller.h>
//
* @version 1.0
* @brief This file is the implementation file of MVC event listener
*/
+#include <stddef.h>
#include <dpl/event/event_listener.h>
//
* @version 1.0
* @brief This file is the implementation file of MVC event support
*/
+#include <stddef.h>
#include <dpl/event/event_support.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of generic event call
*/
+#include <stddef.h>
#include <dpl/event/generic_event_call.h>
//
* @version 1.0
* @brief This file is the implementation file of ICDelegate functionality
*/
+#include <stddef.h>
#include <dpl/event/inter_context_delegate.h>
//
* @version 1.0
* @brief This file is the implementation file of main event dispatcher for EFL
*/
+#include <stddef.h>
#include <dpl/event/main_event_dispatcher.h>
#include <dpl/log/log.h>
#include <dpl/assert.h>
if ((m_eventCallHandler = ecore_event_handler_add(m_eventId, &StaticDispatchEvent, this)) == NULL)
ThrowMsg(Exception::CreateFailed, "Failed to register event handler!");
+ // Allocate WaitableEvent
+ m_crossEventCallInvoker = new WaitableEvent();
+
// Register cross event handler
- m_crossEventCallHandler = ecore_main_fd_handler_add(m_crossEventCallInvoker.GetHandle(), ECORE_FD_READ, &StaticDispatchCrossInvoker, this, NULL, NULL);
+ m_crossEventCallHandler = ecore_main_fd_handler_add(m_crossEventCallInvoker->GetHandle(), ECORE_FD_READ, &StaticDispatchCrossInvoker, this, NULL, NULL);
if (m_crossEventCallHandler == NULL)
ThrowMsg(Exception::CreateFailed, "Failed to register cross event handler!");
MainEventDispatcher::~MainEventDispatcher()
{
- // Remove event class handler
- ecore_event_handler_del(m_eventCallHandler);
- m_eventCallHandler = NULL;
-
// Remove cross event handler
ecore_main_fd_handler_del(m_crossEventCallHandler);
m_crossEventCallHandler = NULL;
-
LogPedantic("ECORE cross-event handler unregistered");
+ // Remove m_crossEventCallInvoker
+ delete m_crossEventCallInvoker;
+ m_crossEventCallInvoker = NULL;
+
+ // Remove event class handler
+ ecore_event_handler_del(m_eventCallHandler);
+ m_eventCallHandler = NULL;
+
// Decrement ECORE init count
// We do not need ecore routines any more
ecore_shutdown();
g_lateMainEventDispatcher = NULL;
}
+void MainEventDispatcher::ResetCrossEventCallHandler()
+{
+ // Remove cross event handler
+ ecore_main_fd_handler_del(m_crossEventCallHandler);
+ m_crossEventCallHandler = NULL;
+ LogPedantic("ECORE cross-event handler unregistered");
+
+ // Re-allocate WaitableEvent
+ delete m_crossEventCallInvoker;
+ m_crossEventCallInvoker = new WaitableEvent();
+
+ // Register cross event handler
+ m_crossEventCallHandler =
+ ecore_main_fd_handler_add(m_crossEventCallInvoker->GetHandle(),
+ ECORE_FD_READ,
+ &StaticDispatchCrossInvoker,
+ this,
+ NULL,
+ NULL);
+
+ if (m_crossEventCallHandler == NULL) {
+ ThrowMsg(Exception::CreateFailed, "Failed to register cross event handler!");
+ }
+
+ LogPedantic("ECORE cross-event handler re-registered");
+}
+
void MainEventDispatcher::StaticDeleteEvent(void *data, void *event)
{
LogPedantic("Static ECORE delete event handler");
// Critical section
{
- m_crossEventCallInvoker.Reset();
+ m_crossEventCallInvoker->Reset();
Mutex::ScopedLock lock(&m_crossEventCallMutex);
m_wrappedCrossEventCallList.swap(stolenCrossEvents);
}
{
Mutex::ScopedLock lock(&m_crossEventCallMutex);
m_wrappedCrossEventCallList.push_back(WrappedEventCall(abstractEventCall, false, 0.0));
- m_crossEventCallInvoker.Signal();
+ m_crossEventCallInvoker->Signal();
}
LogPedantic("Event pushed to cross-thread event list");
{
Mutex::ScopedLock lock(&m_crossEventCallMutex);
m_wrappedCrossEventCallList.push_back(WrappedEventCall(abstractEventCall, true, dueTime));
- m_crossEventCallInvoker.Signal();
+ m_crossEventCallInvoker->Signal();
}
LogPedantic("Event pushed to cross-thread event list");
* @version 1.0
* @brief This file is the implementation file of model
*/
+#include <stddef.h>
#include <dpl/event/model.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of thread event dispatcher
*/
+#include <stddef.h>
#include <dpl/event/thread_event_dispatcher.h>
#include <dpl/log/log.h>
#include <dpl/assert.h>
#
SET(DPL_LOCALIZATION_SOURCES
- ${PROJECT_SOURCE_DIR}/modules/localization/src/localization_utils.cpp
${PROJECT_SOURCE_DIR}/modules/localization/src/w3c_file_localization.cpp
+ ${PROJECT_SOURCE_DIR}/modules/localization/src/LanguageTagsProvider.cpp
PARENT_SCOPE
)
SET(DPL_LOCALIZATION_HEADERS
${PROJECT_SOURCE_DIR}/modules/localization/include/dpl/localization/localization_utils.h
${PROJECT_SOURCE_DIR}/modules/localization/include/dpl/localization/w3c_file_localization.h
+ ${PROJECT_SOURCE_DIR}/modules/localization/include/LanguageTagsProvider.h
PARENT_SCOPE
)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file LanguageTagsProvider.h
+ * @author Marcin Kaminski (marcin.ka@samsung.com)
+ * @version 1.0
+ */
+
+#ifndef LANGUAGETAGSPROVIDER_H
+#define LANGUAGETAGSPROVIDER_H
+
+#include <dpl/optional.h>
+#include <dpl/string.h>
+#include <dpl/singleton.h>
+#include <list>
+
+typedef std::list<DPL::String> LanguageTags;
+
+class LanguageTagsProvider {
+
+public:
+ /*
+ * Get list of currently set language tags
+ */
+ const LanguageTags getLanguageTags() const;
+
+ /*
+ * Set new language tags (other than based on system locales)
+ */
+ void setLanguageTags(const LanguageTags& taglist );
+
+ /*
+ * Set language tags from given locales.
+ * Supported format is: xx[-yy[-zz]][.encoding]
+ */
+ void setLanguageTagsFromLocales(const char* locales);
+
+ /*
+ * Set language tags based on system language settings
+ */
+ void resetLanguageTags();
+
+ /*
+ * Adds default widget locales to language tags if
+ * it doesn't exist within actual tags.
+ * Default locales i added:
+ * - at the beginning if less then 2 tags exists on list
+ * - just before empty ("") locales - pre-last position
+ * - at the end if last position is not empty locale
+ */
+ void addWidgetDefaultLocales(const DPL::String&);
+
+ /*
+ * Function converts language tag string (i.e. en-US)
+ * into locales string (en_US).
+ */
+ static DPL::String BCP47LanguageTagToLocale(const DPL::String&);
+
+ /*
+ * Function converts locales string (i.e. en_US.UTF-8) into language tag (i.e. en-US)
+ */
+ static DPL::String LocaleToBCP47LanguageTag(const DPL::String&);
+
+private:
+ friend class DPL::Singleton<LanguageTagsProvider>;
+
+ LanguageTags m_languageTagsList;
+
+ LanguageTagsProvider();
+ virtual ~LanguageTagsProvider();
+
+ void loadSystemTags();
+ void createTagsFromLocales(const char* language);
+};
+
+typedef DPL::Singleton<LanguageTagsProvider> LanguageTagsProviderSingleton;
+
+#endif /* LANGUAGETAGSPROVIDER_H */
};
typedef DPL::Optional<WidgetIcon> OptionalWidgetIcon;
-typedef std::list<DPL::String> LanguageTagsList;
typedef DPL::Optional<WidgetStartFileInfo> OptionalWidgetStartFileInfo;
-namespace LocalizationUtils {
-DPL::String BCP47LanguageTagToLocale(const DPL::String&);
-DPL::String LocaleToBCP47LanguageTag(const DPL::String&);
-
-void SetUserLanguageTags(const LanguageTagsList& tags);
-void SetSystemLanguageTags(const LanguageTagsList& tags);
-LanguageTagsList GetUserAgentLanguageTags();
-
-void Initialize();
-}
-
#endif //LOCALIZATION_UTILS_H
#ifndef W3C_FILE_LOCALIZATION_H
#define W3C_FILE_LOCALIZATION_H
-#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <dpl/optional.h>
#include <dpl/string.h>
#include <list>
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags,
+ const DPL::String &url);
+DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String &url);
+DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
+ WrtDB::WidgetDAOReadOnlyPtr dao,
const DPL::String &url);
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags,
const DPL::String& file);
+DPL::Optional<DPL::String> getFilePathInWidgetPackage(
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String& file);
+DPL::Optional<DPL::String> getFilePathInWidgetPackage(
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String& file);
+
+DPL::OptionalString getStartFile(WrtDB::DbWidgetHandle handle);
+DPL::OptionalString getStartFile(const WrtDB::WidgetPkgName & pkgname);
+DPL::OptionalString getStartFile(WrtDB::WidgetDAOReadOnlyPtr dao);
-DPL::OptionalString getStartFile(WrtDB::DbWidgetHandle widgetHandle);
OptionalWidgetIcon getIcon(WrtDB::DbWidgetHandle widgetHandle);
+OptionalWidgetIcon getIcon(const WrtDB::WidgetPkgName & pkgname);
+OptionalWidgetIcon getIcon(WrtDB::WidgetDAOReadOnlyPtr dao);
+
WidgetIconList getValidIconsList(
- WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags);
+ WrtDB::DbWidgetHandle widgetHandle);
+WidgetIconList getValidIconsList(
+ const WrtDB::WidgetPkgName &pkgname);
+WidgetIconList getValidIconsList(
+ WrtDB::WidgetDAOReadOnlyPtr dao);
OptionalWidgetStartFileInfo getStartFileInfo(
- WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &tagsList);
+ WrtDB::DbWidgetHandle widgetHandle);
+OptionalWidgetStartFileInfo getStartFileInfo(
+ const WrtDB::WidgetPkgName &pkgname);
+OptionalWidgetStartFileInfo getStartFileInfo(
+ WrtDB::WidgetDAOReadOnlyPtr dao);
+
WrtDB::WidgetLocalizedInfo getLocalizedInfo(WrtDB::DbWidgetHandle widgetHandle);
+WrtDB::WidgetLocalizedInfo getLocalizedInfo(const WrtDB::WidgetPkgName & pkgname);
+WrtDB::WidgetLocalizedInfo getLocalizedInfo(WrtDB::WidgetDAOReadOnlyPtr dao);
}
#endif //W3C_FILE_LOCALIZATION_H
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file LanguageTagsProvider.cpp
+ * @author Marcin Kaminski (marcin.ka@samsung.com)
+ * @version 1.0
+ */
+#include <stddef.h>
+#include "LanguageTagsProvider.h"
+
+#include <dpl/log/log.h>
+#include <vconf.h>
+#include <algorithm>
+#include <iostream>
+#include <cassert>
+#include <dpl/singleton_impl.h>
+IMPLEMENT_SINGLETON(LanguageTagsProvider)
+
+/* ========== public ========== */
+const LanguageTags LanguageTagsProvider::getLanguageTags() const
+{
+ return m_languageTagsList;
+}
+
+void LanguageTagsProvider::setLanguageTags(const LanguageTags& taglist)
+{
+ m_languageTagsList = taglist;
+ /* If given list does not contain default value (empty string)
+ * than append it to the list.
+ * In case of empty list given as parameter only default value
+ * will exist on m_languageTagsList. */
+ DPL::String tofind = L"";
+ if(std::find(m_languageTagsList.begin(), m_languageTagsList.end(),
+ tofind) == m_languageTagsList.end()) {
+ m_languageTagsList.push_back(L"");
+ }
+}
+
+void LanguageTagsProvider::setLanguageTagsFromLocales(const char* locales)
+{
+ LogDebug("Setting new language tags for locales " << locales);
+ this->createTagsFromLocales(locales);
+}
+
+void LanguageTagsProvider::resetLanguageTags()
+{
+ this->loadSystemTags();
+}
+
+void LanguageTagsProvider::addWidgetDefaultLocales(const DPL::String& defaultLocale){
+ if (defaultLocale.size() > 0 &&
+ std::find(m_languageTagsList.begin(), m_languageTagsList.end(), defaultLocale) == m_languageTagsList.end())
+ {
+ if (m_languageTagsList.size() < 2) {
+ m_languageTagsList.push_front(defaultLocale);
+ } else {
+ LanguageTags::iterator placeToInsert = m_languageTagsList.end();
+ --placeToInsert;
+ if (*placeToInsert != L"")
+ {
+ ++placeToInsert;
+ }
+ m_languageTagsList.insert(placeToInsert, defaultLocale);
+ }
+ }
+}
+
+DPL::String LanguageTagsProvider::BCP47LanguageTagToLocale(const DPL::String& inLanguageTag)
+{
+ DPL::String languageTag(inLanguageTag);
+ /* Replace all */
+ std::replace(languageTag.begin(), languageTag.end(), '-', '_');
+ return languageTag;
+}
+
+DPL::String LanguageTagsProvider::LocaleToBCP47LanguageTag(const DPL::String& inLocaleString)
+{
+ /* Cut off codepage information from given string (if any exists)
+ * i.e. change en_US.UTF-8 into en_US */
+ DPL::String localeString = inLocaleString.substr(
+ 0, inLocaleString.find_first_of(L"."));
+ /* Replace all '_' with '-' */
+ std::replace(localeString.begin(), localeString.end(), '_', '-');
+ return localeString;
+}
+
+/* ========== private ========== */
+LanguageTagsProvider::LanguageTagsProvider()
+{
+ LogDebug("Creating LanguageTagsProvider instance");
+ this->loadSystemTags();
+}
+
+LanguageTagsProvider::~LanguageTagsProvider()
+{
+}
+
+void LanguageTagsProvider::loadSystemTags()
+{
+ char* language = vconf_get_str(VCONFKEY_LANGSET);
+ if(!language) {
+ LogError("Failed to get language from vconf");
+ }
+ else {
+ LogDebug("Language fetched from vconf: " << language);
+ }
+ createTagsFromLocales(language);
+ free(language);
+}
+
+void LanguageTagsProvider::createTagsFromLocales(const char* language)
+{
+ m_languageTagsList.clear();
+ if(!language) {
+ LogDebug("Setting default language tags");
+ /* If NULL language given than set default language tags
+ * and return. */
+ m_languageTagsList.push_back(L"");
+ return;
+ }
+
+ LogDebug("Setting tags for language: " << language);
+ DPL::String langdescr = LocaleToBCP47LanguageTag(DPL::FromUTF8String(language));
+
+ size_t position;
+ if(langdescr.empty()) {
+ LogError("Empty language description while correct value needed");
+ }
+ else {
+ /* Language tags list should not be cleared before this place to
+ * avoid losing current data when new data are invalid */
+ while (true) {
+ LogDebug("Processing language description: " << langdescr);
+ m_languageTagsList.push_back(langdescr);
+
+ position = langdescr.find_last_of(L"-");
+ if (position == DPL::String::npos) {
+ break;
+ }
+ langdescr = langdescr.substr(0, position);
+ }
+ }
+ /* Add empty tag for non-localized content */
+ m_languageTagsList.push_back(L"");
+}
#include <dpl/localization/localization_utils.h>
-#include <appcore-efl.h>
-#include <vconf.h>
-#include <dpl/framework_efl.h>
-
#include <dpl/foreach.h>
#include <dpl/mutex.h>
-#include <dpl/wrt-dao-rw/widget_dao.h>
-
-namespace {
-
-static int LanguageChanged(void *)
-{
- char* lang = vconf_get_str(VCONFKEY_LANGSET);
- if (!lang) {
- LogError("Cannot get locale settings from vconf");
- return 0;
- }
- LogDebug("Language set to: " << lang);
-
- using namespace LocalizationUtils;
-
- LanguageTagsList list;
- list.push_back(DPL::FromUTF8String(lang));
- SetSystemLanguageTags(list);
-
- LogDebug("LanguageChanged to " << lang);
-
- return 0;
-}
-}
namespace LocalizationUtils {
static LanguageTagsList m_systemLanguageTags;
-static LanguageTagsList m_userLanguageTags;
static LanguageTagsList m_languageTags;
static DPL::ReadWriteMutex m_readWriteMutex;
// WARNING!!!!! This function shall be called
// only when mutex is locked in readWriteMode!
- LanguageTagsList list = m_userLanguageTags;
- list.insert(list.begin(),
- m_systemLanguageTags.begin(),
- m_systemLanguageTags.end());
m_languageTags.clear();
- FOREACH(i, list) {
+ FOREACH(i, m_systemLanguageTags) {
DPL::String tag = LocaleToBCP47LanguageTag(*i);
while (true) { //W3C Packaging 9. Step 5. 2. D
if (tag.empty()) { continue; }
m_languageTags.push_back(L"");
}
-void SetUserLanguageTags(const LanguageTagsList& tags)
-{
- DPL::ReadWriteMutex::ScopedWriteLock lock(&m_readWriteMutex);
- if (m_userLanguageTags != tags) {
- m_userLanguageTags = tags;
- UpdateUserAgentLanguageTags();
- }
-}
-
void SetSystemLanguageTags(const LanguageTagsList& tags)
{
DPL::ReadWriteMutex::ScopedWriteLock lock(&m_readWriteMutex);
DPL::ReadWriteMutex::ScopedReadLock lock(&m_readWriteMutex);
return m_languageTags;
}
-
-void Initialize()
-{
- appcore_set_event_callback(
- APPCORE_EVENT_LANG_CHANGE,
- &LanguageChanged,
- NULL);
-
- LanguageChanged(NULL); // updating language for the first time
-}
-
}
* @author Lukasz Wrzosek (l.wrzosek@samsung.com)
* @version 1.0
*/
-
+#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <assert.h>
#include <dpl/localization/w3c_file_localization.h>
-#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <dpl/localization/localization_utils.h>
#include <dpl/log/log.h>
#include <dpl/optional.h>
#include <dpl/foreach.h>
+#include <LanguageTagsProvider.h>
+
using namespace WrtDB;
namespace {
const DPL::String FILE_URI_BEGIN = L"file://";
const DPL::String WIDGET_URI_BEGIN = L"widget://";
+const DPL::String LOCALE_PREFIX = L"locales/";
DPL::Optional<std::string> GetFilePathInWidgetPackageInternal(
- const LanguageTagsList &tags,
const std::string& basePath,
std::string filePath)
{
LogDebug("Looking for file: " << filePath << " in: " << basePath);
- using namespace LocalizationUtils;
+
+ const LanguageTags& ltags = LanguageTagsProviderSingleton::Instance().getLanguageTags();
//Check if string isn't empty
if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
//Removing preceding '/'
if (filePath[0] == '/') { filePath.erase(0, 1); }
+ // In some cases (start file localization) url has unnecessary "/" at the end
+ if(filePath[filePath.size()-1] == '/') { filePath.erase(filePath.size()-1, 1); }
//Check if string isn't empty
if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
- LogDebug("locales size = " << tags.size());
- for (LanguageTagsList::const_iterator it = tags.begin();
- it != tags.end();
- ++it) {
+ LogDebug("locales size = " << ltags.size());
+ for (LanguageTags::const_iterator it = ltags.begin();
+ it != ltags.end();
+ ++it) {
LogDebug("Trying locale: " << *it);
std::string path = basePath;
if (path[path.size() - 1] == '/') {
}
DPL::Optional<DPL::String> GetFilePathInWidgetPackageInternal(
- const LanguageTagsList &languageTags,
const DPL::String& basePath,
const DPL::String& filePath)
{
DPL::Optional<std::string> path =
- GetFilePathInWidgetPackageInternal(languageTags,
- DPL::ToUTF8String(basePath),
+ GetFilePathInWidgetPackageInternal(DPL::ToUTF8String(basePath),
DPL::ToUTF8String(filePath));
DPL::Optional<DPL::String> dplPath;
if (!!path) {
}
namespace W3CFileLocalization {
+
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags,
+ const DPL::String &url)
+{
+ return getFilePathInWidgetPackageFromUrl(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
+ url);
+}
+
+DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String &url)
+{
+ return getFilePathInWidgetPackageFromUrl(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
+ url);
+}
+
+DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
+ WrtDB::WidgetDAOReadOnlyPtr dao,
const DPL::String &url)
{
DPL::String req = url;
- WidgetDAO dao(widgetHandle);
if (req.find(WIDGET_URI_BEGIN) == 0) {
req.erase(0, WIDGET_URI_BEGIN.length());
} else if (req.find(FILE_URI_BEGIN) == 0) {
req.erase(0, FILE_URI_BEGIN.length());
- if (req.find(dao.getPath()) == 0) {
- req.erase(0, dao.getPath().length());
+ if (req.find(dao->getPath()) == 0) {
+ req.erase(0, dao->getPath().length());
+ }
+ if (req.find(LOCALE_PREFIX) == 0) {
+ req.erase(0, LOCALE_PREFIX.length());
+ size_t position = req.find('/');
+ // should always be >0 as correct locales path is
+ // always locales/xx/ or locales/xx-XX/
+ if (position != std::string::npos && position > 0) {
+ req.erase(0, position+1);
+ }
}
} else {
LogDebug("Unknown path format, ignoring");
return DPL::Optional<DPL::String>::Null;
}
- auto widgetPath = dao.getPath();
+ auto widgetPath = dao->getPath();
DPL::Optional<DPL::String> found =
- GetFilePathInWidgetPackageInternal(languageTags, widgetPath, req);
+ GetFilePathInWidgetPackageInternal(widgetPath, req);
if (!found) {
LogError("Path not found within current locale in current widget");
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags,
const DPL::String& file)
{
- WidgetDAO dao(widgetHandle);
- return GetFilePathInWidgetPackageInternal(languageTags, dao.getPath(), file);
+ return getFilePathInWidgetPackage(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
+ file);
+}
+
+DPL::Optional<DPL::String> getFilePathInWidgetPackage(
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String& file)
+{
+ return getFilePathInWidgetPackage(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
+ file);
}
-DPL::OptionalString getStartFile(const WrtDB::DbWidgetHandle widgetHandle)
+DPL::Optional<DPL::String> getFilePathInWidgetPackage(
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String& file)
{
- using namespace LocalizationUtils;
+ return GetFilePathInWidgetPackageInternal(dao->getPath(), file);
+}
- WidgetDAO dao(widgetHandle);
+DPL::OptionalString getStartFile(const WrtDB::WidgetPkgName & pkgname)
+{
+ return getStartFile(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+}
+
+DPL::OptionalString getStartFile(const WrtDB::DbWidgetHandle handle)
+{
+ return getStartFile(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(handle)));
+}
- WidgetDAO::LocalizedStartFileList locList = dao.getLocalizedStartFileList();
- WidgetDAO::WidgetStartFileList list = dao.getStartFileList();
- LanguageTagsList tagsList = LocalizationUtils::GetUserAgentLanguageTags();
+DPL::OptionalString getStartFile(WrtDB::WidgetDAOReadOnlyPtr dao)
+{
+ WidgetDAOReadOnly::LocalizedStartFileList locList = dao->getLocalizedStartFileList();
+ WidgetDAOReadOnly::WidgetStartFileList list = dao->getStartFileList();
+ LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
- DPL::OptionalString defaultLoc = dao.getDefaultlocale();
+ DPL::OptionalString defaultLoc = dao->getDefaultlocale();
if (!!defaultLoc) {
tagsList.push_back(*defaultLoc);
}
return DPL::OptionalString::Null;
}
-OptionalWidgetIcon getIcon(const WrtDB::DbWidgetHandle widgetHandle)
+OptionalWidgetIcon getIcon(const WrtDB::WidgetPkgName & pkgname)
{
- using namespace LocalizationUtils;
- WidgetDAO dao(widgetHandle);
+ return getIcon(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+}
- WidgetDAO::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
- WidgetDAO::WidgetIconList list = dao.getIconList();
- LanguageTagsList tagsList = LocalizationUtils::GetUserAgentLanguageTags();
+OptionalWidgetIcon getIcon(WrtDB::DbWidgetHandle widgetHandle)
+{
+ return getIcon(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
+}
+
+OptionalWidgetIcon getIcon(WrtDB::WidgetDAOReadOnlyPtr dao)
+{
+ WidgetDAOReadOnly::WidgetLocalizedIconList locList = dao->getLocalizedIconList();
+ WidgetDAOReadOnly::WidgetIconList list = dao->getIconList();
+ LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
- DPL::OptionalString defaultLoc = dao.getDefaultlocale();
+ DPL::OptionalString defaultLoc = dao->getDefaultlocale();
if (!!defaultLoc) {
tagsList.push_back(*defaultLoc);
}
return OptionalWidgetIcon::Null;
}
-WidgetIconList getValidIconsList(
- WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagsList &languageTags)
+WidgetIconList getValidIconsList(WrtDB::DbWidgetHandle widgetHandle)
+{
+ return getValidIconsList(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
+}
+
+WidgetIconList getValidIconsList(const WrtDB::WidgetPkgName &pkgname)
+{
+ return getValidIconsList(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+}
+
+WidgetIconList getValidIconsList(WrtDB::WidgetDAOReadOnlyPtr dao)
{
- using namespace LocalizationUtils;
- WidgetDAO dao(widgetHandle);
- WidgetDAO::WidgetIconList list = dao.getIconList();
+ WidgetDAOReadOnly::WidgetIconList list = dao->getIconList();
WidgetIconList outlist;
FOREACH(it, list)
{
LogDebug(":" << it->iconSrc);
- if (!!getFilePathInWidgetPackage(widgetHandle,
- languageTags,
+ if (!!getFilePathInWidgetPackage(dao->getHandle(),
it->iconSrc))
{
WidgetIcon ret;
return outlist;
}
-OptionalWidgetStartFileInfo getStartFileInfo(
- WrtDB::DbWidgetHandle widgetHandle,
- const LanguageTagList &tagsList)
+OptionalWidgetStartFileInfo getStartFileInfo(WrtDB::DbWidgetHandle widgetHandle)
+{
+ return getStartFileInfo(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
+}
+
+OptionalWidgetStartFileInfo getStartFileInfo(const WrtDB::WidgetPkgName &pkgname)
{
- using namespace LocalizationUtils;
+ return getStartFileInfo(
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+
+}
+
+OptionalWidgetStartFileInfo getStartFileInfo(WrtDB::WidgetDAOReadOnlyPtr dao)
+{
WidgetStartFileInfo info;
- WidgetDAO dao(widgetHandle);
- WidgetDAO::LocalizedStartFileList locList =
- dao.getLocalizedStartFileList();
- WidgetDAO::WidgetStartFileList list = dao.getStartFileList();
+ WidgetDAOReadOnly::LocalizedStartFileList locList =
+ dao->getLocalizedStartFileList();
+ WidgetDAOReadOnly::WidgetStartFileList list = dao->getStartFileList();
+ const LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
FOREACH(tag, tagsList)
{
if (tag->empty()) {
info.localizedPath = it->src;
} else {
- info.localizedPath = L"locales/" + *tag;
+ info.localizedPath = L"locales/" + *tag + L"/";
info.localizedPath += it->src;
}
return info;
WidgetLocalizedInfo getLocalizedInfo(const WrtDB::DbWidgetHandle handle)
{
- LanguageTagList languages =
- LocalizationUtils::GetUserAgentLanguageTags();
- WidgetDAO dao(handle);
- DPL::OptionalString dl = dao.getDefaultlocale();
+ return getLocalizedInfo(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(handle)));
+}
+
+WidgetLocalizedInfo getLocalizedInfo(const WrtDB::WidgetPkgName & pkgname)
+{
+ return getLocalizedInfo(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+}
+
+WidgetLocalizedInfo getLocalizedInfo(WidgetDAOReadOnlyPtr dao)
+{
+ LanguageTags languages = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ DPL::OptionalString dl = dao->getDefaultlocale();
if (!!dl) {
languages.push_back(*dl);
}
WidgetLocalizedInfo result;
FOREACH(i, languages)
{
- WidgetLocalizedInfo languageResult = dao.getLocalizedInfo(*i);
+ WidgetLocalizedInfo languageResult = dao->getLocalizedInfo(*i);
#define OVERWRITE_IF_NULL(FIELD) if (!result.FIELD) { \
result.FIELD = languageResult.FIELD; \
#include <dpl/log/abstract_log_provider.h>
#include <dpl/log/dlog_log_provider.h>
#include <dpl/log/old_style_log_provider.h>
-#include <dpl/read_write_mutex.h>
#include <sstream>
#include <list>
: private Noncopyable
{
private:
- ReadWriteMutex m_spinLock;
-
typedef std::list<AbstractLogProvider *> AbstractLogProviderPtrList;
AbstractLogProviderPtrList m_providers;
* @version 1.0
* @brief This file is the implementation file of abstract log provider
*/
+#include <stddef.h>
#include <dpl/log/abstract_log_provider.h>
#include <cstring>
* @version 1.0
* @brief This file is the implementation file of DLOG log provider
*/
+#include <stddef.h>
#include <dpl/log/dlog_log_provider.h>
#include <cstring>
#include <sstream>
* @version 1.0
* @brief This file is the implementation file of log system
*/
+#include <stddef.h>
#include <dpl/log/log.h>
#include <dpl/singleton_impl.h>
void LogSystem::AddProvider(AbstractLogProvider *provider)
{
- ReadWriteMutex::ScopedWriteLock lock(&m_spinLock);
m_providers.push_back(provider);
}
void LogSystem::RemoveProvider(AbstractLogProvider *provider)
{
- ReadWriteMutex::ScopedWriteLock lock(&m_spinLock);
m_providers.remove(provider);
}
void LogSystem::Debug(const char *message, const char *filename, int line, const char *function)
{
- ReadWriteMutex::ScopedReadLock lock(&m_spinLock);
-
for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
(*iterator)->Debug(message, filename, line, function);
}
void LogSystem::Info(const char *message, const char *filename, int line, const char *function)
{
- ReadWriteMutex::ScopedReadLock lock(&m_spinLock);
-
for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
(*iterator)->Info(message, filename, line, function);
}
void LogSystem::Warning(const char *message, const char *filename, int line, const char *function)
{
- ReadWriteMutex::ScopedReadLock lock(&m_spinLock);
-
for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
(*iterator)->Warning(message, filename, line, function);
}
void LogSystem::Error(const char *message, const char *filename, int line, const char *function)
{
- ReadWriteMutex::ScopedReadLock lock(&m_spinLock);
-
for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
(*iterator)->Error(message, filename, line, function);
}
void LogSystem::Pedantic(const char *message, const char *filename, int line, const char *function)
{
- ReadWriteMutex::ScopedReadLock lock(&m_spinLock);
-
for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
(*iterator)->Pedantic(message, filename, line, function);
}
* @version 1.0
* @brief This file is the implementation file of old style log provider
*/
+#include <stddef.h>
#include <dpl/log/old_style_log_provider.h>
#include <dpl/colors.h>
#include <cstdio>
#include <dpl/rpc/abstract_rpc_connection.h>
#include <dpl/abstract_waitable_input_output.h>
#include <dpl/socket/waitable_input_output_execution_context_support.h>
-#include <dpl/scoped_ptr.h>
+#include <memory>
namespace DPL
{
virtual void OnInputStreamClosed();
virtual void OnInputStreamBroken();
-
ScopedPtr<AbstractWaitableInputOutput> m_inputOutput;
+
std::unique_ptr<AbstractWaitableInputOutput> m_inputOutput;
public:
/**
* @version 1.0
* @brief This file is the implementation file of abstract RPC connection
*/
+#include <stddef.h>
#include <dpl/rpc/abstract_rpc_connection.h>
//
* @version 1.0
* @brief This file is the implementation file of abstract RPC connector
*/
+#include <stddef.h>
#include <dpl/rpc/abstract_rpc_connector.h>
//
* @version 1.0
* @brief This file is the implementation file of generic RPC connection
*/
+#include <stddef.h>
#include <dpl/rpc/generic_rpc_connection.h>
#include <dpl/scoped_array.h>
#include <dpl/log/log.h>
* @version 1.0
* @brief This file is the implementation file of generic socket RPC client
*/
+#include <stddef.h>
#include <dpl/rpc/generic_socket_rpc_client.h>
//
* @version 1.0
* @brief This file is the implementation file of generic socket RPC connection
*/
+#include <stddef.h>
#include <dpl/rpc/generic_socket_rpc_connection.h>
//
* @version 1.0
* @brief This file is the implementation file of generic socket RPC
*/
+#include <stddef.h>
#include <dpl/rpc/generic_socket_rpc_server.h>
//
* @version 1.0
* @brief This file is the implementation file of unix socket RPC client
*/
+#include <stddef.h>
#include <dpl/rpc/unix_socket_rpc_client.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
* @version 1.0
* @brief This file is the implementation file of unix socket RPC connection
*/
+#include <stddef.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
namespace DPL
* @version 1.0
* @brief This file is the implementation file of unix socket RPC server
*/
+#include <stddef.h>
#include <dpl/rpc/unix_socket_rpc_server.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
--- /dev/null
+SET(TARGET_SECURITY_ORIGIN_DAO_DB "Sqlite3DbSecurityOrigin")
+
+ADD_CUSTOM_COMMAND( OUTPUT .security_origin.db
+ COMMAND rm -f ${CMAKE_CURRENT_BINARY_DIR}/.security_origin.db
+ COMMAND gcc -Wall -I${PROJECT_SOURCE_DIR}/modules/db/include -I${PROJECT_SOURCE_DIR}/modules/security_origin_dao/orm -E ${PROJECT_SOURCE_DIR}/modules/security_origin_dao/orm/security_origin_db_sql_generator.h | grep --invert-match "^#" > ${CMAKE_CURRENT_BINARY_DIR}/security_origin_db.sql
+ COMMAND sqlite3 ${CMAKE_CURRENT_BINARY_DIR}/.security_origin.db ".read ${CMAKE_CURRENT_BINARY_DIR}/security_origin_db.sql" || rm -f ${CMAKE_CURRENT_BINARY_DIR}/.security_origin.db
+ DEPENDS ${PROJECT_SOURCE_DIR}/modules/security_origin_dao/orm/security_origin_db_sql_generator.h ${PROJECT_SOURCE_DIR}/modules/security_origin_dao/orm/security_origin_db
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .security_origin.db-journal
+ COMMAND touch
+ ARGS ${CMAKE_CURRENT_BINARY_DIR}/.security_origin.db-journal
+ )
+
+ADD_CUSTOM_TARGET(${TARGET_SECURITY_ORIGIN_DAO_DB} ALL DEPENDS .security_origin.db .security_origin.db-journal)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/security_origin_db.sql DESTINATION share/wrt-engine/)
+
+###############################################################################
+
+INCLUDE(FindPkgConfig)
+
+PKG_CHECK_MODULES(SECURITY_ORIGIN_DAO_DEPS
+ glib-2.0
+ REQUIRED)
+
+SET(SECURITY_ORIGIN_DAO_INCLUDE_DIRS
+ ${PROJECT_SOURCE_DIR}/modules/security_origin_dao/include
+ ${PROJECT_SOURCE_DIR}/modules/security_origin_dao/orm
+ ${PROJECT_SOURCE_DIR}/modules/core/include
+ ${PROJECT_SOURCE_DIR}/modules/db/include
+ ${PROJECT_SOURCE_DIR}/modules/log/include
+ ${PROJECT_SOURCE_DIR}/modules/widget_dao/include
+)
+
+SET(SECURITY_ORIGIN_DAO_SOURCES
+ dao/security_origin_dao_types.cpp
+ dao/security_origin_database.cpp
+ dao/security_origin_dao.cpp
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${SECURITY_ORIGIN_DAO_DEPS_INCLUDE_DIRS} )
+INCLUDE_DIRECTORIES(${SECURITY_ORIGIN_DAO_INCLUDE_DIRS})
+
+ADD_LIBRARY(${TARGET_SECURITY_ORIGIN_DAO_LIB} SHARED ${SECURITY_ORIGIN_DAO_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_SECURITY_ORIGIN_DAO_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+TARGET_LINK_LIBRARIES(${TARGET_SECURITY_ORIGIN_DAO_LIB} ${TARGET_DPL_EFL} ${TARGET_DPL_DB_EFL} ${TARGET_WRT_DAP_RO_LIB} ${SECURITY_ORIGIN_DAO_DEPS_LIBRARIES})
+ADD_DEPENDENCIES(${TARGET_SECURITY_ORIGIN_DAO_LIB} ${TARGET_SECURITY_ORIGIN_DAO_DB})
+
+INSTALL(TARGETS ${TARGET_SECURITY_ORIGIN_DAO_LIB} DESTINATION lib)
+
+INSTALL(FILES
+ include/wrt-commons/security-origin-dao/security_origin_dao_types.h
+ include/wrt-commons/security-origin-dao/security_origin_database.h
+ include/wrt-commons/security-origin-dao/security_origin_dao.h
+ DESTINATION include/dpl-efl/wrt-commons/security-origin-dao
+)
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file security_origin_dao.cpp
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the definition of security origin dao class.
+ */
+
+#include <wrt-commons/security-origin-dao/security_origin_database.h>
+#include <wrt-commons/security-origin-dao/security_origin_dao.h>
+#include <wrt-commons/security-origin-dao/security_origin_dao_types.h>
+#include <orm_generator_security_origin.h>
+#include <dpl/foreach.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
+#include <dpl/wrt-dao-ro/WrtDatabase.h>
+#include <dpl/wrt-dao-ro/widget_config.h>
+#include <dpl/wrt-dao-ro/global_config.h>
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+#include <sys/stat.h>
+#include <fstream>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::security_origin;
+
+namespace SecurityOriginDB {
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
+ Catch(DPL::DB::SqlConnection::Exception::Base) { \
+ LogError(message); \
+ ReThrowMsg(SecurityOriginDAO::Exception::DatabaseError, \
+ message); \
+ }
+
+namespace {
+DPL::DB::SqlConnection::Flag::Option SECURITY_ORIGIN_DB_OPTION =
+ DPL::DB::SqlConnection::Flag::RW;
+DPL::DB::SqlConnection::Flag::Type SECURITY_ORIGIN_DB_TYPE =
+ DPL::DB::SqlConnection::Flag::UseLucene;
+const char* const SECURITY_ORIGIN_DB_NAME = ".security_origin.db";
+const char* const SECURITY_ORIGIN_DB_SQL_PATH =
+ "/usr/share/wrt-engine/security_origin_db.sql";
+
+std::string createDatabasePath(const WrtDB::WidgetPkgName &pkgName)
+{
+ std::stringstream filename;
+
+ filename << WrtDB::WidgetConfig::GetWidgetPersistentStoragePath(pkgName)
+ << "/"
+ << SECURITY_ORIGIN_DB_NAME;
+ return filename.str();
+}
+
+std::string createDatabasePath(int widgetHandle)
+{
+ using namespace DPL::DB::ORM;
+ using namespace WrtDB::WidgetConfig;
+ using namespace WrtDB::GlobalConfig;
+
+ WrtDB::WidgetPkgName pkgname;
+
+ Try
+ {
+ pkgname = WrtDB::WidgetDAOReadOnly::getPkgName(widgetHandle);
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ LogError("Failed to get database Path");
+ }
+ return createDatabasePath(pkgname);
+}
+
+void checkDatabase(std::string databasePath)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ if (databasePath.empty()) {
+ ThrowMsg(SecurityOriginDAO::Exception::DatabaseError,
+ "Wrong database Path is passed");
+ }
+
+ struct stat buffer;
+ if (stat(databasePath.c_str(), &buffer) != 0) {
+
+ //Create fresh database
+ LogInfo("Creating database " << databasePath);
+
+ std::fstream file;
+ file.open(SECURITY_ORIGIN_DB_SQL_PATH, std::ios_base::in);
+ if (!file) {
+ ThrowMsg(SecurityOriginDAO::Exception::DatabaseError,
+ "Fail to get database Path");
+ }
+
+ std::stringstream ssBuffer;
+ ssBuffer << file.rdbuf();
+
+ file.close();
+
+ DPL::DB::SqlConnection con(databasePath,
+ SECURITY_ORIGIN_DB_TYPE,
+ SECURITY_ORIGIN_DB_OPTION);
+ con.ExecCommand(ssBuffer.str().c_str());
+ }
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to get database Path")
+}
+}
+
+SecurityOriginDAO::SecurityOriginDAO(int handle) :
+ m_securityOriginDBPath(createDatabasePath(handle)),
+ m_securityOriginDBInterface(m_securityOriginDBPath, SECURITY_ORIGIN_DB_TYPE)
+{
+ checkDatabase(m_securityOriginDBPath);
+ m_securityOriginDBInterface.AttachToThread(SECURITY_ORIGIN_DB_OPTION);
+}
+
+SecurityOriginDAO::SecurityOriginDAO(const WrtDB::WidgetPkgName &pkgName) :
+ m_securityOriginDBPath(createDatabasePath(pkgName)),
+ m_securityOriginDBInterface(m_securityOriginDBPath, SECURITY_ORIGIN_DB_TYPE)
+{
+ checkDatabase(m_securityOriginDBPath);
+ m_securityOriginDBInterface.AttachToThread(SECURITY_ORIGIN_DB_OPTION);
+}
+
+SecurityOriginDAO::~SecurityOriginDAO()
+{
+ m_securityOriginDBInterface.DetachFromThread();
+}
+
+SecurityOriginDataList SecurityOriginDAO::getSecurityOriginDataList(void)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ SecurityOriginDataList list;
+ SECURITY_ORIGIN_DB_SELECT(select, SecurityOriginInfo, &m_securityOriginDBInterface);
+ typedef std::list<SecurityOriginInfo::Row> RowList;
+ RowList rowList = select->GetRowList();
+
+ FOREACH(it, rowList) {
+ Origin origin(it->Get_scheme(), it->Get_host(), it->Get_port());
+ list.push_back(
+ SecurityOriginDataPtr(
+ new SecurityOriginData(
+ static_cast<Feature>(it->Get_feature()), origin)));
+ }
+ return list;
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get data list")
+}
+
+Result SecurityOriginDAO::getResult(const SecurityOriginData &securityOriginData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ SECURITY_ORIGIN_DB_SELECT(select, SecurityOriginInfo, &m_securityOriginDBInterface);
+ select->Where(
+ And(And(And(Equals<SecurityOriginInfo::feature>(securityOriginData.feature),
+ Equals<SecurityOriginInfo::scheme>(securityOriginData.origin.scheme)),
+ Equals<SecurityOriginInfo::host>(securityOriginData.origin.host)),
+ Equals<SecurityOriginInfo::port>(securityOriginData.origin.port)));
+ SecurityOriginInfo::Select::RowList rows = select->GetRowList();
+
+ if (rows.empty()) {
+ return RESULT_UNKNOWN;
+ }
+ SecurityOriginInfo::Row row = rows.front();
+ return static_cast<Result>(row.Get_result());
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get result for security origin")
+}
+
+void SecurityOriginDAO::setSecurityOriginData(const SecurityOriginData &securityOriginData,
+ const Result result)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_securityOriginDBInterface);
+ SecurityOriginInfo::Row row;
+ row.Set_feature(securityOriginData.feature);
+ row.Set_scheme(securityOriginData.origin.scheme);
+ row.Set_host(securityOriginData.origin.host);
+ row.Set_port(securityOriginData.origin.port);
+ row.Set_result(result);
+
+ if (true == hasResult(securityOriginData)) {
+ SECURITY_ORIGIN_DB_UPDATE(update,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface);
+ update->Values(row);
+ update->Execute();
+ } else {
+ SECURITY_ORIGIN_DB_INSERT(
+ insert,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface);
+ insert->Values(row);
+ insert->Execute();
+ }
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set security origin data")
+}
+
+void SecurityOriginDAO::removeSecurityOriginData(
+ const SecurityOriginData &securityOriginData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_securityOriginDBInterface);
+
+ if (true == hasResult(securityOriginData)) {
+ SECURITY_ORIGIN_DB_DELETE(del, SecurityOriginInfo, &m_securityOriginDBInterface)
+ del->Where(
+ And(And(And(Equals<SecurityOriginInfo::feature>(securityOriginData.feature),
+ Equals<SecurityOriginInfo::scheme>(securityOriginData.origin.scheme)),
+ Equals<SecurityOriginInfo::host>(securityOriginData.origin.host)),
+ Equals<SecurityOriginInfo::port>(securityOriginData.origin.port)));
+ del->Execute();
+ transaction.Commit();
+ }
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set security origin data")
+}
+
+void SecurityOriginDAO::removeSecurityOriginData(const Result result)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_securityOriginDBInterface);
+ SECURITY_ORIGIN_DB_DELETE(del, SecurityOriginInfo, &m_securityOriginDBInterface)
+ del->Where(Equals<SecurityOriginInfo::result>(result));
+ del->Execute();
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to remove data by result")
+}
+
+bool SecurityOriginDAO::hasResult(const SecurityOriginData &securityOriginData)
+{
+ Result res=getResult(securityOriginData);
+ return (res != RESULT_UNKNOWN);
+}
+
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
+
+} // namespace SecurityOriginDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file security_origin_dao_types.cpp
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the implementation of
+ * common data types for wrt_security_origin.db
+ */
+
+#include <wrt-commons/security-origin-dao/security_origin_dao_types.h>
+#include <dpl/log/log.h>
+
+namespace SecurityOriginDB {
+} // namespace SecurityOriginDB
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <wrt-commons/security-origin-dao/security_origin_database.h>
+
+DPL::Mutex g_securityOriginDBQueriesMutex;
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file securoty_origin_dao.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of security origin dao
+ */
+#ifndef _SECURITY_ORIGIN_DAO_H_
+#define _SECURITY_ORIGIN_DAO_H_
+
+#include <dpl/db/thread_database_support.h>
+#include <wrt-commons/security-origin-dao/security_origin_dao_types.h>
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+
+namespace SecurityOriginDB {
+
+class SecurityOriginDAO
+{
+ public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
+ DECLARE_EXCEPTION_TYPE(Base, DataNotExist)
+ };
+
+ explicit SecurityOriginDAO(int handle) __attribute__((deprecated));
+ explicit SecurityOriginDAO(const WrtDB::WidgetPkgName &pkgName);
+ virtual ~SecurityOriginDAO();
+ SecurityOriginDataList getSecurityOriginDataList();
+ Result getResult(const SecurityOriginData &securityOriginData);
+ void setSecurityOriginData(const SecurityOriginData &securityOriginData,
+ const Result result);
+ void removeSecurityOriginData(const SecurityOriginData &securityOriginData);
+ void removeSecurityOriginData(const Result result);
+ private:
+ std::string m_securityOriginDBPath;
+ DPL::DB::ThreadDatabaseSupport m_securityOriginDBInterface;
+ bool hasResult(const SecurityOriginData &securityOriginData);
+};
+
+typedef std::shared_ptr<SecurityOriginDAO> SecurityOriginDAOPtr;
+
+} // namespace SecurityOriginDB
+
+#endif // _SECURITY_ORIGIN_DAO_H_
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file security_origin_dao_types.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of
+ * common data types for security origin database.
+ */
+#ifndef _SECURITY_ORIGIN_DAO_TYPES_H_
+#define _SECURITY_ORIGIN_DAO_TYPES_H_
+
+#include <list>
+#include <memory>
+#include <dpl/string.h>
+
+namespace SecurityOriginDB {
+
+enum Feature
+{
+ FEATURE_START = 0,
+ FEATURE_GEOLOCATION = 0,
+ FEATURE_WEB_NOTIFICATION,
+ FEATURE_WEB_DATABASE,
+ FEATURE_FILE_SYSTEM_ACCESS,
+ FEATURE_END = FEATURE_FILE_SYSTEM_ACCESS
+};
+
+enum Result
+{
+ RESULT_UNKNOWN = 0,
+ RESULT_ALLOW_ONCE,
+ RESULT_DENY_ONCE,
+ RESULT_ALLOW_ALWAYS,
+ RESULT_DENY_ALWAYS
+};
+
+struct Origin
+{
+ DPL::String scheme;
+ DPL::String host;
+ unsigned int port;
+
+ Origin(const DPL::String& Scheme,
+ const DPL::String& Host,
+ const unsigned int Port) :
+ scheme(Scheme),
+ host(Host),
+ port(Port)
+ {
+ }
+
+ bool operator== (const Origin& other) const
+ {
+ return (!DPL::StringCompare(scheme, other.scheme) &&
+ !DPL::StringCompare(host, other.host) &&
+ port == other.port);
+ }
+
+ bool operator!= (const Origin& other) const
+ {
+ return !(*this == other);
+ }
+};
+
+struct SecurityOriginData
+{
+ Feature feature;
+ Origin origin;
+
+ SecurityOriginData(const Feature features, const Origin& ori) :
+ feature(features),
+ origin(ori)
+ {
+ }
+
+ bool operator== (const SecurityOriginData& other) const
+ {
+ return !(origin == other.origin) &&
+ !(feature == other.feature);
+ }
+
+ bool operator!= (const SecurityOriginData& other) const
+ {
+ return !(*this == other);
+ }
+};
+
+typedef std::shared_ptr<SecurityOriginData> SecurityOriginDataPtr;
+typedef std::list<SecurityOriginDataPtr> SecurityOriginDataList;
+
+} // namespace SecurityOriginDB
+
+#endif // _SECURITY_ORIGIN_DAO_TYPES_H_
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _SECURITY_ORIGIN_DATABASE_H_
+#define _SECURITY_ORIGIN_DATABASE_H_
+
+#include <dpl/thread.h>
+#include <dpl/mutex.h>
+
+extern DPL::Mutex g_securityOriginDBQueriesMutex;
+
+#define SECURITY_ORIGIN_DB_INTERNAL(tlsCommand, InternalType, interface) \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ { \
+ DPL::Mutex::ScopedLock lock(&g_securityOriginDBQueriesMutex); \
+ if (!tlsCommand ## Ptr) { \
+ static DPL::ThreadLocalVariable<InternalType> tmp; \
+ tlsCommand ## Ptr = &tmp; \
+ } \
+ } \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
+
+#define SECURITY_ORIGIN_DB_SELECT(name, type, interface) \
+ SECURITY_ORIGIN_DB_INTERNAL(name, type::Select, interface)
+
+#define SECURITY_ORIGIN_DB_INSERT(name, type, interface) \
+ SECURITY_ORIGIN_DB_INTERNAL(name, type::Insert, interface)
+
+#define SECURITY_ORIGIN_DB_UPDATE(name, type, interface) \
+ SECURITY_ORIGIN_DB_INTERNAL(name, type::Update, interface)
+
+#define SECURITY_ORIGIN_DB_DELETE(name, type, interface) \
+ SECURITY_ORIGIN_DB_INTERNAL(name, type::Delete, interface)
+
+#endif // _SECURITY_ORIGIN_DATABASE_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _ORM_GENERATOR_SECURITY_ORIGIN_H_
+#define _ORM_GENERATOR_SECURITY_ORIGIN_H_
+
+#define ORM_GENERATOR_DATABASE_NAME security_origin_db_definitions
+#include <dpl/db/orm_generator.h>
+#undef ORM_GENERATOR_DATABASE_NAME
+
+#endif // _ORM_GENERATOR_SECURITY_ORIGIN_H_
--- /dev/null
+SQL(BEGIN TRANSACTION;)
+
+CREATE_TABLE(SecurityOriginInfo)
+ COLUMN_NOT_NULL(feature, INT, )
+ COLUMN_NOT_NULL(scheme, TEXT,DEFAULT '')
+ COLUMN_NOT_NULL(host, TEXT,DEFAULT '')
+ COLUMN_NOT_NULL(port, INT, DEFAULT 0)
+ COLUMN_NOT_NULL(result, INT, DEFAULT 0)
+ TABLE_CONSTRAINTS(PRIMARY KEY(feature,scheme,host,port))
+CREATE_TABLE_END()
+
+SQL(COMMIT;)
--- /dev/null
+DATABASE_START(security_origin)
+
+#include "security_origin_db"
+
+DATABASE_END()
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file security_origin_db_sql_generator.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief Macro definitions for generating the SQL
+ * input file from database definition.
+ */
+
+//Do not include this file directly! It is used only for SQL code generation.
+#include <dpl/db/orm_macros.h>
+
+#include "security_origin_db_definitions"
* @version 1.0
* @brief This file is the implementation file of generic socket
*/
+#include <stddef.h>
#include <dpl/socket/generic_socket.h>
//
* @version 1.0
* @brief This file is the implementation file of unix socket
*/
+#include <stddef.h>
#include <dpl/socket/unix_socket.h>
#include <dpl/log/log.h>
#include <dpl/exception.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
+#include <string.h>
namespace DPL
{
GenericSocket<UnixSocket>::Bind(address);
// Always set proper permissions to the socket file
- chmod(address.GetAddress().c_str(), 0777);
+ if(chmod(address.GetAddress().c_str(), 0777)<0){
+ LogError("Error setting permissions to the socket file. Errno " << strerror(errno));
+ }
}
-
}
} // namespace DPL
* @version 1.0
* @brief This file is the implementation file of waitable input-output execution context support
*/
+#include <stddef.h>
#include <dpl/socket/waitable_input_output_execution_context_support.h>
#include <dpl/scoped_array.h>
#include <dpl/socket/abstract_socket.h> // FIXME: Remove !!!
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+#
+# @file config.cmake
+# @author Lukasz Marek (l.marek@samsung.com)
+# @version 1.0
+# @brief
+#
+
+
+SET(DPL_WRT_ENGINE_HEADERS
+ ${PROJECT_SOURCE_DIR}/modules/support/wrt_plugin_export.h
+ PARENT_SCOPE
+)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file wrt_plugin_export.h
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief Header file for plugin export API
+ */
+#ifndef WRT_PLUGIN_EXPORT_H
+#define WRT_PLUGIN_EXPORT_H
+
+#include <stddef.h>
+
+/**
+ * Widget handle type
+ */
+typedef int widget_handle_t;
+
+/**
+ * Parameter which should be used during policy evaluation.
+ */
+typedef struct ace_param_s
+{
+ const char *name;
+ const char *value;
+} ace_param_t;
+
+/**
+ * List of additional parameters which should be used during policy evaluation.
+ */
+typedef struct ace_param_list_s
+{
+ size_t count;
+ ace_param_t *param;
+} ace_param_list_t;
+
+/**
+ * Contains list of device capabilities. Each device capability may have
+ * associated list of function params.
+ */
+typedef struct ace_device_cap_s
+{
+ size_t devcapsCount;
+ const char** dev_cap_names;
+ size_t paramsCount;
+ ace_param_list_t* params;
+} ace_device_cap_t;
+
+/**
+ * List of device capabilities which must be check.
+ */
+typedef struct ace_device_capabilities_s
+{
+ size_t count;
+ const char **device_cap;
+} ace_device_capabilities_t;
+
+/**
+ * List of api features that must be checked
+ */
+typedef struct ace_api_features_s
+{
+ size_t count;
+ const char **api_feature;
+} ace_api_features_t;
+
+/**
+ * Data from request will be used to evaluate policy file.
+ */
+typedef struct ace_request_s
+{
+ widget_handle_t widget_handle;
+ const char* feature_api;
+ const char* function_name;
+ ace_device_capabilities_t device_capabilities;
+ ace_param_list_t param_list;
+} ace_request_t;
+
+/**
+ * Data from request will be used to evaluate policy file.
+ */
+typedef struct ace_request_2_s
+{
+ widget_handle_t widget_handle;
+ ace_api_features_t api_features;
+ const char* function_name;
+ ace_device_cap_t device_capabilities;
+} ace_request_2_t;
+
+/**
+ * info returned by plugin_api_check_access
+ */
+#define PLUGIN_API_ACCESS_GRANTED 1
+#define PLUGIN_API_ACCESS_DENIED 0
+#define PLUGIN_API_ACCESS_ERROR -1
+
+
+typedef const void* java_script_context_t;
+
+typedef struct js_object_properties_s
+{
+ size_t count;
+ char** properties;
+} js_object_properties_t;
+
+typedef const void* js_class_template_t;
+typedef void* js_object_ref_t;
+typedef const void* js_value_ref_t;
+
+typedef js_class_template_t (*js_class_template_getter) (void);
+typedef void* (*js_class_constructor_cb_t)(js_class_template_t,
+ js_object_ref_t, size_t, js_value_ref_t[],
+ js_value_ref_t*);
+
+typedef enum class_definition_type_e
+{
+ JS_CLASS,
+ JS_FUNCTION,
+ JS_INTERFACE
+} class_definition_type_t;
+
+typedef enum class_definition_iframe_behaviour_e
+{
+ //object should not be initalized in iframes
+ //it is default one
+ NONE,
+ //object should be copied as reference to each iframe
+ REFERENCE,
+ //object should be created for each iframe and NOT inform plugin
+ CREATE_INSTANCE,
+} class_definition_iframe_behaviour_t;
+
+typedef enum class_definition_iframe_notice_e
+{
+ //it is default one
+ NONE_NOTICE,
+ ALWAYS_NOTICE
+} class_definition_iframe_notice_t;
+
+typedef enum class_definition_iframe_overlay_e
+{
+ IGNORED,
+ USE_OVERLAYED,
+ OVERLAYED_BEFORE_ORIGINAL
+} class_definition_iframe_overlay_t;
+
+typedef void* js_object_instance_t;
+//global_context - id
+typedef void(*iframe_loaded_cb)(java_script_context_t global_context,
+ js_object_instance_t iframe,
+ js_object_instance_t object);
+
+typedef void* (*js_function_impl)(void*);
+
+typedef struct class_definition_options_s
+{
+ class_definition_type_t type;
+ class_definition_iframe_behaviour_t iframe_option;
+ class_definition_iframe_notice_t iframe_notice;
+ class_definition_iframe_overlay_t iframe_overlay;
+ iframe_loaded_cb cb;
+ void * private_data;
+ js_function_impl function;
+} class_definition_options_t;
+
+
+/*
+ * list of device caps
+ */
+typedef struct devcaps_s
+{
+ char** deviceCaps;
+ size_t devCapsCount;
+} devcaps_t;
+
+/*
+ * mapping from a feature to corresponding list of device capabilities
+ */
+typedef struct feature_devcaps_s
+{
+ char* feature_name;
+ devcaps_t devCaps;
+} feature_devcaps_t;
+
+/*
+ * list of feature_devcaps_t structs
+ */
+typedef struct feature_mapping_s
+{
+ feature_devcaps_t* features;
+ size_t featuresCount;
+} feature_mapping_t;
+
+
+typedef feature_mapping_t* pfeature_mapping_t;
+
+typedef pfeature_mapping_t (*features_getter)(void);
+
+typedef const devcaps_t* (*devcaps_getter)(pfeature_mapping_t /*features*/,
+ const char* /*featureName*/);
+typedef void (*deinitializer)(pfeature_mapping_t /*features*/);
+
+typedef struct feature_mapping_interface_s
+{
+ features_getter featGetter; /* returns a list of api features */
+ devcaps_getter dcGetter; /*
+ * for a given api feature returns a list of
+ * corresponding device capabilities
+ */
+
+ deinitializer release; /* as memory ownership of features is
+ * transfered to callee you have to call
+ * the release function ptr on features
+ */
+} feature_mapping_interface_t;
+
+
+/*
+ * This is a structure describing a JS entity template (a class, an interface
+ * or function), object name and it's parent class name (parent_name). JS
+ * entity will be bind to a parent class name (parent_name.js_entity_name).
+ * @param parent_name - parent name (ie Widget.Device)
+ * @param object_name - object name (DeviceStatus)
+ * @param interface_name - interface name (e.g. Widget)
+ * @param js_class_template_getter_fun - js_class_template required to create
+ * JS object
+ * @param js_class_consturctor_cb - constructor to call to when instance of
+ * certain interface is created
+ * @param private_data private data for object creator if required (usually
+ * NULL)
+ */
+typedef struct js_entity_definition_s
+{
+ const char *parent_name;
+ const char *object_name;
+ const char *interface_name;
+ js_class_template_getter js_class_template_getter_fun;
+ js_class_constructor_cb_t js_class_constructor_cb;
+ //class options may be null - default
+ class_definition_options_t* class_options;
+} js_entity_definition_t;
+
+typedef const js_entity_definition_t *js_entity_definition_ptr_t;
+
+/**
+ * Plugin export names
+ */
+#define PLUGIN_WIDGET_START_PROC on_widget_start
+#define PLUGIN_WIDGET_INIT_PROC on_widget_init
+#define PLUGIN_WIDGET_STOP_PROC on_widget_stop
+#define PLUGIN_FRAME_LOAD_PROC on_frame_load
+#define PLUGIN_FRAME_UNLOAD_PROC on_frame_unload
+#define PLUGIN_CLASS_MAP class_map
+#define PLUGIN_GET_CLASS_PROC_MAP get_widget_class_map
+
+#define PLUGIN_WIDGET_START_PROC_NAME "on_widget_start"
+#define PLUGIN_WIDGET_INIT_PROC_NAME "on_widget_init"
+#define PLUGIN_WIDGET_STOP_PROC_NAME "on_widget_stop"
+#define PLUGIN_FRAME_LOAD_PROC_NAME "on_frame_load"
+#define PLUGIN_FRAME_UNLOAD_PROC_NAME "on_frame_unload"
+#define PLUGIN_CLASS_MAP_NAME "class_map"
+#define PLUGIN_GET_CLASS_MAP_PROC_NAME "get_widget_class_map"
+
+/**
+ * Plugin export typedefs
+ */
+typedef void (*on_widget_start_proc)(int widgetId);
+
+typedef void (*on_widget_init_proc)(feature_mapping_interface_t *interface);
+
+/**
+ * FIXME: Add documentation
+ */
+typedef void (*on_widget_stop_proc)(int widgetId);
+
+typedef void (*on_frame_load_proc)(java_script_context_t context);
+
+typedef void (*on_frame_unload_proc)(java_script_context_t context);
+
+typedef const js_entity_definition_t* (*get_widget_entity_map_proc)();
+
+#endif // WRT_PLUGIN_EXPORT_H
#ifndef DPL_TEST_RESULTS_COLLECTOR_H
#define DPL_TEST_RESULTS_COLLECTOR_H
-#include <dpl/shared_ptr.h>
#include <dpl/noncopyable.h>
#include <vector>
#include <list>
#include <map>
#include <string>
+#include <memory>
namespace DPL
{
{
class TestResultsCollectorBase;
-typedef DPL::SharedPtr<TestResultsCollectorBase>
+typedef std::shared_ptr<TestResultsCollectorBase>
TestResultsCollectorBasePtr;
class TestResultsCollectorBase
NONE,
FAILED,
IGNORED,
- TODO,
INTERNAL
};
};
#include <vector>
#include <list>
#include <set>
+#include <map>
namespace DPL
{
{
class TestRunner
{
- TestResultsCollectorBasePtr m_collector;
- std::string m_collectorName;
+ typedef std::map<std::string, TestResultsCollectorBasePtr>
+ TestResultsCollectors;
+ TestResultsCollectors m_collectors;
+
std::string m_startTestId;
+ bool m_runIgnored;
public:
typedef void (*TestCase)();
DPL::Atomic m_totalAssertions;
void Banner();
- void InvalidArgs();
+ void InvalidArgs(const std::string& message = "Invalid arguments!");
void Usage();
- enum Status { FAILED, TODO, IGNORED, PASS };
+ enum Status { FAILED, IGNORED, PASS };
Status RunTestCase(const TestCaseStruct& testCase);
void RunTests();
+ void CollectResult(const std::string& id,
+ const std::string& description,
+ const TestResultsCollectorBase::FailStatus::Type status
+ = TestResultsCollectorBase::FailStatus::NONE,
+ const std::string& reason = std::string());
+
public:
class TestFailed
{
}
};
- class ToDo
- {
- private:
- std::string m_message;
-
- public:
- ToDo()
- {
- }
-
- ToDo(const std::string &message)
- : m_message(message)
- {
- }
-
- std::string GetMessage() const
- {
- return m_message;
- }
- };
-
class Ignored
{
private:
int ExecTestRunner(int argc, char *argv[]);
typedef std::vector<std::string> ArgsList;
int ExecTestRunner(const ArgsList& args);
+ bool getRunIgnored() const;
};
typedef DPL::Singleton<TestRunner> TestRunnerSingleton;
#define RUNNER_FAIL RUNNER_ASSERT(false)
-#define RUNNER_TODO_MSG(message) do { std::ostringstream assertMsg; assertMsg << message; throw DPL::Test::TestRunner::ToDo(assertMsg.str()); } while (0)
-
#define RUNNER_IGNORED_MSG(message) do { std::ostringstream assertMsg; assertMsg << message; throw DPL::Test::TestRunner::Ignored(assertMsg.str()); } while (0)
#endif // DPL_TEST_RUNNER_H
* @version 1.0
* @brief Implementation file some concrete TestResulstsCollector
*/
-
+#include <cstddef>
#include <dpl/test/test_results_collector.h>
#include <dpl/colors.h>
#include <dpl/assert.h>
#include <dpl/foreach.h>
#include <dpl/scoped_fclose.h>
+#include <dpl/exception.h>
+#include <dpl/errno_string.h>
#include <string>
+#include <string.h>
#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <cstdlib>
+
+#define GREEN_RESULT_OK "[%s%s%s]\n", BOLD_GREEN_BEGIN, " OK ", BOLD_GREEN_END
namespace DPL
{
namespace
{
const char *DEFAULT_HTML_FILE_NAME = "index.html";
+const char *DEFAULT_TAP_FILE_NAME = "results.tap";
+const char *DEFAULT_XML_FILE_NAME = "results.xml";
+
+bool ParseCollectorFileArg(const std::string &arg, std::string &filename)
+{
+ const std::string argname = "--file=";
+ if (0 == arg.find(argname)) {
+ filename = arg.substr(argname.size());
+ return true;
+ }
+ return false;
+}
class Statistic
{
Statistic() :
m_failed(0),
m_ignored(0),
- m_todo(0),
m_passed(0),
m_count(0)
{
case TestResultsCollectorBase::FailStatus::INTERNAL:
case TestResultsCollectorBase::FailStatus::FAILED: ++m_failed; break;
case TestResultsCollectorBase::FailStatus::IGNORED: ++m_ignored; break;
- case TestResultsCollectorBase::FailStatus::TODO: ++m_todo; break;
case TestResultsCollectorBase::FailStatus::NONE: ++m_passed; break;
default:
Assert(false && "Bad FailStatus");
}
}
- size_t GetTotal() const { return m_count; }
- size_t GetPassed() const { return m_passed; }
- size_t GetSuccesed() const { return m_passed; }
- size_t GetFailed() const { return m_failed; }
- size_t GetTODO() const { return m_todo; }
- size_t GetIgnored() const { return m_ignored; }
+ std::size_t GetTotal() const { return m_count; }
+ std::size_t GetPassed() const { return m_passed; }
+ std::size_t GetSuccesed() const { return m_passed; }
+ std::size_t GetFailed() const { return m_failed; }
+ std::size_t GetIgnored() const { return m_ignored; }
float GetPassedOrIgnoredPercend() const
{
float passIgnoredPercent =
}
private:
- size_t m_failed;
- size_t m_ignored;
- size_t m_todo;
- size_t m_passed;
- size_t m_count;
+ std::size_t m_failed;
+ std::size_t m_ignored;
+ std::size_t m_passed;
+ std::size_t m_count;
};
class ConsoleCollector
printf("Running test case %-60s", tmp.c_str());
switch(status) {
case TestResultsCollectorBase::FailStatus::NONE:
- printf("[%s%s%s]\n", BOLD_GREEN_BEGIN, " OK ", BOLD_GREEN_END); break;
+ printf(GREEN_RESULT_OK); break;
case TestResultsCollectorBase::FailStatus::FAILED:
PrintfErrorMessage( " FAILED ", reason, true); break;
case TestResultsCollectorBase::FailStatus::IGNORED:
PrintfIgnoredMessage("Ignored ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::TODO:
- PrintfTODOMessage( " TODO ", reason, true); break;
case TestResultsCollectorBase::FailStatus::INTERNAL:
PrintfErrorMessage( "INTERNAL", reason, true); break;
default:
}
}
- void PrintfTODOMessage(const char* type,
- const std::string& message,
- bool verbosity)
- {
- using namespace DPL::Colors::Text;
- if (verbosity) {
- printf("[%s%s%s] %s%s%s\n",
- BOLD_WHITE_BEGIN,
- type,
- BOLD_WHITE_END,
- BOLD_GOLD_BEGIN,
- message.c_str(),
- BOLD_GOLD_END);
- } else {
- printf("[%s%s%s]\n",
- BOLD_WHITE_BEGIN,
- type,
- BOLD_WHITE_END);
- }
- }
-
void PrintfIgnoredMessage(const char* type,
const std::string& message,
bool verbosity)
using namespace DPL::Colors::Text;
printf("\n%sResults [%s]: %s\n", BOLD_GREEN_BEGIN, title.c_str(), BOLD_GREEN_END);
printf("%s%s%3d%s\n", CYAN_BEGIN, "Total tests: ", stats.GetTotal(), CYAN_END);
- printf("%s%s%3d%s\n", CYAN_BEGIN, "Succeeded or ignored: ", stats.GetPassed() + stats.GetIgnored(), CYAN_END);
- printf(" %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
- printf(" %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
- printf("%s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
- printf("%s%s%3d%s\n", CYAN_BEGIN, "Todo: ", stats.GetTODO(), CYAN_END);
- printf("%s%s%3.0f%%%s\n", CYAN_BEGIN, "Succeeded or ignored %: ", stats.GetPassedOrIgnoredPercend(), CYAN_END);
+ printf(" %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
+ printf(" %s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
+ printf(" %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
}
Statistic m_stats;
virtual bool ParseCollectorSpecificArg(const std::string& arg)
{
- const std::string argname = "--file=";
- if (0 == arg.find(argname)) {
- m_filename = arg.substr(argname.size());
- return true;
- } else {
- return false;
- }
+ return ParseCollectorFileArg(arg, m_filename);
}
virtual void CollectResult(const std::string& id,
fprintf(m_fp.Get(), "Running test case %-100s", tmp.c_str());
switch(status) {
case TestResultsCollectorBase::FailStatus::NONE:
- fprintf(m_fp.Get(), "[%s%s%s]\n", BOLD_GREEN_BEGIN, " OK ", BOLD_GREEN_END); break;
+ fprintf(m_fp.Get(), GREEN_RESULT_OK); break;
case TestResultsCollectorBase::FailStatus::FAILED:
PrintfErrorMessage( " FAILED ", reason, true); break;
case TestResultsCollectorBase::FailStatus::IGNORED:
PrintfIgnoredMessage("Ignored ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::TODO:
- PrintfTODOMessage( " TODO ", reason, true); break;
case TestResultsCollectorBase::FailStatus::INTERNAL:
PrintfErrorMessage( "INTERNAL", reason, true); break;
default:
}
}
- void PrintfTODOMessage(const char* type,
- const std::string& message,
- bool verbosity)
- {
- using namespace DPL::Colors::Html;
- if (verbosity) {
- fprintf(m_fp.Get(),
- "[%s%s%s] %s%s%s\n",
- BOLD_WHITE_BEGIN,
- type,
- BOLD_WHITE_END,
- BOLD_GOLD_BEGIN,
- message.c_str(),
- BOLD_GOLD_END);
- } else {
- fprintf(m_fp.Get(),
- "[%s%s%s]\n",
- BOLD_WHITE_BEGIN,
- type,
- BOLD_WHITE_END);
- }
- }
-
void PrintfIgnoredMessage(const char* type,
const std::string& message,
bool verbosity)
using namespace DPL::Colors::Html;
fprintf(m_fp.Get(), "\n%sResults [%s]:%s\n", BOLD_GREEN_BEGIN, name.c_str(), BOLD_GREEN_END);
fprintf(m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN, "Total tests: ", stats.GetTotal(), CYAN_END);
- fprintf(m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN, "Succeeded or ignored: ", stats.GetPassed() + stats.GetIgnored(), CYAN_END);
- fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
- fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
- fprintf(m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
- fprintf(m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN, "Todo: ", stats.GetTODO(), CYAN_END);
- fprintf(m_fp.Get(), "%s%s%3.0f%%%s\n", CYAN_BEGIN, "Succeeded or ignored %: ", stats.GetPassedOrIgnoredPercend(), CYAN_END);
+ fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
+ fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
+ fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
}
std::string m_filename;
return new HtmlCollector();
}
+
+class XmlCollector
+ : public TestResultsCollectorBase
+{
+ public:
+ static TestResultsCollectorBase* Constructor();
+
+ private:
+ XmlCollector() : m_filename(DEFAULT_XML_FILE_NAME) {}
+
+ virtual void CollectCurrentTestGroupName(const std::string& name)
+ {
+ std::size_t pos = GetCurrentGroupPosition();
+ if (std::string::npos != pos)
+ {
+ GroupFinish(pos);
+ FlushOutput();
+ m_stats = Statistic();
+ }
+
+ pos = m_outputBuffer.find("</testsuites>");
+ if (std::string::npos == pos)
+ {
+ ThrowMsg(DPL::Exception, "Could not find test suites closing tag");
+ }
+ GroupStart(pos, name);
+ }
+
+ void GroupStart(const std::size_t pos, const std::string& name)
+ {
+ std::stringstream groupHeader;
+ groupHeader << "\n\t<testsuite";
+ groupHeader << " name=\"" << EscapeSpecialCharacters(name) << "\"";
+ groupHeader << R"( tests="1")"; // include SegFault
+ groupHeader << R"( failures="1")"; // include SegFault
+ groupHeader << R"( skipped="0")";
+ groupHeader << ">";
+
+ groupHeader << "\n\t\t<testcase name=\"unknown\" status=\"FAILED\">";
+ groupHeader << "\n\t\t\t<failure type=\"FAILED\" message=\"segmentation fault\"/>";
+ groupHeader << "\n\t\t</testcase>";
+
+ groupHeader << "\n\t</testsuite>";
+
+ m_outputBuffer.insert(pos - 1, groupHeader.str());
+ }
+
+ virtual bool Configure()
+ {
+ m_fp.Reset(fopen (m_filename.c_str(), "w"));
+ if (!m_fp) {
+ LogPedantic("Could not open file " << m_filename << " for writing");
+ return false;
+ }
+ return true;
+ }
+
+ virtual std::string CollectorSpecificHelp() const
+ {
+ return "--file=<filename> - name of file for output\n"
+ " default - results.xml\n";
+ }
+
+ virtual void Start()
+ {
+ Assert(!!m_fp && "File handle must not be null");
+ m_outputBuffer.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
+ m_outputBuffer.append("<testsuites>\n</testsuites>");
+ FlushOutput();
+ }
+
+ virtual void Finish()
+ {
+ std::size_t pos = GetCurrentGroupPosition();
+ if (std::string::npos != pos)
+ {
+ GroupFinish(pos);
+ FlushOutput();
+ }
+ }
+
+ virtual bool ParseCollectorSpecificArg(const std::string& arg)
+ {
+ return ParseCollectorFileArg(arg, m_filename);
+ }
+
+ virtual void CollectResult(const std::string& id,
+ const std::string& /*description*/,
+ const FailStatus::Type status = FailStatus::NONE,
+ const std::string& reason = "")
+ {
+ m_resultBuffer.erase();
+ m_resultBuffer.append("\t\t<testcase name=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(id));
+ m_resultBuffer.append("\"");
+ switch(status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ m_resultBuffer.append(" status=\"OK\"/>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ m_resultBuffer.append(" status=\"FAILED\">\n");
+ PrintfErrorMessage("FAILED", EscapeSpecialCharacters(reason), true);
+ m_resultBuffer.append("\t\t</testcase>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ m_resultBuffer.append(" status=\"Ignored\">\n");
+ PrintfIgnoredMessage("Ignored", EscapeSpecialCharacters(reason), true);
+ m_resultBuffer.append("\t\t</testcase>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ m_resultBuffer.append(" status=\"FAILED\">\n");
+ PrintfErrorMessage("INTERNAL", EscapeSpecialCharacters(reason), true);
+ m_resultBuffer.append("\t\t</testcase>");
+ break;
+ default:
+ Assert(false && "Bad status");
+ }
+ std::size_t group_pos = GetCurrentGroupPosition();
+ if (std::string::npos == group_pos)
+ {
+ ThrowMsg(DPL::Exception, "No current group set");
+ }
+
+ std::size_t last_case_pos = m_outputBuffer.find("<testcase name=\"unknown\"", group_pos);
+ if (std::string::npos == last_case_pos)
+ {
+ ThrowMsg(DPL::Exception, "Could not find SegFault test case");
+ }
+ m_outputBuffer.insert(last_case_pos - 2, m_resultBuffer);
+
+ m_stats.AddTest(status);
+
+ UpdateGroupHeader(group_pos,
+ m_stats.GetTotal() + 1, // include SegFault
+ m_stats.GetFailed() + 1, // include SegFault
+ m_stats.GetIgnored());
+ FlushOutput();
+ }
+
+ std::size_t GetCurrentGroupPosition() const
+ {
+ return m_outputBuffer.rfind("<testsuite ");
+ }
+
+ void UpdateGroupHeader(const std::size_t groupPosition,
+ const unsigned int tests,
+ const unsigned int failures,
+ const unsigned int skipped)
+ {
+ UpdateElementAttribute(groupPosition, "tests", UIntToString(tests));
+ UpdateElementAttribute(groupPosition, "failures", UIntToString(failures));
+ UpdateElementAttribute(groupPosition, "skipped", UIntToString(skipped));
+ }
+
+ void UpdateElementAttribute(const std::size_t elementPosition,
+ const std::string& name,
+ const std::string& value)
+ {
+ std::string pattern = name + "=\"";
+
+ std::size_t start = m_outputBuffer.find(pattern, elementPosition);
+ if (std::string::npos == start)
+ {
+ ThrowMsg(DPL::Exception, "Could not find attribute " << name << " beginning");
+ }
+
+ std::size_t end = m_outputBuffer.find("\"", start + pattern.length());
+ if (std::string::npos == end)
+ {
+ ThrowMsg(DPL::Exception, "Could not find attribute " << name << " end");
+ }
+
+ m_outputBuffer.replace(start + pattern.length(),
+ end - start - pattern.length(),
+ value);
+ }
+
+ std::string UIntToString(const unsigned int value)
+ {
+ std::stringstream result;
+ result << value;
+ return result.str();
+ }
+
+ void GroupFinish(const std::size_t groupPosition)
+ {
+ std::size_t segFaultStart =
+ m_outputBuffer.find("<testcase name=\"unknown\"", groupPosition);
+ if (std::string::npos == segFaultStart)
+ {
+ ThrowMsg(DPL::Exception, "Could not find SegFault test case start position");
+ }
+ segFaultStart -= 2; // to erase tabs
+
+ std::string closeTag = "</testcase>";
+ std::size_t segFaultEnd = m_outputBuffer.find(closeTag, segFaultStart);
+ if (std::string::npos == segFaultEnd)
+ {
+ ThrowMsg(DPL::Exception, "Could not find SegFault test case end position");
+ }
+ segFaultEnd += closeTag.length() + 1; // to erase new line
+
+ m_outputBuffer.erase(segFaultStart, segFaultEnd - segFaultStart);
+
+ UpdateGroupHeader(groupPosition,
+ m_stats.GetTotal(),
+ m_stats.GetFailed(),
+ m_stats.GetIgnored());
+ }
+
+ void FlushOutput()
+ {
+ int fd = fileno(m_fp.Get());
+ if (-1 == fd)
+ {
+ int error = errno;
+ ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
+ }
+
+ if (-1 == TEMP_FAILURE_RETRY(ftruncate(fd, 0L)))
+ {
+ int error = errno;
+ ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
+ }
+
+ if (-1 == TEMP_FAILURE_RETRY(fseek(m_fp.Get(), 0L, SEEK_SET)))
+ {
+ int error = errno;
+ ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
+ }
+
+ if (0 > fprintf(m_fp.Get(), m_outputBuffer.c_str()))
+ {
+ int error = errno;
+ ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
+ }
+
+ if (-1 == TEMP_FAILURE_RETRY(fflush(m_fp.Get())))
+ {
+ int error = errno;
+ ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
+ }
+ }
+
+ void PrintfErrorMessage(const char* type,
+ const std::string& message,
+ bool verbosity)
+ {
+ if (verbosity) {
+ m_resultBuffer.append("\t\t\t<failure type=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(type));
+ m_resultBuffer.append("\" message=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(message));
+ m_resultBuffer.append("\"/>\n");
+
+ } else {
+
+ m_resultBuffer.append("\t\t\t<failure type=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(type));
+ m_resultBuffer.append("\"/>\n");
+ }
+ }
+
+ void PrintfIgnoredMessage(const char* type,
+ const std::string& message,
+ bool verbosity)
+ {
+ if (verbosity) {
+ m_resultBuffer.append("\t\t\t<skipped type=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(type));
+ m_resultBuffer.append("\" message=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(message));
+ m_resultBuffer.append("\"/>\n");
+ } else {
+
+ m_resultBuffer.append("\t\t\t<skipped type=\"");
+ m_resultBuffer.append(EscapeSpecialCharacters(type));
+ m_resultBuffer.append("\"/>\n");
+ }
+ }
+
+ std::string EscapeSpecialCharacters(std::string s)
+ {
+ for (unsigned int i = 0; i < s.size();) {
+ switch(s[i]){
+ case '"':
+ s.erase(i,1);
+ s.insert(i, """);
+ i+=6;
+ break;
+
+ case '&':
+ s.erase(i,1);
+ s.insert(i, "&");
+ i+=5;
+ break;
+
+ case '<':
+ s.erase(i,1);
+ s.insert(i, "<");
+ i+=4;
+ break;
+
+ case '>':
+ s.erase(i,1);
+ s.insert(i, ">");
+ i+=4;
+ break;
+
+ case '\'':
+ s.erase(i,1);
+ s.insert(i, "'");
+ i+=5;
+ break;
+ default:
+ ++i;
+ break;
+ }
+ }
+ return s;
+ }
+
+ std::string m_filename;
+ ScopedFClose m_fp;
+ Statistic m_stats;
+ std::string m_outputBuffer;
+ std::string m_resultBuffer;
+};
+
+TestResultsCollectorBase* XmlCollector::Constructor()
+{
+ return new XmlCollector();
+}
+
+
+
class CSVCollector
: public TestResultsCollectorBase
{
case TestResultsCollectorBase::FailStatus::NONE: statusMsg = "OK"; break;
case TestResultsCollectorBase::FailStatus::FAILED: statusMsg = "FAILED"; break;
case TestResultsCollectorBase::FailStatus::IGNORED: statusMsg = "IGNORED"; break;
- case TestResultsCollectorBase::FailStatus::TODO: statusMsg = "TODO"; break;
case TestResultsCollectorBase::FailStatus::INTERNAL: statusMsg = "FAILED"; break;
default:
Assert(false && "Bad status");
}
+class TAPCollector
+ : public TestResultsCollectorBase
+{
+ public:
+ static TestResultsCollectorBase* Constructor();
+
+ private:
+ TAPCollector() : m_filename(DEFAULT_TAP_FILE_NAME) {}
+
+ virtual bool Configure()
+ {
+ m_output.open(m_filename.c_str(), std::ios_base::trunc);
+ if (m_output.fail()) {
+ LogError("Can't open output file: " << m_filename);
+ return false;
+ }
+ return true;
+ }
+ virtual std::string CollectorSpecificHelp() const
+ {
+ std::string retVal = "--file=<filename> - name of file for output\n"
+ " default - ";
+ retVal += DEFAULT_TAP_FILE_NAME;
+ retVal += "\n";
+ return retVal;
+ }
+
+ virtual void Start()
+ {
+ Assert(m_output.good() && "Output file must be opened.");
+ m_output << "TAP version 13" << std::endl;
+ m_testIndex = 0;
+ }
+
+ virtual void Finish()
+ {
+ m_output << "1.." << m_testIndex << std::endl;
+ m_output << m_collectedData.rdbuf();
+ m_output.close();
+ }
+
+ virtual bool ParseCollectorSpecificArg(const std::string& arg)
+ {
+ return ParseCollectorFileArg(arg, m_filename);
+ }
+
+ virtual void CollectResult(const std::string& id,
+ const std::string& description,
+ const FailStatus::Type status = FailStatus::NONE,
+ const std::string& reason = "")
+ {
+ m_testIndex++;
+ switch(status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ LogBasicTAP(true, id, description);
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ LogBasicTAP(false, id, description);
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ LogBasicTAP(true, id, description);
+ m_collectedData << " # skip " << reason;
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ LogBasicTAP(true, id, description);
+ endTAPLine();
+ m_collectedData << " ---" << std::endl;
+ m_collectedData << " message: " << reason << std::endl;
+ m_collectedData << " severity: Internal" << std::endl;
+ m_collectedData << " ..." << std::endl;
+ break;
+ default:
+ Assert(false && "Bad status");
+ }
+ }
+
+ void LogBasicTAP(bool isOK, const std::string& id,
+ const std::string& description)
+ {
+ if (!isOK) {
+ m_collectedData << "not ";
+ }
+ m_collectedData << "ok " << m_testIndex << " [" <<
+ id << "] " << description;
+ }
+
+ void endTAPLine()
+ {
+ m_collectedData << std::endl;
+ }
+
+
+ std::string m_filename;
+ std::stringstream m_collectedData;
+ std::ofstream m_output;
+ int m_testIndex;
+};
+
+
+TestResultsCollectorBase* TAPCollector::Constructor()
+{
+ return new TAPCollector();
+}
+
+
void TestResultsCollectorBase::RegisterCollectorConstructor(
const std::string& name,
TestResultsCollectorBase::CollectorConstructorFunc func)
TestResultsCollectorBase::RegisterCollectorConstructor(
"csv",
&CSVCollector::Constructor);
+ TestResultsCollectorBase::RegisterCollectorConstructor(
+ "tap",
+ &TAPCollector::Constructor);
+ TestResultsCollectorBase::RegisterCollectorConstructor(
+ "xml",
+ &XmlCollector::Constructor);
return 0;
}
}
}
+#undef GREEN_RESULT_OK
* @version 1.0
* @brief This file is the implementation file of test runner
*/
+#include <stddef.h>
#include <dpl/test/test_runner.h>
#include <dpl/test/test_results_collector.h>
#include <dpl/exception.h>
#include <memory.h>
#include <libgen.h>
#include <cstring>
+#include <cstdlib>
+#include <dpl/utils/wrt_global_settings.h>
#include <dpl/singleton_impl.h>
IMPLEMENT_SINGLETON(DPL::Test::TestRunner)
catch (const TestFailed &e)
{
// Simple test failure
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::FAILED,
- e.GetMessage());
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::FAILED,
+ e.GetMessage());
return FAILED;
}
catch (const Ignored &e)
{
- // Simple test have to be implemented
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::IGNORED,
- e.GetMessage());
+ if (m_runIgnored) {
+ // Simple test have to be implemented
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::IGNORED,
+ e.GetMessage());
+ }
return IGNORED;
}
- catch (const ToDo &e)
- {
- // Simple test have to be implemented
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::TODO,
- e.GetMessage());
-
- return TODO;
- }
catch (const DPL::Exception &e)
{
// DPL exception failure
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::INTERNAL,
- "DPL exception:" +
- e.GetMessage());
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::INTERNAL,
+ "DPL exception:" + e.GetMessage());
return FAILED;
}
catch (const std::exception &)
{
// std exception failure
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::INTERNAL,
- "std exception");
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::INTERNAL,
+ "std exception");
return FAILED;
}
catch (...)
{
// Unknown exception failure
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::INTERNAL,
- "unknown exception");
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::INTERNAL,
+ "unknown exception");
return FAILED;
}
- m_collector->CollectResult(testCase.name,
- "",
- TestResultsCollectorBase::FailStatus::NONE);
+ CollectResult(testCase.name,
+ "",
+ TestResultsCollectorBase::FailStatus::NONE);
+
// Everything OK
return PASS;
}
using namespace DPL::Colors::Text;
Banner();
- m_collector->Start();
+ std::for_each(m_collectors.begin(),
+ m_collectors.end(),
+ [](const TestResultsCollectors::value_type& collector)
+ {
+ collector.second->Start();
+ });
fprintf(stderr, "%s%s%s\n", GREEN_BEGIN, "Running tests...", GREEN_END);
FOREACH(group, m_testGroups) {
TestCaseStructList list = group->second;
if (!list.empty()) {
- m_collector->CollectCurrentTestGroupName(group->first);
+ std::for_each(
+ m_collectors.begin(),
+ m_collectors.end(),
+ [&group](const TestResultsCollectors::value_type& collector)
+ {
+ collector.second->
+ CollectCurrentTestGroupName(group->first);
+ });
list.sort();
for (TestCaseStructList::const_iterator iterator = list.begin();
}
}
- m_collector->Finish();
+ std::for_each(m_collectors.begin(),
+ m_collectors.end(),
+ [](const TestResultsCollectors::value_type& collector)
+ {
+ collector.second->Finish();
+ });
+
// Finished
fprintf(stderr, "%s%s%s\n\n", GREEN_BEGIN, "Finished", GREEN_END);
}
+void TestRunner::CollectResult(
+ const std::string& id,
+ const std::string& description,
+ const TestResultsCollectorBase::FailStatus::Type status,
+ const std::string& reason)
+{
+ std::for_each(m_collectors.begin(),
+ m_collectors.end(),
+ [&](const TestResultsCollectors::value_type& collector)
+ {
+ collector.second->CollectResult(id,
+ description,
+ status,
+ reason);
+ });
+}
+
void TestRunner::Banner()
{
using namespace DPL::Colors::Text;
GREEN_END);
}
-void TestRunner::InvalidArgs()
+void TestRunner::InvalidArgs(const std::string& message)
{
using namespace DPL::Colors::Text;
fprintf(stderr,
"%s%s%s\n",
BOLD_RED_BEGIN,
- "Invalid parameters!",
+ message.c_str(),
BOLD_RED_END);
}
{
fprintf(stderr, "Usage: runner [options]\n\n");
fprintf(stderr, "Output type:\n");
- fprintf(stderr, " --output=<output type>\n");
- fprintf(stderr, " possible output types:\n");
+ fprintf(stderr, " --output=<output type> --output=<output type> ...\n");
+ fprintf(stderr, "\n possible output types:\n");
FOREACH (type, TestResultsCollectorBase::GetCollectorsNames()) {
- fprintf(stderr, " --output=%s\n", type->c_str());
+ fprintf(stderr, " --output=%s\n", type->c_str());
}
+ fprintf(stderr, "\n example:\n");
+ fprintf(stderr, " test-binary --output=text --output=xml --file=output.xml\n\n");
fprintf(stderr, "Other parameters:\n");
fprintf(stderr,
" --regexp='regexp'\t Only selected tests"
" which names match regexp run\n\n");
fprintf(stderr, " --start=<test id>\tStart from concrete test id");
fprintf(stderr, " --group=<group name>\t Run tests only from one group\n");
+ fprintf(stderr, " --runignored\t Run also ignored tests\n");
fprintf(stderr, " --list\t Show a list of Test IDs\n");
fprintf(stderr, " --listgroups\t Show a list of Test Group names \n");
fprintf(stderr, " --listingroup=<group name>\t Show a list of Test IDS in one group\n");
fprintf(stderr, " --help\t This help\n\n");
- if (m_collector) {
- fprintf(stderr, "Output %s has specific args:\n", m_collectorName.c_str());
- fprintf(stderr, "%s\n", m_collector->CollectorSpecificHelp().c_str());
- }
+ std::for_each(m_collectors.begin(),
+ m_collectors.end(),
+ [](const TestResultsCollectors::value_type& collector)
+ {
+ fprintf(stderr,
+ "Output %s has specific args:\n",
+ collector.first.c_str());
+ fprintf(stderr,
+ "%s\n",
+ collector.second->
+ CollectorSpecificHelp().c_str());
+ });
fprintf(stderr, "For bug reporting, please write to:\n");
fprintf(stderr, "<p.dobrowolsk@samsung.com>\n");
}
int TestRunner::ExecTestRunner(const ArgsList& value)
{
+ m_runIgnored = false;
ArgsList args = value;
// Parse command line
if (args.size() == 1)
bool showHelp = false;
+ TestResultsCollectorBasePtr currentCollector;
+
// Parse each argument
FOREACH(it, args)
{
const std::string regexp = "--regexp=";
const std::string output = "--output=";
const std::string groupId = "--group=";
+ const std::string runIgnored = "--runignored";
const std::string listCmd = "--list";
const std::string startCmd = "--start=";
const std::string listGroupsCmd = "--listgroups";
const std::string listInGroup = "--listingroup=";
- if (m_collector && m_collector->ParseCollectorSpecificArg(arg)) continue;
- else if (arg.find(startCmd) == 0)
+ if (currentCollector)
+ {
+ if (currentCollector->ParseCollectorSpecificArg(arg))
+ {
+ continue;
+ }
+ }
+
+ if (arg.find(startCmd) == 0)
{
arg.erase(0, startCmd.length());
FOREACH(group, m_testGroups) {
return -1;
}
}
+ else if (arg == runIgnored)
+ {
+ m_runIgnored = true;
+ }
else if (arg == listCmd)
{
FOREACH(group, m_testGroups) {
else if (arg.find(output) == 0)
{
arg.erase(0, output.length());
- m_collector.Reset(TestResultsCollectorBase::Create(arg));
- if (!m_collector) {
- InvalidArgs();
+ if (m_collectors.find(arg) != m_collectors.end())
+ {
+ InvalidArgs("Multiple outputs of the same type are not supported!");
Usage();
return -1;
- } else {
- m_collectorName = arg;
}
+ currentCollector.reset(TestResultsCollectorBase::Create(arg));
+ if (!currentCollector) {
+ InvalidArgs("Unsupported output type!");
+ Usage();
+ return -1;
+ }
+ m_collectors[arg] = currentCollector;
}
else if (arg.find(regexp) == 0)
{
}
}
+ currentCollector.reset();
+
// Show help
if (showHelp)
{
return 0;
}
- if (!m_collector)
- m_collector.Reset(TestResultsCollectorBase::Create("text"));
+ if (m_collectors.empty())
+ {
+ TestResultsCollectorBasePtr collector(
+ TestResultsCollectorBase::Create("text"));
+ m_collectors["text"] = collector;
+ }
- if (!m_collector->Configure()) {
- fprintf(stderr, "Could not configure selected output");
- return 0;
+ for (auto it = m_collectors.begin(); it != m_collectors.end(); ++it)
+ {
+ if (!it->second->Configure())
+ {
+ fprintf(stderr, "Could not configure selected output");
+ return 0;
+ }
}
// Run tests
return 0;
}
+bool TestRunner::getRunIgnored() const
+{
+ return m_runIgnored;
+}
+
}
} // namespace DPL
#
SET(DPL_UTILS_SOURCES
- ${PROJECT_SOURCE_DIR}/modules/utils/src/file_utils.cpp
+ ${PROJECT_SOURCE_DIR}/modules/utils/src/bash_utils.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/folder_size.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/mime_type_utils.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/warp_iri.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/widget_version.cpp
- ${PROJECT_SOURCE_DIR}/modules/utils/src/wrt_global_settings_internal.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/wrt_global_settings.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/wrt_utility.cpp
PARENT_SCOPE
SET(DPL_UTILS_HEADERS
- ${PROJECT_SOURCE_DIR}/modules/utils/include/file_utils.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/folder_size.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/mime_type_utils.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/warp_iri.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/widget_version.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/wrt_global_settings.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/wrt_global_settings_internal.h
- ${PROJECT_SOURCE_DIR}/modules/utils/include/wrt_utility.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/bash_utils.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/folder_size.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/mime_type_utils.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/warp_iri.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/widget_version.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/wrt_global_settings.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/wrt_utility.h
PARENT_SCOPE
)
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file bash_utils.h
+ * @author Iwanek Tomasz
+ * @version 1.0
+ */
+
+#ifndef BASH_UTILS_H
+#define BASH_UTILS_H
+
+#include<string>
+
+namespace BashUtils {
+
+/**
+ * Escapes bash special characters in string and return string in double quotes
+ * @param source string to be escaped
+ * @return escaped string
+ */
+std::string escape_arg(const std::string & source);
+
+}
+
+#endif // BASH_UTILS_H
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file file_utils.h
+ * @author Bartosz Janiak (b.janiak@samsung.com)
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @version 1.0
+ */
+
+#ifndef FILEUTILS_H
+#define FILEUTILS_H
+
+#include <sys/types.h>
+#include <string>
+
+#include <dpl/string.h>
+#include <dpl/exception.h>
+
+namespace FileUtils {
+DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDirectoryException)
+DECLARE_EXCEPTION_TYPE(DPL::Exception, RemoveDirectoryException)
+
+bool FileExists(const DPL::String& absolutePath);
+bool DirectoryExists(const DPL::String& absolutePath);
+
+/**
+ * Creates specified path recursively.
+ * @param path Path to create (e.g. /tmp/dir1/dir2).
+ * @param mode Mode for the non-existing parts of the path (e.g. 0755).
+ * @throw DPL::CommonException::::InternalError If sth bad happens.
+ */
+void MakePath(const std::string& path, mode_t mode);
+
+/**
+ * Removes specified directory recursively.
+ * @param path Full path to directory to remove.
+ * @throw FileUtils::DirectoryRemoveException If an error occured.
+ */
+void RemoveDir(const std::string& path);
+
+} // namespace FileUtils
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ *
+ * @file folder_size.h
+ * @author Jaroslaw Osmanski (j.osmanski@samsung.com)
+ * @version 1.0
+ * @brief Declaration for function calculating directory size
+ */
+
+#ifndef SRC_COMMON_FOLDER_SIZE_H_
+#define SRC_COMMON_FOLDER_SIZE_H_
+
+#include <string>
+
+#include <dpl/string.h>
+
+namespace Utils {
+
+size_t getFolderSize(const std::string& path);
+
+DPL::String fromFileSizeString(size_t fileSize);
+
+}
+
+#endif /* SRC_COMMON_FOLDER_SIZE_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 MIME_TYPE_UTILS_H
+#define MIME_TYPE_UTILS_H
+
+#include <dpl/string.h>
+#include <dpl/optional_typedefs.h>
+
+class MimeTypeUtils
+{
+ public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, InvalidFileName)
+ };
+
+ private:
+ //TODO use hash_map if possible
+ static const std::set<DPL::String>& getMimeTypesSupportedForIcon();
+ static const std::set<DPL::String>& getMimeTypesSupportedForStartFile();
+
+ typedef std::map<DPL::String, DPL::String> FileIdentificationMap;
+
+ static DPL::String getFileNameFromPath(const DPL::String& path);
+ static const FileIdentificationMap& getFileIdentificationMap();
+ static DPL::String stripMimeParameters(const DPL::String& mimeType);
+
+ public:
+ typedef std::map<DPL::String, DPL::String> MimeAttributes;
+ static bool isValidIcon(const DPL::String& path);
+ static bool isValidStartFile(const DPL::String& path,
+ const DPL::OptionalString& providedMimeType);
+ static bool isMimeTypeSupportedForStartFile(const DPL::String& mimeType);
+ static bool isMimeTypeSupportedForIcon(const DPL::String& mimeType);
+ static MimeAttributes getMimeAttributes(const DPL::String& mimeType);
+ ///implements 9.1.10. (Rule for Identifying the Media Type of a File)
+ ///from W3C packaging specification
+ static DPL::String identifyFileMimeType(const DPL::String& path);
+};
+
+#endif /* MIME_TYPE_UTILS_H */
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 _WARPIRI_H_
+#define _WARPIRI_H_
+
+#include <vector>
+
+#include <dpl/string.h>
+#include <dpl/log/log.h>
+
+class WarpIRI
+{
+ static const unsigned int UNKNOWN_PORT = 0;
+ public:
+ WarpIRI();
+
+ void set(const char *iri,
+ bool domain);
+ void set(const DPL::String &iristring,
+ bool domain);
+
+ /* It also checks port and schema */
+ bool isSubDomain(const WarpIRI &second) const;
+ bool isAccessDefinition() const;
+ bool getSubDomain() const;
+
+ static bool isIRISchemaIgnored(const char *iri);
+
+ bool operator ==(const WarpIRI &other) const
+ {
+ return m_domain == other.m_domain &&
+ m_host == other.m_host &&
+ m_schema == other.m_schema &&
+ m_port == other.m_port &&
+ m_isAccessDefinition == other.m_isAccessDefinition &&
+ m_isIRIValid == other.m_isIRIValid;
+ }
+
+ private:
+ unsigned int getPort(const DPL::String &schema) const;
+
+ bool m_domain;
+ std::vector<DPL::String> m_host;
+ DPL::String m_schema;
+ unsigned int m_port;
+ bool m_isAccessDefinition;
+ bool m_isIRIValid;
+};
+
+#endif // _WarpIRI_H_
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file widget_version.h
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief Header file for widget version
+ */
+#ifndef WIDGET_VERSION_H
+#define WIDGET_VERSION_H
+
+#include <dpl/string.h>
+#include <dpl/optional.h>
+#include <ostream>
+
+/*
+ * Note: This class also support non-WAC compliant version numbers
+ *
+ * WAC Waikiki Beta Release Core Specification: Widget Runtime
+ * 10 Dec 2010
+ *
+ * WL-3370 The WRT MUST process widget packages as an update when received under the following conditions:
+ *
+ * - the Widget Id matches the Widget Id of an installed widget
+ * - the Widget version number is greater (as a compared string) than that of the installed widget, or no version
+ * information was provided for the installed widget
+ *
+ * To ensure that a string comparison of widget versions can reliably determine which version is an updated widget,
+ * WAC will mandate a specific version string format for WAC widgets. All widgets coming through the WAC channel
+ * will be required to have version strings in this format. Side-loaded widgets may have any format and, in this
+ * case, there is no requirement that the WRT support version detection for update of these widgets.
+ *
+ * The widget version format is the rec-version-tag grammar as described in [Widget Packaging]:
+ *
+ * rec-version-tag = 1*DIGIT "." 1*DIGIT [ "." 1*DIGIT] *[ 1*ALPHA / SP / 1*DIGIT ]
+ *
+ * Examples of rec-version-tag:
+ *
+ * 1.0
+ * 1.10.1 beta1
+ * 1.02.12 RC1
+ *
+ * WL-3371 The WRT MUST use the following widget version comparison algorithm to compare WAC widget version strings:
+ *
+ * - prepare the version strings for comparison:
+ * - all leading zeros are discarded
+ * - the optional *[ 1*ALPHA / SP / 1*DIGIT ] part, if present, is discarded
+ * - the resulting numbers are then in the format major.minor[.micro]
+ * - Version A = Amajor.Aminor[.Amicro] is equal to Version B = Bmajor.Bminor[.Bmicro] if and only if:
+ * - Amajor Bmajor
+ * - Aminor Bminor
+ * - both Amicro and Bmicro are present and Amicro == Bmicro; or both Amicro and Bmicro are absent.
+ * - Version A = Amajor.Aminor[.Amicro] is greater than Version B = Bmajor.Bminor[.Bmicro] if and only if:
+ * - Amajor > Bmajor; or
+ * - Amajor Bmajor && Aminor > Bminor; or
+ * - Amajor Bmajor && Aminor == Bminor && both Amicro and Bmicro are present and Amicro > Bmicro; or Bmicro is absent.
+ */
+class WidgetVersion
+{
+ private:
+ bool m_isWac;
+ DPL::String m_raw;
+
+ DPL::String m_major;
+ DPL::String m_minor;
+ DPL::Optional<DPL::String> m_micro;
+ DPL::Optional<DPL::String> m_optional;
+
+ void WacCertify(const DPL::String &major,
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional);
+
+ public:
+ explicit WidgetVersion(const DPL::String &str = DPL::String());
+ WidgetVersion(const DPL::String &major,
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional);
+
+ bool IsWac() const;
+ const DPL::String &Raw() const;
+
+ const DPL::String &Major() const;
+ const DPL::String &Minor() const;
+ const DPL::Optional<DPL::String> &Micro() const;
+ const DPL::Optional<DPL::String> &Optional() const;
+};
+
+bool operator<(const WidgetVersion &left,
+ const WidgetVersion &right);
+bool operator<=(const WidgetVersion &left,
+ const WidgetVersion &right);
+bool operator>(const WidgetVersion &left,
+ const WidgetVersion &right);
+bool operator>=(const WidgetVersion &left,
+ const WidgetVersion &right);
+bool operator==(const WidgetVersion &left,
+ const WidgetVersion &right);
+bool operator!=(const WidgetVersion &left,
+ const WidgetVersion &right);
+std::ostream & operator<<(std::ostream& stream,
+ const WidgetVersion& version);
+
+#endif // WIDGET_VERSION_H
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file wrt_global_settings.h
+ * @version 0.6
+ * @author Pawel Sikorski(p.sikorski@samsung.com)
+ * @brief Header file for global predefined wrt setting
+ */
+
+#ifndef WRT_COMMON_GLOBAL_SETTINGS_H_
+#define WRT_COMMON_GLOBAL_SETTINGS_H_
+
+namespace GlobalSettings {
+
+// Methods for getting test mode environment flag
+bool TestModeEnabled();
+bool PopupsTestModeEnabled();
+bool WarpTestModeEnabled();
+bool RoamingTestModeEnabled();
+bool OCSPTestModeEnabled();
+bool CrlTestModeEnabled();
+bool MakeScreenTestModeEnabled();
+bool IsEmulator();
+
+}
+
+#endif /* WRT_COMMON_GLOBAL_SETTINGS_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file wrt_utility.h
+ * @version 0.8
+ * @author Janusz Majnert <j.majnert@samsung.com>
+ * @brief Common utility functions
+ */
+
+#ifndef _WRT_UTILITY_H_
+#define _WRT_UTILITY_H_
+
+#include <sys/stat.h>
+
+/**
+ * Joins two paths into one
+ *
+ * @param[out] joined String for storing joined paths
+ * @param[in] parent String containing the first part of path
+ * @param[in] child String containing the second part of the path
+ *
+ * Data stored in joined before the function call will be replaced with joined
+ * paths.
+ */
+void WrtUtilJoinPaths(std::string &joined, const std::string &parent, const std::string &child);
+
+/**
+ * Creates directories specified by path
+ *
+ * @param[in] path Path to create
+ * @param[in] mode access flags, default to 0755
+ * @return true on success, false on failure
+ *
+ * Function creates directory specified by path argument and all directories
+ * leading up to it, if they don't exist. Note that if yout wish to create
+ * several nested directories, you must make sure that the mode flag allows you
+ * to write and search the direcotries you create.
+ */
+bool WrtUtilMakeDir(const std::string &newpath, mode_t mode=0755);
+
+/**
+ * This function removes the directory or file pointed to by path
+ *
+ * @param[in] path Path to the file/directory to be deleted
+ *
+ * @return true on success, false otherwise
+ */
+bool WrtUtilRemove(const std::string &path);
+
+/**
+ * Checks if path exists and is a regular file
+ *
+ * @param[in] path the string representing path to check
+ *
+ * @return true if regular file is accessible under path, false otherwise
+ */
+bool WrtUtilFileExists(const std::string &path);
+
+/**
+ * Checks if path exists and is a directory
+ *
+ * @param[in] path the string representing path to check
+ *
+ * @return true if directory is accessible under path, false otherwise
+ */
+bool WrtUtilDirExists(const std::string &path);
+
+#endif //_WRT_UTILITY_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file bash_utils.cpp
+ * @author Iwanek Tomasz
+ * @version 1.0
+ */
+#include <stddef.h>
+#include<dpl/utils/bash_utils.h>
+#include<dpl/log/log.h>
+
+#include<string>
+
+namespace BashUtils {
+
+std::string escape_arg(const std::string & source)
+{
+ static const std::string special("!$`\\\"");
+ std::string ret = "\"";
+ for(std::string::const_iterator iter = source.begin(); iter != source.end(); ++iter)
+ {
+ if(special.find(*iter) != std::string::npos)
+ {
+ ret += std::string("\\") + *iter;
+ }
+ else
+ {
+ ret += *iter;
+ }
+ }
+ return ret + "\"";
+}
+
+}
#include <dpl/exception.h>
#include <dpl/errno_string.h>
-#include <file_utils.h>
+#include <dpl/utils/file_utils.h>
#include <dpl/wrt-dao-ro/path_builder.h>
mode_t mode)
{
if (mkpath(path.c_str(), mode) == -1) {
- ThrowMsg(DPL::CommonException::InternalError, "Cannot make path");
+ ThrowMsg(CreateDirectoryException, "Cannot make path");
}
}
* @version 1.0
* @brief Implementation for function calculating directory size
*/
-
+#include <stddef.h>
#include <string.h>
-#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
+#include <fts.h>
#include <sstream>
#include <vector>
#include <dpl/log/log.h>
#include <dpl/foreach.h>
-#include <folder_size.h>
+#include <dpl/utils/folder_size.h>
namespace Utils {
-namespace {
-
-size_t getObjectSize(const std::string& path)
-{
- struct stat tmp;
-
- if (stat(path.c_str(), &tmp) == -1) {
- LogError("Failed to open file" << path);
- return 0;
- }
- //it is not a file nor a directory
- //not counting
- if (!S_ISDIR(tmp.st_mode) && !S_ISREG(tmp.st_mode)) {
- LogWarning("Not a regular file nor a directory: " << path);
- return 0;
- }
- return tmp.st_size;
-}
-}
size_t getFolderSize(const std::string& path)
{
size_t size = 0;
-
- DIR *dir;
- std::vector<std::string> localDirs;
- if ((dir=opendir(path.c_str())) == NULL) {
- LogError("Cannot open dir " << path);
+ FTS *fts;
+ FTSENT *ftsent;
+ char * const paths[] = {const_cast<char * const>(path.c_str()), NULL};
+
+ if ((fts = fts_open(paths, FTS_PHYSICAL|FTS_NOCHDIR, NULL)) == NULL) {
+ //ERROR
+ int error = errno;
+ LogWarning(__PRETTY_FUNCTION__ << ": fts_open failed with error: "
+ << strerror(error));
return 0;
}
- struct dirent* el;
- while ((el = readdir(dir)) != 0) {
- if (strcmp(el->d_name, ".") == 0 || strcmp(el->d_name, "..") == 0) {
- continue;
- }
- struct stat tmp;
- std::string local = path + el->d_name;
- if (stat(local.c_str(), &tmp) == -1) {
- LogError("Failed to open file " << local);
- char* errstring = strerror(errno);
- LogError("Reason: " << errstring);
- continue;
- }
- size += getObjectSize(local);
- if (S_ISDIR(tmp.st_mode)) {
- localDirs.push_back(local + "/");
+ while ((ftsent = fts_read(fts)) != NULL) {
+ switch (ftsent->fts_info) {
+ case FTS_DP:
+ case FTS_DC:
+ //directory in postorder and directory causing a loop
+ break;
+ case FTS_F:
+ case FTS_D:
+ case FTS_NSOK:
+ case FTS_SL:
+ case FTS_SLNONE:
+ case FTS_DEFAULT:
+ //regular files and other objects that can be counted
+ size += ftsent->fts_statp->st_size;
+ break;
+ case FTS_NS:
+ case FTS_DOT:
+ case FTS_DNR:
+ case FTS_ERR:
+ default:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": traversal failed on file: "
+ << ftsent->fts_path
+ << " with error: "
+ << strerror(ftsent->fts_errno));
+ return 0;
}
}
- closedir(dir);
-
- FOREACH (localDir, localDirs) {
- size += getFolderSize(*localDir);
+ if (fts_close(fts) == -1) {
+ int error = errno;
+ LogWarning(__PRETTY_FUNCTION__ << ": fts_close failed with error: "
+ << strerror(error));
+ return 0;
}
return size;
template<typename... Rest>
struct Pre;
+
template<typename Postfix, typename... Rest>
struct Pre<Postfix, Rest...>
{
- static const double value = Pre<Rest...>::value * stepSize;
+ static const double value;
static std::string printSize(double fileSize)
{
if(fileSize >= Pre<Rest...>::value) {
}
};
+
const double Pre<>::value = 1.0;
+template<typename Postfix, typename... Params> const double Pre<Postfix, Params...>::value(Pre<>::value * stepSize);
+
typedef Pre<PrefixGB, PrefixMB, PrefixKB, PrefixB> FolderSizeToStringType;
+
+
} //anonymous namespace
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <stddef.h>
#include <set>
#include <dpl/assert.h>
#include <vector>
#include <map>
-#include <mime_type_utils.h>
+#include <dpl/utils/mime_type_utils.h>
const std::set<DPL::String>& MimeTypeUtils::getMimeTypesSupportedForIcon()
{
* but there are some patent issue between W3C WARP SPEC and APPLE.
* so if you want to use this file, refer to the README file in root directory
*/
-
-#include <warp_iri.h>
+#include <stddef.h>
+#include <list>
+#include <set>
+#include <string>
+#include <dpl/utils/warp_iri.h>
#include <dpl/string.h>
+#include <dpl/auto_ptr.h>
#include <dpl/foreach.h>
#include <idna.h>
#include <istream>
#include <iri.h>
-#include <ValidatorCommon.h>
+//#include <ValidatorCommon.h>
namespace {
// All schemes which are supported by external application should be ignored
// This will create AutoPtr deleter for iri_struct.
// Deleter must be in the same namespace as definition of AutoPtr.
-namespace ValidationCore {
-VC_DECLARE_DELETER(iri_struct, iri_destroy)
-}
+
+namespace DPL{
+DECLARE_DELETER(iri_struct, iri_destroy)
+} // namespace DPL
WarpIRI::WarpIRI() :
m_domain(false),
return;
}
- ValidationCore::AutoPtr<iri_struct> iri(iri_parse(p_iri));
+ DPL::AutoPtr<iri_struct> iri(iri_parse(p_iri));
if (!iri.get()) {
LogError("Error in iri_parse!");
return m_isAccessDefinition;
}
-// KW bool WarpIRI::isIRIValid() const {
-// KW return m_isIRIValid;
-// KW }
-
bool WarpIRI::getSubDomain() const
{
return m_domain;
* @version 1.0
* @brief Implementation file for widget version
*/
-#include <widget_version.h>
+#include <stddef.h>
+#include <dpl/utils/widget_version.h>
#include <dpl/assert.h>
#include <dpl/log/log.h>
#include <ctype.h>
* @author Lukasz Wrzosek (l.wrzosek@samsung.com)
* @brief runtime
*/
-#include <dpl/assert.h>
-#include <dpl/log/log.h>
-#include <string.h>
-#include <stdlib.h>
-#include <wrt_global_settings_internal.h>
+#include <stddef.h>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <sys/utsname.h>
+#include <dpl/utils/wrt_global_settings.h>
+
+namespace GlobalSettings {
namespace {
-bool GetPopupsEnabledFlag()
+const int ROAMING_TEST = 0x00000001;
+const int POPUPS_TEST = 0x00000002;
+const int OCSP_TEST = 0x00000004;
+const int WARP_TEST = 0x00000008;
+const int CRL_TEST = 0x00000010;
+const int SCREEN_SHOT_TEST = 0x00000020;
+const int ALL_TEST = (ROAMING_TEST | POPUPS_TEST | OCSP_TEST | WARP_TEST
+ | CRL_TEST | SCREEN_SHOT_TEST);
+const char* WRT_TEST_MODE = "WRT_TEST_MODE";
+const char* MACHINE_NAME_EMUL = "emulated"; // "arch_emulated"
+enum MachineType
{
- //TODO : env var. will be removed after UX guide for POWDER is enabled.
- const char *env = getenv("WRT_POPUP_ENABLE");
- if (env && 0 == strcmp(env, "1")) {
- return true;
- } else {
- return false;
- }
-}
+ MACHINE_TYPE_TARGET,
+ MACHINE_TYPE_EMULATOR,
+ MACHINE_TYPE_UNKNOWN
+};
+
+struct Settings {
+ bool isEmulator;
+ int testModes;
-static bool initializeGlobalSettings();
+ Settings()
+ : isEmulator(false), testModes(0)
+ {}
+};
-static bool initHelper = initializeGlobalSettings();
+Settings gSettings;
+
+bool initializeGlobalSettings();
+bool initHelper = initializeGlobalSettings();
+
+MachineType getMachineType()
+{
+ // get current machine name
+ struct utsname u;
+ if (0 == uname(&u)) {
+ if (0 == strlen(u.machine)) {
+ return MACHINE_TYPE_UNKNOWN;
+ } else {
+ // If current machine is emul,
+ // machine name include "<arch>_emulated"
+ std::string machine = u.machine;
+ // find "emulated" string in the u.machine
+ if (std::string::npos != machine.find(MACHINE_NAME_EMUL)) {
+ return MACHINE_TYPE_EMULATOR;
+ } else {
+ return MACHINE_TYPE_TARGET;
+ }
+ }
+ }
+
+ return MACHINE_TYPE_UNKNOWN;
+}
bool initializeGlobalSettings()
{
(void)initHelper;
- LogDebug("Initializing globall settings");
- GlobalSettings::IGlobalSettingsFunctions functions;
- functions.getPopupsEnabledFlag = &GetPopupsEnabledFlag;
- GlobalSettings::SetPredefinedGlobalSettings(functions);
+
+ // ignore environment variables if this flag is not set
+#ifdef GLOBAL_SETTINGS_CONTROL
+ char * envStr = getenv(WRT_TEST_MODE);
+ int testMode = 0;
+ if (NULL != envStr) {
+ std::string env = envStr;
+ if ("1" == env) {
+ testMode = ALL_TEST;
+ } else {
+ std::istringstream str(envStr);
+ while (std::getline(str, env, '|')) {
+ if ("popups" == env) {
+ testMode |= POPUPS_TEST;
+ } else if ("roaming" == env) {
+ testMode |= ROAMING_TEST;;
+ } else if ("ocsp" == env) {
+ testMode |= OCSP_TEST;;
+ } else if ("warp" == env) {
+ testMode |= WARP_TEST;;
+ } else if ("crl" == env) {
+ testMode |= CRL_TEST;
+ } else if ("screen" == env) {
+ testMode |= SCREEN_SHOT_TEST;;
+ }
+ }
+ }
+ gSettings.testModes = testMode;
+ }
+ // TODO other settings initialization
+
+#endif
+ gSettings.isEmulator = (MACHINE_TYPE_EMULATOR == getMachineType());
return false;
}
+} // namespace
+
+bool TestModeEnabled()
+{
+ return ((gSettings.testModes & ALL_TEST) == ALL_TEST);
+}
+
+bool PopupsTestModeEnabled() {
+ return (gSettings.testModes & POPUPS_TEST);
+}
+bool WarpTestModeEnabled() {
+ return (gSettings.testModes & WARP_TEST);
+}
+bool RoamingTestModeEnabled() {
+ return (gSettings.testModes & ROAMING_TEST);
+}
+bool OCSPTestModeEnabled() {
+ return (gSettings.testModes & OCSP_TEST);
}
+bool CrlTestModeEnabled() {
+ return (gSettings.testModes & CRL_TEST);
+}
+bool MakeScreenTestModeEnabled() {
+ return (gSettings.testModes & SCREEN_SHOT_TEST);
+}
+
+bool IsEmulator()
+{
+ return gSettings.isEmulator;
+}
+
+} // GlobalSettings
* limitations under the License.
*/
/**
- * @file wrt_utility.cpp
- * @version 0.6
- * @author Wei Dong(d.wei@samsung.com)
- * @author Ma Quan(jason.ma@samsung.com)
- * @brief This file implemented some common functions for widget manager
+ * @file wrt_utility.cpp
+ * @version 0.8
+ * @author Janusz Majnert <j.majnert@samsung.com>
+ * @brief Implementation of some common utility functions
*/
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdarg.h>
-#include <errno.h>
-#include <libgen.h>
-#include <sys/types.h>
+#include <stddef.h>
+#include <fts.h>
+#include <string>
#include <sys/stat.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <ctype.h>
#include <dpl/log/log.h>
-#include <wrt_utility.h>
+#include <dpl/utils/wrt_utility.h>
-using namespace std;
-
-bool _WrtUtilSetAbsolutePath(char* absolutePath,
- const char* parentPath,
- const char* fileName)
+void WrtUtilJoinPaths(std::string &joined, const std::string &parent, const std::string &child)
{
- int len;
- if (NULL == absolutePath || NULL == parentPath || NULL == fileName) {
- return false;
+ size_t parent_len = parent.length();;
+ joined=parent;
+ joined+=child;
+ //In case someone used windows-style paths
+ std::replace(joined.begin(), joined.end(), '\\', '/');
+
+ if (parent_len != 0 && child.length() != 0) {
+ if (joined[parent_len-1] != '/' && joined[parent_len] != '/')
+ joined.insert(parent_len, "/");
+ else if (joined[parent_len-1] == '/' && joined[parent_len] == '/')
+ joined.erase(parent_len, 1);
}
- len = strlen(parentPath);
- if (len > 0) {
- // not check the valid of parentPath and fileName.
- if (parentPath[len - 1] == '/') {
- snprintf(absolutePath,
- MAX_WIDGET_PATH_LENGTH,
- "%s%s",
- parentPath,
- fileName);
- } else {
- snprintf(absolutePath,
- MAX_WIDGET_PATH_LENGTH,
- "%s/%s",
- parentPath,
- fileName);
- }
- } else {
- LogDebug("The parent path is null");
- return false;
- }
-
- //some widget use Windows notation. We need to change '\' to '/'
- for (int i = 0; absolutePath[i] != 0; ++i) {
- if (absolutePath[i] == '\\') {
- absolutePath[i] = '/';
- }
- }
-
- return true;
}
-// KW bool _WrtUtilConvertStrToBool(char* value, bool *result)
-// KW {
-// KW bool ret = false;
-// KW if (NULL == value || NULL == result)
-// KW {
-// KW return ret;
-// KW }
-// KW
-// KW char* source = value;
-// KW char* changed = (char*)malloc(strlen(value) + 1);
-// KW if (NULL == changed)
-// KW {
-// KW return ret;
-// KW }
-// KW memset(changed, 0, strlen(value) + 1);
-// KW
-// KW char* cur = changed;
-// KW while(*source)
-// KW {
-// KW *cur++ = tolower(*source++);
-// KW }
-// KW if (!strcmp(changed,"false") || !strcmp(changed,"0"))
-// KW {
-// KW *result = false;
-// KW ret = true;
-// KW }
-// KW else if(!strcmp(changed,"true") || !strcmp(changed,"1"))
-// KW {
-// KW *result = true;
-// KW ret = true;
-// KW }
-// KW free(changed);
-// KW
-// KW return ret;
-// KW }
-
-void _WrtUtilGetDirAndFileName(const char* fullPath,
- char** dirName,
- char** fileName)
+bool WrtUtilMakeDir(const std::string &newpath, mode_t mode)
{
- int length = 0;
- int index = 0;
- if (NULL == fullPath || (NULL == dirName && NULL == fileName)) {
- return;
- }
-
- length = strlen(fullPath);
- for (index = length - 1; index >= 0; index--) {
- if ('/' == fullPath[index]) {
- if (index == length - 1) {
- LogDebug(" Warning: The end of directroy is '/'! ");
- if (dirName) {
- *dirName = (char*)malloc(sizeof(char) * (length + 1));
- if (*dirName != NULL) {
- memset(*dirName, 0, sizeof(char) * (length + 1));
- strncpy(*dirName, fullPath, length);
- }
- }
- return;
- }
- break;
- }
- }
- if (index >= 0) {
- if (dirName) {
- int dirName_len = index + 2;
-
- *dirName = (char*)malloc(sizeof(char) * dirName_len);
- if (*dirName != NULL) {
- memset(*dirName, 0, sizeof(char) * dirName_len);
- strncpy(*dirName, fullPath, dirName_len - 1);
- }
- }
-
- if (fileName) {
- int fileName_len = length - index;
+ size_t pos = 0;
+ int error;
- *fileName = (char*)malloc(sizeof(char) * fileName_len);
- if (*fileName != NULL) {
- memset(*fileName, 0, sizeof(char) * fileName_len);
- strncpy(*fileName, &fullPath[index + 1], fileName_len - 1);
- }
- }
- } else {
- if (fileName) {
- *fileName = (char*)malloc(sizeof(char) * (length + 1));
- if (*fileName != NULL) {
- memset(*fileName, 0, sizeof(char) * (length + 1));
- strncpy(*fileName, fullPath, length);
- }
- }
- }
-}
+ if (newpath.length() == 0) return false;
-// KW bool _WrtUtilStringCmp(const char* srcStr, const char* destStr)
-// KW {
-// KW bool ret = false;
-// KW char* strString = NULL;
-// KW char* destString = NULL;
-// KW
-// KW if (NULL == srcStr || NULL == destStr )
-// KW {
-// KW return ret;
-// KW }
-// KW
-// KW _WrtUtilStringToLower(srcStr, &strString);
-// KW _WrtUtilStringToLower(destStr,&destString);
-// KW
-// KW if(!strcmp(strString, destString))
-// KW {
-// KW ret = true;
-// KW }
-// KW
-// KW free(strString);
-// KW free(destString);
-// KW
-// KW return ret;
-// KW }
+ std::string path=newpath;
-// check it deeply later.
-bool _WrtMakeDir (const char *path,
- long mode,
- int flags)
-{
- if (NULL == path) {
- return false;
- }
+ if (*(path.rbegin()) != '/') path += '/';
- const int defaultMode = 0777;
- if (!(flags & WRT_FILEUTILS_RECUR)) {
- if (mkdir(path, defaultMode) < 0) {
- LogDebug("Failed to make dir " << path);
+ while ((pos = path.find('/', pos+1)) != std::string::npos) {
+ if (mkdir(path.substr(0, pos).c_str(), mode) != 0) {
+ error=errno;
+ if (error == EEXIST) continue;
+ LogWarning(__PRETTY_FUNCTION__ << ": failed to create directory "
+ << path.substr(0,pos)
+ << ". Error: "
+ << strerror(error));
return false;
}
- if (mode != -1 && chmod(path, mode) < 0) {
- LogDebug("Failed to chmod");
- remove(path);
- return false;
- }
- } else {
- struct stat st;
- if (stat(path, &st) < 0 && errno == ENOENT) {
- bool ret;
- char *buf = NULL;
- char *parent = NULL;
- // mode_t mask;
-
- // mask = umask (0);
- // umask (mask);
-
- buf = strdup(path);
- parent = dirname(buf);
- //ret = _WrtMakeDir(parent, (defaultMode & ~mask) | 0300, WRT_FILEUTILS_RECUR);
- ret = _WrtMakeDir(parent, (defaultMode) | 0300, WRT_FILEUTILS_RECUR);
- free(buf);
-
- if ((!ret) || (!_WrtMakeDir(path, mode, 0))) {
- LogDebug("Failed to _WrtMakeDir");
- return false;
- }
- }
}
-
return true;
}
-bool _WrtUtilChangeDir(const char* path)
+bool WrtUtilRemove(const std::string &path)
{
- if (NULL == path) {
+ FTS *fts;
+ FTSENT *ftsent;
+ bool rv = true;
+ int error = 0;
+ char * const paths[] = {const_cast<char * const>(path.c_str()), NULL};
+
+ if ((fts = fts_open(paths, FTS_PHYSICAL|FTS_NOCHDIR, NULL)) == NULL) {
+ //ERROR
+ error = errno;
+ LogWarning(__PRETTY_FUNCTION__ << ": fts_open failed with error: "
+ << strerror(error));
return false;
}
- if (-1 == chdir(path)) {
- if (ENOENT == errno) {
- if (!_WrtMakeDir(path, 0664, WRT_FILEUTILS_RECUR)) {
- return false;
- }
- if (-1 == chdir(path)) {
- remove(path);
- return false;
- }
- } else {
- return false;
+
+ while ((ftsent = fts_read(fts)) != NULL) {
+ switch (ftsent->fts_info) {
+ case FTS_D:
+ //directory in preorder - do nothing
+ break;
+ case FTS_DP:
+ //directory in postorder - remove
+ if (rmdir(ftsent->fts_accpath) != 0) {
+ error = errno;
+ LogWarning(__PRETTY_FUNCTION__
+ << ": rmdir failed with error: "
+ << strerror(error));
+ rv = false;
+ }
+ break;
+ case FTS_DC:
+ case FTS_F:
+ case FTS_NSOK:
+ case FTS_SL:
+ case FTS_SLNONE:
+ case FTS_DEFAULT:
+ //regular files and other objects that can safely be removed
+ if (unlink(ftsent->fts_accpath) != 0) {
+ error = errno;
+ LogWarning(__PRETTY_FUNCTION__
+ << ": unlink failed with error: "
+ << strerror(error));
+ rv = false;
+ }
+ break;
+ case FTS_NS:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": couldn't get stat info for file: "
+ << ftsent->fts_path
+ << ". The error was: "
+ << strerror(ftsent->fts_errno));
+ rv = false;
+ break;
+ case FTS_DOT:
+ case FTS_DNR:
+ case FTS_ERR:
+ default:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": traversal failed with error: "
+ << strerror(ftsent->fts_errno));
+ rv = false;
+ break;
}
}
- return true;
+ if (fts_close(fts) == -1) {
+ error = errno;
+ LogWarning(__PRETTY_FUNCTION__ << ": fts_close failed with error: "
+ << strerror(error));
+ rv = false;
+ }
+ return rv;
}
-bool _WrtUtilRemoveDir(const char* path)
+bool WrtUtilFileExists(const std::string &path)
{
- DIR* dir = NULL;
- struct dirent* ptr = NULL;
- char childPath[MAX_WIDGET_PATH_LENGTH + 1] = { 0 };
- if (path == NULL) {
- LogWarning("Path is null");
- return false;
- }
- dir = opendir(path);
- if (NULL != dir) {
- while ((ptr = readdir(dir)) != NULL) {
- if ((!strcmp(ptr->d_name, ".")) || (!strcmp(ptr->d_name, ".."))) {
- continue;
- }
- int len = strlen(path);
- if (path[len - 1] == '/') {
- snprintf(childPath,
- MAX_WIDGET_PATH_LENGTH,
- "%s%s",
- path,
- ptr->d_name);
- } else {
- snprintf(childPath,
- MAX_WIDGET_PATH_LENGTH,
- "%s/%s",
- path,
- ptr->d_name);
- }
- if (ptr->d_type == DT_DIR) {
- if (!_WrtUtilRemoveDir(childPath)) {
- closedir(dir);
- return false;
- }
- } else {
- if (unlink(childPath) != 0) {
- closedir(dir);
- LogWarning("Failed to remove file " << childPath);
- return false;
- }
- }
- }
- closedir(dir);
- } else if (errno == ENOTDIR) {
- if (unlink(path) != 0) {
- LogWarning("Failed to remove file " << path);
- return false;
- }
- return true;
- } else if (errno == ENOENT) { //not exist
- LogWarning("Cannot remove non existent directory " << path);
- return true;
+ struct stat tmp;
+ if (stat(path.c_str(),&tmp) == 0) {
+ return S_ISREG(tmp.st_mode);
} else {
- LogWarning("Can't remove directory " << path);
return false;
}
- if (rmdir(path) != 0) {
- LogWarning("Removing directory failed :" << path << " errno: " << errno);
- return false;
- }
-
- return true;
}
-bool
-_WrtUtilStringToLower(const char* str,
- char** lowerStr)
+bool WrtUtilDirExists(const std::string &path)
{
- if (!str || !lowerStr) {
- return true;
- }
-
- char* cur = NULL;
- int length = strlen(str);
-
- *lowerStr = (char*)malloc(length + 1);
-
- if (!(*lowerStr)) {
+ struct stat tmp;
+ if (stat(path.c_str(),&tmp) == 0) {
+ return S_ISDIR(tmp.st_mode);
+ } else {
return false;
}
-
- memset(*lowerStr, 0, length + 1);
- strncpy(*lowerStr, str, length);
-
- cur = *lowerStr;
-
- while (*str != '\0') {
- *cur++ = tolower(*str++);
- //cur++;
- }
-
- return true;
}
+SET(TARGET_WRT_DAO_DB "Sqlite3DbWRT")
+
ADD_CUSTOM_COMMAND(
OUTPUT ${CMAKE_BINARY_DIR}/modules/widget_dao/database_checksum.h
COMMAND ${CMAKE_SOURCE_DIR}/modules/widget_dao/orm/gen_db_md5.sh
ARGS ${CMAKE_CURRENT_BINARY_DIR}/.wrt.db-journal
)
-ADD_CUSTOM_TARGET(Sqlite3DbWRT ALL DEPENDS .wrt.db .wrt.db-journal)
+ADD_CUSTOM_TARGET(${TARGET_WRT_DAO_DB} ALL DEPENDS .wrt.db .wrt.db-journal)
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/wrt_db.sql
DESTINATION share/wrt-engine/
INCLUDE(FindPkgConfig)
PKG_CHECK_MODULES(WRT_DAO_DEPS
- cert-svc
ecore
appcore-efl
libxml-2.0
dao/common_dao_types.cpp
dao/feature_dao_read_only.cpp
dao/global_dao_read_only.cpp
- dao/global_config.cpp
dao/path_builder.cpp
dao/plugin_dao_read_only.cpp
dao/property_dao_read_only.cpp
dao/widget_dao.cpp
)
-ADD_DEFINITIONS("-DSEPARATED_SINGLETON_IMPLEMENTATION")
-
SET(WRT_DAO_INCLUDE_DIRS
${PROJECT_SOURCE_DIR}/modules/widget_dao/include
${PROJECT_SOURCE_DIR}/modules/event/include
${PROJECT_SOURCE_DIR}/modules/core/include
${PROJECT_SOURCE_DIR}/modules/db/include
${PROJECT_SOURCE_DIR}/modules/log/include
- ${WRT_DAO_DEPS_INCLUDE_DIRS}
- )
+ ${PROJECT_SOURCE_DIR}/modules/localization/include
+)
INCLUDE_DIRECTORIES(${WRT_DAO_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(SYSTEM ${WRT_DAO_DEPS_INCLUDE_DIRS})
ADD_LIBRARY(${TARGET_WRT_DAO_RO_LIB} SHARED
${WRT_DAO_RO_SOURCES}
)
SET_TARGET_PROPERTIES(${TARGET_WRT_DAO_RO_LIB} PROPERTIES
- SOVERSION ${VERSION})
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION})
SET_TARGET_PROPERTIES(${TARGET_WRT_DAO_RO_LIB} PROPERTIES
COMPILE_FLAGS -fPIC)
${TARGET_DPL_EFL}
${TARGET_DPL_DB_EFL}
${WRT_DAO_DEPS_LIBRARIES})
+ADD_DEPENDENCIES(${TARGET_WRT_DAO_RO_LIB} ${TARGET_WRT_DAO_DB})
ADD_LIBRARY(${TARGET_WRT_DAO_RW_LIB} SHARED ${WRT_DAO_RW_SOURCES})
SET_TARGET_PROPERTIES(${TARGET_WRT_DAO_RW_LIB} PROPERTIES
- SOVERSION ${VERSION})
+ SOVERSION ${API_VERSION}
+ VERSION ${VERSION})
SET_TARGET_PROPERTIES(${TARGET_WRT_DAO_RW_LIB} PROPERTIES COMPILE_FLAGS -fPIC)
target_link_libraries(${TARGET_WRT_DAO_RW_LIB}
${TARGET_WRT_DAO_RO_LIB})
+ADD_DEPENDENCIES(${TARGET_WRT_DAO_RW_LIB} ${TARGET_WRT_DAO_DB})
INSTALL(TARGETS ${TARGET_WRT_DAO_RO_LIB}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
- )
+ DESTINATION lib)
INSTALL(TARGETS ${TARGET_WRT_DAO_RW_LIB}
- DESTINATION lib
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
- )
+ DESTINATION lib)
INSTALL(FILES
include/dpl/wrt-dao-ro/config_parser_data.h
include/dpl/wrt-dao-ro/plugin_dao_read_only.h
include/dpl/wrt-dao-ro/property_dao_read_only.h
include/dpl/wrt-dao-ro/widget_config.h
+ include/dpl/wrt-dao-ro/vconf_config.h
include/dpl/wrt-dao-ro/widget_dao_read_only.h
+ include/dpl/wrt-dao-ro/wrt_db_types.h
include/dpl/wrt-dao-ro/WrtDatabase.h
DESTINATION include/dpl-efl/dpl/wrt-dao-ro
- )
+ )
INSTALL(FILES
include/dpl/wrt-dao-rw/feature_dao.h
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/WrtDatabase.h>
#include <dpl/db/thread_database_support.h>
WrtDatabase::Address(),
WrtDatabase::Flags());
-void WrtDatabase::attachToThread()
+void WrtDatabase::attachToThreadRO()
+{
+ m_interface.AttachToThread(DPL::DB::SqlConnection::Flag::RO);
+}
+
+void WrtDatabase::attachToThreadRW()
{
- m_interface.AttachToThread();
+ m_interface.AttachToThread(DPL::DB::SqlConnection::Flag::RW);
}
void WrtDatabase::detachFromThread()
* @version 1.0
* @brief This file contains the implementation of common data types for wrtdb
*/
-
-#include <dpl/wrt-dao-ro/common_dao_types.h>
-
-#include <dpl/log/log.h>
-
+#include <stddef.h>
namespace WrtDB {
-namespace Powder {
-
-Description::LevelEntry::LevelEntry(LevelEnum level) :
- level(level)
-{
-}
-
-bool Description::LevelEntry::isContextValid(LevelEnum level,
- const DPL::OptionalString& aContext) const
-{
- if (!aContext) {
- return level < level;
- } else {
- Context::const_iterator iter = context.find(*aContext);
- if (iter != context.end()) {
- return level < level;
- } else {
- return true;
- }
- }
-}
-
-bool Description::CategoryEntry::isCategoryValid(LevelEntry& aReason,
- LevelEnum aLevel,
- const DPL::OptionalString& aContext) const
-{
- for (LevelsContainer::const_iterator iter = levels.begin();
- iter != levels.end(); ++iter) {
- if (!iter->isContextValid(aLevel, aContext)) {
- aReason = *iter;
- return false;
- }
- }
- return true;
-}
-}
-
-namespace ChildProtection
-{
-
-PowderRules::CategoryRule::CategoryRule(const DPL::String& aCategory,
- Powder::Description::LevelEnum aLevel,
- const DPL::OptionalString& aContext) :
- category(aCategory),
- level(aLevel),
- context(aContext)
-{
-}
-
-PowderRules::PowderResult::PowderResult(InvalidReason aReason,
- const Powder::Description::LevelEntry& anInvalidDescription,
- const CategoryRule& anInvalidRule) :
- invalidDescription(anInvalidDescription),
- invalidRule(anInvalidRule),
- reason(aReason)
-{
-}
-
-//! Function checks if rule is fulfilled by description
-//! \param[in] rule checked rule
-//! \param[in] description
-//! \retval true rule is valid
-//! \retval false rule is invalid
-PowderRules::ResultPair PowderRules::isRuleValidForDescription(
- const CategoryRule& aRule,
- const Powder::Description& aDescription) const
-{
- Powder::Description::CategoryEntries::const_iterator
- iter = aDescription.categories.find(aRule.category);
- if (iter != aDescription.categories.end()) {
- Powder::Description::LevelEntry invalidDescription;
- if (!iter->second.isCategoryValid(invalidDescription, aRule.level,
- aRule.context)) {
- LogWarning("Widget forbidden for children detected");
- return std::make_pair(false,
- PowderResult(PowderResult::InvalidRule,
- invalidDescription,
- aRule));
- } else {
- return std::make_pair(true, PowderResult());
- }
- } else {
- return std::make_pair(true, PowderResult());
- }
-}
-
-//! Function checks if age limit is fulfilled by description
-//! \param[in] description
-//! \retval true age is valid
-//! \retval false age is invalid
-PowderRules::ResultPair PowderRules::isAgeValidForDescription(
- const Powder::Description& aDescription) const
-{
- if (!ageLimit) {
- return std::make_pair(true, PowderResult());
- } else {
- if (!!aDescription.ageRating) {
- if (*aDescription.ageRating <= *ageLimit) {
- return std::make_pair(true, PowderResult());
- } else {
- return std::make_pair(false,
- PowderResult(PowderResult::InvalidAge));
- }
- } else {
- if (!isAgeRatingRequired) {
- return std::make_pair(true, PowderResult());
- } else {
- return std::make_pair(
- false,
- PowderResult(PowderResult::AgeRatingNotSet));
- }
- }
- }
-}
-
-//! Function check if Widget description is valid for ChildProtection
-//! configuration
-//! \param description widget description
-//! \retval true widget is valid
-//! \retval false widget is invalid
-PowderRules::ResultPair PowderRules::isDescriptionValid(
- const Powder::Description& aDescription) const
-{
- ResultPair powderResult;
- for (RulesContainer::const_iterator iter = rules.begin();
- iter != rules.end(); ++iter) {
- powderResult = isRuleValidForDescription(*iter, aDescription);
- if (!powderResult.first) {
- return powderResult;
- }
- }
- return isAgeValidForDescription(aDescription);
-}
-
-}
} // namespace WrtDB
* @version 0.1
* @brief
*/
+#include <stddef.h>
#include <dpl/wrt-dao-ro/config_parser_data.h>
#include <dpl/log/log.h>
#include <libxml/xmlreader.h>
#include <libxml/xmlstring.h>
namespace WrtDB {
+bool IsSpace(const xmlChar* str);
+bool CopyChar(xmlChar* out, xmlChar* in);
+
bool IsSpace(const xmlChar* str)
{
case 0xa9:
case 0xaf:
return true;
+ default:
+ return false;
}
case 0x81:
if (*(str + 2) == 0x9f) {
return paramsList <= other.paramsList;
}
+bool ConfigParserData::Privilege::operator==(const Privilege& other) const
+{
+ return name == other.name;
+}
+
+bool ConfigParserData::Privilege::operator!=(const Privilege& other) const
+{
+ return name != other.name;
+}
+
+bool ConfigParserData::Privilege::operator >(const Privilege& other) const
+{
+ return name > other.name;
+}
+
+bool ConfigParserData::Privilege::operator>=(const Privilege& other) const
+{
+ return name >= other.name;
+}
+
+bool ConfigParserData::Privilege::operator <(const Privilege& other) const
+{
+ return name < other.name;
+}
+
+bool ConfigParserData::Privilege::operator<=(const Privilege& other) const
+{
+ return name < other.name;
+}
+
bool ConfigParserData::Icon::operator==(const Icon& other) const
{
return src == other.src;
m_scheme != info.m_scheme &&
m_mime != info.m_mime;
}
+
+bool ConfigParserData::LiveboxInfo::operator==(const LiveboxInfo& other) const
+{
+ return m_liveboxId == other.m_liveboxId &&
+ m_autoLaunch == other.m_autoLaunch &&
+ m_updatePeriod == other.m_updatePeriod &&
+ m_primary == other.m_primary &&
+ m_label == other.m_label &&
+ m_icon == other.m_icon;
+}
+
+bool ConfigParserData::LiveboxInfo::operator!=(const LiveboxInfo& other) const
+{
+ return m_liveboxId != other.m_liveboxId &&
+ m_autoLaunch != other.m_autoLaunch &&
+ m_updatePeriod != other.m_updatePeriod &&
+ m_primary != other.m_primary &&
+ m_label != other.m_label &&
+ m_icon != other.m_icon;
+}
+
} // namespace WrtDB
* @version 1.0
* @brief This file contains the definition of feature configuration.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-rw/feature_dao.h>
#include <dpl/foreach.h>
#include <dpl/db/orm.h>
namespace WrtDB {
namespace FeatureDAO {
-const int STRANGE_FEATURE_PROPERTIES_ID = 0;
-
FeatureHandle RegisterFeature(const PluginMetafileData::Feature &feature,
const DbPluginHandle pluginHandle)
{
}
}
-FeatureHandle RegisterStrangeFeature(const std::string& featureName)
+void UnregisterFeature(FeatureHandle featureHandle)
{
Try
{
- LogDebug("Registering Feature " << featureName);
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ LogDebug("Unregistering Feature " << featureHandle);
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
- if (FeatureDAOReadOnly::isFeatureInstalled(featureName)) {
- LogError(" >> Feature " << featureName <<
- " is already registered.");
- transaction.Commit();
- return -1;
+ if (FeatureDAOReadOnly::isFeatureInstalled(featureHandle)) {
+ LogError("Feature handle is invalid");
+ return;
}
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
- //register feature
- LogInfo(" |-- Registering feature " << featureName);
-
- FeaturesList::Row row;
- row.Set_FeatureName(DPL::FromUTF8String(featureName));
+ // Unregister DeviceCapabilities
+ FeatureDAOReadOnly::DeviceCapabilitiesList capabilitiesList =
+ FeatureDAOReadOnly(featureHandle).GetDeviceCapabilities();
- // PluginPropertiesId '0' is not used as PluginPropertiesId for normal features(calendar, contact....).
- // PluginPropertiesId for normal features start from '1'
- row.Set_PluginPropertiesId(STRANGE_FEATURE_PROPERTIES_ID);
-
- WRT_DB_INSERT(insert, FeaturesList, &WrtDatabase::interface())
- insert->Values(row);
- insert->Execute();
-
- FeatureHandle featureHandle =
- FeatureDAOReadOnly(featureName).GetFeatureHandle();
+ FOREACH(it, capabilitiesList) {
+ WRT_DB_DELETE(del, DeviceCapabilities, &WrtDatabase::interface())
+ del->Where(
+ Equals<DeviceCapabilities::DeviceCapName>(
+ DPL::FromUTF8String(*it)));
+ del->Execute();
+ }
+ // Unregister Feature
+ WRT_DB_DELETE(del, FeaturesList, &WrtDatabase::interface())
+ del->Where(Equals<FeaturesList::FeatureUUID>(featureHandle));
+ del->Execute();
transaction.Commit();
- return featureHandle;
+ return;
}
Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
- "Failure during Registering Feature");
+ "Fail to unregister Feature");
}
}
+
} // namespace FeatureDAO
} // namespace WrtDB
* @version 1.0
* @brief This file contains the implementation of feature dao read only
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/feature_dao_read_only.h>
#include <sstream>
#include <dpl/log/log.h>
failure.str()); \
}
-std::string FeatureDAOReadOnly::GetInstallURI() const
-{
- GET_PLUGIN_DATA(getInstallURI)
-}
-
-std::string FeatureDAOReadOnly::GetKeyCn() const
-{
- GET_PLUGIN_DATA(getKeyCn)
-}
-
-std::string FeatureDAOReadOnly::GetRootKey() const
-{
- GET_PLUGIN_DATA(getRootKey)
-}
-
-std::string FeatureDAOReadOnly::GetRootKeyFingerprint() const
-{
- GET_PLUGIN_DATA(getRootKeyFingerprint)
-}
-
std::string FeatureDAOReadOnly::GetLibraryPath() const
{
GET_PLUGIN_DATA(getLibraryPath)
}
}
+FeatureDAOReadOnly::NameMap
+FeatureDAOReadOnly::GetNames()
+{
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
+
+ NameMap nameMap;
+
+ FeaturesList::Select::RowList rows = select->GetRowList();
+ FOREACH(rowIt, rows)
+ {
+ nameMap.insert(std::pair<FeatureHandle, std::string>(rowIt->Get_FeatureUUID(), DPL::ToUTF8String(rowIt->Get_FeatureName())));
+ }
+
+ return nameMap;
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
+ "Failure during getting GetNames");
+ }
+}
+
+FeatureDAOReadOnly::DeviceCapabilitiesMap
+FeatureDAOReadOnly::GetDevCapWithFeatureHandle()
+{
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ DECLARE_COLUMN_TYPE_LIST()
+ SELECTED_COLUMN(FeatureDeviceCapProxy, FeatureUUID)
+ SELECTED_COLUMN(DeviceCapabilities, DeviceCapName)
+ DECLARE_COLUMN_TYPE_LIST_END(DevCapNameList)
+
+ WRT_DB_SELECT(select, FeatureDeviceCapProxy, &WrtDatabase::interface())
+ select->Join<DevCapNameList>(Equal<FeatureDeviceCapProxy::DeviceCapID, DeviceCapabilities::DeviceCapID>());
+
+ DeviceCapabilitiesMap devCap;
+
+ std::list< CustomRow<DevCapNameList> > rowList = select->GetCustomRowList< DevCapNameList, CustomRow<DevCapNameList> >();
+ FOREACH(rowIt, rowList)
+ {
+ FeatureHandle featureHandle = (*rowIt).GetColumnData<FeatureDeviceCapProxy::FeatureUUID>();
+ std::string devName = DPL::ToUTF8String((*rowIt).GetColumnData<DeviceCapabilities::DeviceCapName>());
+ devCap.insert(std::pair<FeatureHandle, std::string>(featureHandle, devName));
+ }
+
+ return devCap;
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
+ "Failure during getting DeviceCapabilities names");
+ }
+}
+
+FeatureDAOReadOnly::FeatureMap
+FeatureDAOReadOnly::GetFeatures(const std::list<std::string>& featureNames)
+{
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ std::set<typename FeaturesList::FeatureName::ColumnType> nameList;
+ FOREACH(nm, featureNames) {
+ nameList.insert(DPL::FromUTF8String(*nm));
+ }
+
+ WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
+ select->Where(In<FeaturesList::FeatureName>(nameList));
+
+ FeatureMap featureMap;
+ FeatureData featureData;
+ FeaturesList::Select::RowList rows = select->GetRowList();
+ FOREACH(rowIt, rows) {
+ featureData.featureName = DPL::ToUTF8String(
+ rowIt->Get_FeatureName());
+ featureData.pluginHandle = rowIt->Get_PluginPropertiesId();
+ featureMap.insert(std::pair<FeatureHandle, FeatureData>(
+ rowIt->Get_FeatureUUID(), featureData));
+ }
+
+ return featureMap;
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
+ "Failure during getting GetFeatures");
+ }
+}
+
} // namespace WrtDB
* @version 1.0
* @brief This file contains the definition of global dao class.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-rw/global_dao.h>
#include <dpl/log/log.h>
#include <dpl/string.h>
#include <dpl/wrt-dao-ro/WrtDatabase.h>
namespace WrtDB {
-
-void GlobalDAO::AddAdultBlackListElement(const DPL::String &url)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
- ScopedTransaction transaction(&WrtDatabase::interface());
- if (IsElementOnAdultBlackList(url)) {
- transaction.Commit();
- return;
- }
-
- WRT_DB_INSERT(insert, ChildProtectionBlacklist, &WrtDatabase::interface())
- ChildProtectionBlacklist::Row row;
- row.Set_url(url);
-
- insert->Values(row);
- insert->Execute();
- transaction.Commit();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to add element to AdultBlackList");
- }
-}
-
-void GlobalDAO::RemoveAdultBlackListElement(const DPL::String &url)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_DELETE(deleteFrom, ChildProtectionBlacklist, &WrtDatabase::interface())
-
- deleteFrom->Where(Equals<ChildProtectionBlacklist::url>(url));
- deleteFrom->Execute();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to removed element from AdultBlackList");
- }
-}
-
-void GlobalDAO::UpdateAdultBlackList(const DPL::String &oldUrl,
- const DPL::String &newUrl)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
- ScopedTransaction transaction(&WrtDatabase::interface());
- if (IsElementOnAdultBlackList(newUrl)) {
- transaction.Commit();
- return;
- }
- WRT_DB_UPDATE(update, ChildProtectionBlacklist, &WrtDatabase::interface())
- ChildProtectionBlacklist::Row row;
- row.Set_url(newUrl);
-
- update->Where(Equals<ChildProtectionBlacklist::url>(oldUrl));
- update->Values(row);
- update->Execute();
- transaction.Commit();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to update an element in AdultBlackList");
- }
-}
-
void GlobalDAO::SetDeveloperMode(bool mode)
{
LogDebug("updating Developer mode to:" << mode);
}
}
-void GlobalDAO::AddDefferedWidgetPackageInstallation(const DPL::String &path)
-{
- LogDebug("Adding widget package as defered. Path: " << path);
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- DefferedWidgetPackageInstallation::Row row;
- row.Set_path(path);
-
- WRT_DB_INSERT(insert, DefferedWidgetPackageInstallation, &WrtDatabase::interface())
- insert->Values(row);
- insert->Execute();
- }
- Catch(DPL::DB::SqlConnection::Exception::Base){
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to add defered widget package");
- }
-}
-
-void GlobalDAO::RemoveDefferedWidgetPackageInstallation(const DPL::String &path)
-{
- LogDebug("Remove widget package from differed list. Path: " << path);
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_DELETE(del, DefferedWidgetPackageInstallation, &WrtDatabase::interface())
- del->Where(Equals<DefferedWidgetPackageInstallation::path>(path));
- del->Execute();
- }
- Catch(DPL::DB::SqlConnection::Exception::Base){
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to remove defered widget package");
- }
-}
-
-void GlobalDAO::SetParentalMode(bool parental_status)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- GlobalProperties::Row row;
- row.Set_parental_mode(parental_status);
- WRT_DB_UPDATE(update, GlobalProperties, &WrtDatabase::interface())
-
- update->Values(row);
- update->Execute();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to update Parental Mode");
- }
-}
-
-void GlobalDAO::SetParentalAllowedAge(const DPL::OptionalInt& age)
-{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- Try {
- typedef wrt::GlobalProperties::Row ParentalAllowedAgeRow;
-
- ParentalAllowedAgeRow row;
- row.Set_parental_allowed_age(age);
- WRT_DB_UPDATE(update, GlobalProperties, &WrtDatabase::interface())
- update->Values(row);
- update->Execute();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to update Parental Mode");
- }
-}
-
void GlobalDAO::SetSecureByDefault(bool secure)
{
//If secure == true -> widget does not need to be signed
}
}
-void GlobalDAO::AddCategoryRule(const ChildProtection::PowderRules::
- CategoryRule& powder)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- PowderRules::Row row;
- row.Set_category(powder.category);
- row.Set_level(powder.level);
- row.Set_context(powder.context);
-
- wrt::ScopedTransaction transaction(&WrtDatabase::interface());
- if (IsPowderRulePresent(powder)) {
- transaction.Commit();
- return;
- }
- WRT_DB_INSERT(insert, PowderRules, &WrtDatabase::interface())
-
- insert->Values(row);
- insert->Execute();
- transaction.Commit();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to add POWDER rules");
- }
-}
-
-void GlobalDAO::RemoveCategoryRule(const ChildProtection::PowderRules::
- CategoryRule& powder)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
- if (!powder.context.IsNull()) {
- WRT_DB_DELETE(delWithContext, PowderRules, &WrtDatabase::interface())
-
- delWithContext->Where(
- And(Equals<PowderRules::category>(powder.category),
- And(Equals<PowderRules::level>(powder.level),
- Equals<PowderRules::context>(powder.context))));
- delWithContext->Execute();
- } else {
- WRT_DB_DELETE(delWithoutContext, PowderRules, &WrtDatabase::interface())
- delWithoutContext->Where(
- And(Equals<PowderRules::category>(powder.category),
- And(Equals<PowderRules::level>(powder.level),
- Is<PowderRules::context>(powder.context))));
- delWithoutContext->Execute();
- }
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to remove POWDER rules");
- }
-}
-
-void GlobalDAO::UpdateCategoryRule(
- const ChildProtection::PowderRules::CategoryRule& oldRule,
- const ChildProtection::PowderRules::CategoryRule& newRule)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- PowderRules::Row row;
- row.Set_category(newRule.category);
- row.Set_level(newRule.level);
- row.Set_context(newRule.context);
-
- wrt::ScopedTransaction transaction(&WrtDatabase::interface());
-
- if (IsPowderRulePresent(newRule)) {
- transaction.Commit();
- return;
- }
-
- if (!oldRule.context.IsNull()) {
- WRT_DB_UPDATE(updateWithContext, PowderRules, &WrtDatabase::interface())
- updateWithContext->Where(
- And(Equals<PowderRules::category>(oldRule.category),
- And(Equals<PowderRules::level>(oldRule.level),
- Equals<PowderRules::context>(oldRule.context))));
- updateWithContext->Values(row);
- updateWithContext->Execute();
- } else {
- WRT_DB_UPDATE(updateWithoutContext, PowderRules, &WrtDatabase::interface())
- updateWithoutContext->Where(
- And(Equals<PowderRules::category>(oldRule.category),
- And(Equals<PowderRules::level>(oldRule.level),
- Is<PowderRules::context>(oldRule.context))));
- updateWithoutContext->Values(row);
- updateWithoutContext->Execute();
- }
- transaction.Commit();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Failed to update POWDER rules");
- }
-}
-
void GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::NetworkAccessMode newMode)
{
LogDebug("updating home network data usage to:" << newMode);
}
}
-void GlobalDAO::SetAutoSaveIdPasswd(const DPL::String &url,
- const AutoSaveData &saveData)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- ScopedTransaction transaction(&WrtDatabase::interface());
- AutoSaveIdPasswd::Row row;
-
- row.Set_address(url);
- row.Set_userId(saveData.userId);
- row.Set_passwd(saveData.passwd);
-
- DPL::Optional<GlobalDAO::AutoSaveData> savedData =
- GetAutoSaveIdPasswd(url);
-
- if (!savedData.IsNull()) {
- WRT_DB_UPDATE(update, AutoSaveIdPasswd, &WrtDatabase::interface())
-
- update->Where(Equals<AutoSaveIdPasswd::address>(url));
- update->Values(row);
- update->Execute();
- } else {
- WRT_DB_INSERT(insert, AutoSaveIdPasswd, &WrtDatabase::interface());
- insert->Values(row);
- insert->Execute();
- }
-
- transaction.Commit();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAO::Exception::DatabaseError,
- "Fail to register id, passwd for autosave");
- }
-}
-
void GlobalDAO::AddWhiteURI(const std::string &uri, bool subDomain)
{
LogDebug("Add White URI : " << uri);
}
}
+void GlobalDAO::SetCookieSharingMode(bool mode)
+{
+ LogDebug("updating Cookie Sharing mode to:" << mode);
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ GlobalProperties::Row row;
+ row.Set_cookie_sharing_mode(mode);
+
+ WRT_DB_UPDATE(update, GlobalProperties, &WrtDatabase::interface())
+ update->Values(row);
+ update->Execute();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(GlobalDAO::Exception::DatabaseError,
+ "Failed to update Cookie Sharing Mode");
+ }
+}
+
} // namespace WrtDB
* @version 1.0
* @brief This file contains the definition of global dao class.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/global_dao_read_only.h>
#include <dpl/foreach.h>
namespace WrtDB {
-ChildProtection::BlackList GlobalDAOReadOnly::GetAdultBlackList()
-{
- LogDebug("Getting AdultBlackList");
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, ChildProtectionBlacklist, &WrtDatabase::interface())
- std::list<DPL::String> list =
- select->GetValueList<ChildProtectionBlacklist::url>();
- ChildProtection::BlackList blacklist(list.begin(), list.end());
- return blacklist;
- }
- Catch(DPL::DB::SqlConnection::Exception::Base){
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failed to get AdultBalckList");
- }
-}
-
-bool GlobalDAOReadOnly::IsElementOnAdultBlackList(const DPL::String &url)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, ChildProtectionBlacklist, &WrtDatabase::interface())
- select->Where(Equals<ChildProtectionBlacklist::url>(url));
-
- return !select->GetRowList().empty();
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failure during checking if url is on pwoder black list");
- }
-}
-
bool GlobalDAOReadOnly::GetDeveloperMode()
{
LogDebug("Getting Developer mode");
}
}
-WidgetPackageList GlobalDAOReadOnly::GetDefferedWidgetPackageInstallationList()
-{
- LogDebug("Getting widget packages list defered for installation");
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, DefferedWidgetPackageInstallation, &WrtDatabase::interface())
- return select->GetValueList<DefferedWidgetPackageInstallation::path>();
- }
- Catch(DPL::DB::SqlConnection::Exception::Base){
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failed to get defered widget packages list");
- }
-}
-
-bool GlobalDAOReadOnly::GetParentalMode()
-{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
- return select->GetSingleValue<GlobalProperties::parental_mode>();
-}
-
-DPL::OptionalInt GlobalDAOReadOnly::GetParentalAllowedAge()
-{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
- return select->GetSingleValue<GlobalProperties::parental_allowed_age>();
-}
-
bool GlobalDAOReadOnly::GetSecureByDefault()
{
using namespace DPL::DB::ORM;
}
}
-
-bool GlobalDAOReadOnly::IsPowderRulePresent(
- const ChildProtection::PowderRules::CategoryRule& powder)
-{
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
- if (!powder.context.IsNull()) {
- WRT_DB_SELECT(selWithContext, PowderRules, &WrtDatabase::interface())
-
- selWithContext->Where(
- And(Equals<PowderRules::category>(powder.category),
- And(Equals<PowderRules::level>(powder.level),
- Equals<PowderRules::context>(powder.context))));
- return !selWithContext->GetRowList().empty();
- } else {
- WRT_DB_SELECT(selWithoutContext, PowderRules, &WrtDatabase::interface())
- selWithoutContext->Where(
- And(Equals<PowderRules::category>(powder.category),
- And(Equals<PowderRules::level>(powder.level),
- Is<PowderRules::context>(powder.context))));
- return !selWithoutContext->GetRowList().empty();
- }
- }
- Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failure during checking if rule is present");
- }
-}
-
-ChildProtection::PowderRules GlobalDAOReadOnly::GetPowderRules()
-{
- ChildProtection::PowderRules powder;
- powder.ageLimit = GetParentalAllowedAge();
-
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- typedef std::list<PowderRules::Row> PowderRulesList;
- WRT_DB_SELECT(select, PowderRules, &WrtDatabase::interface())
-
- PowderRulesList list = select->GetRowList();
- FOREACH(it, list) {
- using namespace Powder;
- powder.rules.push_back(
- ChildProtection::PowderRules::CategoryRule(
- it->Get_category(),
- static_cast<Description::LevelEnum>(it->Get_level()),
- it->Get_context()));
- }
- return powder;
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failed to get POWDER rules");
- }
-}
-
GlobalDAOReadOnly::NetworkAccessMode
GlobalDAOReadOnly::GetHomeNetworkDataUsage()
{
}
}
-DPL::Optional<GlobalDAOReadOnly::AutoSaveData>
- GlobalDAOReadOnly::GetAutoSaveIdPasswd(const DPL::String &url)
-{
- Try{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, AutoSaveIdPasswd, &WrtDatabase::interface());
- select->Where(Equals<AutoSaveIdPasswd::address>(url));
- AutoSaveIdPasswd::Select::RowList rows = select->GetRowList();
-
- if (rows.empty()) {
- return DPL::Optional<GlobalDAOReadOnly::AutoSaveData>::Null;
- }
-
- GlobalDAOReadOnly::AutoSaveData saveData;
- saveData.userId = rows.front().Get_userId();
- saveData.passwd = rows.front().Get_passwd();
- return saveData;
- } Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
- "Failed to get autosave data string");
- }
-}
-
WidgetAccessInfoList GlobalDAOReadOnly::GetWhiteURIList()
{
LogDebug("Getting WhiteURIList.");
}
}
+bool GlobalDAOReadOnly::GetCookieSharingMode()
+{
+ LogDebug("Getting Cookie Sharing mode");
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
+ return select->GetSingleValue<GlobalProperties::cookie_sharing_mode>();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
+ "Failed to get Cookie Sharing mode");
+ }
+}
+
} // namespace WrtDB
* @version 1.0
* @brief Implementation file for PathBuilde class.
*/
+#include <stddef.h>
#include <dpl/wrt-dao-ro/path_builder.h>
#include <sstream>
* @version 1.0
* @brief This file contains the definition of plugin dao class.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-rw/plugin_dao.h>
#include <dpl/log/log.h>
#include <dpl/foreach.h>
row.Set_InstallationState(INSTALLATION_IN_PROGRESS);
row.Set_PluginLibraryPath(
DPL::FromUTF8String(pluginPath));
- row.Set_InstallURI(
- DPL::FromUTF8String(metafile.m_featuresInstallURI));
- row.Set_KeyCN(
- DPL::FromUTF8String(metafile.m_featuresKeyCN));
- row.Set_RootKeyCN(
- DPL::FromUTF8String(metafile.m_featuresRootCN));
- row.Set_RootKeyFingerprint(
- DPL::FromUTF8String(metafile.m_featuresRootFingerprint));
WRT_DB_INSERT(insert, PluginProperties, &WrtDatabase::interface())
insert->Values(row);
}
}
+void PluginDAO::unregisterPlugin(DbPluginHandle pluginHandle)
+{
+ LogDebug("unregisterPlugin plugin. Handle: " << pluginHandle);
+
+ Try {
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
+
+ if (!isPluginInstalled(pluginHandle)) {
+ LogInfo("PluginHandle is invalid. Handle: " << pluginHandle);
+ return;
+
+ } else {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ WRT_DB_DELETE(del, PluginProperties, &WrtDatabase::interface())
+ del->Where(
+ Equals<PluginProperties::PluginPropertiesId>(pluginHandle));
+ del->Execute();
+
+ transaction.Commit();
+ LogDebug(" >> Plugin Unregistered. Handle: " << pluginHandle);
+ }
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base)
+ {
+ ReThrowMsg(PluginDAO::Exception::DatabaseError,
+ "Failed in UnregisterPlugin");
+ }
+}
+
} // namespace WrtDB
* @version 1.0
* @brief This file contains the implementation of plugin dao read only
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/plugin_dao_read_only.h>
#include <sstream>
return ret;
}
-std::string PluginDAOReadOnly::getInstallURI() const
-{
- LogDebug("Getting plugin install URI. Handle: " << m_pluginHandle);
- PluginRow row = getPluginRow(m_pluginHandle);
- RETURN_STD_STRING(row.Get_InstallURI(), "install URI")
-}
-
-std::string PluginDAOReadOnly::getKeyCn() const
-{
- LogDebug("Getting plugin KeyCn. Handle: " << m_pluginHandle);
- PluginRow row = getPluginRow(m_pluginHandle);
- RETURN_STD_STRING(row.Get_KeyCN(), "keyCN")
-}
-
-std::string PluginDAOReadOnly::getRootKey() const
-{
- LogDebug("Getting plugin rootKey. Handle: " << m_pluginHandle);
- PluginRow row = getPluginRow(m_pluginHandle);
- RETURN_STD_STRING(row.Get_RootKeyCN(), "rootKey")
-}
-
-std::string PluginDAOReadOnly::getRootKeyFingerprint() const
-{
- LogDebug("Getting plugin rootKeyFingerprint. Handle: " << m_pluginHandle);
- PluginRow row = getPluginRow(m_pluginHandle);
- RETURN_STD_STRING(row.Get_RootKeyFingerprint(), "rootKeyFingerprint")
-}
-
#undef RETURN_STD_STRING
PluginHandleSetPtr PluginDAOReadOnly::getLibraryDependencies() const
* @version 1.0
* @brief This file contains the definition of property dao class.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-rw/property_dao.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <dpl/log/log.h>
namespace WrtDB {
namespace PropertyDAO {
-
+//deprecated
void RemoveProperty(DbWidgetHandle widgetHandle,
const PropertyDAOReadOnly::WidgetPropertyKey &key)
{
+ RemoveProperty(WidgetDAOReadOnly::getPkgName(widgetHandle),key);
+}
+
+void RemoveProperty(WidgetPkgName pkgName,
+ const PropertyDAOReadOnly::WidgetPropertyKey &key)
+{
//TODO below there are two queries.
// First query asks if given property can be removed,
// Second removes it. Maybe it should be combined two one.
- LogDebug("Removing Property. Handle: " << widgetHandle << ", key: " << key);
+ LogDebug("Removing Property. pkgName: " << pkgName << ", key: " << key);
Try {
DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
DPL::OptionalInt readonly = PropertyDAOReadOnly::CheckPropertyReadFlag(
- widgetHandle,
+ pkgName,
key);
if (!readonly.IsNull() && *readonly == 1) {
LogError("'" << key <<
using namespace DPL::DB::ORM::wrt;
WRT_DB_DELETE(del, WidgetPreference, &WrtDatabase::interface())
del->Where(And(
- Equals<WidgetPreference::app_id>(widgetHandle),
+ Equals<WidgetPreference::pkgname>(pkgName),
Equals<WidgetPreference::key_name>(key)));
del->Execute();
}
}
+//deprecated
void SetProperty(DbWidgetHandle widgetHandle,
const PropertyDAOReadOnly::WidgetPropertyKey &key,
const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly)
{
- LogDebug("Setting/updating Property. Handle: " << widgetHandle <<
+ SetProperty(WidgetDAOReadOnly::getPkgName(widgetHandle),key,value,readOnly);
+}
+
+void SetProperty(WidgetPkgName pkgName,
+ const PropertyDAOReadOnly::WidgetPropertyKey &key,
+ const PropertyDAOReadOnly::WidgetPropertyValue &value,
+ bool readOnly)
+{
+ LogDebug("Setting/updating Property. pkgName: " << pkgName <<
", key: " << key);
Try {
using namespace DPL::DB::ORM;
DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
DPL::OptionalInt readonly = PropertyDAOReadOnly::CheckPropertyReadFlag(
- widgetHandle,
+ pkgName,
key);
if (!readonly.IsNull() && *readonly == 1) {
LogError("'" << key <<
if (readonly.IsNull()) {
WidgetPreference::Row row;
- row.Set_app_id(widgetHandle);
+ row.Set_pkgname(pkgName);
row.Set_key_name(key);
row.Set_key_value(value);
row.Set_readonly(readOnly ? 1 : 0);
WRT_DB_UPDATE(update, WidgetPreference, &WrtDatabase::interface())
update->Where(And(
- Equals<WidgetPreference::app_id>(widgetHandle),
+ Equals<WidgetPreference::pkgname>(pkgName),
Equals<WidgetPreference::key_name>(key)));
update->Values(row);
}
}
+//deprecated
void RegisterProperties(DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info)
{
- LogDebug("Registering proferences for widget. Handle: " << widgetHandle);
+ RegisterProperties(WidgetDAOReadOnly::getPkgName(widgetHandle),regInfo);
+}
+
+void RegisterProperties(WidgetPkgName pkgName,
+ const WidgetRegisterInfo ®Info)
+{
+ LogDebug("Registering proferences for widget. pkgName: " << pkgName);
// Try-Catch in WidgetDAO
{
{ // Insert into table Widget Preferences
WidgetPreference::Row row;
- row.Set_app_id(widgetHandle);
+ row.Set_pkgname(pkgName);
row.Set_key_name(it->name);
row.Set_key_value(it->value);
int readonly = true == it->readonly ? 1 : 0;
* Created on: Nov 16, 2011
* Author: Krzysztof Jackiewicz(k.jackiewicz@samsung.com)
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/property_dao_read_only.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <dpl/wrt-dao-ro/webruntime_database.h>
FOREACH(it, ormWidgetPrefRow) {
WidgetPreferenceRow row;
- row.app_id = it->Get_app_id();
+ row.pkgname = it->Get_pkgname();
row.key_name = it->Get_key_name();
row.key_value = it->Get_key_value();
row.readonly = it->Get_readonly();
}
+//deprecated
+DPL::OptionalInt CheckPropertyReadFlag(DbWidgetHandle widgetHandle,
+ const WidgetPropertyKey &key)
+{
+ return CheckPropertyReadFlag(WidgetDAOReadOnly::getPkgName(widgetHandle),
+ key);
+}
+
+DPL::OptionalInt CheckPropertyReadFlag(WidgetPkgName pkgName,
+ const WidgetPropertyKey &key)
+{
+ LogDebug("Checking Property flag. pkgName: " << pkgName <<
+ ", key: " << key);
+
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
+ select->Where(And(Equals<WidgetPreference::pkgname>(pkgName),
+ Equals<WidgetPreference::key_name>(key)));
+
+ return select->GetSingleValue<WidgetPreference::readonly>();
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base){
+ ReThrowMsg(Exception::DatabaseError,
+ "Failure during checking readonly flag for property");
+ }
+}
+
+//deprecated
WidgetPropertyKeyList GetPropertyKeyList(DbWidgetHandle widgetHandle)
{
- LogDebug("Get PropertyKey list. Handle: " << widgetHandle);
+ return GetPropertyKeyList(WidgetDAOReadOnly::getPkgName(widgetHandle));
+}
+
+WidgetPropertyKeyList GetPropertyKeyList(WidgetPkgName pkgName)
+{
+ LogDebug("Get PropertyKey list. pkgName: " << pkgName);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
ORMWidgetPropertyKeyList keyList;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(Equals<WidgetPreference::app_id>(widgetHandle));
+ select->Where(Equals<WidgetPreference::pkgname>(pkgName));
keyList = select->GetValueList<WidgetPreference::key_name>();
WidgetPropertyKeyList retKeyList;
}
}
+//deprecated
WidgetPreferenceList GetPropertyList(DbWidgetHandle widgetHandle)
{
- LogDebug("Get Property list. Handle: " << widgetHandle);
+ Try{
+ WidgetPkgName pkgName=WidgetDAOReadOnly::getPkgName(widgetHandle);
+ return GetPropertyList(pkgName);
+ }Catch(WidgetDAOReadOnly::Exception::WidgetNotExist){
+ WidgetPreferenceList empty;
+ return empty;
+ }
+}
+
+WidgetPreferenceList GetPropertyList(WidgetPkgName pkgName)
+{
+ LogDebug("Get Property list. pkgName: " << pkgName);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(Equals<WidgetPreference::app_id>(widgetHandle));
+ select->Where(Equals<WidgetPreference::pkgname>(pkgName));
ORMWidgetPreferenceList ormPrefList = select->GetRowList();
WidgetPreferenceList prefList;
}
}
+//deprecated
WidgetPropertyValue GetPropertyValue(DbWidgetHandle widgetHandle,
const WidgetPropertyKey &key)
{
- LogDebug("Get Property value. Handle: " << widgetHandle <<
+ return GetPropertyValue(WidgetDAOReadOnly::getPkgName(widgetHandle),key);
+}
+
+WidgetPropertyValue GetPropertyValue(WidgetPkgName pkgName,
+ const WidgetPropertyKey &key)
+{
+ LogDebug("Get Property value. pkgName: " << pkgName <<
", key: " << key);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(And(Equals<WidgetPreference::app_id>(widgetHandle),
+ select->Where(And(Equals<WidgetPreference::pkgname>(pkgName),
Equals<WidgetPreference::key_name>(key)));
ORMWidgetPropertyValue ormPropValue =
}
}
-DPL::OptionalInt CheckPropertyReadFlag(DbWidgetHandle widgetHandle,
- const WidgetPropertyKey &key)
-{
- LogDebug("Checking Property flag. Handle: " << widgetHandle <<
- ", key: " << key);
- Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(And(Equals<WidgetPreference::app_id>(widgetHandle),
- Equals<WidgetPreference::key_name>(key)));
-
- return select->GetSingleValue<WidgetPreference::readonly>();
- }
- Catch(DPL::DB::SqlConnection::Exception::Base){
- ReThrowMsg(Exception::DatabaseError,
- "Failure during checking readonly flag for property");
- }
-}
-
} // namespace PropertyDAOReadOnly
} // namespace WrtDB
* @version 1.0
* @brief This file contains the definition of webruntime database
*/
+#include <stddef.h>
#include <dpl/wrt-dao-ro/webruntime_database.h>
DPL::Mutex g_wrtDbQueriesMutex;
* @version 1.0
* @brief This file contains the definition of Configuration.
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-rw/widget_dao.h>
#include <sstream>
message); \
}
-#define CHECK_WIDGET_EXISTENCE(macro_transaction, macro_handle) \
- if (!WidgetDAO::isWidgetInstalled(macro_handle)) \
- { \
- macro_transaction.Commit(); \
- LogWarning("Cannot find widget. Handle: " << macro_handle); \
- ThrowMsg(WidgetDAO::Exception::WidgetNotExist, \
- "Cannot find widget. Handle: " << macro_handle); \
- }
-
+WidgetDAO::WidgetDAO(DPL::OptionalString widgetGUID) :
+ WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(widgetGUID))
+{
+}
-WidgetDAO::WidgetDAO(DbWidgetHandle widgetHandle) :
- WidgetDAOReadOnly(widgetHandle)
+WidgetDAO::WidgetDAO(DPL::String pkgName) :
+ WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(pkgName))
{
}
-WidgetDAO::WidgetDAO(DPL::OptionalString widgetGUID) :
- WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(widgetGUID))
+WidgetDAO::WidgetDAO(DbWidgetHandle handle) :
+ WidgetDAOReadOnly(handle)
{
}
void WidgetDAO::setPkgName(const DPL::OptionalString& pkgName)
{
+
+ // if(!!pkgName)
+ setPkgName_TEMPORARY_API(*pkgName);
+}
+
+
+void WidgetDAO::setPkgName_TEMPORARY_API(const WidgetPkgName& pkgName)
+{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
using namespace DPL::DB::ORM;
wrt::ScopedTransaction transaction(&WrtDatabase::interface());
- isWidgetInstalled(getHandle());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
wrt::WidgetInfo::Row row;
row.Set_pkgname(pkgName);
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
}
-DbWidgetHandle WidgetDAO::registerWidget(const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity,
- const LanguageTagsList& languageTags)
+void WidgetDAO::setSecurityPopupUsage(const SettingsType value)
{
- LogDebug("Registering widget");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ ScopedTransaction transaction(&WrtDatabase::interface());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
+
+ WidgetSecuritySettings::Row row;
+ row.Set_security_popup_usage(value);
- //Register into WidgetInfo has to be first
- //as all other tables depend upon that
- DbWidgetHandle widgetHandle =
- registerWidgetInfo(widgetRegInfo, wacSecurity);
+ WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
+ update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
+ update->Values(row);
+ update->Execute();
- registerWidgetExtendedInfo(widgetHandle, widgetRegInfo);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set security popup usage")
+}
+
+void WidgetDAO::setGeolocationUsage(const SettingsType value)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
- registerWidgetLocalizedInfo(widgetHandle, widgetRegInfo);
+ ScopedTransaction transaction(&WrtDatabase::interface());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
- registerWidgetUserAgentLocales(
- widgetHandle, widgetRegInfo, languageTags);
+ WidgetSecuritySettings::Row row;
+ row.Set_geolocation_usage(value);
- registerWidgetIcons(widgetHandle, widgetRegInfo);
+ WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
+ update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
+ update->Values(row);
+ update->Execute();
- registerWidgetStartFile(widgetHandle, widgetRegInfo);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set geolocation usage")
+}
- PropertyDAO::RegisterProperties(widgetHandle, widgetRegInfo);
+void WidgetDAO::setWebNotificationUsage(const SettingsType value)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
- registerWidgetFeatures(widgetHandle, widgetRegInfo);
+ ScopedTransaction transaction(&WrtDatabase::interface());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
- registerWidgetWindowModes(widgetHandle, widgetRegInfo);
+ WidgetSecuritySettings::Row row;
+ row.Set_web_notification_usage(value);
- registerWidgetWarpInfo(widgetHandle, widgetRegInfo);
+ WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
+ update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
+ update->Values(row);
+ update->Execute();
- registerWidgetCertificates(widgetHandle, wacSecurity);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set web notification usage")
+}
- CertificateChainList list;
- wacSecurity.getCertificateChainList(list);
- registerLaunchCertificates(widgetHandle,list);
+void WidgetDAO::setWebDatabaseUsage(const SettingsType value)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
- registerWidgetPowderData(widgetHandle, widgetRegInfo);
+ ScopedTransaction transaction(&WrtDatabase::interface());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
- registerWidgetSettings(widgetHandle, widgetRegInfo);
+ WidgetSecuritySettings::Row row;
+ row.Set_web_database_usage(value);
- registerAppService(widgetHandle, widgetRegInfo);
+ WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
+ update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
+ update->Values(row);
+ update->Execute();
transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set web database usage")
+}
- return widgetHandle;
+void WidgetDAO::setFileSystemUsage(const SettingsType value)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ ScopedTransaction transaction(&WrtDatabase::interface());
+ if (!isWidgetInstalled(getHandle())) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << getHandle());
+ }
+
+ WidgetSecuritySettings::Row row;
+ row.Set_file_system_usage(value);
+
+ WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
+ update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
+ update->Values(row);
+ update->Execute();
+
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set filesystem usage")
+}
+
+void WidgetDAO::registerWidget(
+ const WidgetPkgName & widgetPkgname,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity)
+{
+ LogDebug("Registering widget");
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ registerWidgetInternal(widgetPkgname, widgetRegInfo, wacSecurity);
+ transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
}
+void WidgetDAO::registerWidget(
+ WrtDB::DbWidgetHandle handle,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity)
+{
+ LogDebug("Registering widget");
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ registerWidgetInternal(generateTizenId(), widgetRegInfo, wacSecurity, handle);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
+}
+
+DbWidgetHandle WidgetDAO::registerWidget(
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity)
+{
+ //make it more precise due to very fast tests
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ srand(time(NULL) + tv.tv_usec);
+ DbWidgetHandle widgetHandle;
+ do {
+ widgetHandle = rand();
+ } while (isWidgetInstalled(widgetHandle));
+
+ registerWidget(widgetHandle, pWidgetRegisterInfo, wacSecurity);
+ return widgetHandle;
+}
+
+WidgetPkgName WidgetDAO::registerWidgetGenerateTizenId(
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity)
+{
+ WidgetPkgName widgetPkgName = generateTizenId();
+ registerWidget(widgetPkgName, pWidgetRegisterInfo, wacSecurity);
+ return widgetPkgName;
+}
+
+void WidgetDAO::registerWidgetInternal(
+ const WidgetPkgName & widgetName,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle)
+{
+ //Register into WidgetInfo has to be first
+ //as all other tables depend upon that
+ DbWidgetHandle widgetHandle = registerWidgetInfo(widgetName, widgetRegInfo, wacSecurity, handle);
+
+ registerWidgetExtendedInfo(widgetHandle, widgetRegInfo);
+
+ registerWidgetLocalizedInfo(widgetHandle, widgetRegInfo);
+
+ registerWidgetIcons(widgetHandle, widgetRegInfo);
+
+ registerWidgetStartFile(widgetHandle, widgetRegInfo);
+
+ PropertyDAO::RegisterProperties(widgetHandle, widgetRegInfo);
+
+ registerWidgetFeatures(widgetHandle, widgetRegInfo);
+
+ registerWidgetPrivilege(widgetHandle, widgetRegInfo);
+
+ registerWidgetWindowModes(widgetHandle, widgetRegInfo);
+
+ registerWidgetWarpInfo(widgetHandle, widgetRegInfo);
+
+ registerWidgetCertificates(widgetHandle, wacSecurity);
+
+ CertificateChainList list;
+ wacSecurity.getCertificateChainList(list, SIGNATURE_DISTRIBUTOR);
+ registerCertificatesChains(widgetHandle, SIGNATURE_DISTRIBUTOR, list);
+
+ list.clear();
+ wacSecurity.getCertificateChainList(list, SIGNATURE_AUTHOR);
+ registerCertificatesChains(widgetHandle, SIGNATURE_AUTHOR, list);
+
+ registerWidgetSettings(widgetHandle, widgetRegInfo);
+
+ registerAppService(widgetHandle, widgetRegInfo);
+
+ registerEncryptedResouceInfo(widgetHandle, widgetRegInfo);
+
+ registerExternalLocations(widgetHandle, widgetRegInfo.externalLocations);
+
+ registerWidgetSecuritySettings(widgetHandle);
+}
+
+void WidgetDAO::registerOrUpdateWidget(
+ const WidgetPkgName & widgetName,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity)
+{
+ LogDebug("Reregistering widget");
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+
+ unregisterWidgetInternal(widgetName);
+ registerWidgetInternal(widgetName, widgetRegInfo, wacSecurity);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to reregister widget")
+}
+
#define DO_INSERT(row, table) \
{ \
WRT_DB_INSERT(insert, table, &WrtDatabase::interface()) \
row.Set_app_id(widgetHandle);
// row.Set_share_href (DPL::FromUTF8String(regInfo.shareHref));
row.Set_signature_type(regInfo.signatureType);
- row.Set_factory_widget(regInfo.isFactoryWidget);
row.Set_test_widget(regInfo.isTestWidget);
row.Set_install_time(regInfo.installedTime);
+ row.Set_splash_img_src(regInfo.configInfo.splashImgSrc);
+ row.Set_background_page(regInfo.configInfo.backgroundPage);
+ row.Set_installed_path(regInfo.widgetInstalledPath);
DO_INSERT(row, WidgetExtendedInfo)
}
-DbWidgetHandle WidgetDAO::registerWidgetInfo(const WidgetRegisterInfo ®Info,
- const IWacSecurity &wacSecurity)
+DbWidgetHandle WidgetDAO::registerWidgetInfo(
+ const WidgetPkgName & widgetName,
+ const WidgetRegisterInfo ®Info,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
// Because of that, "Optional" is not used there
WidgetInfo::Row row;
- row.Set_widget_type(regInfo.type.appType);
+ if(!!handle)
+ {
+ row.Set_app_id(*handle);
+ }
+
+ if (regInfo.webAppType == APP_TYPE_UNKNOWN && regInfo.type !=
+ APP_TYPE_UNKNOWN) {
+ // TODO : regInfo.type is temporary code for security.
+ // This code will be removed.
+ row.Set_widget_type(regInfo.type.appType);
+ } else {
+ row.Set_widget_type(regInfo.webAppType.appType);
+ }
row.Set_widget_id(widgetConfigurationInfo.widget_id);
row.Set_defaultlocale(widgetConfigurationInfo.defaultlocale);
row.Set_widget_version(widgetConfigurationInfo.version);
row.Set_author_href(widgetConfigurationInfo.authorHref);
row.Set_base_folder(DPL::FromUTF8String(regInfo.baseFolder));
row.Set_webkit_plugins_required(widgetConfigurationInfo.flashNeeded);
- row.Set_child_protection(1);
row.Set_recognized(wacSecurity.isRecognized());
row.Set_wac_signed(wacSecurity.isWacSigned());
row.Set_distributor_signed(wacSecurity.isDistributorSigned());
+ row.Set_pkgname(widgetName);
{
std::stringstream tmp;
- tmp << widgetConfigurationInfo.minVersionRequired;
+ tmp << regInfo.minVersion;
row.Set_min_version(DPL::FromUTF8String(tmp.str()));
}
row.Set_back_supported(widgetConfigurationInfo.backSupported);
row.Set_access_network(widgetConfigurationInfo.accessNetwork);
- row.Set_pkgname(regInfo.pkgname);
+ row.Set_pkg_type(regInfo.packagingType.pkgType);
- wrt::WidgetInfo::app_id::ColumnType appID;
+ Try
+ {
+ DO_INSERT(row, WidgetInfo);
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base)
{
- WRT_DB_INSERT(insert, WidgetInfo, &WrtDatabase::interface())
- insert->Values(row);
- appID = insert->Execute();
+ ReThrowMsg(WidgetDAO::Exception::DatabaseError,
+ "Failed to register widget info.");
+ }
+
+ if(!handle)
+ {
+ //get autoincremented value of widgetHandle
+ WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
+ select->Where(Equals<WidgetInfo::pkgname>(widgetName));
+ return select->GetSingleValue<WidgetInfo::app_id>();
+ }
+ else
+ {
+ return *handle;
}
- return appID;
}
void WidgetDAO::registerWidgetLocalizedInfo(DbWidgetHandle widgetHandle,
}
}
-void WidgetDAO::registerWidgetUserAgentLocales(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo &/*regInfo*/,
- const LanguageTagsList& languageTags)
-{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
-
- FOREACH(i, languageTags)
- {
- wrt::WidgetUserAgentLocales::Row row;
- row.Set_app_id(widgetHandle);
- row.Set_language_tag(*i);
-
- DO_INSERT(row, wrt::WidgetUserAgentLocales)
- }
-}
-
void WidgetDAO::registerWidgetIcons(DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info)
{
widgetFeature.Set_app_id(widgetHandle);
widgetFeature.Set_name(pWidgetFeature->name);
widgetFeature.Set_required(pWidgetFeature->required);
+ widgetFeature.Set_rejected(false);
wrt::WidgetFeature::widget_feature_id::ColumnType widgetFeatureID;
{
wrt::FeatureParam::Row featureParam;
featureParam.Set_widget_feature_id(widgetFeatureID);
- ConfigParserData::ParamsList::const_iterator iter;
-
FOREACH(iter, pWidgetFeature->paramsList)
{
featureParam.Set_name(iter->name);
}
}
+void WidgetDAO::registerWidgetPrivilege(DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info)
+{
+ using namespace DPL::DB::ORM;
+ const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
+
+ FOREACH(it, widgetConfigurationInfo.privilegeList)
+ {
+ wrt::WidgetPrivilege::Row widgetPrivilege;
+ widgetPrivilege.Set_app_id(widgetHandle);
+ widgetPrivilege.Set_name(it->name);
+
+ DO_INSERT(widgetPrivilege, wrt::WidgetPrivilege)
+ }
+}
+
+void WidgetDAO::updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature){
+ // This function could be merged with registerWidgetFeature but it requires desing change:
+ // 1. Check "ace step" in installer must be done before "update database step"
+ // And:
+ // ConfigurationParserData shouldn't be called "ParserData" any more.
+ using namespace DPL::DB::ORM;
+
+ wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ WRT_DB_SELECT(select, wrt::WidgetFeature, &WrtDatabase::interface())
+ select->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
+ Equals<wrt::WidgetFeature::name>(widgetFeature.name)));
+
+ auto row = select->GetSingleRow();
+ row.Set_rejected(widgetFeature.rejected);
+
+ WRT_DB_UPDATE(update, wrt::WidgetFeature, &WrtDatabase::interface())
+ update->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
+ Equals<wrt::WidgetFeature::name>(widgetFeature.name)));
+ update->Values(row);
+ update->Execute();
+ transaction.Commit();
+}
+
void WidgetDAO::registerWidgetWindowModes(DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info)
{
}
}
-void WidgetDAO::registerWidgetPowderData(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
-{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
-
- using namespace Powder;
-
- FOREACH(i, regInfo.powderDescription.categories)
- {
- const DPL::String& categoryName(i->first);
- const Description::CategoryEntry& categoryEntry(i->second);
- FOREACH(l, categoryEntry.levels)
- {
- PowderLevels::id::ColumnType powderID;
- {
- PowderLevels::Row row;
- row.Set_app_id(widgetHandle);
- row.Set_category(categoryName);
- row.Set_level(l->level);
-
- WRT_DB_INSERT(insert, PowderLevels, &WrtDatabase::interface())
- insert->Values(row);
- powderID = insert->Execute();
- }
-
- FOREACH(c, l->context)
- {
- PowderLevelContexts::Row row;
- row.Set_levelId(powderID);
- row.Set_context(*c);
-
- DO_INSERT(row, PowderLevelContexts)
- }
- }
- }
-}
-
-void WidgetDAO::registerLaunchCertificates(DbWidgetHandle widgetHandle,
+void WidgetDAO::registerCertificatesChains(DbWidgetHandle widgetHandle,
+ CertificateSource certificateSource,
const CertificateChainList &certificateChainList)
{
using namespace DPL::DB::ORM;
{
WidgetCertificate::Row row;
row.Set_app_id(widgetHandle);
+ row.Set_cert_source(certificateSource);
row.Set_encoded_chain(DPL::FromASCIIString(*certChain));
DO_INSERT(row, WidgetCertificate);
FOREACH(pWidgetSetting, widgetConfigurationInfo.settingsList)
{
- SettginsList::Row row;
+ SettingsList::Row row;
row.Set_appId(widgetHandle);
row.Set_settingName(pWidgetSetting->m_name);
row.Set_settingValue(pWidgetSetting->m_value);
- DO_INSERT(row, SettginsList)
+ DO_INSERT(row, SettingsList)
}
}
}
}
-#undef DO_INSERT
+void WidgetDAO::registerEncryptedResouceInfo(DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info)
+{
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ FOREACH(it, regInfo.encryptedFiles)
+ {
+ EncryptedResourceList::Row row;
+ row.Set_app_id(widgetHandle);
+ row.Set_resource(it->fileName);
+ row.Set_size(it->fileSize);
+
+ DO_INSERT(row, EncryptedResourceList)
+ }
+}
-void WidgetDAO::unregisterWidget(DbWidgetHandle widgetHandle)
+void WidgetDAO::registerExternalLocations(DbWidgetHandle widgetHandle,
+ const ExternalLocationList & externals)
{
- LogDebug("Unregistering widget from DB. Handle: " << widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
-
- CHECK_WIDGET_EXISTENCE(transaction, widgetHandle)
-
- // Delete from table Widget Info
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ LogDebug("Inserting external files for widgetHandle: " << widgetHandle);
+ FOREACH(it, externals)
{
- WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
- del->Where(Equals<WidgetInfo::app_id>(widgetHandle));
- del->Execute();
+ WidgetExternalLocations::Row row;
+ row.Set_app_id(widgetHandle);
+ row.Set_path(DPL::FromUTF8String(*it));
+
+ DO_INSERT(row, WidgetExternalLocations)
}
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register external files");
+}
- // Deleting in other tables is done via "delete cascade" in SQL
+void WidgetDAO::registerWidgetSecuritySettings(DbWidgetHandle widgetHandle)
+{
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WidgetSecuritySettings::Row row;
+ row.Set_app_id(widgetHandle);
+ row.Set_security_popup_usage(SETTINGS_TYPE_ON);
+ row.Set_geolocation_usage(SETTINGS_TYPE_ON);
+ row.Set_web_notification_usage(SETTINGS_TYPE_ON);
+ row.Set_web_database_usage(SETTINGS_TYPE_ON);
+ row.Set_file_system_usage(SETTINGS_TYPE_ON);
+
+ DO_INSERT(row, WidgetSecuritySettings)
+}
+
+void WidgetDAO::unregisterAllExternalLocations()
+{
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ LogDebug("Deleting external files for widgetHandle: " << m_widgetHandle);
+ WRT_DB_DELETE(del, WidgetExternalLocations, &WrtDatabase::interface());
+ del->Where(Equals<WidgetExternalLocations::app_id>(m_widgetHandle));
+ del->Execute();
+}
+
+void WidgetDAO::unregisterWidget(const WidgetPkgName & pkgName)
+{
+ LogDebug("Unregistering widget from DB. PkgName: " << pkgName);
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ unregisterWidgetInternal(pkgName);
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to unregister widget")
+}
+
+void WidgetDAO::unregisterWidget(WrtDB::DbWidgetHandle handle)
+{
+ LogDebug("Unregistering widget from DB. Handle: " << handle);
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ ScopedTransaction transaction(&WrtDatabase::interface());
+
+ // Delete from table Widget Info
+ WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
+ del->Where(Equals<WidgetInfo::app_id>(handle));
+ del->Execute();
transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to unregister widget")
}
+void WidgetDAO::unregisterWidgetInternal(
+ const WidgetPkgName & pkgName)
+{
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ DbWidgetHandle handle = getHandle(pkgName);
+
+ // Delete from table Widget Info
+ WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
+ del->Where(Equals<WidgetInfo::app_id>(handle));
+ del->Execute();
+
+ // Deleting in other tables is done via "delete cascade" in SQL
+}
+
+#undef DO_INSERT
+
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
-#undef CHECK_WIDGET_EXISTENCE
} // namespace WrtDB
* @version 1.0
* @brief This file contains the declaration of widget dao
*/
-
+#include <stddef.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <sstream>
#include <dpl/wrt-dao-ro/widget_config.h>
#include <dpl/wrt-dao-ro/feature_dao_read_only.h>
#include <orm_generator_wrt.h>
+#include <LanguageTagsProvider.h>
namespace WrtDB {
typedef DPL::DB::ORM::wrt::WidgetInfo::Row WidgetInfoRow;
typedef DPL::DB::ORM::wrt::WidgetFeature::widget_feature_id::ColumnType
- WidgetFeatureId;
+ WidgetFeatureId;
+typedef DPL::DB::ORM::wrt::WidgetSecuritySettings::Row
+ WidgetSecuritySettingsRow;
namespace {
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::wrt;
+
WidgetInfoRow getWidgetInfoRow(int widgetHandle)
{
LogDebug("Getting WidgetInfo row. Handle: " << widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetInfo::app_id>(widgetHandle));
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in GetWidgetInfoRow")
}
+WidgetSecuritySettingsRow getWidgetSecuritySettingsRow(int widgetHandle)
+{
+ LogDebug("Getting WidgetSecuritySettings row. Handle: " << widgetHandle);
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WRT_DB_SELECT(select, WidgetSecuritySettings, &WrtDatabase::interface())
+ select->Where(Equals<WidgetSecuritySettings::app_id>(widgetHandle));
+
+ WidgetSecuritySettings::Select::RowList rows = select->GetRowList();
+ if (rows.empty()) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << widgetHandle);
+ }
+ return rows.front();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getWidgetSecuritySettingsRow")
+}
+
+const int MAX_TIZENID_LENGTH = 10;
+
+WidgetPkgName getPkgNameByHandle(const DbWidgetHandle handle)
+{
+ LogDebug("Getting WidgetPkgName by DbWidgetHandle: " << handle);
+
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
+ select->Where(Equals<WidgetInfo::app_id>(handle));
+ WidgetInfo::Select::RowList rowList = select->GetRowList();
+
+ if (rowList.empty()) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Failed to get widget by handle");
+ }
+ WidgetPkgName pkgname = rowList.front().Get_pkgname();
+
+ return pkgname;
+
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
+}
} // namespace
{
}
+WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::OptionalString widgetGUID) :
+ m_widgetHandle(WidgetDAOReadOnly::getHandle(widgetGUID))
+{
+}
+
+WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::String pkgName) :
+ m_widgetHandle(WidgetDAOReadOnly::getHandle(pkgName))
+{
+
+}
+
WidgetDAOReadOnly::~WidgetDAOReadOnly()
{
}
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetInfo::widget_id>(GUID));
WidgetInfo::Select::RowList rowList = select->GetRowList();
return rowList.front().Get_app_id();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
-
- ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Failed to get widget by guid");
}
DbWidgetHandle WidgetDAOReadOnly::getHandle(const DPL::String pkgName)
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetInfo::pkgname>(pkgName));
WidgetInfo::Select::RowList rowList = select->GetRowList();
return rowList.front().Get_app_id();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
+}
+
+WidgetPkgName WidgetDAOReadOnly::getPkgName() const
+{
+ return getPkgNameByHandle(m_widgetHandle);
+}
+
+WidgetPkgName WidgetDAOReadOnly::getPkgName(const WidgetGUID GUID)
+{
+ return getPkgNameByHandle(getHandle(GUID));
+}
- ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Failed to get widget by package name");
+WidgetPkgName WidgetDAOReadOnly::getPkgName(const DbWidgetHandle handle)
+{
+ return getPkgNameByHandle(handle);
}
PropertyDAOReadOnly::WidgetPropertyKeyList
WidgetDAOReadOnly::getPropertyKeyList() const
{
- return PropertyDAOReadOnly::GetPropertyKeyList(m_widgetHandle);
+ return PropertyDAOReadOnly::GetPropertyKeyList(getPkgName());
}
PropertyDAOReadOnly::WidgetPreferenceList
WidgetDAOReadOnly::getPropertyList() const
{
- return PropertyDAOReadOnly::GetPropertyList(m_widgetHandle);
+ return PropertyDAOReadOnly::GetPropertyList(getPkgName());
}
PropertyDAOReadOnly::WidgetPropertyValue WidgetDAOReadOnly::getPropertyValue(
const PropertyDAOReadOnly::WidgetPropertyKey &key) const
{
- return PropertyDAOReadOnly::GetPropertyValue(m_widgetHandle, key);
+ return PropertyDAOReadOnly::GetPropertyValue(getPkgName(), key);
}
DPL::OptionalInt WidgetDAOReadOnly::checkPropertyReadFlag(
const PropertyDAOReadOnly::WidgetPropertyKey &key) const
{
- return PropertyDAOReadOnly::CheckPropertyReadFlag(m_widgetHandle, key);
+ return PropertyDAOReadOnly::CheckPropertyReadFlag(getPkgName(), key);
}
DPL::String WidgetDAOReadOnly::getPath() const
{
- DPL::String path = DPL::FromUTF8String(
- GlobalConfig::GetUserInstalledWidgetPath());
+ DPL::String path = *getWidgetInstalledPath();
DPL::String srcPath = DPL::FromUTF8String(GlobalConfig::GetWidgetSrcPath());
- bool isFactoryWidget = isFactory();
-
- if (isFactoryWidget) {
- WidgetGUID widgetGUID = getGUID();
- if (!widgetGUID) {
- Throw(WidgetDAOReadOnly::Exception::GUIDisNull);
- }
- path += L"/" + *widgetGUID + L"/";
- } else {
- // if the widget is a "downloaded widget",
- // use unique package name.
- DPL::OStringStream strAppId;
- strAppId << m_widgetHandle;
- DPL::OptionalString pkgname = getPkgname();
- path += L"/" + *pkgname + L"/";
- path += srcPath + L"/";
- }
+ path += srcPath + L"/";
return path;
}
LogDebug("Getting Localized Info. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ ScopedTransaction transaction(&WrtDatabase::interface());
CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
select->Where(
And(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle),
LogDebug("Getting FeaturesList. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ ScopedTransaction transaction(&WrtDatabase::interface());
CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, DPL::DB::ORM::wrt::WidgetFeature, &WrtDatabase::interface())
- select->Where(Equals<DPL::DB::ORM::wrt::WidgetFeature::app_id>(m_widgetHandle));
+ WRT_DB_SELECT(select, WidgetFeature, &WrtDatabase::interface())
+ select->Where(Equals<WidgetFeature::app_id>(m_widgetHandle));
DbWidgetFeatureSet resultSet;
- typedef std::list<DPL::DB::ORM::wrt::WidgetFeature::Row> RowList;
+ typedef std::list<WidgetFeature::Row> RowList;
RowList list = select->GetRowList();
for (RowList::iterator i = list.begin(); i != list.end(); ++i) {
DbWidgetFeature feature;
feature.name = i->Get_name();
feature.required = i->Get_required();
+ feature.rejected = i->Get_rejected();
feature.params = getFeatureParams(i->Get_widget_feature_id());
FeatureDAOReadOnly featureDao(DPL::ToUTF8String(i->Get_name()));
feature.pluginId = featureDao.GetPluginHandle();
LogDebug("Getting feature Params. featureId: " << widgetFeatureId);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, DPL::DB::ORM::wrt::FeatureParam, &WrtDatabase::interface())
- select->Where(Equals<DPL::DB::ORM::wrt::FeatureParam::widget_feature_id>(
+ WRT_DB_SELECT(select, FeatureParam, &WrtDatabase::interface())
+ select->Where(Equals<FeatureParam::widget_feature_id>(
widgetFeatureId));
WidgetParamMap resultMap;
- typedef std::list<DPL::DB::ORM::wrt::FeatureParam::Row> RowList;
+ typedef std::list<FeatureParam::Row> RowList;
RowList list = select->GetRowList();
FOREACH(i, list)
m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ ScopedTransaction transaction(&WrtDatabase::interface());
CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, wrt::WidgetFeature, &WrtDatabase::interface())
select->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
Equals<wrt::WidgetFeature::name>(
LogDebug("Getting AccessHostList. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ ScopedTransaction transaction(&WrtDatabase::interface());
CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetAccessHost, &WrtDatabase::interface())
select->Where(Equals<WidgetAccessHost::app_id>(m_widgetHandle));
std::list<WidgetAccessHost::host::ColumnType> values =
LogDebug("Getting DbWidgetHandle List");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
return select->GetValueList<WidgetInfo::app_id>();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get handle list")
}
+WidgetPkgNameList WidgetDAOReadOnly::getPkgnameList()
+{
+ LogDebug("Getting Pkgname List ");
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
+ return select->GetValueList<WidgetInfo::pkgname>();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgname list")
+}
+
+WidgetPkgNameList_TEMPORARY_API WidgetDAOReadOnly::getPkgnameList_TEMPORARY_API()
+{
+ LogDebug("Getting Pkgname List ");
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
+ return select->GetValueList<WidgetInfo::pkgname>();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgname list")
+}
+
+DbWidgetDAOReadOnlyList WidgetDAOReadOnly::getWidgetList()
+{
+ LogDebug("Getting DbWidget List");
+ DbWidgetDAOReadOnlyList list;
+ FOREACH(iterator, getHandleList()) {
+ list.push_back(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(*iterator)));
+ }
+ return list;
+}
+
bool WidgetDAOReadOnly::isWidgetInstalled(DbWidgetHandle handle)
{
LogDebug("Checking if widget exist. Handle: " << handle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetInfo::app_id>(handle));
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
}
-bool WidgetDAOReadOnly::isWidgetInstalled(DPL::String pkgName)
+bool WidgetDAOReadOnly::isWidgetInstalled(const WidgetPkgName & pkgName)
{
LogDebug("Checking if widget exist. package name " << pkgName);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetInfo::pkgname>(pkgName));
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
}
-CertificateChainList WidgetDAOReadOnly::getWidgetCertificate() const
+ExternalLocationList WidgetDAOReadOnly::getWidgetExternalLocations() const
+{
+ LogDebug("Getting WidgetExtranalFiles List");
+ ExternalLocationList result;
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetExternalLocations, &WrtDatabase::interface());
+ select->Where(Equals<WidgetExternalLocations::app_id>(m_widgetHandle));
+ WidgetExternalLocations::Select::RowList rows = select->GetRowList();
+ FOREACH(it, rows)
+ {
+ result.push_back(DPL::ToUTF8String(it->Get_path()));
+ }
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get handle list")
+ return result;
+}
+
+CertificateChainList WidgetDAOReadOnly::getWidgetCertificate(
+ CertificateSource source) const
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetCertificate, &WrtDatabase::interface())
- select->Where(Equals<WidgetCertificate::app_id>(m_widgetHandle));
+ select->Where(
+ And(
+ Equals<WidgetCertificate::app_id>(m_widgetHandle),
+ Equals<WidgetCertificate::cert_source>(source)));
- std::list<DPL::DB::ORM::wrt::WidgetCertificate::Row> chainList = select->GetRowList();
+ std::list<WidgetCertificate::Row> chainList = select->GetRowList();
CertificateChainList result;
DPL::OptionalString WidgetDAOReadOnly::getPkgname() const
{
- WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
- return row.Get_pkgname();
+ return DPL::OptionalString(getPkgName());
}
DPL::OptionalString WidgetDAOReadOnly::getDefaultlocale() const
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
bool WidgetDAOReadOnly::isTestWidget() const
{
Try {
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
if (ret.IsNull() || *ret == 0) { return false; } else { return true; }
}
-bool WidgetDAOReadOnly::isFactory() const
+time_t WidgetDAOReadOnly::getInstallTime() const
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
"Cannot find widget. Handle: " << m_widgetHandle);
}
- DPL::OptionalInt ret = rows.front().Get_factory_widget();
- if (ret.IsNull()) {
- return false;
- }
- return static_cast<bool>(*ret);
+ return static_cast<time_t>(*rows.front().Get_install_time());
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get isFactory")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget install time")
}
-time_t WidgetDAOReadOnly::getInstallTime() const
+DPL::OptionalString WidgetDAOReadOnly::getSplashImgSrc() const
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
"Cannot find widget. Handle: " << m_widgetHandle);
}
- return static_cast<time_t>(*rows.front().Get_install_time());
+ DPL::OptionalString value = rows.front().Get_splash_img_src();
+ if (value.IsNull()) {
+ return DPL::OptionalString::Null;
+ }
+
+ return DPL::OptionalString(getPath() + *value);
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget install time")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get splash image path")
}
WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::getLocalizedIconList() const
//TODO check widget existance??
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
- std::list<DPL::DB::ORM::wrt::WidgetLocalizedIcon::Row> list =
+ std::list<WidgetLocalizedIcon::Row> list =
select->GetRowList();
WidgetLocalizedIconList ret;
FOREACH(it,list)
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, wrt::WidgetIcon, &WrtDatabase::interface())
select->Where(Equals<wrt::WidgetIcon::app_id>(m_widgetHandle));
- std::list<DPL::DB::ORM::wrt::WidgetIcon::Row> list =
+ std::list<WidgetIcon::Row> list =
select->GetRowList();
WidgetIconList ret;
FOREACH(it,list)
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetLocalizedStartFile, &WrtDatabase::interface())
select->Where(Equals<WidgetLocalizedStartFile::app_id>(
m_widgetHandle));
select->OrderBy("start_file_id ASC");
- std::list<DPL::DB::ORM::wrt::WidgetLocalizedStartFile::Row> list =
+ std::list<WidgetLocalizedStartFile::Row> list =
select->GetRowList();
LocalizedStartFileList ret;
FOREACH(it,list)
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetStartFile, &WrtDatabase::interface())
select->Where(Equals<WidgetStartFile::app_id>(m_widgetHandle));
select->OrderBy("start_file_id ASC");
- std::list<DPL::DB::ORM::wrt::WidgetStartFile::Row> list =
+ std::list<WidgetStartFile::Row> list =
select->GetRowList();
WidgetStartFileList ret;
FOREACH(it,list)
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetWindowModes, &WrtDatabase::interface())
select->Where(Equals<WidgetWindowModes::app_id>(m_widgetHandle));
return baseFolder;
}
-bool WidgetDAOReadOnly::isDeletable() const
-{
- return !WidgetDAOReadOnly::isFactory();
-}
-
WidgetCertificateDataList WidgetDAOReadOnly::getCertificateDataList() const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
select->Where(Equals<WidgetCertificateFingerprint::app_id>(
m_widgetHandle));
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
select->Where(And(And(
Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
FingerPrintList keys;
FOREACH(it, rows)
{
- DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
- keys.push_back(md5.IsNull() ? "" : DPL::ToUTF8String(*md5));
DPL::Optional<DPL::String> sha1 = it->Get_sha1_fingerprint();
- keys.push_back(sha1.IsNull() ? "" : DPL::ToUTF8String(*sha1));
+ if (!sha1.IsNull()) {
+ keys.push_back(DPL::ToUTF8String(*sha1));
+ }
+ DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
+ if (!md5.IsNull()) {
+ keys.push_back(DPL::ToUTF8String(*md5));
+ }
}
return keys;
}
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
select->Where(And(And(
Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
ResourceAttributeList WidgetDAOReadOnly::getResourceAttribute(
const std::string &resourceId) const
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, DPL::DB::ORM::wrt::WidgetFeature, &WrtDatabase::interface())
- select->Where(And(Equals<DPL::DB::ORM::wrt::WidgetFeature::app_id>(m_widgetHandle),
- Equals<DPL::DB::ORM::wrt::WidgetFeature::name>(
+ WRT_DB_SELECT(select, WidgetFeature, &WrtDatabase::interface())
+ select->Where(And(Equals<WidgetFeature::app_id>(m_widgetHandle),
+ Equals<WidgetFeature::name>(
DPL::FromUTF8String(resourceId))));
- std::list<DPL::DB::ORM::wrt::WidgetFeature::Row> list = select->GetRowList();
+ std::list<WidgetFeature::Row> list = select->GetRowList();
ResourceAttributeList result;
if (!list.empty()) {
int widgetFeatureId = list.begin()->Get_widget_feature_id();
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetWARPInfo, &WrtDatabase::interface())
select->Where(Equals<WidgetWARPInfo::app_id>(m_widgetHandle));
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get accessinfo list")
}
-LanguageTagList WidgetDAOReadOnly::getLanguageTags() const
+LanguageTags WidgetDAOReadOnly::getLanguageTags() const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
select->Where(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle));
return select->GetValueList<LocalizedWidgetInfo::widget_locale>();
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get language tags")
}
-LanguageTagList WidgetDAOReadOnly::getIconLanguageTags() const
+LanguageTags WidgetDAOReadOnly::getIconLanguageTags() const
{
//TODO check widget existance
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
select->Distinct();
using namespace WrtDB::WidgetConfig;
std::ostringstream path;
- DPL::OptionalString pkgname = getPkgname();
+ WidgetPkgName pkgname = getPkgName();
- path << GetWidgetPersistentStoragePath(*pkgname);
+ path << GetWidgetPersistentStoragePath(pkgname);
path << "/";
path << GlobalConfig::GetCookieDatabaseFile();
std::string WidgetDAOReadOnly::getPrivateLocalStoragePath() const
{
std::ostringstream path;
- DPL::OptionalString pkgname = getPkgname();
- path << WidgetConfig::GetWidgetWebLocalStoragePath(*pkgname);
+ WidgetPkgName pkgname = getPkgName();
+ path << WidgetConfig::GetWidgetWebLocalStoragePath(pkgname);
path << "/";
- if (isFactory()) {
- WidgetGUID widgetGUID = getGUID();
- if (!widgetGUID) {
- Throw(WidgetDAOReadOnly::Exception::GUIDisNull);
- }
- path << DPL::ToUTF8String(*widgetGUID);
- }
-
return path.str();
}
-ChildProtection::Record WidgetDAOReadOnly::getChildProtection() const
-{
- WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
- return ChildProtection::Record(row.Get_child_protection());
-}
-
-Powder::Description WidgetDAOReadOnly::getPowderDescription() const
-{
- //TODO check widget existance
- SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
- {
- using namespace Powder;
- Description description;
-
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, PowderLevels, &WrtDatabase::interface())
- select->Where(Equals<PowderLevels::app_id>(m_widgetHandle));
- typedef std::list<PowderLevels::Row> RowList;
- RowList list = select->GetRowList();
-
- FOREACH(it, list)
- {
- Description::CategoryEntry& categoryEntry =
- description.categories[it->Get_category()];
- Description::LevelEntry levelEntry(
- (Description::LevelEnum)it->Get_level());
-
- WRT_DB_SELECT(selectContexts, PowderLevelContexts, &WrtDatabase::interface())
- selectContexts->Where(Equals<PowderLevelContexts::levelId>(
- it->Get_id()));
- typedef std::list<PowderLevelContexts::Row> ContextsRowList;
- ContextsRowList contextsList = selectContexts->GetRowList();
-
- FOREACH(c, contextsList)
- levelEntry.context.insert(c->Get_context());
-
- categoryEntry.levels.push_back(levelEntry);
- }
- return description;
- }
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get powder description")
-}
-
void WidgetDAOReadOnly::getWidgetSettings(
WidgetSettings& outWidgetSettings) const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(select, SettginsList, &WrtDatabase::interface())
- select->Where(Equals<SettginsList::appId>(m_widgetHandle));
+ WRT_DB_SELECT(select, SettingsList, &WrtDatabase::interface())
+ select->Where(Equals<SettingsList::appId>(m_widgetHandle));
- SettginsList::Select::RowList rows = select->GetRowList();
+ SettingsList::Select::RowList rows = select->GetRowList();
FOREACH(it, rows)
{
LogDebug("Getting getAppServiceList. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ ScopedTransaction transaction(&WrtDatabase::interface());
CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
- using namespace DPL::DB::ORM;
- using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, ApplicationServiceInfo, &WrtDatabase::interface())
select->Where(Equals<ApplicationServiceInfo::app_id>(m_widgetHandle));
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get access host list")
}
+PackagingType WidgetDAOReadOnly::getPackagingType() const
+{
+ WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_pkg_type();
+ return PackagingType(static_cast<PkgType>(*result));
+}
+
+void WidgetDAOReadOnly::getEncryptedFileList(EncryptedFileList& filesList) const
+{
+ //TODO check widget existance
+ WRT_DB_SELECT(select, EncryptedResourceList, &WrtDatabase::interface())
+ select->Where(Equals<EncryptedResourceList::app_id>(m_widgetHandle));
+
+ typedef std::list<EncryptedResourceList::Row> RowList;
+ RowList list = select->GetRowList();
+
+ FOREACH(it, list) {
+ EncryptedFileInfo info;
+ info.fileName = it->Get_resource();
+ info.fileSize = it->Get_size();
+ filesList.insert(info);
+ }
+}
+
+DPL::OptionalString WidgetDAOReadOnly::getBackgroundPage() const
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
+ select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
+
+ WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
+ if (rows.empty()) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << m_widgetHandle);
+ }
+
+ return rows.front().Get_background_page();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get background page")
+}
+
+WidgetPkgName WidgetDAOReadOnly::generateTizenId() {
+ std::string allowed("0123456789"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz");
+ WidgetPkgName tizenId;
+ tizenId.resize(MAX_TIZENID_LENGTH);
+ do {
+ for (int i = 0; i < MAX_TIZENID_LENGTH; ++i) {
+ tizenId[i] = allowed[rand() % allowed.length()];
+ }
+ } while (isWidgetInstalled(tizenId));
+ return tizenId;
+}
+
+SettingsType WidgetDAOReadOnly::getSecurityPopupUsage(void) const
+{
+ WidgetSecuritySettingsRow row =
+ getWidgetSecuritySettingsRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_security_popup_usage();
+ return static_cast<SettingsType>(*result);
+}
+
+SettingsType WidgetDAOReadOnly::getGeolocationUsage(void) const
+{
+ WidgetSecuritySettingsRow row =
+ getWidgetSecuritySettingsRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_geolocation_usage();
+ return static_cast<SettingsType>(*result);
+}
+
+SettingsType WidgetDAOReadOnly::getWebNotificationUsage(void) const
+{
+ WidgetSecuritySettingsRow row =
+ getWidgetSecuritySettingsRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_web_notification_usage();
+ return static_cast<SettingsType>(*result);
+}
+
+SettingsType WidgetDAOReadOnly::getWebDatabaseUsage(void) const
+{
+ WidgetSecuritySettingsRow row =
+ getWidgetSecuritySettingsRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_web_database_usage();
+ return static_cast<SettingsType>(*result);
+}
+
+SettingsType WidgetDAOReadOnly::getFileSystemUsage(void) const
+{
+ WidgetSecuritySettingsRow row =
+ getWidgetSecuritySettingsRow(m_widgetHandle);
+ DPL::OptionalInt result = row.Get_file_system_usage();
+ return static_cast<SettingsType>(*result);
+}
+
+DPL::OptionalString WidgetDAOReadOnly::getWidgetInstalledPath() const
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+ WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
+ select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
+
+ WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
+ if (rows.empty()) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Cannot find widget. Handle: " << m_widgetHandle);
+ }
+
+ return rows.front().Get_installed_path();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget installed path")
+}
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
#undef CHECK_WIDGET_EXISTENCE
public:
static const char *Address();
static DPL::DB::SqlConnection::Flag::Type Flags();
- static void attachToThread();
+ static void attachToThreadRO();
+ static void attachToThreadRW();
static void detachFromThread();
static DPL::DB::ThreadDatabaseSupport& interface();
static bool CheckTableExist(const char *name);
* @brief This file contains the declaration of common data types for wrtdb
*/
-#ifndef WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
-#define WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
+#ifndef WRT_WIDGET_DAO_COMMON_DAO_TYPES_H_
+#define WRT_WIDGET_DAO_COMMON_DAO_TYPES_H_
#include <set>
#include <string>
#include <map>
#include <vector>
#include <list>
+#include <memory>
#include <dpl/optional_typedefs.h>
-#include <dpl/shared_ptr.h>
-namespace WrtDB {
-namespace Powder {
-
-typedef std::set<DPL::String> StringSet;
-//! Widget description
-struct Description
-{
- //!Content level
- typedef enum
- {
- Level0 = 0,
- Level1,
- Level2,
- Level3,
- Level4,
- Level5,
- LevelUnknown
- } LevelEnum;
- struct LevelEntry
- {
- LevelEnum level; //!< content level
-
- typedef StringSet Context;
-
- //! POWDER context
- //! xa This material appears in an artistic context
- //! xb This material appears in an educational context
- //! xc This material appears in a medical context
- //! xd This material appears in a sports context
- //! xe This material appears in a violent context
- Context context;
- explicit LevelEntry(LevelEnum level = LevelUnknown);
- //! Function checks if context is valid
- //! \param[in] level POWDER content level
- //! \param[in] context POWDER context
- bool isContextValid(LevelEnum level,
- const DPL::OptionalString& context) const;
- };
-
- struct CategoryEntry
- {
- //! Levels entries for POWDER description
- typedef std::vector <LevelEntry> LevelsContainer;
- LevelsContainer levels;
- //! Function checks if context is valid
- //! \param[out] reason set if context invalid
- //! \param[in] level POWDER content level
- //! \param[in] context POWDER context
- bool isCategoryValid(LevelEntry& reason,
- LevelEnum level,
- const DPL::OptionalString& context) const;
- };
-
- //! POWDER Category -> Category entry map for Widget
- //!
- //! nu Nudity
- //! se Sex
- //! vi Violence
- //! la Potentially offensive language
- //! dr Drug use
- //! ga Gambling
- //! ha Hate or harmful activities
- //! ug Use of user-generated content
- typedef std::map<DPL::String, CategoryEntry> CategoryEntries;
-
- CategoryEntries categories;
-
- //! Age rating for widget
- //! If Null not set
- DPL::OptionalInt ageRating;
-};
-} // namespace Powder
-
-namespace ChildProtection {
-
-//! Blacklist with forbidden URLs
-//! It should be stored in WidgetDAO
-typedef std::vector<DPL::String> BlackList;
-
-//! Widget Child protection record
-//! Record should be stored in WingetDAO
-struct Record
-{
- //! Child protection enabled
- bool enabled;
- explicit Record(bool enabled) :
- enabled(enabled)
- {
- }
-};
-
-//! Powder processing
-struct PowderRules
-{
- //! Rule set by parent about forbidden category
- //! Powder category
- //! nu Nudity
- //! se Sex
- //! vi Violence
- //! la Potentially offensive language
- //! dr Drug use
- //! ga Gambling
- //! ha Hate or harmful activities
- //! ug Use of user-generated content
- //! Powder context
- //! xa This material appears in an artistic conteaxt
- //! xb This material appears in an educational context
- //! xc This material appears in a medical context
- //! xd This material appears in a sports context
- //! xe This material appears in a violent context
- struct CategoryRule
- {
- DPL::String category;
- Powder::Description::LevelEnum level;
- DPL::OptionalString context;
- explicit CategoryRule(const DPL::String& category = DPL::String(),
- Powder::Description::LevelEnum level =
- Powder::Description::LevelUnknown,
- const DPL::OptionalString& context = DPL::OptionalString());
- };
-
- struct PowderResult
- {
- //! Reasoning outcome: part of POWDER description used to invalidate
- Powder::Description::LevelEntry invalidDescription;
- //! Reasoning outcome: rule set by parent not full filed by description
- CategoryRule invalidRule;
-
- //! Reasoning outcome: type of invalidity
- enum InvalidReason
- {
- InvalidRule, //!< One of rules was not fulfilled
- InvalidAge, //!< Age is invalid
- AgeRatingNotSet, //!< Age rating for widget is not set
- Valid //!< Description valid
- };
- InvalidReason reason;
- explicit PowderResult(InvalidReason reason = Valid,
- const Powder::Description::LevelEntry& invalidDescription =
- Powder::Description::LevelEntry(),
- const CategoryRule& invalidRule = CategoryRule());
- };
-
- typedef std::pair<bool, PowderResult> ResultPair;
-
- //! Function checks if rule is fulfilled by description
- //! \param[in] rule checked rule
- //! \param[in] description
- //! \retval true rule is valid
- //! \retval false rule is invalid
- ResultPair isRuleValidForDescription(const CategoryRule& rule,
- const Powder::Description& description) const;
- //! Function checks if age limit is fulfilled by description
- //! \param[in] description
- //! \retval true age is valid
- //! \retval false age is invalid
- ResultPair isAgeValidForDescription(
- const Powder::Description& description) const;
-
- //! It is the maximum age rating valid for child
- //! Uniform age is stored in WidgetDAO
- DPL::OptionalInt ageLimit;
-
- //! Set to true if age rating is required
- //! If ageLimit is not set value is ignored
- bool isAgeRatingRequired;
-
- //! Set of rules configured by parent
- //! Rules are stored in WidgetDAO and are uniform for all widgets
- typedef std::vector<CategoryRule> RulesContainer;
- RulesContainer rules;
-
- //! Function check if Widget description is valid for ChildProtection
- //! configuration
- //! \param description widget description
- //! \retval true widget is valid
- //! \retval false widget is invalid
- ResultPair isDescriptionValid(const Powder::Description& description)
- const;
-
- PowderRules() :
- isAgeRatingRequired(false)
- {
- }
-};
-} // namespace ChildProtection
+namespace WrtDB {
class PluginMetafileData
{
public:
}
std::string m_libraryName;
- std::string m_featuresInstallURI;
- std::string m_featuresKeyCN;
- std::string m_featuresRootCN;
- std::string m_featuresRootFingerprint;
-
FeatureContainer m_featureContainer;
};
{
public:
typedef std::set<std::string> Objects;
- typedef DPL::SharedPtr<Objects> ObjectsPtr;
+ typedef std::shared_ptr<Objects> ObjectsPtr;
public:
explicit PluginObjectsDAO() {}
* FindWidgetModel routine.
*/
typedef int DbWidgetHandle;
+typedef DPL::String WidgetPkgName;
+
+/**
+ * Value of invalid widget handle
+ */
+enum {
+ INVALID_WIDGET_HANDLE = -1
+};
/**
* @brief Structure to hold the information of widget's size
}
};
+struct EncryptedFileInfo
+{
+ DPL::String fileName;
+ int fileSize;
+
+ bool operator==(const EncryptedFileInfo& info) const
+ {
+ return fileName == info.fileName;
+ }
+
+ bool operator==(const DPL::String& file) const
+ {
+ return fileName == file;
+ }
+
+ bool operator< (const EncryptedFileInfo& info) const
+ {
+ return fileName < info.fileName;
+ }
+};
+
typedef std::list<WidgetAccessInfo> WidgetAccessInfoList;
typedef std::list<DPL::String> WindowModeList;
+typedef std::set<EncryptedFileInfo> EncryptedFileList;
+
/**
* @brief Widget configuration parameter key
*/
{
DPL::String name; /// Feature name
bool required; /// Whether feature is required
- DbPluginHandle pluginId; /// Plugin id that implement this feature
+ bool rejected; /// Api feature was rejected by ace
+ DbPluginHandle pluginId; /// Plugin id that implement this feature
WidgetParamMap params; /// Widget's params
DbWidgetFeature() :
*/
typedef std::list<DbWidgetHandle> DbWidgetHandleList;
+typedef std::list<WidgetPkgName> WidgetPkgNameList; //TODO: this cannot be null -> appropriate changes in db schema needed
+typedef std::list<WidgetPkgName> WidgetPkgNameList_TEMPORARY_API; //TODO: this cannot be null -> appropriate changes in db schema needed
+
+class WidgetDAOReadOnly; //forward declaration
+typedef std::shared_ptr<WidgetDAOReadOnly> WidgetDAOReadOnlyPtr;
+/**
+ * @brief Default container with WidgetDAOReadOnly
+ */
+typedef std::list<WidgetDAOReadOnlyPtr> DbWidgetDAOReadOnlyList;
+
/**
* @brief Widget specific type
*
enum AppType
{
APP_TYPE_UNKNOWN = 0, // unknown
- APP_TYPE_WAC10, // WAC 1.0
APP_TYPE_WAC20, // WAC 2.0
- APP_TYPE_TIZENWEBAPP, // Tizen webapp
+ APP_TYPE_TIZENWEBAPP // Tizen webapp
};
class WidgetType
{
return appType == other;
}
+ bool operator!= (const AppType& other) const
+ {
+ return appType != other;
+ }
std::string getApptypeToString()
{
switch (appType) {
#define X(x) case x: return #x;
X(APP_TYPE_UNKNOWN)
- X(APP_TYPE_WAC10)
X(APP_TYPE_WAC20)
X(APP_TYPE_TIZENWEBAPP)
#undef X
AppType appType;
};
+/**
+ * @brief Package specific type
+ *
+ * Package type describes belowed in Tizen webapp, C++ service App
+ */
+enum PkgType
+{
+ PKG_TYPE_UNKNOWN = 0, // unknown
+ PKG_TYPE_NOMAL_WEB_APP,
+ PKG_TYPE_DIRECTORY_WEB_APP,
+ PKG_TYPE_HOSTED_WEB_APP, // request from browser
+ PKG_TYPE_HYBRID_WEB_APP // Tizen webapp with C++ service app
+};
+
+class PackagingType
+{
+ public:
+ PackagingType()
+ :pkgType(PKG_TYPE_UNKNOWN)
+ {
+ }
+ PackagingType(const PkgType type)
+ :pkgType(type)
+ {
+ }
+ bool operator== (const PkgType& other) const
+ {
+ return pkgType == other;
+ }
+ bool operator!= (const PkgType& other) const
+ {
+ return pkgType != other;
+ }
+ std::string getPkgtypeToString()
+ {
+ switch (pkgType) {
+#define X(x) case x: return #x;
+ X(PKG_TYPE_UNKNOWN)
+ X(PKG_TYPE_NOMAL_WEB_APP)
+ X(PKG_TYPE_DIRECTORY_WEB_APP)
+ X(PKG_TYPE_HOSTED_WEB_APP)
+ X(PKG_TYPE_HYBRID_WEB_APP)
+#undef X
+ default:
+ return "UNKNOWN";
+ }
+ }
+
+ PkgType pkgType;
+};
+
+enum SettingsType
+{
+ SETTINGS_TYPE_UNKNOWN = 0,
+ SETTINGS_TYPE_ON,
+ SETTINGS_TYPE_ALWAYS_ASK,
+ SETTINGS_TYPE_OFF
+};
} // namespace WrtDB
struct WidgetSetting
};
typedef std::list<WidgetApplicationService> WidgetApplicationServiceList;
-#endif /* WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_ */
+
+#endif /* WRT_WIDGET_DAO_COMMON_DAO_TYPES_H_ */
public:
struct Param
{
- Param(const DPL::String& name) : name(name)
+ Param(const DPL::String& _name) : name(_name)
{
}
DPL::String name;
struct Feature
{
- Feature(const DPL::String& name,
- bool required = true) : name(name),
- required(required)
+ Feature(const DPL::String& _name,
+ bool _required = true) : name(_name),
+ required(_required)
{
}
DPL::String name;
};
typedef std::set<Feature> FeaturesList;
+ struct Privilege
+ {
+ Privilege(const DPL::String& _name) : name(_name)
+ {
+ }
+ DPL::String name;
+
+ bool operator==(const Privilege&) const;
+ bool operator!=(const Privilege&) const;
+ bool operator >(const Privilege&) const;
+ bool operator>=(const Privilege&) const;
+ bool operator <(const Privilege&) const;
+ bool operator<=(const Privilege&) const;
+ };
+ typedef std::set<Privilege> PrivilegeList;
+
struct Icon
{
- Icon(const DPL::String& src) : src(src)
+ Icon(const DPL::String& _src) : src(_src)
{
}
DPL::String src;
struct Preference
{
- Preference(const DPL::String& name,
- bool readonly = false) :
- name(name),
+ Preference(const DPL::String& _name,
+ bool _readonly = false) :
+ name(_name),
value(),
- readonly(readonly)
+ readonly(_readonly)
{
}
DPL::String name;
typedef std::set<Setting> SettingsList;
+ /* ServiceInfo will be removed.
+ * ServiceInfo will be changed AppControl
+ */
struct ServiceInfo
{
ServiceInfo(
bool operator==(const ServiceInfo&) const;
bool operator!=(const ServiceInfo&) const;
};
- typedef std::list<ServiceInfo> ServiceInfoList;
+
+ struct AppControlInfo
+ {
+ AppControlInfo(
+ const DPL::String& operation) :
+ m_operation(operation)
+ {
+ }
+ DPL::String m_src;
+ DPL::String m_operation;
+ std::set <DPL::String> m_uriList;
+ std::set <DPL::String> m_mimeList;
+
+ bool operator==(const AppControlInfo&) const;
+ bool operator!=(const AppControlInfo&) const;
+ };
+
+ typedef std::list<ServiceInfo> ServiceInfoList; // It will be removed.
+ typedef std::list<AppControlInfo> AppControlInfoList;
+
+ typedef std::list<std::pair<DPL::String, DPL::String>> BoxSizeList;
+
+ struct LiveboxInfo
+ {
+ LiveboxInfo() { }
+
+ struct BoxContent
+ {
+ DPL::String m_boxSrc;
+ BoxSizeList m_boxSize ;
+ DPL::String m_pdSrc;
+ DPL::String m_pdWidth;
+ DPL::String m_pdHeight;
+ }; typedef BoxContent BoxContentInfo;
+
+ DPL::String m_label;
+ DPL::String m_icon;
+ DPL::String m_liveboxId;
+ DPL::String m_primary;
+ DPL::String m_autoLaunch;
+ DPL::String m_updatePeriod;
+ BoxContentInfo m_boxInfo;
+
+ bool operator==(const LiveboxInfo&) const;
+ bool operator!=(const LiveboxInfo&) const;
+ bool operator >(const LiveboxInfo&) const;
+ bool operator>=(const LiveboxInfo&) const;
+ bool operator <(const LiveboxInfo&) const;
+ bool operator<=(const LiveboxInfo&) const;
+ };
+ typedef std::list<DPL::Optional<LiveboxInfo>> LiveboxList;
+ LiveboxList m_livebox;
+
+ typedef std::list<DPL::OptionalString> DependsPkgList;
+
+ typedef std::set<DPL::String> CategoryList;
StringsList nameSpaces;
DPL::OptionalString authorEmail;
FeaturesList featuresList;
+ PrivilegeList privilegeList;
SettingsList settingsList;
bool flashNeeded;
- DPL::OptionalFloat minVersionRequired;
- DPL::OptionalInt minVersionRequiredFound;
- StringsList powderDescriptionLinks;
+ DPL::OptionalString minVersionRequired;
bool backSupported;
bool accessNetwork;
DPL::OptionalString startFileContentType;
IconsList iconsList;
- // pakcage name determined by operator for TIZEN webapp
- DPL::OptionalString pkgname;
+ // tizen id / required platform min version for TIZEN webapp
+ DPL::OptionalString tizenId;
+ DPL::OptionalString tizenMinVersionRequired;
+
//Application service model list
- ServiceInfoList appServiceList;
+ ServiceInfoList appServiceList; //It will be removed.
+ AppControlInfoList appControlList;
+
+ // For link shared directory
+ DependsPkgList dependsPkgList;
+ // Splash image path
+ DPL::OptionalString splashImgSrc;
+ // Background page filename
+ DPL::OptionalString backgroundPage;
+ // For category
+ CategoryList categoryList;
ConfigParserData() :
flashNeeded(false),
- minVersionRequired(1.0),
- minVersionRequiredFound(),
+ minVersionRequired(),
backSupported(false),
accessNetwork(false),
startFileEncountered(false)
};
typedef std::set<std::string> DeviceCapabilitiesList;
+ typedef std::multimap<FeatureHandle, std::string> DeviceCapabilitiesMap;
+ typedef std::map<FeatureHandle, std::string> NameMap;
+ typedef std::map<FeatureHandle, FeatureData> FeatureMap;
static bool isDeviceCapabilityInstalled(const std::string &deviceCapName);
static FeatureHandleList GetHandleList();
std::string GetName() const;
- std::string GetInstallURI() const;
- std::string GetKeyCn() const;
- std::string GetRootKey() const;
- std::string GetRootKeyFingerprint() const;
FeatureHandle GetFeatureHandle() const;
std::string GetLibraryPath() const;
std::string GetLibraryName() const;
DeviceCapabilitiesList GetDeviceCapabilities() const;
DbPluginHandle GetPluginHandle() const;
+ static NameMap GetNames();
+ static DeviceCapabilitiesMap GetDevCapWithFeatureHandle();
+
+ static FeatureMap GetFeatures(const std::list<std::string>& featureNames);
+
protected:
FeatureHandle m_featureHandle;
};
#include <dpl/event/model.h>
#include <dpl/event/property.h>
-#include <dpl/shared_ptr.h>
+#include <memory>
#include <string>
#include <list>
#include <set>
typedef int FeatureHandle;
typedef std::list<FeatureHandle> FeatureHandleList;
-typedef DPL::SharedPtr<FeatureHandleList> FeatureHandleListPtr;
+typedef std::shared_ptr<FeatureHandleList> FeatureHandleListPtr;
typedef int FeatureSetHandle;
typedef std::list<FeatureSetHandle> FeatureSetHandleList;
+typedef struct {
+ std::string featureName;
+ DbPluginHandle pluginHandle;
+} FeatureData;
+
class FeatureModel : public DPL::Event::Model
{
public:
PHandle(this, -1)
{
}
+
+ void SetData(const std::string& name, const std::set<std::string>& deviceCapabilities, const DbPluginHandle& pluginHandle)
+ {
+ Name.SetWithoutLock(name);
+ DeviceCapabilities.SetWithoutLock(deviceCapabilities);
+ PHandle.SetWithoutLock(pluginHandle);
+ }
};
-typedef DPL::SharedPtr<FeatureModel> FeatureModelPtr;
+typedef std::shared_ptr<FeatureModel> FeatureModelPtr;
} // namespace WrtDB
}
/**
- * WRT factory widgets that are loaded by default
+ * WRT widgets that are downloaded and installed by user
+ */
+inline const char* GetUserInstalledWidgetPath()
+{
+ return "/opt/usr/apps";
+}
+
+/**
+ * WRT widgets that are preloaded
*/
-inline const char* GetFactoryInstalledWidgetPath()
+inline const char* GetUserPreloadedWidgetPath()
{
- return "/opt/apps/widget/system";
+ return "/usr/apps";
}
/**
* WRT widgets that are downloaded and installed by user
*/
-inline const char* GetUserInstalledWidgetPath()
+inline const char* GetWidgetUserDataPath()
{
- return "/opt/apps";
+ return "/opt/usr/apps";
}
/**
*/
inline const char* GetWidgetSrcPath()
{
- return "res/src";
+ return "/res/wgt";
}
/**
*/
inline const char* GetPublicVirtualRootPath()
{
- return "/opt/apps/widget/data/Public";
+ return "/opt/share/widget/data/Public";
}
/**
*/
inline const char* GetTestsDataPath()
{
- return "/opt/apps/widget/tests";
+ return "/opt/share/widget/tests";
}
/**
*/
inline const char* GetUserWidgetExecPath()
{
- return "bin";
+ return "/bin";
}
/**
return "data";
}
+/**
+ * widgets share directory path
+ */
+inline const char* GetWidgetSharePath()
+{
+ return "share";
+}
/**
* widgets desktop files path
*/
inline const char* GetUserWidgetDesktopIconPath()
{
- return "res/icons/default/small";
+ return "/opt/share/icons/default/small";
}
/**
return "/usr/share/wrt-engine/wrt_widget_default_icon.png";
}
-/**
- * WRT downloaded widgets
- */
-// KW inline const char* GetDownloadedWidgetPath()
-// KW {
-// KW return "/opt/apps/widget/test-widgets";
-// KW }
-
inline const char* GetSignatureXmlSchema()
{
//TODO please rename, this filename is not descriptive enough
}
/**
+ * Plugin .so prefix
+ */
+inline const char* GetPluginPrefix()
+{
+ return "libwrt-plugins-";
+}
+
+/**
+ * Plugin .so suffix
+ */
+inline const char* GetPluginSuffix()
+{
+ return ".so";
+}
+
+/**
* WRT device plugins installation required
* File which indicate that new plugins
* are available and should be installed
*/
inline const char* GetPluginInstallInitializerName()
{
- return "/opt/apps/widget/plugin-installation-required";
+ return "/opt/share/widget/plugin-installation-required";
}
/**
inline const char* GetVCoreDatabaseFilePath()
{
- return "/opt/dbspace/.vcore.db";
+ return "/opt/dbspace/.cert_svc_vcore.db";
}
-bool IsOCSPEnabled();
-bool IsCRLEnabled();
/**
* widgets cookie database file name
{
return "/tmp";
}
+
+inline const char* GetWACVersion()
+{
+ return "2.0";
+}
+
+inline const char* GetTizenVersion()
+{
+ return "1.0";
+}
+
+inline const char* GetShareDirectoryPath()
+{
+ return "/opt/share";
+}
+
+inline const char* GetTempInstallInfoPath()
+{
+ return "/opt/share/widget/temp_info";
+}
+
+inline const char* GetVconfKeyPrefixPath()
+{
+ return "file/private";
+}
+
+inline const char* GetVconfKeyPopupUsagePath()
+{
+ return "/popup_usage";
+}
+
+inline const char* GetVconfKeyGeolocationUsagePath()
+{
+ return "/geolocation_usage";
+}
+
+inline const char* GetVconfKeyWebNotificationUsagePath()
+{
+ return "/web_notification_usage";
+}
+
+inline const char* GetVconfKeyWebDatabaseUsagePath()
+{
+ return "/web_database_usage";
+}
+
+inline const char* GetVconfKeyFilesystemUsagePath()
+{
+ return "/filesystem_usage";
+}
+
+inline const char* GetVconfKeyMemorySavingModePath()
+{
+ return "/memory_saving_mode";
+}
+
} // namespace GlobalConfig
} // namespace WrtDB
};
public:
- /**
- * Retrieve Parental mode status
- *
- * @return true for Parental Mode on, false for Parental Mode off
- */
- static bool GetParentalMode();
-
- /**
- * Retrieve Parental mode maximal allowed age
- *
- * @return NULL if allowed age not set, else pointer value is allowed age
- */
- static DPL::OptionalInt GetParentalAllowedAge();
- /**
- * Retrieve Parental mode maximal allowed age
- *
- * @return NULL if allowed age not set, else pointer value is allowed age
- */
static bool IsValidSubTag(const DPL::String& tag, int type);
- static bool IsPowderRulePresent(
- const ChildProtection::PowderRules::CategoryRule& rule);
-
- static ChildProtection::PowderRules GetPowderRules();
-
- static ChildProtection::BlackList GetAdultBlackList();
-
- static bool IsElementOnAdultBlackList(const DPL::String &url);
-
- /**
- * Retrieve list of deffered widget packages to be installed
- *
- * @return Widget package list
- */
- static WidgetPackageList GetDefferedWidgetPackageInstallationList();
-
static bool GetDeveloperMode();
static bool GetSecureByDefault();
static WidgetAccessInfoList GetWhiteURIList();
+ static bool GetCookieSharingMode();
+
enum NetworkAccessMode
{
NEVER_CONNECT,
static DeviceCapabilitySet GetDeviceCapability(
const DPL::String &apifeature);
-
- /**
- * This method gets Autofill for Webkit
- */
- struct AutoSaveData
- {
- DPL::String userId;
- DPL::String passwd;
- };
-
- static DPL::Optional<AutoSaveData> GetAutoSaveIdPasswd(
- const DPL::String &url);
-
protected:
GlobalDAOReadOnly()
{
#include <string>
#include <list>
+#include <memory>
#include <dpl/exception.h>
-#include <dpl/shared_ptr.h>
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
typedef std::list<DbPluginHandle> PluginHandleList;
typedef std::set<DbPluginHandle> PluginHandleSet;
typedef std::list<std::string> ImplementedObjectsList;
-typedef
DPL::SharedPtr<PluginHandleSet> PluginHandleSetPtr;
+typedef
std::shared_ptr<PluginHandleSet> PluginHandleSetPtr;
//TODO make it friend to FeatureDAO or inherit
class PluginDAOReadOnly
PluginInstallationState getInstallationStatus() const;
std::string getLibraryPath() const;
std::string getLibraryName() const;
- std::string getInstallURI() const;
- std::string getKeyCn() const;
- std::string getRootKey() const;
- std::string getRootKeyFingerprint() const;
PluginHandleSetPtr getLibraryDependencies() const;
private:
typedef std::list<WidgetPropertyKey> WidgetPropertyKeyList;
struct WidgetPreferenceRow {
- int app_id;
+ WidgetPkgName pkgname;
WidgetPropertyKey key_name;
WidgetPropertyValue key_value;
DPL::OptionalInt readonly;
DECLARE_EXCEPTION_TYPE(Base, ReadOnlyProperty)
};
+//deprecated
/* This method checks read only flag for given property
*/
DPL::OptionalInt CheckPropertyReadFlag(DbWidgetHandle widgetHandle,
+ const WidgetPropertyKey &key)
+ __attribute__((deprecated));
+
+/* This method checks read only flag for given property
+ */
+DPL::OptionalInt CheckPropertyReadFlag(WidgetPkgName pkgName,
const WidgetPropertyKey &key);
+//deprecated
/* This method gets widget property key list
*/
-WidgetPropertyKeyList GetPropertyKeyList(DbWidgetHandle widgetHandle);
+WidgetPropertyKeyList GetPropertyKeyList(DbWidgetHandle widgetHandle)
+ __attribute__((deprecated));
+/* This method gets widget property key list
+ */
+WidgetPropertyKeyList GetPropertyKeyList(WidgetPkgName pkgName);
+
+//deprecated
/* This method gets widget property list
*/
-WidgetPreferenceList GetPropertyList(DbWidgetHandle widgetHandle);
+WidgetPreferenceList GetPropertyList(DbWidgetHandle widgetHandle)
+ __attribute__((deprecated));
+/* This method gets widget property list
+ */
+WidgetPreferenceList GetPropertyList(WidgetPkgName pkgName);
+
+//deprecated
/* This method get widget property value
*/
WidgetPropertyValue GetPropertyValue(DbWidgetHandle widgetHandle,
const WidgetPropertyKey &key);
+/* This method get widget property value
+ */
+WidgetPropertyValue GetPropertyValue(WidgetPkgName pkgName,
+ const WidgetPropertyKey &key);
+
} // PropertyDAOReadOnly
} // namespace WrtDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file vconf_config.h
+ * @author Jihoon Chung (jihoon.chung@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for vconf key config.
+ */
+#ifndef SRC_DOMAIN_VCONF_CONFIG_H
+#define SRC_DOMAIN_VCONF_CONFIG_H
+
+#include <string>
+#include <dpl/string.h>
+
+#include <dpl/wrt-dao-ro/global_config.h>
+#include <dpl/wrt-dao-ro/path_builder.h>
+
+namespace WrtDB {
+namespace VconfConfig {
+inline std::string GetVconfKeyRootPath(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyPopupUsage(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyPopupUsagePath())
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyGeolocationUsage(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyGeolocationUsagePath())
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyWebNotificationUsage(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyWebNotificationUsagePath())
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyWebDatabaseUsage(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyWebDatabaseUsagePath())
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyFilesystemUsage(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyFilesystemUsagePath())
+ .GetFullPath();
+}
+
+inline std::string GetVconfKeyMemorySavingMode(DPL::String pkgName)
+{
+ return PathBuilder()
+ .Append(GlobalConfig::GetVconfKeyPrefixPath())
+ .Append(DPL::ToUTF8String(pkgName))
+ .Concat(GlobalConfig::GetVconfKeyMemorySavingModePath())
+ .GetFullPath();
+}
+
+} // namespace VconfConfig
+} // namespace WrtDB
+
+#endif
inline std::string GetWidgetBasePath(DPL::String pkgName)
{
return PathBuilder()
- .Append(GlobalConfig::GetUserInstalledWidgetPath())
+ .Append(GlobalConfig::GetWidgetUserDataPath())
.Append(DPL::ToUTF8String(pkgName))
.GetFullPath();
}
SIGNATURE_TYPE_UNIDENTIFIED
};
+enum CertificateSource {
+ SIGNATURE_DISTRIBUTOR = 0,
+ SIGNATURE_AUTHOR = 1
+};
+
typedef std::list<DPL::String> StringList;
struct WidgetLocalizedInfo
typedef DPL::String Locale;
typedef std::set<Locale> LocaleSet;
+typedef std::list<std::string> ExternalLocationList;
/**
* WidgetRegisterInfo
//Constructor
WidgetRegisterInfo() :
- type(APP_TYPE_UNKNOWN),
+ webAppType(APP_TYPE_UNKNOWN),
signatureType(SIGNATURE_TYPE_UNIDENTIFIED),
- isFactoryWidget(0),
isTestWidget(0),
- configInfo()
+ configInfo(),
+ packagingType(PKG_TYPE_UNKNOWN)
{
}
- WidgetType type;
+ WidgetType webAppType;
+ WidgetType type; // TODO : This type will be removed.
DPL::OptionalString guid;
DPL::OptionalString version;
+ DPL::OptionalString minVersion;
std::string shareHref;
std::string baseFolder;
WidgetSignatureType signatureType;
- int isFactoryWidget;
int isTestWidget;
ConfigParserData configInfo;
- Powder::Description powderDescription;
LocalizationData localizationData;
+
DPL::OptionalString pkgname;
+ WidgetPkgName pkgName;
+
time_t installedTime;
+ PackagingType packagingType;
+ EncryptedFileList encryptedFiles;
+ ExternalLocationList externalLocations;
+ DPL::OptionalString widgetInstalledPath;
};
typedef std::list<std::string> CertificateChainList;
virtual bool isWacSigned() const = 0;
- virtual void getCertificateChainList(CertificateChainList& list) const = 0;
+ virtual void getCertificateChainList(CertificateChainList& list,
+ CertificateSource source) const = 0;
};
/**
};
typedef std::list<WidgetLocalizedStartFileRow> LocalizedStartFileList;
-
/**
* This is a constructor.
*
* @param[in] widgetHandle application id of widget.
*/
WidgetDAOReadOnly(DbWidgetHandle widgetHandle);
+ WidgetDAOReadOnly(DPL::OptionalString widgetGUID);
+ WidgetDAOReadOnly(DPL::String pkgName);
/**
* Destructor
static DbWidgetHandle getHandle(const DPL::String pkgName);
/**
+ * Returns pkgname for the specified widget
+ *
+ * @return pkgname
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
+ */
+ WidgetPkgName getPkgName() const;
+ static WidgetPkgName getPkgName(const WidgetGUID GUID);
+ static WidgetPkgName getPkgName(const DbWidgetHandle handle);
+
+ /**
* This method returns the root directory of widget resource.
*
* @return path name of root directory.
*/
WidgetGUID getGUID() const;
+
/**
- * This method returns the Package name of the widget.
- *
- * @return pkgname
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
- */
+ * This method returns the Package name of the widget.
+ *
+ * @return pkgname
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
+ */
DPL::OptionalString getPkgname() const;
/**
bool getWebkitPluginsRequired() const;
/**
- * This method returns a list of all the installed widgets.
+ * This method returns a list of all the installed widgets' app id.
*
* @return list of installed widgets' app id.
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
*/
static DbWidgetHandleList getHandleList();
+ /**
+ * This method returns list of pkgname of installed packages
+ * @return list of pkgname of installed packages
+ */
+ static WidgetPkgNameList getPkgnameList();
+ static WidgetPkgNameList_TEMPORARY_API getPkgnameList_TEMPORARY_API();
+
+ /**
+ * This method returns a list of all the installed widgets.
+ *
+ * @return list of installed widgets.
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ static DbWidgetDAOReadOnlyList getWidgetList();
+
/**
* This method removes a widget's information from EmDB.
*
std::string getShareHref() const;
/**
- * This method checks whether specified widget is a factory widget.
- *
- * @param[in] widgetHandle widget's app id
- * @return true if yes, false if no.
- */
- bool isFactory() const;
-
- /**
* This method get widget installed time
*
* @return time_t : return widget's install time
*/
std::string getBaseFolder() const;
- /**
- * This method gets deletable property of widget.
- *
- * @return true: can be deleted; false: can not be deleted
- * @exception WRT_CONF_ERR_GCONF_FAILURE
- * @exception WRT_CONF_ERR_EMDB_FAILURE
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD
- */
- bool isDeletable() const;
-
/* This method gets the parameter list for resource.
*/
ResourceAttributeList getResourceAttribute(
LanguageTagList getLanguageTags() const;
LanguageTagList getIconLanguageTags() const;
+
+
WidgetLocalizedInfo getLocalizedInfo(const DPL::String& languageTag) const;
std::string getCookieDatabasePath() const;
// Local storage
std::string getPrivateLocalStoragePath() const;
- ChildProtection::Record getChildProtection() const;
-
- Powder::Description getPowderDescription() const;
-
bool getBackSupported() const;
static bool isWidgetInstalled(DbWidgetHandle handle);
- static bool isWidgetInstalled(DPL::String pkgName);
+ static bool isWidgetInstalled(const WidgetPkgName & pkgName);
- CertificateChainList getWidgetCertificate() const;
+ /* This method get path of the splash image.
+ *
+ * @return path of the widget's splash image
+ */
+ DPL::OptionalString getSplashImgSrc() const;
+
+ ExternalLocationList getWidgetExternalLocations() const;
+
+ /*
+ * Default value is required to keep compatibility with
+ * wrt-installer and wrt.
+ */
+ CertificateChainList getWidgetCertificate(
+ CertificateSource source = SIGNATURE_DISTRIBUTOR) const;
void getWidgetSettings(WidgetSettings& outWidgetSettings) const;
*/
void getAppServiceList(
WidgetApplicationServiceList& outAppServiceList) const;
+
+ /**
+ * This method returns the type of the package.
+ *
+ * @return PackagingType
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching
+ records in DB table.
+ */
+ PackagingType getPackagingType() const;
+
+ void getEncryptedFileList(EncryptedFileList& filesList) const;
+
+ /**
+ * This method returns widget's background page filename.
+ *
+ * @return Name of file containing background page
+ */
+ DPL::OptionalString getBackgroundPage() const;
+
+ /**
+ * @brief generateTizenId generates new tizen id
+ *
+ * If widget do not supplies it's own tizen id, this method can be used,
+ * although it should be removed in future.
+ *
+ * @return new tizen id
+ */
+ static WidgetPkgName generateTizenId();
+
+ /**
+ * @brief This method return each value for security setting
+ *
+ * @return SettingsType
+ * SETTINGS_TYPE_UNKNOWN : unknow value
+ * SETTINGS_TYPE_ON : enable
+ * SETTINGS_TYPE_ALWAYS_ASK : ask by popup
+ * SETTINGS_TYPE_OFF : disable
+ */
+ SettingsType getSecurityPopupUsage() const;
+ SettingsType getGeolocationUsage() const;
+ SettingsType getWebNotificationUsage() const;
+ SettingsType getWebDatabaseUsage() const;
+ SettingsType getFileSystemUsage() const;
+
+ /**
+ * This method returns widget's installed path
+ *
+ * @return path of widget installed
+ */
+ DPL::OptionalString getWidgetInstalledPath() const;
};
} // namespace WrtDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file wrt_db_types.h
+ * @author Krzysztof Jackiewicz
+ * @version 1.0
+ * @brief This file contains the declaration of common data types for wrtdb
+ */
+#ifndef _WRT_DB_TYPES_H_
+#define _WRT_DB_TYPES_H_
+
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+
+typedef WrtDB::DbWidgetHandle WidgetHandle;
+typedef WrtDB::DbWidgetHandleList WidgetHandleList;
+typedef WrtDB::DbWidgetDAOReadOnlyList WidgetDAOReadOnlyList;
+
+typedef WrtDB::DbWidgetFeature WidgetFeature;
+typedef WrtDB::DbWidgetFeatureSet WidgetFeatureSet;
+
+typedef WrtDB::DbWidgetSize WidgetSize;
+typedef WrtDB::DbPluginHandle PluginHandle;
+
+#endif
namespace FeatureDAO {
FeatureHandle RegisterFeature(const PluginMetafileData::Feature &feature,
const DbPluginHandle pluginHandle);
-
- FeatureHandle RegisterStrangeFeature(const std::string& featureName);
+ void UnregisterFeature(FeatureHandle featureHandle);
} // namespace FeatureDB
} // namespace WrtDB
class GlobalDAO : public GlobalDAOReadOnly
{
public:
- /**
- * Set new Parental mode status
- */
- static void SetParentalMode(bool parental_status);
-
- /**
- * Retrieve Parental mode maximal allowed age
- *
- * @return NULL if allowed age not set, else pointer value is allowed age
- */
- static void SetParentalAllowedAge(const DPL::OptionalInt& age);
-
- static void AddCategoryRule(
- const ChildProtection::PowderRules::CategoryRule& powder);
-
- static void RemoveCategoryRule(
- const ChildProtection::PowderRules::CategoryRule& powder);
-
- static void UpdateCategoryRule(
- const ChildProtection::PowderRules::CategoryRule& oldRule,
- const ChildProtection::PowderRules::CategoryRule& newRule);
-
- static void AddAdultBlackListElement(const DPL::String &url);
-
- static void RemoveAdultBlackListElement(const DPL::String &url);
-
- static void UpdateAdultBlackList(const DPL::String &oldUrl,
- const DPL::String &newUrl);
-
- /**
- * Add deffered widget packages to be installed
- */
- static void AddDefferedWidgetPackageInstallation(const DPL::String &path);
-
- /**
- * Remove deffered widget packages to be installed
- */
- static void RemoveDefferedWidgetPackageInstallation(const DPL::String &arg);
-
static void SetDeveloperMode(bool mode);
static void SetSecureByDefault(bool secureByDefault);
*/
static void SetRoamingDataUsage(NetworkAccessMode newMode);
- /**
- * This method sets Autofill for Webkit
- */
- static void SetAutoSaveIdPasswd(
- const DPL::String &url, const AutoSaveData &saveData);
-
+ static void SetCookieSharingMode(bool mode);
private:
GlobalDAO()
static void setPluginInstallationStatus(
DbPluginHandle,
PluginInstallationState);
+
+ static void unregisterPlugin(DbPluginHandle pluginHandle);
};
} // namespace WrtDB
namespace PropertyDAO {
+//deprecated
void RemoveProperty(DbWidgetHandle widgetHandle,
+ const PropertyDAOReadOnly::WidgetPropertyKey &key)
+ __attribute__((deprecated));
+
+void RemoveProperty(WidgetPkgName pkgName,
const PropertyDAOReadOnly::WidgetPropertyKey &key);
+//deprecated
/* This method sets widget property
*/
void SetProperty(DbWidgetHandle widgetHandle,
const PropertyDAOReadOnly::WidgetPropertyKey &key,
const PropertyDAOReadOnly::WidgetPropertyValue &value,
+ bool readOnly = false)
+ __attribute__((deprecated));
+
+/* This method sets widget property
+ */
+void SetProperty(WidgetPkgName pkgName,
+ const PropertyDAOReadOnly::WidgetPropertyKey &key,
+ const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly = false);
+//deprecated
/* This method registers properties for widget.
* Properties unregistering is done via "delete cascade" mechanism in SQL
*/
void RegisterProperties(DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info)
+ __attribute__((deprecated));
+
+/* This method registers properties for widget.
+ * Properties unregistering is done via "delete cascade" mechanism in SQL
+ */
+void RegisterProperties(WidgetPkgName pkgName,
const WidgetRegisterInfo ®Info);
} // namespace PropertyDAO
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <list>
#include <string>
+#include <sys/time.h>
+#include <ctime>
+#include <cstdlib>
#include <dpl/exception.h>
#include <dpl/db/orm.h>
#include <dpl/wrt-dao-ro/config_parser_data.h>
public:
typedef std::list<DPL::String> LanguageTagsList;
- /**
- * This is a constructor.
- *
- * @param[in] widgetHandle application id of widget.
- * @param[in] widgetGUID application guid of widget.
- */
- WidgetDAO(DbWidgetHandle widgetHandle);
+ WidgetDAO(DbWidgetHandle handle);
WidgetDAO(DPL::OptionalString widgetGUID);
+ WidgetDAO(DPL::String pkgName);
/**
* Destructor
virtual ~WidgetDAO();
/**
- * This method registers the widget information to the DB when it is installed.
+ * This method registers the widget information in the DB when it is installed.
*
* @see WidgetRegisterInfo
* @see UnRegisterWidget()
+ * @param[in] widgetPkgname Widget Pkgname that will be registered.
* @param[in] pWidgetRegisterInfo Specified the widget's information needed to be registered.
- * @return widget's app id issued by app manager; 0 represents a failure during register.
+ * @param[in] wacSecurity Widget's security certificates.
*/
+ static void registerWidget(
+ const WidgetPkgName & widgetPkgname,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity);
+
static DbWidgetHandle registerWidget(
- const WidgetRegisterInfo &pWidgetRegisterInfo,
- const IWacSecurity &wacSecurity,
- const LanguageTagsList& languageTags);
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity) __attribute__((deprecated));
+
+ /**
+ * @brief registerWidgetGenerateTizenId Registers widget with auto-generated tizen id
+ *
+ * This function is disadviced and should be used only in tests.
+ * Function is not thread-safe.
+ *
+ * @param pWidgetRegisterInfo registeration information
+ * @param wacSecurity Widget's security certificates.
+ * @return pkgname generated
+ */
+ static WidgetPkgName registerWidgetGenerateTizenId(
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity);
+
+ /**
+ * This method re-registers the widget information to the DB when it is installed.
+ *
+ * It performs unregistration and new registration of widget in db in one transaction.
+ *
+ * @see WidgetRegisterInfo
+ * @param[in] widgetName Widget pkgname that will be registered.
+ * @param[in] pWidgetRegisterInfo Specified the widget's information needed to be registered.
+ * @param[in] wacSecurity Widget's security certificates.
+ */
+ static void registerOrUpdateWidget(
+ const WidgetPkgName & widgetName,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity);
+
+ static void registerWidget(
+ WrtDB::DbWidgetHandle handle,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity) __attribute__((deprecated));
/**
* This method removes a widget's information from EmDB.
*
* @see RegisterWidget()
- * @param[in] widgetHandle widget's app id
- * @return true if succeed, false if fail.
+ * @param[in] pkgName widgets name to be unregistered
*/
- static void unregisterWidget(DbWidgetHandle widgetHandle);
+ static void unregisterWidget(const WidgetPkgName & pkgName);
+
+ static void unregisterWidget(WrtDB::DbWidgetHandle handle) __attribute__((deprecated));
/* This method removes widget property
*/
void removeProperty(const PropertyDAOReadOnly::WidgetPropertyKey &key);
+ /**
+ * @brief registerExternalLocations Removes rows from WidgetExternalLocations
+ */
+ void unregisterAllExternalLocations();
+
/* This method sets widget property
*/
void setProperty(const PropertyDAOReadOnly::WidgetPropertyKey &key,
/* set PkgName
*/
void setPkgName(const DPL::OptionalString& pkgName);
+ void setPkgName_TEMPORARY_API(const WidgetPkgName& pkgName);
+
+ /* This function will update of api-feature status.
+ * If status is true (feature rejected) plugin connected with this
+ * api feature mustn't be loaded durign widget launch.
+ */
+ void updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature);
+
+ /*
+ * This method change security settings value
+ */
+ void setSecurityPopupUsage(const SettingsType value);
+ void setGeolocationUsage(const SettingsType value);
+ void setWebNotificationUsage(const SettingsType value);
+ void setWebDatabaseUsage(const SettingsType value);
+ void setFileSystemUsage(const SettingsType value);
private:
//Methods used during widget registering
static DbWidgetHandle registerWidgetInfo(
+ const WidgetPkgName & widgetName,
const WidgetRegisterInfo ®Info,
- const IWacSecurity &wacSecurity);
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle = DPL::Optional<DbWidgetHandle>());
static void registerWidgetExtendedInfo(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
static void registerWidgetLocalizedInfo(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
- static void registerWidgetUserAgentLocales(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo &rInf,
- const LanguageTagsList& languageTags);
static void registerWidgetIcons(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
static void registerWidgetFeatures(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
+ static void registerWidgetPrivilege(
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetWindowModes(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
static void registerWidgetCertificates(
DbWidgetHandle widgetHandle,
const IWacSecurity &wacSecurity);
- static void registerWidgetPowderData(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
- static void registerLaunchCertificates(
+ static void registerCertificatesChains(
DbWidgetHandle widgetHandle,
+ CertificateSource certificateSource,
const CertificateChainList &list);
static void registerWidgetSettings(
DbWidgetHandle widgetHandle,
static void registerAppService(
DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info);
+ static void registerEncryptedResouceInfo(
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
+ /**
+ * @brief registerExternalLocations Inserts new rows to WidgetExternalLocations
+ * @param externals list of files
+ */
+ static void registerExternalLocations(DbWidgetHandle widgetHandle,
+ const ExternalLocationList & externals);
+ static void registerWidgetSecuritySettings(DbWidgetHandle widgetHandle);
+
+
+ static void registerWidgetInternal(
+ const WidgetPkgName & widgetName,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle = DPL::Optional<DbWidgetHandle>());
+ static void unregisterWidgetInternal(
+ const WidgetPkgName & pkgName);
};
} // namespace WrtDB
/*TODO: secure_by_default should be 0 by default*/
CREATE_TABLE(GlobalProperties)
COLUMN_NOT_NULL(developer_mode, INT, DEFAULT 0)
- COLUMN_NOT_NULL(parental_mode, INT, DEFAULT 0)
- COLUMN(parental_allowed_age, INT, DEFAULT NULL)
COLUMN_NOT_NULL(secure_by_default, INT, DEFAULT 1)
COLUMN_NOT_NULL(home_network_data_usage, TINYINT, DEFAULT 1)
COLUMN_NOT_NULL(roaming_data_usage, TINYINT, DEFAULT 1)
COLUMN_NOT_NULL(compliance_mode, TINYINT, DEFAULT 0)
COLUMN_NOT_NULL(compliance_fake_imei, VARCHAR(256), DEFAULT '')
COLUMN_NOT_NULL(compliance_fake_meid, VARCHAR(256), DEFAULT '')
+ COLUMN_NOT_NULL(cookie_sharing_mode, INT, DEFAULT 0)
CREATE_TABLE_END()
SQL(
COLUMN(base_folder, VARCHAR(256), DEFAULT '')
COLUMN(webkit_plugins_required, TINYINT, DEFAULT 0)
COLUMN(security_domain, INT, DEFAULT 0)
- COLUMN_NOT_NULL(child_protection,INT, DEFAULT 0)
COLUMN(recognized, INT, DEFAULT 0)
COLUMN(wac_signed, INT, DEFAULT 0)
COLUMN(distributor_signed, INT, DEFAULT 0)
COLUMN_NOT_NULL(back_supported, TINYINT, DEFAULT 0)
COLUMN(access_network, TINYINT, DEFAULT 0)
COLUMN(defaultlocale, VARCHAR(256), DEFAULT 0)
- COLUMN(pkgname, VARCHAR(256), DEFAULT 0)
+ COLUMN_NOT_NULL(pkgname, VARCHAR(256), DEFAULT 0 UNIQUE)
+ COLUMN(pkg_type, INT, DEFAULT 0)
CREATE_TABLE_END()
+SQL(
+ CREATE INDEX IF NOT EXISTS WidgetInfo_PkgnameIndex ON WidgetInfo(pkgname);
+)
+
CREATE_TABLE(WidgetCertificate)
COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(cert_source, INT, CHECK(cert_source between 0 and 1))
COLUMN_NOT_NULL(encoded_chain, VARCHAR(16000),)
TABLE_CONSTRAINTS(
FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE_END()
-CREATE_TABLE(WidgetUserAgentLocales)
- COLUMN_NOT_NULL(id, INTEGER, PRIMARY KEY AUTOINCREMENT)
- COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(language_tag, TEXT,)
- TABLE_CONSTRAINTS(
- FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
- )
-CREATE_TABLE_END()
-
CREATE_TABLE(LocalizedWidgetInfo)
COLUMN_NOT_NULL(app_id, INT,)
COLUMN_NOT_NULL(widget_locale, TEXT,)
COLUMN(option_state, INT, DEFAULT 0)
COLUMN(share_href, VARCHAR(256), DEFAULT '')
COLUMN(signature_type, INT, DEFAULT 0)
- COLUMN(factory_widget, INT, DEFAULT 0)
COLUMN(updated, INT, DEFAULT 0)
COLUMN(update_policy, INT, DEFAULT 0)
COLUMN_NOT_NULL(test_widget, INT, CHECK(test_widget between 0 and 1) DEFAULT 0)
+ COLUMN(splash_img_src, VARCHAR(256), DEFAULT '')
+ COLUMN(background_page, VARCHAR(256), DEFAULT '')
+ COLUMN(installed_path, VARCHAR(512), DEFAULT '')
TABLE_CONSTRAINTS(
FOREIGN KEY(app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE_END()
CREATE_TABLE(WidgetPreference)
- COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(pkgname, VARCHAR(256), DEFAULT 0)
COLUMN_NOT_NULL(key_name, VARCHAR(256),)
COLUMN(key_value, VARCHAR(8000), DEFAULT '')
COLUMN(readonly, INT, DEFAULT 0)
TABLE_CONSTRAINTS(
- PRIMARY KEY(app_id, key_name),
- FOREIGN KEY(app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
+ PRIMARY KEY(pkgname, key_name),
+ FOREIGN KEY(pkgname) REFERENCES WidgetInfo (pkgname) ON DELETE CASCADE
)
CREATE_TABLE_END()
COLUMN_NOT_NULL(app_id, INT,)
COLUMN_NOT_NULL(name, VARCHAR(256),)
COLUMN_NOT_NULL(required, INT,)
+ COLUMN_NOT_NULL(rejected, INT,)
TABLE_CONSTRAINTS(
FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
COLUMN_NOT_NULL(widget_feature_id, INTEGER,)
COLUMN_NOT_NULL(name, TEXT,)
COLUMN_NOT_NULL(value, TEXT,)
-
TABLE_CONSTRAINTS(
FOREIGN KEY (widget_feature_id) REFERENCES WidgetFeature (widget_feature_id) ON DELETE CASCADE
)
CREATE_TABLE_END()
+CREATE_TABLE(WidgetPrivilege)
+ COLUMN_NOT_NULL(widget_privilege_id, INTEGER, primary key autoincrement)
+ COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(name, VARCHAR(256),)
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
+ )
+CREATE_TABLE_END()
+
CREATE_TABLE(WidgetIcon)
COLUMN_NOT_NULL(icon_id, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(app_id, INT,)
)
CREATE_TABLE_END()
+CREATE_TABLE(WidgetExternalLocations)
+ COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(path, TEXT,)
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY(app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE,
+ PRIMARY KEY(app_id, path)
+ )
+CREATE_TABLE_END()
+
CREATE_TABLE(WidgetAccessHost)
COLUMN_NOT_NULL(app_id, INT,)
COLUMN_NOT_NULL(host, VARCHAR(256),)
)
CREATE_TABLE_END()
+CREATE_TABLE(WidgetSecuritySettings)
+ COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(security_popup_usage, INT, DEFAULT 1)
+ COLUMN_NOT_NULL(geolocation_usage, INT, DEFAULT 1)
+ COLUMN_NOT_NULL(web_notification_usage, INT, DEFAULT 1)
+ COLUMN_NOT_NULL(web_database_usage, INT, DEFAULT 1)
+ COLUMN_NOT_NULL(file_system_usage, INT, DEFAULT 1)
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
+ )
+CREATE_TABLE_END()
+
CREATE_TABLE(FeaturesList)
COLUMN_NOT_NULL(FeatureUUID, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(FeatureName, TEXT, unique)
COLUMN_NOT_NULL(PluginPropertiesId, INT,)
+
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (PluginPropertiesId) REFERENCES PluginProperties (PluginPropertiesId) ON DELETE CASCADE
+ )
CREATE_TABLE_END()
CREATE_TABLE(PluginProperties)
COLUMN_NOT_NULL(InstallationState, INTEGER, DEFAULT 0)
COLUMN_NOT_NULL(PluginLibraryName, TEXT, unique)
COLUMN(PluginLibraryPath, TEXT,)
- COLUMN(InstallURI, TEXT,)
- COLUMN(KeyCN, TEXT,)
- COLUMN(RootKeyCN, TEXT,)
- COLUMN(RootKeyFingerprint, TEXT,)
CREATE_TABLE_END()
CREATE_TABLE(PluginDependencies)
COLUMN_NOT_NULL(PluginPropertiesId, INTEGER, not null)
COLUMN_NOT_NULL(RequiredPluginPropertiesId, INTEGER, not null)
+
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (PluginPropertiesId) REFERENCES PluginProperties (PluginPropertiesId) ON DELETE CASCADE
+ )
CREATE_TABLE_END()
CREATE_TABLE(PluginImplementedObjects)
COLUMN_NOT_NULL(PluginObject, TEXT, unique)
COLUMN_NOT_NULL(PluginPropertiesId, INTEGER, not null)
+
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (PluginPropertiesId) REFERENCES PluginProperties (PluginPropertiesId) ON DELETE CASCADE
+ )
CREATE_TABLE_END()
CREATE_TABLE(PluginRequiredObjects)
COLUMN_NOT_NULL(PluginPropertiesId, INTEGER, not null)
COLUMN_NOT_NULL(PluginObject, TEXT, not null)
+
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (PluginPropertiesId) REFERENCES PluginProperties (PluginPropertiesId) ON DELETE CASCADE
+ )
CREATE_TABLE_END()
CREATE_TABLE(DeviceCapabilities)
COLUMN_NOT_NULL(FeatureUUID, INT, not null)
COLUMN_NOT_NULL(DeviceCapID, INT, not null)
- TABLE_CONSTRAINTS(PRIMARY KEY(FeatureUUID,DeviceCapID))
-CREATE_TABLE_END()
-
-CREATE_TABLE(PowderLevels)
- COLUMN_NOT_NULL(app_id, INT, )
- COLUMN_NOT_NULL(id, INTEGER, primary key autoincrement)
- COLUMN_NOT_NULL(category, TEXT, )
- COLUMN_NOT_NULL(level, INTEGER, )
- TABLE_CONSTRAINTS(
- FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
- )
-CREATE_TABLE_END()
-
-CREATE_TABLE(PowderLevelContexts)
- COLUMN_NOT_NULL(levelId, INTEGER, )
- COLUMN_NOT_NULL(context, TEXT, )
-
TABLE_CONSTRAINTS(
- FOREIGN KEY (levelId) REFERENCES PowderLevels (id) ON DELETE CASCADE
+ FOREIGN KEY (FeatureUUID) REFERENCES FeaturesList (FeatureUUID) ON DELETE CASCADE
+ FOREIGN KEY (DeviceCapID) REFERENCES DeviceCapabilities (DeviceCapID) ON DELETE CASCADE
+ PRIMARY KEY(FeatureUUID,DeviceCapID)
)
CREATE_TABLE_END()
-CREATE_TABLE(ChildProtectionBlacklist)
- COLUMN_NOT_NULL(url, TEXT, unique)
-CREATE_TABLE_END()
-
-CREATE_TABLE(PowderRules)
- COLUMN_NOT_NULL(id, INTEGER, primary key autoincrement)
- COLUMN_NOT_NULL(category, TEXT, )
- COLUMN_NOT_NULL(level, INTEGER, )
- COLUMN(context, TEXT, )
- TABLE_CONSTRAINTS(unique(category,context))
-CREATE_TABLE_END()
-
-CREATE_TABLE(DefferedWidgetPackageInstallation)
- COLUMN_NOT_NULL(path, TEXT, unique)
-CREATE_TABLE_END()
-
CREATE_TABLE(OCSPResponseStorage)
COLUMN_NOT_NULL(cert_chain, TEXT, primary key)
COLUMN(end_entity_check, INT,)
COLUMN(next_update_time, BIGINT,)
CREATE_TABLE_END()
-CREATE_TABLE(AutoSaveIdPasswd)
- COLUMN_NOT_NULL(address, VARCHAR(256), unique)
- COLUMN_NOT_NULL(userId, VARCHAR(128),)
- COLUMN_NOT_NULL(passwd, VARCHAR(128),)
-CREATE_TABLE_END()
-
-CREATE_TABLE(SettginsList)
+CREATE_TABLE(SettingsList)
COLUMN_NOT_NULL(appId, INT,)
COLUMN_NOT_NULL(settingName, TEXT, )
COLUMN_NOT_NULL(settingValue, TEXT, )
COLUMN_NOT_NULL(subdomain_access, INT, CHECK(subdomain_access between 0 and 1))
CREATE_TABLE_END()
+CREATE_TABLE(EncryptedResourceList)
+ COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(resource, TEXT,)
+ COLUMN_NOT_NULL(size, INT,)
+
+ TABLE_CONSTRAINTS(
+ FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
+ )
+CREATE_TABLE_END()
+
SQL(
INSERT INTO WidgetWhiteURIList VALUES("http://samsung.com", 1);
INSERT INTO WidgetWhiteURIList VALUES("http://orange.fr", 1);
CREATE_TABLE_END()
SQL(
+ INSERT INTO UserAgents VALUES("Galaxy S", "Mozilla/5.0 (Linux; U; Android 2.3.7; en-gb; GT-I9000 Build/GRJ22) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
+ INSERT INTO UserAgents VALUES("Galaxy S II", "Mozilla/5.0 (Linux; U; Android 2.3.5; en-gb; GT-I9100 Build/GINGERBREAD) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
+ INSERT INTO UserAgents VALUES("Galaxy S III", "Mozilla/5.0 (Linux; U; Android 4.0.4; en-gb; GT-I9300 Build/IMM76D) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30");
+ INSERT INTO UserAgents VALUES("SLP Galaxy", "Mozilla/5.0 (Linux; U; Android 2.3.4; en-us; GT-I9500 Build/GINGERBREAD) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
INSERT INTO UserAgents VALUES("Tizen", "Mozilla/5.0 (Linux; U; Tizen 1.0; en-us) AppleWebKit/534.46 (KHTML, like Gecko) Mobile Tizen Browser/1.0");
- INSERT INTO UserAgents VALUES("Chrome 16", "Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20110706 Firefox/5.0");
+ INSERT INTO UserAgents VALUES("Galaxy Nexus", "Mozilla/5.0 (Linux; U; Android 4.0.3; en-us; Galaxy Nexus Build/IML74K) AppleWebKit/535.7 (KHTML, like Gecko) Mobile Safari/535.7");
+ INSERT INTO UserAgents VALUES("Samsung", "Mozilla/5.0 (SAMSUNG; SAMSUNG-GT-I9200/1.0; U; Linux/SLP/2.0; ko-kr) AppleWebKit/534.4 (KHTML, like Gecko) Dolfin/2.0 Mobile");
+ INSERT INTO UserAgents VALUES("Samsung Dolfin", "SAMSUNG-GT-S8500/S8500XXJD2 SHP/VPP/R5 Dolfin/2.0 Nextreaming SMM-MMS/1.2.0 profile/MIDP-2.1 configuration/CLDC-1.1");
+ INSERT INTO UserAgents VALUES("Apple iPhone 3", "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_1_3 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7E18 Safari/528.16");
+ INSERT INTO UserAgents VALUES("Apple iPhone 4", "Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_3_5 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8L1 Safari/6533.18.5");
+ INSERT INTO UserAgents VALUES("Apple iOS 5", "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A405 Safari/7534.48.3");
+ INSERT INTO UserAgents VALUES("Android 2.3 (Nexus One)", "Mozilla/5.0 (Linux; U; Android 2.3.4; en-us; Nexus One Build/GRJ22) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
+ INSERT INTO UserAgents VALUES("Opera Mobi", "Opera/9.80 (Windows NT 6.1; U; Edition IBIS; en) Presto/2.6.30 Version/10.63");
+ INSERT INTO UserAgents VALUES("Samsung Bada", "Mozilla/5.0 (SAMSUNG; SAMSUNG-GT-S8500/1.0; U; Bada/1.0; en-us) AppleWebKit/533.1 (KHTML, like Gecko) Dolfin/2.0 Mobile WVGA SMM-MMS/1.2.0 OPN-B");
+ INSERT INTO UserAgents VALUES("Orange TV 3.2 iPhone", "Mozilla/5.0 (OrangeTVPlayer4iPhone/iPhone2,1; U; CPU iPhone OS 4_3 like Mac OS X; fr) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5F136 Safari/525.20 OrangeAppliTVHTTPLS/3.2.16");
+ INSERT INTO UserAgents VALUES("Orange TV 3.2 iPad", "Mozilla/5.0 (OrangeTVPlayer4iPhone/iPad1,1; U; CPU iPhone OS 4_3 like Mac OS X; fr) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5F136 Safari/525.20 iPad=SIMENABLED OrangeAppliTVHTTPLS/3.2.16");
+ INSERT INTO UserAgents VALUES("Orange TV 3.3 iOS", "OrangeTVPlayer4iPhone/_iOS_3.3.3_Apple_iPhone2,1_4.1_OrangeAppliTVHTTPLS/3.3.3");
+ INSERT INTO UserAgents VALUES("Chrome Browser for android", "Mozilla/5.0 (Linux; U; Android 4.0.1; ko-kr; Galaxy Nexus Build/ITL41F) AppleWebKit/535.7 (KHTML, like Gecko) CrMo/16.0.912.75 Mobile Safari/535.7");
+ INSERT INTO UserAgents VALUES("MANGO(Nokia 800C)", "Mozilla/5.0 (compatible; MSIE 9.0; Windows Phone OS 7.5; Trident/5.0; IEMobile/9.0; Nokia; 800C)");
+ INSERT INTO UserAgents VALUES("Orange TV 3.2 Tizen", "Mozilla/5.0 (Linux; U; Tizen 1.0; fr-fr; GT-I8800) AppleWebKit/534.46 (KHTML, like Gecko) Mobile Tizen Browser/1.0 OrangeAppliTV/3.2.0");
+ INSERT INTO UserAgents VALUES("System user agent", "");
+ INSERT INTO UserAgents VALUES("Samsung Bada 2.0", "Mozilla/5.0 (SAMSUNG; SAMSUNG-GT-S8500/1.0; U; Bada/2.0; en-us) AppleWebKit/534.20 (KHTML, like Gecko) Mobile WVGA SMM-MMS/1.2.0 OPN-B Dolfin/3.0");
+ INSERT INTO UserAgents VALUES("Samsung Desktop", "Mozilla/5.0 (U; Linux/SLP/2.0; ko-kr) AppleWebKit/533.1 (KHTML, like Gecko)");
+ INSERT INTO UserAgents VALUES("Firefox 5", "Mozilla/5.0 (Windows NT 6.1; rv:9.0.1) Gecko/20100101 Firefox/9.0.1");
+ INSERT INTO UserAgents VALUES("Firefox 5 Fennec(Mobile)", "Mozilla/5.0 (Android; Linux armv7l; rv:5.0) Gecko/20110615 Firefox/5.0 Fennec/5.0");
+ INSERT INTO UserAgents VALUES("Safari 5.0", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2) AppleWebKit/534.52.7 (KHTML, like Gecko) Version/5.1.2 Safari/534.52.7");
+ INSERT INTO UserAgents VALUES("Google Chrome 18.0", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.16 (KHTML, like Gecko) Chrome/18.0.1003.1 Safari/535.16");
+ INSERT INTO UserAgents VALUES("Internet Explorer 9", "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)");
+ INSERT INTO UserAgents VALUES("Galaxy Tab 10.1", "Mozilla/5.0 (Linux; U; Android 3.0.1; en-us; GT-P7100 Build/HRI83) AppleWebKit/534.13 (KHTML, like Gecko) Version/4.0 Safari/534.13");
+ INSERT INTO UserAgents VALUES("iPad 2", "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8L1 Safari/6533.18.5");
)
-
-SQL(
+ SQL(
COMMIT;
)
--- /dev/null
+#git:framework/web/wrt-commons wrt-commons 0.2.92
+Name: wrt-commons
+Summary: Wrt common library
+Version: 0.2.93
+Release: 1
+Group: Development/Libraries
+License: Apache License, Version 2.0
+URL: N/A
+Source0: %{name}-%{version}.tar.gz
+BuildRequires: cmake
+BuildRequires: pkgconfig(ecore)
+BuildRequires: pkgconfig(appcore-efl)
+BuildRequires: pkgconfig(libssl)
+BuildRequires: pkgconfig(sqlite3)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(gio-2.0)
+BuildRequires: pkgconfig(db-util)
+BuildRequires: pkgconfig(zlib)
+BuildRequires: pkgconfig(libpcrecpp)
+BuildRequires: pkgconfig(icu-i18n)
+BuildRequires: pkgconfig(libxml-2.0)
+BuildRequires: pkgconfig(openssl)
+BuildRequires: pkgconfig(libiri)
+BuildRequires: pkgconfig(libidn)
+
+%description
+Wrt common library
+
+%package devel
+Summary: Wrt common library development headers
+Group: Development/Libraries
+Requires: %{name} = %{version}
+
+%description devel
+Wrt common library development headers
+
+%prep
+%setup -q
+
+%define with_tests 0
+%if "%{WITH_TESTS}" == "ON" || "%{WITH_TESTS}" == "Y" || "%{WITH_TESTS}" == "YES" || "%{WITH_TESTS}" == "TRUE" || "%{WITH_TESTS}" == "1"
+ %define with_tests 1
+%endif
+
+%build
+
+%ifarch %{ix86}
+cp build/encryption/libs/libcal.i586.a build/encryption/libs/libcal.a
+%else
+cp build/encryption/libs/libcal.arm.a build/encryption/libs/libcal.a
+%endif
+
+export LDFLAGS+="-Wl,--rpath=%{_libdir} -Wl,--hash-style=both -Wl,--as-needed"
+
+cmake . -DVERSION=%{version} \
+ -DDPL_LOG="OFF" \
+ -DCMAKE_INSTALL_PREFIX=%{_prefix} \
+ -DCMAKE_BUILD_TYPE=%{?build_type:%build_type} \
+ %{?WITH_TESTS:-DWITH_TESTS=%WITH_TESTS}
+make %{?jobs:-j%jobs}
+
+%install
+mkdir -p %{buildroot}/usr/share/license
+cp %{name} %{buildroot}/usr/share/license/
+%make_install
+
+%clean
+rm -rf %{buildroot}
+
+%post
+mkdir -p /opt/share/widget/system
+mkdir -p /opt/share/widget/user
+mkdir -p /opt/share/widget/exec
+mkdir -p /opt/share/widget/data/Public
+mkdir -p /usr/lib/wrt-plugins
+
+if [ -z ${2} ]; then
+ echo "This is new install of wrt-commons"
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
+else
+ # Find out old and new version of databases
+ WRT_OLD_DB_VERSION=`sqlite3 /opt/dbspace/.wrt.db ".tables" | grep "DB_VERSION_"`
+ WRT_NEW_DB_VERSION=`cat /usr/share/wrt-engine/wrt_db.sql | tr '[:blank:]' '\n' | grep DB_VERSION_`
+ echo "OLD wrt database version ${WRT_OLD_DB_VERSION}"
+ echo "NEW wrt database version ${WRT_NEW_DB_VERSION}"
+
+ if [ ${WRT_OLD_DB_VERSION} -a ${WRT_NEW_DB_VERSION} ]
+ then
+ if [ ${WRT_NEW_DB_VERSION} = ${WRT_OLD_DB_VERSION} ]
+ then
+ echo "Equal database detected so db installation ignored"
+ else
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
+ fi
+ else
+ echo "Calling /usr/bin/wrt_commons_reset_db.sh"
+ /usr/bin/wrt_commons_reset_db.sh
+ fi
+fi
+
+mkdir -p /usr/etc/ace
+mkdir -p /usr/apps/org.tizen.policy
+
+# DBUS services fix
+# WARNING: THIS IS TEMPORARY SOLUTION, AS THIS SHOULD NOT BE OUR
+# RESPONSIBILITY!!! WE HAVE TO CONTACT TO DBUS MAINAINERS
+
+if [ -f /var/lib/dbus/machine-id ]; then
+ echo "machine-id exists"
+else
+ if [ -f /usr/var/lib/dbus/machine-id ]; then
+ echo "machine-id exists"
+ else
+ echo "Creating machine-id"
+ mkdir -p /usr/var/lib/dbus/
+ dbus-uuidgen > /usr/var/lib/dbus/machine-id
+ dbus-uuidgen --ensure=/usr/var/lib/dbus/machine-id
+ fi
+ mkdir -p /var/lib/dbus/
+ cp /usr/var/lib/dbus/machine-id /var/lib/dbus/
+fi
+
+# Set Smack label for db files
+chsmack -a 'wrt-commons::db_wrt' /opt/dbspace/.wrt.db
+chsmack -a 'wrt-commons::db_wrt' /opt/dbspace/.wrt.db-journal
+chsmack -a 'wrt-commons::db_wrt_autosave' /opt/dbspace/.wrt_autosave.db
+chsmack -a 'wrt-commons::db_wrt_autosave' /opt/dbspace/.wrt_autosave.db-journal
+chsmack -a 'wrt-commons::db_wrt_custom_handler' /opt/dbspace/.wrt_custom_handler.db
+chsmack -a 'wrt-commons::db_wrt_custom_handler' /opt/dbspace/.wrt_custom_handler.db-journal
+
+echo "[WRT] wrt-commons postinst done ..."
+
+%files
+%manifest wrt-commons.manifest
+%{_libdir}/*.so
+%{_libdir}/*.so.*
+%{_datadir}/wrt-engine/*
+%{_datadir}/license/%{name}
+%attr(755,root,root) %{_bindir}/wrt_commons_create_clean_db.sh
+%attr(755,root,root) %{_bindir}/wrt_commons_reset_db.sh
+%if %{with_tests}
+ %attr(755,root,root) %{_bindir}/dpl-tests-*
+ %attr(755,root,root) %{_bindir}/dpl-dbus-test-service
+ %attr(755,root,root) %{_bindir}/wrt-tests-*
+ %attr(755,root,root) %{_bindir}/wrt_dao_tests_prepare_db.sh
+ %{_datadir}/dbus-1/services/org.tizen.DBusTestService.service
+ /opt/share/wrt/wrt-commons/tests/*
+%endif
+
+%files devel
+%{_includedir}/dpl-efl/*
+%{_libdir}/pkgconfig/*.pc
-# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
-#
-# 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.
-#
-# @file CMakeLists.txt
-# @author Lukasz Marek (l.marek@samsung.com)
-# @version 1.0
-# @brief
-#
+# Suppress all warnings; TODO: inhibit only specific warnings per target (TURNED OFF)
+#SET(CMAKE_CXX_FLAGS_BACKUP ${CMAKE_CXX_FLAGS})
+#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
-SET(DPL_TEST_INCLUDE_DIR
- ${DPL_CORE_INCLUDE_DIR}
- ${DPL_EVENT_INCLUDE_DIR}
- ${DPL_DBUS_INCLUDE_DIR}
- ${DPL_DB_INCLUDE_DIR}
- ${DPL_RPC_INCLUDE_DIR}
- ${DPL_SOCKET_INCLUDE_DIR}
- ${DPL_TEST_ENGINE_INCLUDE_DIR}
- ${DPL_LOG_INCLUDE_DIR}
+INCLUDE(CMakeUtils.txt)
+
+SET(TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+SET(TESTS_COMMON_DIR "${TESTS_DIR}/common")
+
+WRT_ADD_INTERNAL_DEPENDENCIES(
+ ${TARGET_DPL_TEST_ENGINE_EFL}
)
-ADD_SUBDIRECTORY(core)
-ADD_SUBDIRECTORY(dbus)
-ADD_SUBDIRECTORY(db)
-ADD_SUBDIRECTORY(event)
-ADD_SUBDIRECTORY(ace)
-ADD_SUBDIRECTORY(vcore)
-ADD_SUBDIRECTORY(localization)
+ADD_SUBDIRECTORY(dao)
+ADD_SUBDIRECTORY(dpl)
+
+# Rollback CXX flags
+#SET(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_BACKUP})
\ No newline at end of file
--- /dev/null
+# @file CMakeUtils.txt
+# @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+# @author Pawel Sikorski (p.sikorski@samsung.com)
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+#
+# Discovers target's INCLUDE_DIRECTORIES and LINK_DIRECTORIES.
+# This is done by retrieving the directory target was built in and
+# fetching appropriate properties of that directory.
+FUNCTION(WRT_INTROSPECT_TARGET PREFIX TARGET_NAME)
+ GET_TARGET_PROPERTY(LOCATION ${TARGET_NAME} LOCATION)
+ IF(${LOCATION} STREQUAL "LOCATION-NOTFOUND")
+ MESSAGE(FATAL_ERROR "Target '${TARGET_NAME}' introspection failed")
+ ELSE(${LOCATION} STREQUAL "LOCATION-NOTFOUND")
+ STRING(FIND ${LOCATION} "/" LAST_SLASH_POSITION REVERSE)
+ STRING(SUBSTRING ${LOCATION} 0 ${LAST_SLASH_POSITION} LOCATION)
+
+ GET_DIRECTORY_PROPERTY(INCLUDE_DIRS DIRECTORY ${LOCATION} INCLUDE_DIRECTORIES)
+ SET("${PREFIX}_INCLUDE_DIRS" ${INCLUDE_DIRS} PARENT_SCOPE)
+
+ GET_DIRECTORY_PROPERTY(LIBRARY_DIRS DIRECTORY ${LOCATION} LINK_DIRECTORIES)
+ SET("${PREFIX}_LIBRARY_DIRS" ${LIBRARY_DIRS} PARENT_SCOPE)
+ ENDIF(${LOCATION} STREQUAL "LOCATION-NOTFOUND")
+ENDFUNCTION(WRT_INTROSPECT_TARGET)
+
+#
+# Replacement functions for standard (w/o "WRT_" prefix) CMake functions.
+# They store supplied arguments in global properties to assign them to tests.
+# Anything added with this functions is used by all targets that are built with
+# WRT_TEST_BUILD function.
+
+#
+# Appends directories to global property TESTS_INCLUDE_DIRS which is
+# then read by WRT_TEST_BUILD and its content is forwarded to
+# command INCLUDE_DIRECTORIES() (for all targets).
+FUNCTION(WRT_INCLUDE_DIRECTORIES)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY TESTS_INCLUDE_DIRS ${ARGV})
+ENDFUNCTION(WRT_INCLUDE_DIRECTORIES)
+
+#
+# Appends directories to global property TESTS_LIBRARY_DIRS which is
+# then read by WRT_TEST_BUILD and its content is forwarded to
+# command LINK_DIRECTORIES() (for all targets).
+FUNCTION(WRT_LINK_DIRECTORIES)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY TESTS_LIBRARY_DIRS ${ARGV})
+ENDFUNCTION(WRT_LINK_DIRECTORIES)
+
+#
+# Appends directories to global property TESTS_LIBRARIES which is
+# then read by WRT_TEST_BUILD and its content is forwarded to
+# command TARGET_LINK_LIBRARIES() (for all targets).
+FUNCTION(WRT_TARGET_LINK_LIBRARIES)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY TESTS_LIBRARIES ${ARGV})
+ENDFUNCTION(WRT_TARGET_LINK_LIBRARIES)
+
+#
+# Convenience method that fills TESTS_INCLUDE_DIRS, TESTS_LIBRARY_DIRS
+# and TESTS_LIBRARIES with values discovered from introspecting supplied
+# targets.
+# Function takes arbitrary number of targets.
+FUNCTION(WRT_ADD_INTERNAL_DEPENDENCIES)
+ FOREACH(DEPENDENCY ${ARGV})
+ WRT_INTROSPECT_TARGET(prefix ${DEPENDENCY})
+ WRT_INCLUDE_DIRECTORIES(${prefix_INCLUDE_DIRS})
+ WRT_LINK_DIRECTORIES(${prefix_LIBRARY_DIRS})
+ WRT_TARGET_LINK_LIBRARIES(${DEPENDENCY})
+ ENDFOREACH(DEPENDENCY)
+ENDFUNCTION(WRT_ADD_INTERNAL_DEPENDENCIES)
+
+
+#
+# Replacement functions for standard (w/o "WRT_" prefix) CMake functions.
+# They store supplied arguments in global properties to assign them to specific
+# tests. Properties names are based on the test target name.
+# Anything added with this functions is used only by the specified target that
+# is built with WRT_TEST_BUILD function.
+
+#
+# Appends directories to global property ${TARGET_NAME}_INCLUDE_DIRS
+# which is then read by WRT_TEST_BUILD and its content is forwarded to
+# command INCLUDE_DIRECTORIES() (for specified target).
+FUNCTION(WRT_TEST_INCLUDE_DIRECTORIES TARGET_NAME)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY ${TARGET_NAME}_INCLUDE_DIRS ${ARGN})
+ENDFUNCTION(WRT_TEST_INCLUDE_DIRECTORIES)
+
+#
+# Appends directories to global property ${TARGET_NAME}_LIBRARY_DIRS
+# which is then read by WRT_TEST_BUILD and its content is forwarded to
+# command LINK_DIRECTORIES() (for specified target).
+FUNCTION(WRT_TEST_LINK_DIRECTORIES TARGET_NAME)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY ${TARGET_NAME}_LIBRARY_DIRS ${ARGN})
+ENDFUNCTION(WRT_TEST_LINK_DIRECTORIES)
+
+#
+# Appends directories to global property ${TARGET_NAME}_LIBRARIES
+# which is then read by WRT_TEST_BUILD and its content is forwarded to
+# command TARGET_LINK_LIBRARIES() (for specified target).
+FUNCTION(WRT_TEST_TARGET_LINK_LIBRARIES TARGET_NAME)
+ SET_PROPERTY(GLOBAL APPEND PROPERTY ${TARGET_NAME}_LIBRARIES ${ARGN})
+ENDFUNCTION(WRT_TEST_TARGET_LINK_LIBRARIES)
+
+#
+# Convenience method that fills ${TARGET_NAME}_INCLUDE_DIRS,
+# ${TARGET_NAME}_LIBRARY_DIRS and ${TARGET_NAME}_LIBRARIES with
+# values discovered from introspecting supplied targets.
+# Function takes arbitrary number of targets.
+FUNCTION(WRT_TEST_ADD_INTERNAL_DEPENDENCIES TARGET_NAME)
+ FOREACH(DEPENDENCY ${ARGN})
+ WRT_INTROSPECT_TARGET(prefix ${DEPENDENCY})
+ WRT_TEST_INCLUDE_DIRECTORIES(${TARGET_NAME} ${prefix_INCLUDE_DIRS})
+ WRT_TEST_LINK_DIRECTORIES(${TARGET_NAME} ${prefix_LIBRARY_DIRS})
+ WRT_TEST_TARGET_LINK_LIBRARIES(${TARGET_NAME} ${DEPENDENCY})
+ ENDFOREACH(DEPENDENCY)
+ENDFUNCTION(WRT_TEST_ADD_INTERNAL_DEPENDENCIES)
+
+# Functions used to build test targets (proper sources, includes, libs are
+# added automatically)
+FUNCTION(WRT_TEST_BUILD TARGET_NAME)
+ SET(SOURCES "${ARGN}")
+ ADD_EXECUTABLE("${TARGET_NAME}" ${SOURCES})
+
+ # get include dirs global property
+ GET_PROPERTY(INCLUDE_DIRS GLOBAL PROPERTY TESTS_INCLUDE_DIRS)
+ GET_PROPERTY(TEST_INCLUDE_DIRS GLOBAL PROPERTY ${TARGET_NAME}_INCLUDE_DIRS)
+ INCLUDE_DIRECTORIES(
+ ${INCLUDE_DIRS}
+ ${TEST_INCLUDE_DIRS}
+ )
+
+ # get library dirs global property
+ GET_PROPERTY(LIBRARY_DIRS GLOBAL PROPERTY TESTS_LIBRARY_DIRS)
+ GET_PROPERTY(TEST_LIBRARY_DIRS GLOBAL PROPERTY ${TARGET_NAME}_LIBRARY_DIRS)
+ LINK_DIRECTORIES(
+ ${LIBRARY_DIRS}
+ ${TEST_LIBRARY_DIRS}
+ )
+
+ # get link libraries global property
+ GET_PROPERTY(LINK_LIBRARIES GLOBAL PROPERTY TESTS_LIBRARIES)
+ GET_PROPERTY(TEST_LIBRARIES GLOBAL PROPERTY ${TARGET_NAME}_LIBRARIES)
+ TARGET_LINK_LIBRARIES("${TARGET_NAME}"
+ ${LINK_LIBRARIES}
+ ${TEST_LIBRARIES}
+ )
+ENDFUNCTION(WRT_TEST_BUILD)
+
+FUNCTION(WRT_TEST_INSTALL)
+ SET_TARGET_PROPERTIES(${ARGV} PROPERTIES
+ BUILD_WITH_INSTALL_RPATH ON
+ INSTALL_RPATH_USE_LINK_PATH ON
+ )
+ INSTALL(TARGETS ${ARGV}
+ DESTINATION bin
+ PERMISSIONS OWNER_READ
+ OWNER_WRITE
+ OWNER_EXECUTE
+ GROUP_READ
+ GROUP_EXECUTE
+ WORLD_READ
+ WORLD_EXECUTE
+ )
+ENDFUNCTION(WRT_TEST_INSTALL)
+
+# Takes arbitrary number of arguments and concatenates them using ':' character.
+# Rationale:
+# CMake list when converted to a string is joined with ';' character. However,
+# GCC takes strings with multiple elements separated with ':' (e.g. list of
+# paths). Used typically when generating DB schemas with ORM mechanism.
+FUNCTION(WRT_CONVERT_TO_GCC_LIST OUTPUT_VARIABLE)
+ FOREACH(ITEM ${ARGN})
+ LIST(APPEND ITEMS ${ITEM})
+ ENDFOREACH(ITEM)
+ STRING(REPLACE ";" ":" OUTPUT "${ITEMS}")
+ SET("${OUTPUT_VARIABLE}" "${OUTPUT}" PARENT_SCOPE)
+ENDFUNCTION(WRT_CONVERT_TO_GCC_LIST)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file loop_control.cpp
+ * @author Jaroslaw Osmanski (j.osmanski@samsung.com)
+ * @version 1.0
+ * @brief This file is the definitions of loop controlling utilities
+ */
+
+
+#ifndef LOOP_CONTROL_H_
+#define LOOP_CONTROL_H_
+
+namespace LoopControl
+{
+
+void init_loop(int argc, char *argv[]);
+void wait_for_wrt_init();
+void finish_wait_for_wrt_init();
+void quit_loop();
+
+void wrt_start_loop();
+void wrt_end_loop();
+
+void *abstract_window();
+
+}
+
+#endif /* LOOP_CONTROL_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file loop_control.cpp
+ * @author Jaroslaw Osmanski (j.osmanski@samsung.com)
+ * @version 1.0
+ * @brief This is implementation of EFL version of loop control
+ */
+
+#include <loop_control.h>
+#include <dpl/log/log.h>
+
+#include <dpl/framework_efl.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+
+namespace LoopControl
+{
+void init_loop(int argc, char *argv[])
+{
+ (void)argc;
+ (void)argv;
+ g_type_init();
+ g_thread_init(NULL);
+
+ LogInfo("Starting");
+ elm_init(argc, argv);
+}
+
+void wait_for_wrt_init()
+{
+ ecore_main_loop_begin();
+}
+
+void finish_wait_for_wrt_init()
+{
+ ecore_main_loop_quit();
+}
+
+void quit_loop()
+{
+ elm_shutdown();
+}
+
+void wrt_start_loop()
+{
+ ecore_main_loop_begin();
+}
+
+void wrt_end_loop()
+{
+ ecore_main_loop_quit();
+}
+
+void *abstract_window()
+{
+ return elm_win_add(NULL, "hello", ELM_WIN_BASIC);
+}
+
+}//end of LoopControl namespace
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Pawel Sikorski (p.sikorski@samsung.com)
+# @version 1.0
+# @brief
+#
+
+# common part
+FILE(GLOB DAO_TESTS_SOURCES "${PROJECT_SOURCE_DIR}/tests/dao/*DAO.cpp")
+
+# target wrt-tests-dao
+SET(TARGET_DAO_TEST "wrt-tests-dao")
+WRT_TEST_INCLUDE_DIRECTORIES(${TARGET_DAO_TEST} ${PROJECT_SOURCE_DIR}/modules/support/)
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_DAO_TEST} ${TARGET_WRT_DAO_RW_LIB} ${TARGET_CUSTOM_HANDLER_DAO_RW_LIB})
+WRT_TEST_BUILD(${TARGET_DAO_TEST} ${DAO_TESTS_SOURCES} tests_dao.cpp)
+WRT_TEST_INSTALL(${TARGET_DAO_TEST})
+
+
+# common installed files
+INSTALL(PROGRAMS
+ ${PROJECT_SOURCE_DIR}/tests/dao/wrt_dao_tests_prepare_db.sh
+ DESTINATION bin
+ )
--- /dev/null
+Wrt DAO
+System tests. Tests database access layer: widgets information database, global configuration, plugins.
+Binary file: wrt-tests-dao. Uses our test framework. Allows to use different types of output. Text output shows results on console - green passed.
+To run:
+1. Install wrt-extra on target
+2. Run wrt-tests-dao --output=text
+
+Automatic: YES
+Included in Daily Build: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-INT)
+Included in Gerrit Builds: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-GERRIT)
+Number of test cases: 45
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_CustomHandlerDAO.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for custom handler dao class.
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <wrt-commons/custom-handler-dao-rw/custom_handler_dao.h>
+#include <wrt-commons/custom-handler-dao-ro/common_dao_types.h>
+
+using namespace CustomHandlerDB;
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+namespace
+{
+const DPL::String P_TARGET(L"p_target");
+const DPL::String P_BASE_URL(L"p_base_url");
+const DPL::String P_URL(L"p_url");
+const DPL::String P_TITLE(L"p_title");
+
+const DPL::String C_TARGET(L"c_target");
+const DPL::String C_BASE_URL(L"c_base_url");
+const DPL::String C_URL(L"c_url");
+const DPL::String C_TITLE(L"c_title");
+
+void checkHandlersExistence(CustomHandlerDAOReadOnly& dao, bool protocol, bool content)
+{
+ CustomHandlerDB::CustomHandlerPtr handler;
+ handler = dao.getProtocolHandler(P_TARGET, P_URL);
+ RUNNER_ASSERT_MSG((!!handler) == protocol, "Protocol handler check");
+ handler = dao.getContentHandler(C_TARGET, C_URL);
+ RUNNER_ASSERT_MSG((!!handler) == content, "Content handler check");
+}
+
+} // namespace
+
+RUNNER_TEST(custom_handler_empty_db_read)
+{
+ CustomHandlerDAOReadOnly dao(DPL::String(L"test"));
+}
+
+
+RUNNER_TEST(custom_handlers)
+{
+ CustomHandlerDAOReadOnly dao_ro(L"test");
+ CustomHandlerDAO dao_rw(L"test");
+
+ CustomHandlerDB::CustomHandlerPtr handler;
+ CustomHandlerDB::CustomHandler p_handler;
+ p_handler.target = P_TARGET;
+ p_handler.base_url = P_BASE_URL;
+ p_handler.url = P_URL;
+ p_handler.title = P_TITLE;
+ p_handler.user_decision = Agreed;
+
+ // initial check
+ checkHandlersExistence(dao_ro,false,false);
+
+ // Protocol handler registration
+ dao_rw.registerProtocolHandler(p_handler);
+ checkHandlersExistence(dao_ro,true,false);
+
+ handler = dao_ro.getProtocolHandler(P_TARGET, P_URL);
+ RUNNER_ASSERT(handler);
+ RUNNER_ASSERT(handler->target == P_TARGET);
+ RUNNER_ASSERT(handler->base_url == P_BASE_URL);
+ RUNNER_ASSERT(handler->url == P_URL);
+ RUNNER_ASSERT(handler->title == P_TITLE);
+ RUNNER_ASSERT(handler->user_decision == Agreed);
+
+
+ // Content handler registration
+ CustomHandlerDB::CustomHandler c_handler;
+ c_handler.target = C_TARGET;
+ c_handler.base_url = C_BASE_URL;
+ c_handler.url = C_URL;
+ c_handler.title = C_TITLE;
+ c_handler.user_decision = DeclinedPermanently;
+
+ dao_rw.registerContentHandler(c_handler);
+ checkHandlersExistence(dao_ro,true,true);
+ handler = dao_ro.getContentHandler(C_TARGET, C_URL);
+
+ RUNNER_ASSERT(handler);
+ RUNNER_ASSERT(handler->target == C_TARGET);
+ RUNNER_ASSERT(handler->base_url == C_BASE_URL);
+ RUNNER_ASSERT(handler->url == C_URL);
+ RUNNER_ASSERT(handler->title == C_TITLE);
+ RUNNER_ASSERT(handler->user_decision == DeclinedPermanently);
+
+ // Handler unregistration
+ dao_rw.unregisterProtocolHandler(P_TARGET, P_URL);
+ checkHandlersExistence(dao_ro,false,true);
+
+ // Nonexistent unregistration
+ dao_rw.unregisterContentHandler(L"blah", L"blah");
+ checkHandlersExistence(dao_ro,false,true);
+
+ // Cleanup
+ dao_rw.unregisterContentHandler(C_TARGET, C_URL);
+ checkHandlersExistence(dao_ro,false,false);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_FeatureDAO.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for feature dao class.
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/wrt-dao-rw/feature_dao.h>
+#include <dpl/wrt-dao-rw/plugin_dao.h>
+#include <dpl/wrt-dao-ro/wrt_db_types.h>
+
+using namespace WrtDB;
+
+#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
+ {std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+/*
+Name: feature_dao_test_register_features
+Description: Checks if plugin registeration performs features registration
+Expected: registrartion should succeed
+*/
+RUNNER_TEST(feature_dao_test_register_features)
+{
+ PluginHandle plHandle;
+ {
+ std::string libraryPath("nfp1 lib_path");
+ std::string libraryName("nfp1");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ plHandle = PluginDAO::registerPlugin(pluginData, libraryPath);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ FeatureHandleList old = FeatureDAOReadOnly::GetHandleList();
+ PluginMetafileData::Feature f;
+ f.m_name = std::string("new_f1");
+
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f,plHandle);
+ RUNNER_ASSERT_MSG(handle != -1, "Already registered");
+ RUNNER_ASSERT_MSG(old.size() < FeatureDAOReadOnly::GetHandleList().size(),
+ "New feature should be saved");
+
+ FeatureDAOReadOnly dao(handle);
+
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(),"new_f1");
+ plHandle = dao.GetPluginHandle();
+ }
+
+ {
+ FeatureHandleList old = FeatureDAOReadOnly::GetHandleList();
+
+ PluginMetafileData::Feature f;
+ f.m_name = std::string("new_f2");
+
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f,plHandle);
+ RUNNER_ASSERT_MSG(handle != -1, "Already registered");
+ RUNNER_ASSERT_MSG(old.size() < FeatureDAOReadOnly::GetHandleList().size(),
+ "New feature should be saved");
+
+ FeatureDAOReadOnly dao(handle);
+
+ RUNNER_ASSERT_MSG(plHandle == dao.GetPluginHandle(),
+ "New plugin registered (should be old used)");
+ }
+}
+
+/*
+Name: feature_dao_test_get_feature_properties
+Description: Checks properties of inserted features
+Expected: properties of features should match values inserted to database directly
+*/
+RUNNER_TEST(feature_dao_test_get_feature_properties)
+{
+ {
+ FeatureDAOReadOnly dao("feature1");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(), "feature1");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryName(), "plugin1");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryPath(), "");
+ }
+
+ {
+ FeatureDAOReadOnly dao("feature2");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(), "feature2");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryName(), "p4");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryPath(), "path_to_p4");
+ }
+
+ {
+ FeatureDAOReadOnly dao("feature3");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(), "feature3");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryName(), "p4");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetLibraryPath(), "path_to_p4");
+ }
+}
+
+/*
+Name: feature_dao_test_feature_constructor_name
+Description: -
+Expected: -
+
+TODO: test
+*/
+RUNNER_TEST(feature_dao_test_feature_constructor_name)
+{
+ std::list<const char *> preinstalled;
+ preinstalled.push_back("feature1");
+ preinstalled.push_back("feature2");
+ preinstalled.push_back("feature3");
+ preinstalled.push_back("feature4");
+
+ FOREACH(it, preinstalled)
+ {
+ FeatureDAOReadOnly dao(*it);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(), *it);
+ }
+
+ //TODO check exception that may occur (feature does not exist)
+}
+
+/*
+Name: feature_dao_test_feature_handle_list
+Description: Checks if list of installed features is returend correctly
+Expected: list size should be at last equal number of preinserted features
+*/
+RUNNER_TEST(feature_dao_test_feature_handle_list)
+{
+ FeatureHandleList handles = FeatureDAOReadOnly::GetHandleList();
+ RUNNER_ASSERT(handles.size() >= 4);
+}
+
+/*
+Name: feature_dao_test_is_feature_installed
+Description: Checks if installed features are showed correctly.
+Expected: correct installed features should be present
+*/
+RUNNER_TEST(feature_dao_test_is_feature_installed)
+{
+ //installed
+ {
+ std::list<const char *> preinstalled;
+ preinstalled.push_back("feature1");
+ preinstalled.push_back("feature2");
+ preinstalled.push_back("feature3");
+ preinstalled.push_back("feature4");
+
+ FOREACH(it, preinstalled)
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled(*it));
+ }
+
+ //not installed
+ {
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("not_installed1")==false);
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("plugin1") == false);
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("") == false);
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("ff") == false);
+ }
+}
+
+/*
+Name: feature_dao_test_get_device_capab
+Description: -
+Expected: -
+
+TODO: fix test
+*/
+RUNNER_TEST(feature_dao_test_get_device_capab)
+{
+#if 0
+ //TODO do more tests
+
+ {//check deviceCaps
+ Feature f;
+ f.setName("new_dev_f4");
+ f.setLibraryName("new_dev_f4 lib_name");
+
+ FeatureDAOReadOnly::DeviceCapabilitiesList devList;
+ devList.insert("new_dev_f4 devcap1");
+ devList.insert("new_dev_f4 devcap2");
+
+ FOREACH(it, devList)
+ f.addDeviceCapability(*it);
+
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f,"new_dev_f4 path");
+
+ FeatureDAOReadOnly dao(handle);
+
+ FeatureDAOReadOnly::DeviceCapabilitiesList gotList =
+ dao.GetDeviceCapabilities();
+ RUNNER_ASSERT_MSG(gotList.size() == devList.size(),
+ "deviceCaps wrong");
+ }
+#endif
+}
+
+/*
+Name: feature_dao_test_is_device_capab_installed
+Description: Checks if FeatureDAOReadOnly::isDeviceCapabilityInstalled works correctly.
+Expected: correct capabilities should be present
+*/
+RUNNER_TEST(feature_dao_test_is_device_capab_installed)
+{
+ //installed
+ std::list<const char *> preinstalled;
+ preinstalled.push_back("devicecap1");
+ preinstalled.push_back("devicecap2");
+ preinstalled.push_back("devicecap3");
+ preinstalled.push_back("devicecap4");
+
+ FOREACH(it, preinstalled)
+ RUNNER_ASSERT(FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
+
+ //not installed
+ std::list<const char *> notinstalled;
+ notinstalled.push_back("notinstalled1");
+ notinstalled.push_back("plugin1");
+ notinstalled.push_back("");
+ notinstalled.push_back("ff");
+
+ FOREACH(it, notinstalled)
+ RUNNER_ASSERT(!FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
+}
+
+#undef RUNNER_ASSERT_WHAT_EQUALS
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_GlobalDAO.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for global dao class.
+ */
+
+#include <list>
+#include <vector>
+#include <set>
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/exception.h>
+#include <dpl/string.h>
+#include <dpl/wrt-dao-rw/global_dao.h>
+#include <dpl/wrt-dao-ro/wrt_db_types.h>
+
+using namespace WrtDB;
+
+
+namespace
+{
+const DPL::String widgetPackage5(L"widgetpackage5");
+} // namespace
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+/*
+Name: global_dao_developer_mode
+Description: tests if developer mode is correctly set and get
+Expected: received developer shoudl match the one was set
+*/
+RUNNER_TEST(global_dao_developer_mode)
+{
+ bool prev_mode = GlobalDAO::GetDeveloperMode();
+ GlobalDAO::SetDeveloperMode(false);
+ RUNNER_ASSERT_MSG(!GlobalDAO::GetDeveloperMode(), "set false failed");
+
+ GlobalDAO::SetDeveloperMode(true);
+ RUNNER_ASSERT_MSG(GlobalDAO::GetDeveloperMode(), "set true failed");
+ GlobalDAO::SetDeveloperMode(prev_mode);
+}
+
+/*
+Name: home_network_data_usage
+Description: tests if HomeNetworkDataUsage is correctly set and get
+Expected: received developer shoudl match the one was set
+*/
+RUNNER_TEST(home_network_data_usage)
+{
+ GlobalDAO::NetworkAccessMode original =
+ GlobalDAO::GetHomeNetworkDataUsage();
+
+ GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::CONNECT_AUTOMATICALLY);
+ RUNNER_ASSERT_MSG(GlobalDAO::CONNECT_AUTOMATICALLY ==
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+
+ GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::ALWAYS_ASK);
+ RUNNER_ASSERT_MSG(GlobalDAO::ALWAYS_ASK ==
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+
+ GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::NEVER_CONNECT);
+ RUNNER_ASSERT_MSG(GlobalDAO::NEVER_CONNECT ==
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+
+ GlobalDAO::SetHomeNetworkDataUsage(original);
+ RUNNER_ASSERT_MSG(original == GlobalDAO::GetHomeNetworkDataUsage(),
+ "Value not updated");
+}
+
+/*
+Name: roaming_data_usage
+Description: tests if RoamingDataUsage is correctly set and get
+Expected: received developer shoudl match the one was set
+*/
+RUNNER_TEST(roaming_data_usage)
+{
+ GlobalDAO::NetworkAccessMode original =
+ GlobalDAO::GetRoamingDataUsage();
+
+ GlobalDAO::SetRoamingDataUsage(GlobalDAO::CONNECT_AUTOMATICALLY);
+ RUNNER_ASSERT_MSG(GlobalDAO::CONNECT_AUTOMATICALLY ==
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+
+ GlobalDAO::SetRoamingDataUsage(GlobalDAO::ALWAYS_ASK);
+ RUNNER_ASSERT_MSG(GlobalDAO::ALWAYS_ASK ==
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+
+ GlobalDAO::SetRoamingDataUsage(GlobalDAO::NEVER_CONNECT);
+ RUNNER_ASSERT_MSG(GlobalDAO::NEVER_CONNECT ==
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+
+ GlobalDAO::SetRoamingDataUsage(original);
+ RUNNER_ASSERT_MSG(original == GlobalDAO::GetRoamingDataUsage(),
+ "Value not updated");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_PluginDAO.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for feature dao class.
+ */
+
+#include <list>
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/exception.h>
+#include <dpl/wrt-dao-rw/plugin_dao.h>
+//#include <plugin_install/plugin_objects.h>
+#include <dpl/wrt-dao-ro/wrt_db_types.h>
+#include <dpl/log/log.h>
+
+using namespace WrtDB;
+
+#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
+ {std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+/*
+Name: plugin_dao_test_register_plugins
+Description: registers new plugin and check if it was correctly registered
+Expected: plugin should be correctly registered
+*/
+RUNNER_TEST(plugin_dao_test_register_plugins)
+{
+ {
+ std::string libraryPath("np1 lib_path");
+ std::string libraryName("np1");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ PluginHandle handle = PluginDAO::registerPlugin(pluginData, libraryPath);
+ PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ PluginDAO dao(handle);
+ std::string tmp;
+ tmp = dao.getLibraryPath(); //do for each
+ RUNNER_ASSERT_MSG(tmp == libraryPath, "Equals: " + tmp);
+ }
+
+ {
+ std::string libraryName("np2");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ PluginHandle handle = PluginDAO::registerPlugin(pluginData, "");
+ PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ PluginDAO dao(handle);
+ RUNNER_ASSERT(dao.getLibraryPath() == "");
+ }
+}
+
+/*
+Name: plugin_dao_test_register_plugin_implemented_object
+Description: registers new PluginImplementedObject
+ and check if it was correctly registered
+Expected: plugin dao shoudld be upodated with PluginImplementedObject
+*/
+RUNNER_TEST(plugin_dao_test_register_plugin_implemented_object)
+{
+ {
+ std::string libraryPath("np3 lib_path");
+ std::string libraryName("np3");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ PluginHandle handle =
+ PluginDAO::registerPlugin(pluginData, libraryPath);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ std::string object1("object1");
+ std::string object2("object2");
+ PluginDAO::registerPluginImplementedObject(object1, handle);
+ PluginDAO::registerPluginImplementedObject(object2, handle);
+
+ PluginHandle retHandle1 =
+ PluginDAO::getPluginHandleForImplementedObject(object1);
+ PluginHandle retHandle2 =
+ PluginDAO::getPluginHandleForImplementedObject(object1);
+ RUNNER_ASSERT(retHandle1 == handle);
+ RUNNER_ASSERT(retHandle2 == handle);
+ }
+}
+
+/*
+Name: plugin_dao_test_register_plugin_implemented_object
+Description: registers dependecies for plugins and checks if they were saved
+Expected: registered dependecies should be returned from database
+*/
+RUNNER_TEST(plugin_dao_test_register_library_dependencies)
+{
+ {
+ std::string libraryPath("np4 lib_path");
+ std::string libraryName("np4");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ PluginHandle handle =
+ PluginDAO::registerPlugin(pluginData, libraryPath);
+ PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ PluginHandle depHandles[] = {117, 119};
+
+ PluginHandleSetPtr dependencies(new PluginHandleSet);
+ dependencies->insert(depHandles[1]);
+ dependencies->insert(depHandles[2]);
+
+ PluginDAO::registerPluginLibrariesDependencies(handle, dependencies);
+
+ PluginDAO dao(handle);
+ PluginHandleSetPtr retDependencies;
+ retDependencies = dao.getLibraryDependencies();
+
+ RUNNER_ASSERT(
+ retDependencies->size()==sizeof(depHandles)/sizeof(depHandles[0]));
+ RUNNER_ASSERT(
+ retDependencies->find(depHandles[1]) != retDependencies->end());
+ RUNNER_ASSERT(
+ retDependencies->find(depHandles[2]) != retDependencies->end());
+ }
+}
+
+/*
+Name: plugin_dao_test_register_required_object
+Description: registers required plugin objects for plugins and checks if they were saved
+Expected: registered required plugin objects should be returned from database
+*/
+RUNNER_TEST(plugin_dao_test_register_required_object)
+{
+ {
+ std::string libraryPath("np5 lib_path");
+ std::string libraryName("np5");
+
+ PluginMetafileData pluginData;
+ pluginData.m_libraryName = libraryName;
+
+ PluginHandle handle =
+ PluginDAO::registerPlugin(pluginData, libraryPath);
+ PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
+
+ const size_t numObjects =2;
+ std::string objectReq [numObjects];
+ objectReq[0] = std::string("object1.req");
+ objectReq[1] = std::string("object2.req");
+ PluginDAO::registerPluginRequiredObject(objectReq[0], handle);
+ PluginDAO::registerPluginRequiredObject(objectReq[1], handle);
+
+ WrtDB::PluginObjectsDAO::ObjectsPtr objects =
+ PluginDAO::getRequiredObjectsForPluginHandle(handle);
+
+ RUNNER_ASSERT(objects->size() == numObjects
+ && objects->find(objectReq[0]) != objects->end()
+ && objects->find(objectReq[1]) != objects->end());
+ }
+}
+
+/*
+Name: plugin_dao_test_is_library_installed
+Description: tests if plugin isntallation/registrartion works
+Expected: only registered plugins should be reported as installed
+*/
+RUNNER_TEST(plugin_dao_test_is_library_installed)
+{
+ {
+ //exist
+ std::list<const char *> preinstalled;
+ preinstalled.push_back("plugin1");
+ preinstalled.push_back("plugin2");
+ preinstalled.push_back("plugin3");
+ preinstalled.push_back("p4");
+ preinstalled.push_back("p5");
+
+ FOREACH(it, preinstalled)
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled(*it),
+ std::string("Not found: ") + *it);
+ }
+
+ {
+ //does not exist
+ RUNNER_ASSERT_MSG(
+ PluginDAO::isPluginInstalled("not_installed1") == false,
+ "Found not_installed1");
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("p 4") == false,
+ "Found p 4");
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("") == false,
+ "Found <empty>");
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("p33") == false,
+ "Found p33");
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("feature1") == false,
+ "Found feature1");
+ }
+}
+
+/*
+Name: plugin_dao_test_get_plugin_handle_list
+Description: test of returning plugin handle list
+Expected: returned list should be no less than number of registered plugins
+*/
+RUNNER_TEST(plugin_dao_test_get_plugin_handle_list)
+{
+ PluginHandleList handles = PluginDAO::getPluginHandleList();
+ RUNNER_ASSERT(handles.size() >= 5);
+}
+
+/*
+Name: plugin_dao_test_constructor_name
+Description: tests construction of plugin dao based on plugin name
+Expected: Instance of dao should be constructed only
+ if there is given plugin in database
+*/
+RUNNER_TEST(plugin_dao_test_constructor_name)
+{
+ {
+ //exist
+ std::list<const char *> preinstalled;
+ preinstalled.push_back("plugin1");
+ preinstalled.push_back("plugin2");
+ preinstalled.push_back("plugin3");
+ preinstalled.push_back("p4");
+ preinstalled.push_back("p5");
+
+ FOREACH(it, preinstalled)
+ {
+ PluginDAO dao(*it);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), *it);
+ }
+ }
+
+ {
+ //does not exist
+ std::list<const char *> not_installed;
+ not_installed.push_back("plugin 1");
+ not_installed.push_back("");
+ not_installed.push_back("p 3");
+
+ FOREACH(it, not_installed)
+ {
+ Try {
+ //Plugin not exist
+ PluginDAO dao(*it);
+ RUNNER_ASSERT_MSG(false, "should not be found");
+ }
+ Catch (PluginDAO::Exception::PluginNotExist) {
+ continue;
+ }
+ }
+ }
+
+}
+
+/*
+Name: plugin_dao_test_get_plugin_properties
+Description: tests reading plugin properties from database
+Expected: Data, inserted into database, should be accessible via dao
+*/
+RUNNER_TEST(plugin_dao_test_get_plugin_properties)
+{
+ {
+ PluginDAO dao("p4");
+ RUNNER_ASSERT(dao.getPluginHandle() == 4);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "p4");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_p4");
+ }
+
+ {
+ PluginDAO dao(5);
+ RUNNER_ASSERT(dao.getPluginHandle() == 5);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "p5");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_p5");
+ }
+
+ {
+ PluginDAO dao(2);
+ RUNNER_ASSERT(dao.getPluginHandle() == 2);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "plugin2");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_plugin2");
+ }
+
+ {
+ PluginDAO dao(1);
+ RUNNER_ASSERT(dao.getPluginHandle() == 1);
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "plugin1");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "");
+ }
+}
+
+/*
+Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_1
+Description: tests receiving from dao Implemented Objects
+Expected: returned object is size 0
+*/
+RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_1)
+{
+ {
+ const int handle = 1;
+ PluginDAOReadOnly dao(handle);
+ auto dbHandle = dao.getPluginHandle();
+ RUNNER_ASSERT(dbHandle == handle);
+ auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
+
+ RUNNER_ASSERT(objects.size() == 0);
+ }
+}
+
+/*
+Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_2
+Description: tests receiving from dao Implemented Objects
+Expected: returned object is size as it was inserted
+*/
+RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_2)
+{
+ {
+ std::set< std::string > preinstalled =
+ {
+ ""
+ };
+
+ PluginDAOReadOnly dao(2);
+ auto dbHandle = dao.getPluginHandle();
+ auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
+
+ //LogError("\n" << objects.size() << " " << preinstalled.size() << "\n");
+
+ RUNNER_ASSERT(objects.size() == preinstalled.size());
+
+ FOREACH(dbObject, objects)
+ {
+ RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
+ }
+ }
+}
+
+/*
+Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_3
+Description: tests receiving from dao Implemented Objects
+Expected: returned objects list has preinserted object
+*/
+RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_3)
+{
+ {
+ std::set< std::string > preinstalled =
+ {
+ "Plugin_3_Object_A"
+ };
+
+ PluginDAOReadOnly dao(3);
+ auto dbHandle = dao.getPluginHandle();
+ auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
+ RUNNER_ASSERT(objects.size() == preinstalled.size());
+
+ FOREACH(dbObject, objects)
+ {
+ RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
+ }
+ }
+}
+
+/*
+Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_4
+Description: tests receiving from dao Implemented Objects
+Expected: returned objects list has all preinserted objects
+*/
+RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_4)
+{
+ {
+ std::set< std::string > preinstalled =
+ {
+ "Plugin_4_Object_A",
+ "Plugin_4_Object_B",
+ "Plugin_4_Object_C",
+ };
+
+ PluginDAOReadOnly dao(4);
+ auto dbHandle = dao.getPluginHandle();
+ auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
+ RUNNER_ASSERT(objects.size() == preinstalled.size());
+
+ FOREACH(dbObject, objects)
+ {
+ RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
+ }
+ }
+}
+
+/*
+Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_5
+Description: tests receiving from dao Implemented Objects
+Expected: returned objects list do not have object that was not inserted
+*/
+RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_5)
+{
+ {
+ std::set< std::string > preinstalled =
+ {
+ "Plugin_5_Object_B",
+ };
+
+ PluginDAOReadOnly dao(5);
+ auto dbHandle = dao.getPluginHandle();
+ auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
+ RUNNER_ASSERT(objects.size() == preinstalled.size());
+
+ FOREACH(dbObject, objects)
+ {
+ RUNNER_ASSERT(preinstalled.find(*dbObject) == preinstalled.end());
+ }
+ }
+}
+
+
+#undef RUNNER_ASSERT_WHAT_EQUALS
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_PropertyDAO.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for property dao class.
+ */
+
+#include <list>
+#include <map>
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/exception.h>
+#include <dpl/wrt-dao-rw/property_dao.h>
+#include <dpl/wrt-dao-ro/wrt_db_types.h>
+
+using namespace WrtDB;
+using namespace WrtDB::PropertyDAOReadOnly;
+
+// Widgets used 2000, 2001, 2002, 2003(saved by wrt_dao_tests_prepare_db.sh)
+
+#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
+ {std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+
+#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(in, test) \
+ { \
+ if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
+ else RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in),test);\
+ }
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+/*
+Name: property_dao_get_lists
+Description: tests returning list of properties for given id
+Expected: data received should match those, which were inserted in prepare script
+*/
+RUNNER_TEST(property_dao_get_lists)
+{
+ {//property list
+ std::map<WidgetHandle, size_t> prefsMap;
+ prefsMap.insert(std::pair<WidgetHandle, size_t>(2000, 2));
+ prefsMap.insert(std::pair<WidgetHandle, size_t>(2001, 1));
+ prefsMap.insert(std::pair<WidgetHandle, size_t>(2002, 2));
+ prefsMap.insert(std::pair<WidgetHandle, size_t>(1, 0)); //no widget
+
+ FOREACH(it, prefsMap) {
+ PropertyDAOReadOnly::WidgetPreferenceList prefs =
+ PropertyDAOReadOnly::GetPropertyList(it->first);
+ RUNNER_ASSERT(prefs.size() == it->second);
+ }
+ }
+
+ {//property key list
+ WidgetPropertyKeyList orig_2000;
+ orig_2000.push_back(DPL::FromUTF8String("key1_for_2000"));
+ orig_2000.push_back(DPL::FromUTF8String("key2_for_2000"));
+
+ WidgetPropertyKeyList orig_2001;
+ orig_2001.push_back(DPL::FromUTF8String("key1_for_2001"));
+
+ WidgetPropertyKeyList orig_2002;
+ orig_2002.push_back(DPL::FromUTF8String("key1_for_2002"));
+ orig_2002.push_back(DPL::FromUTF8String("key2_for_2002"));
+
+ std::map<WidgetHandle, WidgetPropertyKeyList *> prefsKeyMap;
+ prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
+ 2000, &orig_2000));
+ prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
+ 2001, &orig_2001));
+ prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
+ 2002, &orig_2002));
+
+ FOREACH(it_out, prefsKeyMap) {
+ WidgetPropertyKeyList got = PropertyDAOReadOnly::GetPropertyKeyList(
+ it_out->first);
+ RUNNER_ASSERT(got.size() == it_out->second->size());
+ //TODO
+ // FOREACH(it_in, got)
+ // {
+ // RUNNER_ASSERT(it_out->second.
+ // }
+ }
+ }
+}
+
+/*
+Name: property_dao_set_update_remove
+Description: tests set new property for widget, updating property and removing it
+Expected: given operation should works
+*/
+RUNNER_TEST(property_dao_set_update_remove)
+{
+ WidgetPropertyKeyList keys = PropertyDAOReadOnly::GetPropertyKeyList(2000);
+
+ //ADD
+ PropertyDAO::SetProperty(2000,
+ DPL::FromUTF8String("new_key"),
+ DPL::FromUTF8String("new_value1"));
+
+ RUNNER_ASSERT_MSG(
+ keys.size() + 1 == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ "new property not added");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
+ PropertyDAOReadOnly::GetPropertyValue(2000,
+ DPL::FromUTF8String("new_key")),
+ "new_value1");
+
+ //UPDATE
+ PropertyDAO::SetProperty(2000,
+ DPL::FromUTF8String("new_key"),
+ DPL::FromUTF8String("new_value2"));
+ RUNNER_ASSERT_MSG(
+ keys.size() + 1 == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ "new property not added");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
+ PropertyDAOReadOnly::GetPropertyValue(2000,
+ DPL::FromUTF8String("new_key")),
+ "new_value2");
+
+ //REMOVE
+ PropertyDAO::RemoveProperty(2000, DPL::FromUTF8String("new_key"));
+
+ RUNNER_ASSERT_MSG(
+ keys.size() == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ "property not removed");
+
+}
+
+/*
+Name: property_dao_get_value
+Description: tests if properties can be received from database
+Expected: value, which were inserted before test, should be present
+*/
+RUNNER_TEST(property_dao_get_value)
+{
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
+ PropertyDAOReadOnly::GetPropertyValue(
+ 2000, DPL::FromUTF8String("key1_for_2000")),
+ "value_for_key1_2000");
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
+ PropertyDAOReadOnly::GetPropertyValue(
+ 2000, DPL::FromUTF8String("key2_for_2000")),
+ "value_for_key2_2000");
+}
+
+#undef RUNNER_ASSERT_WHAT_EQUALS
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases_WidgetDAO.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for widget dao class.
+ */
+
+#include <list>
+#include <cstdlib>
+#include <cstdio>
+#include <string>
+#include <algorithm>
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/exception.h>
+#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <dpl/wrt-dao-ro/wrt_db_types.h>
+#include <dpl/string.h>
+#include <wrt_plugin_export.h>
+
+using namespace WrtDB;
+
+namespace {
+
+class WacSecurityMock : public WrtDB::IWacSecurity
+{
+public:
+ WacSecurityMock() :
+ mRecognized(false),
+ mDistributorSigned(false),
+ mWacSigned(false)
+ {
+ }
+
+ virtual const WidgetCertificateDataList& getCertificateList() const
+ {
+ return mList;
+ }
+
+ virtual bool isRecognized() const { return mRecognized; }
+ virtual bool isDistributorSigned() const { return mDistributorSigned; }
+ virtual bool isWacSigned() const { return mWacSigned; }
+ virtual void getCertificateChainList(CertificateChainList& /*lst*/) const {}
+ virtual void getCertificateChainList(CertificateChainList& /*lst*/,
+ CertificateSource source) const {}
+
+ WrtDB::WidgetCertificateDataList& getCertificateListRef()
+ {
+ return mList;
+ }
+
+ void setRecognized(bool recognized) { mRecognized = recognized; }
+ void setDistributorSigned(bool distributorSigned)
+ {
+ mDistributorSigned = distributorSigned;
+ }
+ void setWacSigned(bool wacSigned) { mWacSigned = wacSigned; }
+
+private:
+ WrtDB::WidgetCertificateDataList mList;
+ // author signature verified
+ bool mRecognized;
+ // known distribuor
+ bool mDistributorSigned;
+ // distributor is wac
+ bool mWacSigned;
+
+};
+
+WidgetPkgName _registerWidget(const WidgetRegisterInfo& regInfo,
+ const IWacSecurity& sec,
+ int line)
+{
+ WidgetPkgName pkgname;
+ Try {
+ auto previous = WidgetDAO::getPkgnameList();
+
+ // register widget
+ pkgname = WidgetDAO::registerWidgetGenerateTizenId(regInfo, sec);
+
+ RUNNER_ASSERT_MSG(!pkgname.empty(),
+ "(called from line " << line << ")");
+
+ auto current = WidgetDAO::getPkgnameList();
+ RUNNER_ASSERT_MSG(previous.size()+1 == current.size(),
+ "(called from line " << line << ")");
+
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname),
+ "(called from line " << line << " pkgname: " << pkgname << ")");
+ }
+ Catch (WidgetDAO::Exception::AlreadyRegistered) {
+ RUNNER_ASSERT_MSG(
+ false,
+ "Unexpected exception (called from line " << line << ")");
+ }
+ return pkgname;
+}
+
+#define REGISTER_WIDGET(regInfo, sec) _registerWidget((regInfo),(sec), __LINE__)
+
+} // namespace
+
+// Widgets used <2300,2500), 2000, 2001, 2002, 2003
+
+#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
+ {std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+
+#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(in, test) \
+ { \
+ if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
+ else RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in),test);\
+ }
+
+#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONALINT(in, test) \
+ { \
+ if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
+ else RUNNER_ASSERT_MSG(*in == test, "Equals: [" + *in + "]"); \
+ }
+
+RUNNER_TEST_GROUP_INIT(DAO)
+
+//2300
+/*
+Name: widget_dao_test_register_widget_empty_strings
+Description: Tests registeration of new widget with empty values
+Expected: widget should be registered in database
+*/
+RUNNER_TEST(widget_dao_test_register_widget_empty_strings)
+{
+ WidgetRegisterInfo regInfo;
+
+ //ext info
+ regInfo.shareHref = "";
+
+ //info
+ regInfo.configInfo.widget_id = DPL::FromUTF8String("");
+ regInfo.configInfo.version = DPL::FromUTF8String("");
+ regInfo.configInfo.width = 10;
+ regInfo.configInfo.height = 10;
+ regInfo.configInfo.authorName = DPL::FromUTF8String("");
+ regInfo.configInfo.authorEmail = DPL::FromUTF8String("");
+ regInfo.configInfo.authorHref = DPL::FromUTF8String("");
+ regInfo.baseFolder = "";
+ //TODO authenticated, etc...
+ regInfo.configInfo.flashNeeded = false;
+ regInfo.configInfo.minVersionRequired = DPL::FromUTF8String("1.0");
+ regInfo.configInfo.backSupported = true;
+
+ //loc info
+ ConfigParserData::LocalizedData locData;
+ locData.name = DPL::FromUTF8String("");
+ locData.shortName = DPL::FromUTF8String("");
+ locData.description = DPL::FromUTF8String("");
+ locData.license = DPL::FromUTF8String("");
+ locData.licenseFile = DPL::FromUTF8String("");
+ locData.licenseHref = DPL::FromUTF8String("");
+ regInfo.configInfo.localizedDataSet.insert(
+ std::make_pair(DPL::FromUTF8String("en"),locData));
+
+ //userAgentLoc
+
+ //icons
+ ConfigParserData::Icon icon(DPL::FromUTF8String(""));
+ icon.width = 10;
+ icon.height = 10;
+ LocaleSet locs;
+ locs.insert(DPL::FromUTF8String("en"));
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ regInfo.localizationData.icons.push_back(locIcon);
+
+ //start file
+ WidgetRegisterInfo::StartFileProperties prop;
+ prop.encoding = DPL::FromUTF8String("");
+ prop.type = DPL::FromUTF8String("");
+ WidgetRegisterInfo::LocalizedStartFile file;
+ file.path = DPL::FromUTF8String("");
+ file.propertiesForLocales.insert(
+ std::make_pair(DPL::FromUTF8String("en"), prop));
+ regInfo.localizationData.startFiles.push_back(file);
+
+ //widget pref
+ ConfigParserData::Preference pref(DPL::FromUTF8String(""),false);
+ pref.value = DPL::FromUTF8String("");
+ regInfo.configInfo.preferencesList.insert(pref);
+
+ //widget feature
+ ConfigParserData::Feature feat(DPL::FromUTF8String(""),false);
+ ConfigParserData::Param par(DPL::FromUTF8String(("")));
+ par.value = DPL::FromUTF8String("");
+ feat.paramsList.insert(par);
+ regInfo.configInfo.featuresList.insert(feat);
+
+ //win modes
+ regInfo.configInfo.windowModes.insert(DPL::FromUTF8String(""));
+
+ //WARP info
+ ConfigParserData::AccessInfo access(DPL::FromUTF8String(""),true);
+ regInfo.configInfo.accessInfoSet.insert(access);
+
+ //certificates
+ WidgetCertificateData cert;
+ cert.owner = WidgetCertificateData::AUTHOR;
+ cert.type = WidgetCertificateData::ROOT;
+ cert.chainId = 1;
+ cert.strMD5Fingerprint = "";
+ cert.strSHA1Fingerprint = "";
+ cert.strCommonName = DPL::FromUTF8String("");
+
+ WacSecurityMock security;
+ security.getCertificateListRef().push_back(cert);
+
+ REGISTER_WIDGET(regInfo,security);
+}
+
+/*
+Name: widget_dao_test_register_widget_empty_strings
+Description: Tests possiblity of registering twice same content (different tizenId)
+Expected: it should be possible
+*/
+RUNNER_TEST(widget_dao_test_twice_install_same_widget)
+{
+ WacSecurityMock sec;
+ {
+ WidgetRegisterInfo regInfo;
+ REGISTER_WIDGET(regInfo, sec);
+ }
+ {
+ WidgetRegisterInfo regInfo;
+ REGISTER_WIDGET(regInfo, sec);
+ }
+
+}
+
+/*
+Name: widget_dao_test_register_widget_minimum_info
+Description: Tests simplest registeration of new widget
+Expected: widget should be registered in database
+*/
+RUNNER_TEST(widget_dao_test_register_widget_minimum_info)
+{
+ WacSecurityMock sec;
+ const std::size_t NUMBER_OF_WIDGETS = 5;
+
+ WidgetPkgName lastPkgname;
+
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
+ {
+ WidgetRegisterInfo regInfo;
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ lastPkgname = pkgname;
+
+ WidgetDAO dao(pkgname);
+ //TODO check nulls
+ }
+}
+
+/*
+Name: widget_dao_test_register_widget_info
+Description: Tests registeration of many widgets
+Expected: all widgets should be registered in database
+*/
+RUNNER_TEST(widget_dao_test_register_widget_info)
+{
+ WacSecurityMock sec;
+ const std::size_t NUMBER_OF_WIDGETS = 5;
+
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
+ {
+ std::ostringstream str;
+ str << "register_info_test_" << number;
+
+ WidgetRegisterInfo regInfo;
+ regInfo.configInfo.widget_id = DPL::FromUTF8String(str.str());
+ regInfo.configInfo.version = DPL::FromUTF8String(str.str());
+ regInfo.configInfo.width = 10;
+ regInfo.configInfo.height = 10;
+ regInfo.configInfo.authorName = DPL::FromUTF8String(str.str());
+ regInfo.configInfo.authorEmail = DPL::FromUTF8String(str.str());
+ regInfo.configInfo.authorHref = DPL::FromUTF8String(str.str());
+ regInfo.baseFolder = str.str(); //base folder at the end has /
+ regInfo.configInfo.flashNeeded = false;
+ //TODO authenticated, etc...
+ //in wrt-installer: TaskWidgetConfig::fillWidgetConfig:
+ //regInfo.minVersion = regInfo.configInfo.minVersionRequired
+ regInfo.minVersion = DPL::FromUTF8String("1.0");
+ regInfo.configInfo.backSupported = true;
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getGUID(), str.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getVersion(), str.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorName(), str.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorEmail(), str.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorHref(), str.str());
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getBaseFolder(), str.str() + "/");
+ RUNNER_ASSERT(dao.getWebkitPluginsRequired() == false);
+// RUNNER_ASSERT(
+// dao.GetWidgetSecurityDomain() == WacSecurity::Trusted);
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getMinimumWacVersion(), "1.0");
+ }
+
+}
+
+/*
+Name: widget_dao_test_register_widget_extended_info
+Description: Tests registeration of widget_extended_info
+Expected: registeration of extended inforamtion is checked
+ via existence of backgroudn page value
+*/
+RUNNER_TEST(widget_dao_test_register_widget_extended_info)
+{
+ WacSecurityMock sec;
+ const std::size_t NUMBER_OF_WIDGETS = 5;
+
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
+ {
+ std::ostringstream str;
+ str << "register_ext_info_test_" << number;
+
+ WidgetRegisterInfo regInfo;
+
+// regInfo.shareHref = str.str();
+ regInfo.configInfo.backgroundPage = L"background.html";
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+// RUNNER_ASSERT_WHAT_EQUALS(dao.GetShareHref(), str.str());
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getBackgroundPage(),
+ "background.html");
+ }
+}
+
+/*
+Name: widget_dao_test_register_widget_localized_info
+Description: Tests registeration of localized widgets information
+Expected: values received by dao should match those which were registered
+*/
+RUNNER_TEST(widget_dao_test_register_widget_localized_info)
+{
+ WacSecurityMock sec;
+ const std::size_t NUMBER_OF_WIDGETS = 5;
+
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
+ {
+ WidgetRegisterInfo regInfo;
+ std::ostringstream str_en;
+ std::ostringstream str_pl;
+ str_en << "register_loc_info_test_en_" << number;
+ str_pl<< "register_loc_info_test_pl_" << number;
+ {//EN
+ ConfigParserData::LocalizedData locDataEn;
+ locDataEn.name = DPL::FromUTF8String(str_en.str());
+ locDataEn.shortName = DPL::FromUTF8String(str_en.str());
+ locDataEn.description = DPL::FromUTF8String(str_en.str());
+ locDataEn.license = DPL::FromUTF8String(str_en.str());
+ locDataEn.licenseFile = DPL::FromUTF8String(str_en.str());
+ locDataEn.licenseHref = DPL::FromUTF8String(str_en.str());
+ regInfo.configInfo.localizedDataSet.insert(
+ std::make_pair(DPL::FromUTF8String("en"),locDataEn));
+ }
+
+ {//PL
+ ConfigParserData::LocalizedData locDataPl;
+ locDataPl.name = DPL::FromUTF8String(str_pl.str());
+ locDataPl.shortName = DPL::FromUTF8String(str_pl.str());
+ locDataPl.description = DPL::FromUTF8String(str_pl.str());
+ locDataPl.license = DPL::FromUTF8String(str_pl.str());
+ locDataPl.licenseFile = DPL::FromUTF8String(str_pl.str());
+ locDataPl.licenseHref = DPL::FromUTF8String(str_pl.str());
+ regInfo.configInfo.localizedDataSet.insert(
+ std::make_pair(DPL::FromUTF8String("pl"),locDataPl));
+ }
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ RUNNER_ASSERT_MSG(dao.getLanguageTags().size() == 2,
+ "language tags list invalid");
+
+ {//EN
+ WidgetLocalizedInfo locInfo =
+ dao.getLocalizedInfo(DPL::FromUTF8String("en"));
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.name,
+ str_en.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.shortName,
+ str_en.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.description,
+ str_en.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.license,
+ str_en.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.licenseHref,
+ str_en.str());
+ }
+
+ {//PL
+ WidgetLocalizedInfo locInfo =
+ dao.getLocalizedInfo(DPL::FromUTF8String("pl"));
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.name,
+ str_pl.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.shortName,
+ str_pl.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.description,
+ str_pl.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.license,
+ str_pl.str());
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.licenseHref,
+ str_pl.str());
+ }
+ }
+}
+
+/*
+Name: widget_dao_test_register_widget_icons
+Description: Tests registeration of localized icons information
+Expected: values received by dao should match those which were registered
+ for icon
+*/
+RUNNER_TEST(widget_dao_test_register_widget_icons)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+
+ ConfigParserData::Icon icon(L"icon1");
+ icon.width = 10;
+ icon.height = 10;
+ LocaleSet locs;
+ locs.insert(DPL::FromUTF8String("en"));
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ regInfo.localizationData.icons.push_back(locIcon);
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();
+
+ RUNNER_ASSERT(list.size() == regInfo.localizationData.icons.size());
+ WidgetDAOReadOnly::WidgetIconList::const_iterator it1 = list.begin();
+ WidgetRegisterInfo::LocalizedIconList::const_iterator it2 =
+ regInfo.localizationData.icons.begin();
+ for(;it1!=list.end() && it2!=regInfo.localizationData.icons.end();
+ ++it1,++it2)
+ {
+ RUNNER_ASSERT(it2->height == it1->iconHeight);
+ RUNNER_ASSERT(it2->width == it1->iconWidth);
+ RUNNER_ASSERT(it2->src == it1->iconSrc);
+ RUNNER_ASSERT(it2->availableLocales == locs);
+ }
+}
+
+/*
+Name: widget_dao_test_register_widget_start_files
+Description: Tests registeration of localized start files
+Expected: no expectations as it should be removed
+*/
+RUNNER_TEST(widget_dao_test_register_widget_start_files)
+{
+ WacSecurityMock sec;
+
+ WidgetRegisterInfo::LocalizedStartFileList files;
+ WidgetRegisterInfo::StartFilePropertiesForLocalesMap map1;
+ WidgetRegisterInfo::StartFileProperties prop1;
+ prop1.encoding = DPL::FromUTF8String("enc1");
+ prop1.type = DPL::FromUTF8String("type1");
+
+ map1.insert(std::make_pair(DPL::FromUTF8String("en"),prop1));
+ map1.insert(std::make_pair(DPL::FromUTF8String("pl"),prop1));
+
+ WidgetRegisterInfo::LocalizedStartFile file1;
+ WidgetRegisterInfo::LocalizedStartFile file2;
+ file1.path = DPL::FromUTF8String("path1");
+ file1.propertiesForLocales = map1;
+ file2.path = DPL::FromUTF8String("path2");
+ file2.propertiesForLocales = map1;
+
+ files.push_back(file1);
+ files.push_back(file1);
+
+ WidgetRegisterInfo regInfo;
+ regInfo.localizationData.startFiles = files;
+
+ REGISTER_WIDGET(regInfo, sec);
+
+ //TODO no getter in WidgetDAO (getter in LocalizedWidgetDAO,
+ // but it will be removed
+}
+
+/*
+Name: widget_dao_test_register_widget_features
+Description: Tests registeration of features of widget
+Expected: number of features should match (for given widget reginfo)
+*/
+RUNNER_TEST(widget_dao_test_register_widget_features)
+{
+ WacSecurityMock sec;
+ ConfigParserData::FeaturesList features;
+ features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f1"),true));
+ features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f2")));
+ features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f3"),
+ false));
+
+ WidgetRegisterInfo regInfo;
+ FOREACH(it, features)
+ regInfo.configInfo.featuresList.insert(*it);
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ WidgetFeatureSet out = dao.getFeaturesList();
+ RUNNER_ASSERT_MSG(out.size() == features.size(),
+ "wrong number of features");
+// FOREACH(it, out)
+// RUNNER_ASSERT(features.find(*it) != features.end());
+}
+
+/*
+Name: widget_dao_test_register_widget_security_settings
+Description: Tests registeration of dafault values of security settings
+Expected: widget should be registered in database.
+ Returned values should match dafault.
+*/
+RUNNER_TEST(widget_dao_test_register_widget_security_settings)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_ON, "SecurityPopupUsage is not deafult on");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON, "GeolocationUsage is not deafult on");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage is not deafult on");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage is not deafult on");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage is not deafult on");
+
+ dao.setSecurityPopupUsage(WrtDB::SETTINGS_TYPE_OFF);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+
+ dao.setGeolocationUsage(WrtDB::SETTINGS_TYPE_ALWAYS_ASK);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+
+ dao.setWebNotificationUsage(WrtDB::SETTINGS_TYPE_OFF);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+
+ dao.setWebDatabaseUsage(WrtDB::SETTINGS_TYPE_ALWAYS_ASK);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+
+ dao.setFileSystemUsage(WrtDB::SETTINGS_TYPE_OFF);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_OFF, "FileSystemUsage - wrong value");
+
+ dao.setFileSystemUsage(WrtDB::SETTINGS_TYPE_ON);
+ RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+}
+
+/*
+Name: widget_dao_test_register_widget_win_modes
+Description: Tests registeration of window modes
+Expected: all modes should be returned from dao
+*/
+RUNNER_TEST(widget_dao_test_register_widget_win_modes)
+{
+ WacSecurityMock sec;
+ std::set<DPL::String> modes;
+ modes.insert(DPL::FromUTF8String("full"));
+ modes.insert(DPL::FromUTF8String("window"));
+
+ WidgetRegisterInfo regInfo;
+
+ FOREACH(it, modes)
+ regInfo.configInfo.windowModes.insert(*it);
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+ std::list<DPL::String> wins = dao.getWindowModes();
+ RUNNER_ASSERT_MSG(modes.size() == wins.size(),
+ "wrong number of window modes");
+ FOREACH(it, wins)
+ RUNNER_ASSERT(modes.find(*it) != modes.end());
+}
+
+/*
+Name: widget_dao_test_register_widget_warp_info
+Description: Tests registeration of access info iris
+Expected: all access info iris should be returned from dao
+*/
+RUNNER_TEST(widget_dao_test_register_widget_warp_info)
+{
+ WacSecurityMock sec;
+ ConfigParserData::AccessInfoSet orig;
+ orig.insert(ConfigParserData::AccessInfo(DPL::FromUTF8String("iri1"),
+ true));
+ orig.insert(ConfigParserData::AccessInfo(DPL::FromUTF8String("iri2"),
+ false));
+ orig.insert(ConfigParserData::AccessInfo(DPL::FromUTF8String("iri3"),
+ true));
+
+ WidgetRegisterInfo regInfo;
+ FOREACH(it, orig)
+ regInfo.configInfo.accessInfoSet.insert(*it);
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+
+ WidgetAccessInfoList out;
+ dao.getWidgetAccessInfo(out);
+ RUNNER_ASSERT_MSG(out.size() == orig.size(),
+ "wrong number of access info elem");
+ FOREACH(it, out){
+ ConfigParserData::AccessInfo tmp(it->strIRI,it->bSubDomains);
+ RUNNER_ASSERT(orig.find(tmp) != orig.end());
+ }
+}
+
+/*
+Name: widget_dao_test_register_widget_certificates
+Description: Tests registeration of widget certificates
+Expected: all certificates should be returned from dao
+ and should contain inserted data
+*/
+RUNNER_TEST(widget_dao_test_register_widget_certificates)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+
+ WidgetCertificateData cert;
+ cert.owner = WidgetCertificateData::AUTHOR;
+ cert.type = WidgetCertificateData::ROOT;
+ cert.chainId = 1;
+ cert.strMD5Fingerprint = "md5";
+ cert.strSHA1Fingerprint = "sha1";
+ cert.strCommonName = DPL::FromUTF8String("common name");
+
+ WidgetCertificateDataList& certListRef = sec.getCertificateListRef();
+ certListRef.push_back(cert);
+
+ // register widget
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+
+ // certificates
+ WidgetCertificateDataList recList = dao.getCertificateDataList();
+ RUNNER_ASSERT(recList.size() == certListRef.size());
+
+ auto recListIt = recList.begin();
+ auto certListIt = certListRef.begin();
+ for(;recListIt != recList.end() && certListIt != certListRef.end();
+ ++recListIt,++certListIt)
+ {
+ RUNNER_ASSERT(recListIt->chainId == certListIt->chainId);
+ RUNNER_ASSERT(recListIt->owner == certListIt->owner);
+ RUNNER_ASSERT(recListIt->strCommonName == certListIt->strCommonName);
+ RUNNER_ASSERT(recListIt->strMD5Fingerprint ==
+ certListIt->strMD5Fingerprint);
+ RUNNER_ASSERT(recListIt->strSHA1Fingerprint ==
+ certListIt->strSHA1Fingerprint);
+ RUNNER_ASSERT(recListIt->type == certListIt->type);
+ }
+
+ // fingerprints
+ RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::DISTRIBUTOR,
+ WidgetCertificateData::ENDENTITY).empty());
+ RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::AUTHOR,
+ WidgetCertificateData::ENDENTITY).empty());
+ RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::DISTRIBUTOR,
+ WidgetCertificateData::ROOT).empty());
+
+ FingerPrintList fingerprints = dao.getKeyFingerprints(
+ WidgetCertificateData::AUTHOR,
+ WidgetCertificateData::ROOT);
+
+ RUNNER_ASSERT(fingerprints.size() == certListRef.size()*2);
+ FOREACH(it, certListRef)
+ {
+ auto md5 = std::find(fingerprints.begin(),
+ fingerprints.end(),
+ it->strMD5Fingerprint);
+ RUNNER_ASSERT(md5 != fingerprints.end());
+
+ auto sha = std::find(fingerprints.begin(),
+ fingerprints.end(),
+ it->strSHA1Fingerprint);
+ RUNNER_ASSERT(sha != fingerprints.end());
+ }
+
+ // common names
+ RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::DISTRIBUTOR,
+ WidgetCertificateData::ENDENTITY).empty());
+ RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::AUTHOR,
+ WidgetCertificateData::ENDENTITY).empty());
+ RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::DISTRIBUTOR,
+ WidgetCertificateData::ROOT).empty());
+
+ FingerPrintList commonNames = dao.getKeyCommonNameList(
+ WidgetCertificateData::AUTHOR,
+ WidgetCertificateData::ROOT);
+
+ RUNNER_ASSERT(commonNames.size() == certListRef.size());
+ FOREACH(it, certListRef)
+ {
+ auto cn = std::find(commonNames.begin(),
+ commonNames.end(),
+ DPL::ToUTF8String(it->strCommonName));
+ RUNNER_ASSERT(cn != commonNames.end());
+ }
+}
+
+/*
+Name: widget_dao_test_is_widget_installed
+Description: Tests checking if widgets are installed
+Expected: installed widgets should be stated as installed
+*/
+RUNNER_TEST(widget_dao_test_is_widget_installed)
+{
+ RUNNER_ASSERT(WidgetDAO::isWidgetInstalled(L"tizenid201"));
+
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ RUNNER_ASSERT(WidgetDAO::isWidgetInstalled(pkgname));
+}
+
+/*
+Name: widget_dao_test_unregister_widget
+Description: Tests unregistering widgets
+Expected: widget register informations should be successfully removed
+*/
+RUNNER_TEST(widget_dao_test_unregister_widget)
+{
+ WacSecurityMock sec;
+ WidgetHandleList handles = WidgetDAO::getHandleList();
+
+ WidgetRegisterInfo regInfo;
+
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO::unregisterWidget(pkgname);
+
+ RUNNER_ASSERT_MSG(handles.size() == WidgetDAO::getHandleList().size(),
+ "Widget unregister failed");
+}
+
+/*
+Name: widget_dao_test_register_or_update_widget
+Description: Tests reregistering widgets
+Expected: widget should be successfully replaced
+*/
+RUNNER_TEST(widget_dao_test_register_or_update_widget)
+{
+ WacSecurityMock sec;
+
+ WidgetRegisterInfo regInfo;
+ regInfo.configInfo.version = L"1.0";
+ regInfo.configInfo.authorName = L"AAA";
+
+ WidgetRegisterInfo regInfo2;
+ regInfo2.configInfo.version = L"1.1";
+ regInfo2.configInfo.authorName = L"BBB";
+
+ WrtDB::WidgetPkgName pkgname(L"abcdefghij");
+
+ //first installation
+ WidgetDAO::registerWidget(pkgname, regInfo, sec);
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname), "Widget is not registered");
+
+ //success full update
+ WidgetDAO::registerOrUpdateWidget(pkgname, regInfo2, sec);
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname), "Widget is not reregistered");
+ WidgetDAO dao(pkgname);
+ RUNNER_ASSERT_MSG(*dao.getVersion() == L"1.1", "Data widget was not updated");
+ RUNNER_ASSERT_MSG(*dao.getAuthorName() == L"BBB", "Data widget was not updated");
+
+ WidgetDAO::unregisterWidget(pkgname);
+}
+
+/*
+Name: widget_dao_test_get_widget_pkgname_list
+Description: Tests getPkgnameList API for backendlib
+Expected: For all position in database should be returned one item in list
+*/
+RUNNER_TEST(widget_dao_test_get_widget_pkgname_list)
+{
+ WidgetPkgNameList pkgnames = WidgetDAO::getPkgnameList();
+ RUNNER_ASSERT(pkgnames.size() >= 3);
+}
+
+/*
+Name: widget_dao_test_get_widget_list
+Description: Tests getPkgnameList API for backendlib
+Expected: For all position in database should be returned one item in list
+ Those item should contain valid pkgname
+*/
+RUNNER_TEST(widget_dao_test_get_widget_list)
+{
+ WidgetDAOReadOnlyList list = WidgetDAOReadOnly::getWidgetList();
+ RUNNER_ASSERT(list.size() >= 3);
+ RUNNER_ASSERT_MSG(!!list.front(), "widget dao exists");
+ WidgetDAOReadOnlyPtr dao = list.front();
+}
+
+/*
+Name: widget_dao_test_get_widget_attributes
+Description: Tests returning basic widget attributes by dao
+Expected: Attributes should match values inserted into database
+*/
+RUNNER_TEST(widget_dao_test_get_widget_attributes)
+{
+ {
+ WidgetPkgName pkgname = L"tizenid201";
+ WidgetDAO dao(pkgname);
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getGUID(), "w_id_2000");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getVersion(), "1.0.0");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorName(), "a_name_2000");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorEmail(),
+ "a_email_2000");
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorHref(), "a_href_2000");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.getBaseFolder(), "basef_2000/");
+ RUNNER_ASSERT(dao.getWebkitPluginsRequired() == true);
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getMinimumWacVersion(), "1.0");
+ }
+}
+
+/*
+Name: widget_dao_test_localization
+Description: Tests inserting and returning localization info
+Expected: Values inserted into database should match values received from database
+*/
+RUNNER_TEST(widget_dao_test_localization)
+{
+ WacSecurityMock sec;
+
+ // icon
+ WidgetRegisterInfo regInfo;
+ ConfigParserData::Icon icon(L"icon1");
+ icon.width = 10;
+ icon.height = 10;
+ LocaleSet locs;
+ locs.insert(DPL::FromUTF8String("en"));
+ locs.insert(DPL::FromUTF8String("pl"));
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ regInfo.localizationData.icons.push_back(locIcon);
+
+ //start file
+ WidgetRegisterInfo::StartFileProperties prop_en;
+ prop_en.encoding = DPL::FromUTF8String("encoding_en");
+ prop_en.type = DPL::FromUTF8String("type_en");
+
+ WidgetRegisterInfo::StartFileProperties prop_pl;
+ prop_pl.encoding = DPL::FromUTF8String("encoding_pl");
+ prop_pl.type = DPL::FromUTF8String("type_pl");
+
+ WidgetRegisterInfo::LocalizedStartFile file;
+ file.path = DPL::FromUTF8String("path");
+ file.propertiesForLocales.insert(
+ std::make_pair(DPL::FromUTF8String("en"), prop_en));
+ file.propertiesForLocales.insert(
+ std::make_pair(DPL::FromUTF8String("pl"), prop_pl));
+ regInfo.localizationData.startFiles.push_back(file);
+
+ // register widget
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(pkgname);
+
+ // check localized icons
+ WidgetDAO::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
+ RUNNER_ASSERT(locList.size() == locs.size());
+
+ // non-localized icon
+ WidgetDAO::WidgetIconList list = dao.getIconList();
+ int iconId = list.front().iconId;
+
+ // compare every icon with the origin
+ auto locsIt = locs.begin();
+ auto iconIt = locList.begin();
+ for(;locsIt!=locs.end() && iconIt!=locList.end();++locsIt,++iconIt) {
+ RUNNER_ASSERT(iconIt->appId == dao.getHandle());
+ RUNNER_ASSERT(iconIt->iconId == iconId);
+ RUNNER_ASSERT(iconIt->widgetLocale == *locsIt);
+ }
+
+ // localized start file list
+ WidgetDAO::LocalizedStartFileList fList = dao.getLocalizedStartFileList();
+ RUNNER_ASSERT(fList.size() == file.propertiesForLocales.size());
+
+ int startFileId = dao.getStartFileList().front().startFileId;
+
+ FOREACH(it,fList)
+ {
+ RUNNER_ASSERT(it->appId == dao.getHandle());
+ auto propIt = file.propertiesForLocales.find(it->widgetLocale);
+ RUNNER_ASSERT(propIt != file.propertiesForLocales.end());
+ RUNNER_ASSERT(it->encoding == propIt->second.encoding);
+ RUNNER_ASSERT(it->type == propIt->second.type);
+ RUNNER_ASSERT(it->startFileId == startFileId);
+ }
+}
+
+/*
+Name: widget_dao_test_wac_security
+Description: Tests inserting and returning wac security information
+Expected: Values inserted into database should match values received from database
+*/
+RUNNER_TEST(widget_dao_test_wac_security)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+ {
+ // register widget
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(pkgname);
+
+ RUNNER_ASSERT(!dao.isDistributorSigned());
+ RUNNER_ASSERT(!dao.isRecognized());
+ RUNNER_ASSERT(!dao.isWacSigned());
+ }
+ sec.setDistributorSigned(true);
+ sec.setRecognized(true);
+ sec.setWacSigned(true);
+ {
+ // register widget
+ WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(pkgname);
+
+ RUNNER_ASSERT(dao.isDistributorSigned());
+ RUNNER_ASSERT(dao.isRecognized());
+ RUNNER_ASSERT(dao.isWacSigned());
+ }
+}
+
+#undef RUNNER_ASSERT_WHAT_EQUALS
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file tests_plugin_dao.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for plugin dao class.
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/log/log.h>
+#include <dpl/wrt-dao-ro/WrtDatabase.h>
+#include <wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h>
+
+int main (int argc, char *argv[])
+{
+ int ret = system("/usr/bin/wrt_dao_tests_prepare_db.sh start");
+ if (ret != 0) {
+ LogError("Preparation script has return error: " << ret
+ << ". Quitting");
+ return -1;
+ }
+
+ WrtDB::WrtDatabase::attachToThreadRW();
+ CustomHandlerDB::Interface::attachDatabaseRW();
+
+ LogInfo("Starting tests");
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+
+ CustomHandlerDB::Interface::detachDatabase();
+ WrtDB::WrtDatabase::detachFromThread();
+
+ ret = system("/usr/bin/wrt_dao_tests_prepare_db.sh stop");
+ if (ret != 0) {
+ LogError("Finalization script has return error: " << ret);
+ return -1;
+ }
+ return status;
+}
--- /dev/null
+#!/bin/sh
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+
+WRT_DB=/opt/dbspace/.wrt.db
+WRT_DB_BCK=/tmp/wrt.db_backup
+
+if [ "x$1" == "xstart" ]; then
+ echo start;
+ cp $WRT_DB $WRT_DB_BCK
+ wrt_commons_create_clean_db.sh;
+
+ #simple plugins
+ INS_MIN_PLUGINPROP="insert into PluginProperties(PluginPropertiesId, InstallationState, PluginLibraryName"
+ INS_ALL_PLUGINPROP="insert into PluginProperties(PluginPropertiesId, InstallationState, PluginLibraryName, PluginLibraryPath)"
+ INS_PLUGIN_OBJECTS="insert into PluginImplementedObjects(PluginObject, PluginPropertiesId)"
+
+ sqlite3 $WRT_DB "${INS_MIN_PLUGINPROP}) VALUES(1, 1, 'plugin1')";
+ sqlite3 $WRT_DB "${INS_MIN_PLUGINPROP}, PluginLibraryPath) VALUES(2, 1, 'plugin2', 'path_to_plugin2')";
+ sqlite3 $WRT_DB "${INS_MIN_PLUGINPROP}) VALUES(3, 1, 'plugin3')";
+ sqlite3 $WRT_DB "${INS_ALL_PLUGINPROP} VALUES(4, 1, 'p4', 'path_to_p4')";
+ sqlite3 $WRT_DB "${INS_ALL_PLUGINPROP} VALUES(5, 1, 'p5', 'path_to_p5')";
+
+ #plugin dependendencies
+ #sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES(1, )";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('', 2)";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('Plugin_3_Object_A', 3)";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('Plugin_4_Object_A', 4)";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('Plugin_4_Object_B', 4)";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('Plugin_4_Object_C', 4)";
+ sqlite3 $WRT_DB "${INS_PLUGIN_OBJECTS} VALUES('Plugin_5_Object_A', 5)";
+
+
+ #simple features
+ INS_ALL_FEATURESLIST="insert into FeaturesList(FeatureUUID, FeatureName, PluginPropertiesId)"
+ sqlite3 $WRT_DB "${INS_ALL_FEATURESLIST} VALUES(1, 'feature1', 1)";
+ sqlite3 $WRT_DB "${INS_ALL_FEATURESLIST} VALUES(2, 'feature2', 4)";
+ sqlite3 $WRT_DB "${INS_ALL_FEATURESLIST} VALUES(3, 'feature3', 4)";
+ sqlite3 $WRT_DB "${INS_ALL_FEATURESLIST} VALUES(4, 'feature4', 4)";
+
+ #device capabilities
+ INS_ALL_DEVICECAPS="insert into DeviceCapabilities(DeviceCapID, DeviceCapName, DeviceCapDefaultValue)"
+ sqlite3 $WRT_DB "${INS_ALL_DEVICECAPS} VALUES(1, 'devicecap1', 1)";
+ sqlite3 $WRT_DB "${INS_ALL_DEVICECAPS} VALUES(2, 'devicecap2', 2)";
+ sqlite3 $WRT_DB "${INS_ALL_DEVICECAPS} VALUES(3, 'devicecap3', 3)";
+ sqlite3 $WRT_DB "${INS_ALL_DEVICECAPS} VALUES(4, 'devicecap4', 4)";
+
+ #Widgets
+ INS_ALL_WIDGETEXT="insert into WidgetExtendedInfo(app_id, share_href, signature_type)"
+ INS_ALL_WIDGET="insert into WidgetInfo(app_id, widget_id, widget_version, widget_width, widget_height, author_name, author_email, author_href, base_folder, webkit_plugins_required, recognized, wac_signed, distributor_signed, min_version, pkgname)"
+ INS_ALL_WIDGET_LOC="insert into LocalizedWidgetInfo(app_id, widget_locale, widget_name, widget_shortname, widget_description, widget_license, widget_license_file, widget_license_href)"
+ INS_ALL_WIDGET_ICONS="insert into WidgetIcon(app_id, icon_src, icon_width, icon_height)"
+ INS_ALL_WIDGET_LOC_ICONS="insert into WidgetLocalizedIcon(app_id, icon_id, widget_locale)"
+ INS_ALL_WIDGET_STARTFILE="insert into WidgetStartFile(app_id, src)"
+ INS_ALL_WIDGET_LOC_STARTFILE="insert into WidgetLocalizedStartFile(app_id, start_file_id, widget_locale, type, encoding)"
+ INS_ALL_WIDGET_DEFPREF="insert into WidgetDefaultPreference(app_id, key_name, key_value, readonly)"
+ INS_ALL_WIDGET_PREF="insert into WidgetPreference(pkgname, key_name, key_value, readonly)"
+ INS_ALL_WIDGET_FEATURE="insert into WidgetFeature(app_id, name, required)"
+ INS_ALL_WIDGET_FEATURE_PARAM="insert into FeatureParam(widget_feature_id, name, value)"
+ INS_ALL_WIDGET_WINMODES="insert into WidgetWindowModes(app_id, window_mode)"
+ INS_ALL_WIDGET_WARP="insert into WidgetWARPInfo(app_id, iri, subdomain_access)"
+ INS_ALL_WIDGET_CERT="insert into WidgetCertificateFingerprint(app_id, owner, chainid, type, md5_fingerprint, sha1_fingerprint, common_name)"
+ INS_ALL_WIDGET_POWDERLEV="insert into PowderLevels(app_id, category, level)"
+ INS_ALL_WIDGET_POWDERLEV_CONT="insert into PowderLevelContexts(levelid, context)"
+
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(2000, 'w_id_2000', '1.0.0', 100, 200, 'a_name_2000', 'a_email_2000', 'a_href_2000', 'basef_2000', 1, 1, 1, 1, '1.0', 'tizenid201')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(2001, 'w_id_2001', '2.0.0', 100, 200, 'a_name_2001', 'a_email_2001', 'a_href_2001', 'basef_2001', 1, 1, 1, 1, '0.5', 'tizenid202')";
+ sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, pkgname) VALUES(2002, 0, 'tizenid203')";
+ sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, pkgname) VALUES(2003, 0, 'tizenid204')"; # for properties tests
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(2000, 'share_href_2000', 0)";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(2001, 'share_href_2001', 0)";
+ sqlite3 $WRT_DB "insert into WidgetExtendedInfo(app_id) VALUES(2002)";
+ sqlite3 $WRT_DB "insert into WidgetExtendedInfo(app_id) VALUES(2003)";
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC} VALUES(2000, 'en', 'w_name_2000_en', 'w_shortname_2000_en', 'w_desc_2000_en', 'w_lic_2000_en', 'w_licf_2000_en', 'w_lic_href_2000_en')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC} VALUES(2000, 'pl', 'w_name_2000_pl', 'w_shortname_2000_pl', 'w_desc_2000_pl', 'w_lic_2000_pl', 'w_licf_2000_pl', 'w_lic_href_2000_pl')";
+ sqlite3 $WRT_DB "insert into LocalizedWidgetInfo(app_id, widget_locale) VALUES(2002, 'en')";
+ sqlite3 $WRT_DB "insert into LocalizedWidgetInfo(app_id, widget_locale) VALUES(2003, 'en')";
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_ICONS} VALUES(2000, 'icon_src_2000', 50, 50)";
+ sqlite3 $WRT_DB "insert into WidgetIcon(app_id, icon_src) VALUES(2002, 'icon_src_2002')";
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC_ICONS} VALUES(2000, 1, 'en')";
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_STARTFILE} VALUES(2000, 'start_file_2000')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_STARTFILE} VALUES(2001, 'start_file_2001')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_STARTFILE} VALUES(2002, 'start_file_2002')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_STARTFILE} VALUES(2003, 'start_file_2003')";
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC_STARTFILE} VALUES(2000, 1, 'en', '', '')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC_STARTFILE} VALUES(2001, 2, 'en', '', '')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC_STARTFILE} VALUES(2002, 3, 'en', '', '')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_LOC_STARTFILE} VALUES(2003, 4, 'en', '', '')";
+
+ #widget properties
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid201', 'key1_for_2000', 'value_for_key1_2000', 0)";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid201', 'key2_for_2000', 'value_for_key2_2000', 0)";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid202', 'key1_for_2001', 'value1_for_key_2001', 1)";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid203', 'key1_for_2002', 'value1_for_key_2002', 0)";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid203', 'key2_for_2002', 'value2_for_key_2002', 1)";
+
+ #create if not exists and fix autoincrement value
+ sqlite3 $WRT_DB "INSERT INTO WidgetInfo(pkgname) VALUES('temp')";
+ sqlite3 $WRT_DB "DELETE FROM WidgetInfo WHERE pkgname = 'temp'";
+ sqlite3 $WRT_DB "UPDATE sqlite_sequence SET seq = 2004 WHERE name = 'WidgetInfo'";
+
+ exit $?
+
+elif [ "x$1" == "xstop" ]; then
+ echo stop;
+ cp $WRT_DB_BCK $WRT_DB
+ exit $?
+else
+ exit 1
+fi
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+SET(TESTS_DPL_DIR "${TESTS_DIR}/dpl")
+
+ADD_SUBDIRECTORY(core)
+ADD_SUBDIRECTORY(db)
+ADD_SUBDIRECTORY(dbus)
+ADD_SUBDIRECTORY(event)
+#ADD_SUBDIRECTORY(localization) TODO localization mockups need to be fixed
+ADD_SUBDIRECTORY(utils)
--- /dev/null
+Unit tests for dpl library functionality.
+There are 6 binaries: dpl-dbus-test-service, dpl-tests-core, dpl-tests-db,
+dpl-tests-dbus, dpl-tests-event, dpl-tests-utils.
+All binaries are using our test framework - it allows to use different types of
+output. Text output shows results on console - green passed.
+To run:
+1. Install wrt-extra on target
+2. Run for f in /usr/bin/dpl-tests-*; do $f --output=text; done
+
+Automatic: YES
+Included in Daily Build: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-INT)
+Included in Gerrit Builds: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-GERRIT)
+Number of test cases: 151
\ No newline at end of file
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+#
+# Test files
+#
+# Define all DPL tests sources.
+# Runner is responsible for runnint it all and
+# generating proper output files
+#
+
+SET(TARGET_NAME "dpl-tests-core")
+
+# Set DPL tests sources
+SET(DPL_TESTS_CORE_SOURCES
+ ${TESTS_DPL_DIR}/core/main.cpp
+ ${TESTS_DPL_DIR}/core/test_address.cpp
+ ${TESTS_DPL_DIR}/core/test_binary_queue.cpp
+ ${TESTS_DPL_DIR}/core/test_foreach.cpp
+ ${TESTS_DPL_DIR}/core/test_fast_delegate.cpp
+ ${TESTS_DPL_DIR}/core/test_log_unhandled_exception.cpp
+ ${TESTS_DPL_DIR}/core/test_once.cpp
+ ${TESTS_DPL_DIR}/core/test_serialization.cpp
+ ${TESTS_DPL_DIR}/core/test_scoped_array.cpp
+ ${TESTS_DPL_DIR}/core/test_scoped_close.cpp
+ ${TESTS_DPL_DIR}/core/test_scoped_fclose.cpp
+ ${TESTS_DPL_DIR}/core/test_scoped_free.cpp
+ ${TESTS_DPL_DIR}/core/test_scoped_ptr.cpp
+ ${TESTS_DPL_DIR}/core/test_semaphore.cpp
+ ${TESTS_DPL_DIR}/core/test_shared_ptr.cpp
+ ${TESTS_DPL_DIR}/core/test_string.cpp
+ ${TESTS_DPL_DIR}/core/test_thread.cpp
+ ${TESTS_DPL_DIR}/core/test_type_list.cpp
+ ${TESTS_DPL_DIR}/core/test_zip_input.cpp
+)
+
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_EFL})
+WRT_TEST_BUILD(${TARGET_NAME} ${DPL_TESTS_CORE_SOURCES})
+WRT_TEST_INSTALL(${TARGET_NAME})
+
+INSTALL(FILES
+ ${TESTS_DPL_DIR}/core/data/sample.zip
+ DESTINATION /opt/share/wrt/wrt-commons/tests/core
+ )
--- /dev/null
+!!!options!!! stop
+Test code
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file main.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main
+ */
+#include <dpl/test/test_runner.h>
+
+int main(int argc, char *argv[])
+{
+ return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_address.cpp
+ * @author Tomasz Swierczek (t.swierczek@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test address
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/address.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(Address_InitialEmpty)
+{
+ DPL::Address address;
+ RUNNER_ASSERT(address.ToString() == ":0");
+}
+
+RUNNER_TEST(Address_InitialAddress)
+{
+ DPL::Address address("www.sample.com");
+ RUNNER_ASSERT(address.ToString() == "www.sample.com:0");
+}
+
+RUNNER_TEST(Address_InitialAddressPort)
+{
+ DPL::Address address("www.somewhere.com", 8080);
+ RUNNER_ASSERT(address.ToString() == "www.somewhere.com:8080");
+}
+
+RUNNER_TEST(Address_Getters)
+{
+ DPL::Address address("www.somewhere.com", 8080);
+ RUNNER_ASSERT(address.GetAddress() == "www.somewhere.com");
+ RUNNER_ASSERT(address.GetPort() == 8080);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_binary_queue.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test binary queue
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/binary_queue.h>
+RUNNER_TEST_GROUP_INIT(DPL)
+
+inline std::string BinaryQueueToString(const DPL::BinaryQueue &queue)
+{
+ char *buffer = new char[queue.Size()];
+ queue.Flatten(buffer, queue.Size());
+ std::string result = std::string(buffer, buffer + queue.Size());
+ delete [] buffer;
+ return result;
+}
+
+RUNNER_TEST(BinaryQueue_InitialEmpty)
+{
+ DPL::BinaryQueue queue;
+ RUNNER_ASSERT(queue.Empty() == true);
+}
+
+RUNNER_TEST(BinaryQueue_InitialSize)
+{
+ DPL::BinaryQueue queue;
+ RUNNER_ASSERT(queue.Size() == 0);
+}
+
+RUNNER_TEST(BinaryQueue_InitialCopy)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy = queue;
+
+ RUNNER_ASSERT(copy.Size() == 0);
+}
+
+RUNNER_TEST(BinaryQueue_InitialConsumeZero)
+{
+ DPL::BinaryQueue queue;
+ queue.Consume(0);
+}
+
+RUNNER_TEST(BinaryQueue_InitialFlattenConsumeZero)
+{
+ DPL::BinaryQueue queue;
+ queue.FlattenConsume(NULL, 0);
+}
+
+RUNNER_TEST(BinaryQueue_InitialFlattenZero)
+{
+ DPL::BinaryQueue queue;
+ queue.Flatten(NULL, 0);
+}
+
+RUNNER_TEST(BinaryQueue_InitialConsumeOne)
+{
+ DPL::BinaryQueue queue;
+
+ Try
+ {
+ queue.Consume(1);
+ }
+ Catch (DPL::BinaryQueue::Exception::OutOfData)
+ {
+ return;
+ }
+
+ RUNNER_FAIL;
+}
+
+RUNNER_TEST(BinaryQueue_InitialFlattenConsumeOne)
+{
+ DPL::BinaryQueue queue;
+
+ Try
+ {
+ char data;
+ queue.FlattenConsume(&data, 1);
+ }
+ Catch (DPL::BinaryQueue::Exception::OutOfData)
+ {
+ return;
+ }
+
+ RUNNER_FAIL;
+}
+
+RUNNER_TEST(BinaryQueue_InitialFlattenOne)
+{
+ DPL::BinaryQueue queue;
+
+ Try
+ {
+ char data;
+ queue.Flatten(&data, 1);
+ }
+ Catch (DPL::BinaryQueue::Exception::OutOfData)
+ {
+ return;
+ }
+
+ RUNNER_FAIL;
+}
+
+RUNNER_TEST(BinaryQueue_ZeroCopyFrom)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ copy.AppendCopyFrom(queue);
+ RUNNER_ASSERT(queue.Empty());
+}
+
+RUNNER_TEST(BinaryQueue_ZeroMoveFrom)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ copy.AppendMoveFrom(queue);
+ RUNNER_ASSERT(queue.Empty());
+}
+
+RUNNER_TEST(BinaryQueue_ZeroCopyTo)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ queue.AppendCopyTo(copy);
+ RUNNER_ASSERT(queue.Empty());
+}
+
+RUNNER_TEST(BinaryQueue_InsertSingleCharacters)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("a", 1);
+ queue.AppendCopy("b", 1);
+ queue.AppendCopy("c", 1);
+ queue.AppendCopy("d", 1);
+
+ RUNNER_ASSERT(queue.Size() == 4);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "abcd");
+}
+
+RUNNER_TEST(BinaryQueue_Consume)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ RUNNER_ASSERT(queue.Size() == 6);
+
+ queue.Consume(1);
+ RUNNER_ASSERT(queue.Size() == 5);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "bcdef");
+
+ queue.Consume(2);
+ RUNNER_ASSERT(queue.Size() == 3);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "def");
+
+ queue.Consume(1);
+ RUNNER_ASSERT(queue.Size() == 2);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "ef");
+
+ queue.Consume(2);
+ RUNNER_ASSERT(queue.Size() == 0);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "");
+}
+
+RUNNER_TEST(BinaryQueue_Flatten)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+ queue.AppendCopy("g", 1);
+
+ RUNNER_ASSERT(queue.Size() == 7);
+
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "abcdefg");
+}
+
+RUNNER_TEST(BinaryQueue_FlattenConsume)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ RUNNER_ASSERT(queue.Size() == 6);
+
+ char buffer[7] = { '\0' };
+ queue.FlattenConsume(buffer, 3);
+
+ RUNNER_ASSERT(queue.Size() == 3);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "def");
+}
+
+RUNNER_TEST(BinaryQueue_AppendCopyFrom)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ copy.AppendCopyFrom(queue);
+
+ RUNNER_ASSERT(queue.Size() == 6);
+ RUNNER_ASSERT(copy.Size() == 6);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "abcdef");
+ RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
+}
+
+RUNNER_TEST(BinaryQueue_AppendCopyTo)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ queue.AppendCopyTo(copy);
+
+ RUNNER_ASSERT(queue.Size() == 6);
+ RUNNER_ASSERT(copy.Size() == 6);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "abcdef");
+ RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
+}
+
+RUNNER_TEST(BinaryQueue_AppendMoveFrom)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ copy.AppendMoveFrom(queue);
+
+ RUNNER_ASSERT(queue.Size() == 0);
+ RUNNER_ASSERT(copy.Size() == 6);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "");
+ RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
+}
+
+RUNNER_TEST(BinaryQueue_AppendMoveTo)
+{
+ DPL::BinaryQueue queue;
+ DPL::BinaryQueue copy;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ queue.AppendMoveTo(copy);
+
+ RUNNER_ASSERT(queue.Size() == 0);
+ RUNNER_ASSERT(copy.Size() == 6);
+ RUNNER_ASSERT(BinaryQueueToString(queue) == "");
+ RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
+}
+
+class Visitor
+ : public DPL::BinaryQueue::BucketVisitor
+{
+private:
+ int m_index;
+
+public:
+ Visitor()
+ : m_index(0)
+ {
+ }
+
+ virtual void OnVisitBucket(const void *buffer, size_t bufferSize)
+ {
+ const char *str = static_cast<const char *>(buffer);
+
+ if (m_index == 0)
+ {
+ RUNNER_ASSERT(bufferSize == 4);
+ RUNNER_ASSERT(str[0] == 'a');
+ RUNNER_ASSERT(str[1] == 'b');
+ RUNNER_ASSERT(str[2] == 'c');
+ RUNNER_ASSERT(str[3] == 'd');
+ }
+ else if (m_index == 1)
+ {
+ RUNNER_ASSERT(bufferSize == 2);
+ RUNNER_ASSERT(str[0] == 'e');
+ RUNNER_ASSERT(str[1] == 'f');
+ }
+ else
+ {
+ RUNNER_FAIL;
+ }
+
+ ++m_index;
+ }
+};
+
+RUNNER_TEST(BinaryQueue_Visitor)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("abcd", 4);
+ queue.AppendCopy("ef", 2);
+
+ Visitor visitor;
+ queue.VisitBuckets(&visitor);
+}
+
+RUNNER_TEST(BinaryQueue_AbstracInputRead)
+{
+ DPL::BinaryQueue queue;
+
+ queue.AppendCopy("abcd", 4);
+
+ queue.Read(0);
+
+ RUNNER_ASSERT(BinaryQueueToString(*queue.Read(1).get()) == "a");
+ RUNNER_ASSERT(BinaryQueueToString(*queue.Read(2).get()) == "bc");
+ RUNNER_ASSERT(BinaryQueueToString(*queue.Read(1).get()) == "d");
+
+ RUNNER_ASSERT(queue.Size() == 0);
+}
+
+RUNNER_TEST(BinaryQueue_AbstracOutputWrite)
+{
+ DPL::BinaryQueue queue;
+ queue.AppendCopy("abcd", 4);
+
+ DPL::BinaryQueue stream;
+
+ stream.Write(queue, 4);
+
+ RUNNER_ASSERT(BinaryQueueToString(*queue.Read(4).get()) == "abcd");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_fast_delegate.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of fast delegate tests.
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/fast_delegate.h>
+#include <dpl/log/log.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+// Sample copied and adopted from
+// http://www.codeproject.com/KB/cpp/FastDelegate.aspx
+//
+// Demonstrate the syntax for FastDelegates.
+// -Don Clugston, May 2004.
+// It's a really boring example, but it shows the most important cases.
+// Declare some functions of varying complexity...
+void SimpleStaticFunction(int num, const char *str);
+void SimpleStaticFunction(int num, const char *str)
+{
+ LogDebug("In SimpleStaticFunction. Num=" << num << ", str =" << str);
+}
+
+void SimpleVoidFunction();
+void SimpleVoidFunction()
+{
+ LogDebug("In SimpleVoidFunction with no parameters.");
+}
+
+class CBaseClass
+{
+protected:
+ const char *m_name;
+
+public:
+ CBaseClass(const char *name)
+ : m_name(name)
+ {
+ }
+
+ virtual ~CBaseClass()
+ {
+ }
+
+ void SimpleMemberFunction(int num, const char *str)
+ {
+ LogDebug("In SimpleMemberFunction in " << m_name << ". Num="
+ << num << ", str = " << str);
+ }
+
+ int SimpleMemberFunctionReturnsInt(int num, const char *str)
+ {
+ LogDebug("In SimpleMemberFunctionReturnsInt in " << m_name << ". Num="
+ << num << ", str = " << str);
+ return -1;
+ }
+
+ void ConstMemberFunction(int num, const char *str) const
+ {
+ LogDebug("In ConstMemberFunction in " << m_name << ". Num="
+ << num << ", str = " << str);
+ }
+
+ virtual void SimpleVirtualFunction(int num, const char *str)
+ {
+ LogDebug("In SimpleVirtualFunction in " << m_name << ". Num="
+ << num << ", str = " << str);
+ }
+
+ static void StaticMemberFunction(int num, const char *str)
+ {
+ LogDebug("In StaticMemberFunction Num="
+ << num << ", str = " << str);
+ }
+};
+
+class COtherClass
+{
+ double rubbish; // to ensure this class has non-zero size.
+
+public:
+ virtual ~COtherClass()
+ {
+ }
+
+ virtual void UnusedVirtualFunction(void)
+ {
+ }
+ virtual void TrickyVirtualFunction(int num, const char *str) = 0;
+};
+
+class VeryBigClass
+{
+ int letsMakeThingsComplicated[400];
+};
+
+// This declaration ensures that we get a convoluted class heirarchy.
+class CDerivedClass
+ : public VeryBigClass,
+ virtual public COtherClass,
+ virtual public CBaseClass
+{
+ double m_somemember[8];
+
+public:
+ CDerivedClass()
+ : CBaseClass("Base of Derived")
+ {
+ m_somemember[0] = 1.2345;
+ }
+
+ void SimpleDerivedFunction(int num, const char *str)
+ {
+ LogDebug("In SimpleDerivedFunction Num="
+ << num << ", str = " << str);
+ }
+
+ virtual void AnotherUnusedVirtualFunction(int num, const char *str)
+ {
+ LogDebug("In AnotherUnusedVirtualFunction in " << m_name << ". Num="
+ << num << ", str = " << str);
+ }
+
+ virtual void TrickyVirtualFunction(int num, const char *str)
+ {
+ LogDebug("In TrickyVirtualFunction in " << m_name << ". Num="
+ << num << ", str = " << str);
+ }
+};
+
+RUNNER_TEST(FastDelegate_Test)
+{
+ // Delegates with up to 8 parameters are supported.
+ // Here's the case for a void function.
+ // We declare a delegate and attach it to SimpleVoidFunction()
+ DPL::FastDelegate0<> noparameterdelegate(&SimpleVoidFunction);
+
+ // invoke the delegate - this calls SimpleVoidFunction()
+ noparameterdelegate();
+
+ LogDebug("-- Examples using two-parameter delegates (int, char *) --");
+
+ // By default, the return value is void.
+ typedef DPL::FastDelegate2<int, const char *> MyDelegate;
+
+ // If you want to have a non-void return value, put it at the end.
+ typedef DPL::FastDelegate2<int, const char *, int> IntMyDelegate;
+
+
+ MyDelegate funclist[12]; // delegates are initialized to empty
+ CBaseClass a("Base A");
+ CBaseClass b("Base B");
+ CDerivedClass d;
+ CDerivedClass c;
+
+ IntMyDelegate newdeleg;
+ newdeleg = DPL::MakeDelegate(&a,
+ &CBaseClass::SimpleMemberFunctionReturnsInt);
+
+ // Binding a simple member function
+ funclist[0].bind(&a, &CBaseClass::SimpleMemberFunction);
+
+ // You can also bind static (free) functions
+ funclist[1].bind(&SimpleStaticFunction);
+
+ // and static member functions
+ funclist[2].bind(&CBaseClass::StaticMemberFunction);
+
+ // and const member functions (these only need a const class pointer).
+ funclist[3].bind((const CBaseClass *) &a,
+ &CBaseClass::ConstMemberFunction);
+
+ funclist[4].bind(&a, &CBaseClass::ConstMemberFunction);
+
+ // and virtual member functions
+ funclist[5].bind(&b, &CBaseClass::SimpleVirtualFunction);
+
+ // You can also use the = operator. For static functions, a fastdelegate
+ // looks identical to a simple function pointer.
+ funclist[6] = &CBaseClass::StaticMemberFunction;
+
+ // The weird rule about the class of derived member function pointers
+ // is avoided. For MSVC, you can use &CDerivedClass::SimpleVirtualFunction
+ // here, but DMC will complain. Note that as well as .bind(), you can also
+ // use the MakeDelegate() global function.
+ funclist[7] = DPL::MakeDelegate(&d, &CBaseClass::SimpleVirtualFunction);
+
+ // The worst case is an abstract virtual function of a virtually-derived
+ // class with at least one non-virtual base class. This is a VERY obscure
+ // situation, which you're unlikely to encounter in the real world.
+ // FastDelegate versions prior to 1.3 had problems with this case on VC6.
+ // Now, it works without problems on all compilers.
+ funclist[8].bind(&c, &CDerivedClass::TrickyVirtualFunction);
+
+ // BUT... in such cases you should be using the base class as an
+ // interface, anyway.
+ funclist[9].bind(&c, &COtherClass::TrickyVirtualFunction);
+
+ // Calling a function that was first declared in the derived class is
+ // straightforward
+ funclist[10] = DPL::MakeDelegate(&c, &CDerivedClass::SimpleDerivedFunction);
+
+ // You can also bind directly using the constructor
+ MyDelegate dg(&b, &CBaseClass::SimpleVirtualFunction);
+
+ const char *msg = "Looking for equal delegate";
+
+ for (int i = 0; i < 12; i++)
+ {
+ LogDebug(i << ":");
+
+ // The == and != operators are provided
+ // Note that they work even for inline functions.
+ if (funclist[i] == dg)
+ {
+ msg = "Found equal delegate";
+ }
+
+ // operator ! can be used to test for an empty delegate
+ // You can also use the .empty() member function.
+ if (!funclist[i])
+ {
+ LogDebug("Delegate is empty");
+ }
+ else
+ {
+ // Invocation generates optimal assembly code.
+ funclist[i](i, msg);
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_foreach.cpp
+ * @author Bartosz Janiak (b.janiak@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of foreach tests.
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <vector>
+#include <set>
+#include <list>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+static const size_t testContainerSize = 1024;
+
+template<typename Container>
+void VerifyForeach(Container& container)
+{
+ size_t i = 0;
+ FOREACH(it, container)
+ {
+ RUNNER_ASSERT(*it == i);
+ i++;
+ }
+ RUNNER_ASSERT(i == container.size());
+}
+
+#define VERIFY_FOREACH(container) \
+ { \
+ size_t i = 0; \
+ FOREACH(it, container) \
+ { \
+ RUNNER_ASSERT(*it == i); \
+ i++; \
+ } \
+ }
+
+static size_t numberOfCallsToTemporaryList = 0;
+std::list<size_t> temporaryList();
+std::list<size_t> temporaryList()
+{
+ ++numberOfCallsToTemporaryList;
+ std::list<size_t> list;
+ for (size_t i = 0 ; i < testContainerSize ; i++)
+ {
+ list.push_back(i);
+ }
+ return list;
+}
+
+static size_t numberOfCallsToTemporaryVector = 0;
+std::vector<size_t> temporaryVector();
+std::vector<size_t> temporaryVector()
+{
+ ++numberOfCallsToTemporaryVector;
+ std::vector<size_t> vector;
+ for (size_t i = 0 ; i < testContainerSize ; i++)
+ {
+ vector.push_back(i);
+ }
+ return vector;
+}
+
+static size_t numberOfCallsToTemporarySet = 0;
+std::set<size_t> temporarySet();
+std::set<size_t> temporarySet()
+{
+ ++numberOfCallsToTemporarySet;
+ std::set<size_t> set;
+ for (size_t i = 0 ; i < testContainerSize ; i++)
+ {
+ set.insert(i);
+ }
+ return set;
+}
+
+RUNNER_TEST(Foreach_std_containers)
+{
+ std::vector<size_t> vector;
+ std::list<size_t> list;
+ std::set<size_t> set;
+
+ for (size_t i = 0 ; i < testContainerSize ; i++)
+ {
+ vector.push_back(i);
+ list.push_back(i);
+ set.insert(i);
+ }
+
+ VerifyForeach(vector);
+ VerifyForeach(list);
+ VerifyForeach(set);
+
+ VERIFY_FOREACH(temporaryList());
+ VERIFY_FOREACH(temporaryVector());
+ VERIFY_FOREACH(temporarySet());
+
+ RUNNER_ASSERT(numberOfCallsToTemporaryList == 1);
+ RUNNER_ASSERT(numberOfCallsToTemporaryVector == 1);
+ RUNNER_ASSERT(numberOfCallsToTemporarySet == 1);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_log_unhandled_exception.cpp
+ * @author Pawel Sikorski (p.marcinkiew@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/exception.h>
+#include <iostream>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class MyException
+{
+};
+
+class MyDPLException
+{
+public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, MyException)
+};
+
+class MySTDException
+ : public std::exception
+{
+public:
+ virtual const char* what()const throw() { return "my std exception occurred";}
+};
+
+RUNNER_TEST(Log_Unknown_Exception)
+{
+ UNHANDLED_EXCEPTION_HANDLER_BEGIN
+ {
+// throw MyException();
+ }
+ UNHANDLED_EXCEPTION_HANDLER_END
+ RUNNER_ASSERT(true);
+}
+
+RUNNER_TEST(Log_DPL_Exception)
+{
+ UNHANDLED_EXCEPTION_HANDLER_BEGIN
+ {
+// Throw(MyDPLException::MyException);
+ }
+ UNHANDLED_EXCEPTION_HANDLER_END
+ RUNNER_ASSERT(true);
+}
+
+RUNNER_TEST(Log_STD_Exception)
+{
+ UNHANDLED_EXCEPTION_HANDLER_BEGIN
+ {
+// throw MySTDException();
+ }
+ UNHANDLED_EXCEPTION_HANDLER_END
+ RUNNER_ASSERT(true);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_once.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of once tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/once.h>
+#include <dpl/waitable_event.h>
+#include <dpl/waitable_handle.h>
+#include <dpl/thread.h>
+#include <dpl/atomic.h>
+#include <memory>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+namespace // anonymous
+{
+gint g_counter;
+
+void Delegate()
+{
+ ++g_counter;
+}
+} // namespace anonymous
+
+RUNNER_TEST(Once_DoubleCall)
+{
+ g_counter = 0;
+
+ DPL::Once once;
+
+ once.Call(&Delegate);
+ once.Call(&Delegate);
+
+ RUNNER_ASSERT_MSG(g_counter == 1, "Counter value is: " << g_counter);
+}
+
+class MyThread
+ : public DPL::Thread
+{
+protected:
+ virtual int ThreadEntry()
+ {
+ DPL::WaitForSingleHandle(m_event->GetHandle());
+ m_once->Call(DPL::Once::Delegate(this, &MyThread::Call));
+ return 0;
+ }
+
+ void Call()
+ {
+ ++*m_atom;
+ }
+
+public:
+ MyThread(DPL::WaitableEvent *event, DPL::Once *once, DPL::Atomic *atom)
+ : m_event(event), m_once(once), m_atom(atom)
+ {
+ }
+
+private:
+ DPL::WaitableEvent *m_event;
+ DPL::Once *m_once;
+ DPL::Atomic *m_atom;
+};
+
+RUNNER_TEST(Once_MultiThreadCall)
+{
+ const size_t NUM_THREADS = 20;
+ typedef std::shared_ptr<MyThread> ThreadPtr;
+
+ ThreadPtr threads[NUM_THREADS];
+ DPL::WaitableEvent event;
+ DPL::Once once;
+ DPL::Atomic atom;
+
+ for (size_t i = 0; i< NUM_THREADS; ++i)
+ {
+ (threads[i] = ThreadPtr(new MyThread(&event, &once, &atom)))->Run();
+ }
+
+ event.Signal();
+
+ for (size_t i = 0; i< NUM_THREADS; ++i)
+ threads[i]->Quit();
+
+ RUNNER_ASSERT_MSG(atom == 1, "Atom value is: " << atom);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_scoped_array.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test scoped array
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_array.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(ScopedArray_Zero)
+{
+ DPL::ScopedArray<char> array;
+
+ RUNNER_ASSERT(!array);
+ RUNNER_ASSERT(!!!array);
+}
+
+RUNNER_TEST(ScopedArray_NonZero)
+{
+ DPL::ScopedArray<char> array(new char[7]);
+
+ RUNNER_ASSERT(array);
+ RUNNER_ASSERT(!!array);
+}
+
+RUNNER_TEST(ScopedArray_Reset)
+{
+ DPL::ScopedArray<char> array(new char[7]);
+ array.Reset();
+
+ RUNNER_ASSERT(!array);
+
+ array.Reset(new char);
+ RUNNER_ASSERT(array);
+}
+
+RUNNER_TEST(ScopedArray_ArrayOperator)
+{
+ DPL::ScopedArray<char> array(new char[7]);
+
+ array[1] = array[2] = 3;
+
+ RUNNER_ASSERT(array[1] == 3);
+ RUNNER_ASSERT(array[2] == 3);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_scoped_close.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test scoped close
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_close.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+// DUNNO
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*!
+ * @file test_scoped_fclose.cpp
+ * @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test scoped fclose
+ */
+
+#include <cstdio>
+#include <cerrno>
+
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_fclose.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+namespace
+{
+FILE* MakeTmp()
+{
+ FILE* result = NULL;
+ do
+ {
+ result = tmpfile();
+ } while (NULL != result && EINTR == errno);
+ return result;
+}
+}//anonymous namespace
+
+RUNNER_TEST(ScopedFClose_Zero)
+{
+ DPL::ScopedFClose file;
+
+ RUNNER_ASSERT(!file);
+ RUNNER_ASSERT(!!!file);
+}
+
+RUNNER_TEST(ScopedFClose_NonZero)
+{
+ DPL::ScopedFClose file(MakeTmp());
+
+ RUNNER_ASSERT(file);
+ RUNNER_ASSERT(!!file);
+}
+
+RUNNER_TEST(ScopedFClose_Reset)
+{
+ DPL::ScopedFClose file(MakeTmp());
+ file.Reset();
+
+ RUNNER_ASSERT(!file);
+
+ file.Reset(MakeTmp());
+ RUNNER_ASSERT(file);
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_scoped_free.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test scoped free
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_free.h>
+#include <malloc.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(ScopedFree_Zero)
+{
+ DPL::ScopedFree<void> free;
+
+ RUNNER_ASSERT(!free);
+ RUNNER_ASSERT(!!!free);
+}
+
+RUNNER_TEST(ScopedFree_NonZero)
+{
+ DPL::ScopedFree<void> free(malloc(7));
+
+ RUNNER_ASSERT(free);
+ RUNNER_ASSERT(!!free);
+}
+
+RUNNER_TEST(ScopedFree_Reset)
+{
+ DPL::ScopedFree<void> free(malloc(7));
+ free.Reset();
+
+ RUNNER_ASSERT(!free);
+
+ free.Reset(malloc(8));
+ RUNNER_ASSERT(free);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_scoped_ptr.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test scoped ptr
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_ptr.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(ScopedPtr_Zero)
+{
+ DPL::ScopedPtr<char> ptr;
+
+ RUNNER_ASSERT(!ptr);
+ RUNNER_ASSERT(!!!ptr);
+}
+
+RUNNER_TEST(ScopedPtr_NonZero)
+{
+ DPL::ScopedPtr<char> ptr(new char(7));
+
+ RUNNER_ASSERT(ptr);
+ RUNNER_ASSERT(!!ptr);
+}
+
+RUNNER_TEST(ScopedPtr_Reset)
+{
+ DPL::ScopedPtr<char> ptr(new char(7));
+ ptr.Reset();
+
+ RUNNER_ASSERT(!ptr);
+
+ ptr.Reset(new char);
+ RUNNER_ASSERT(ptr);
+}
+
+RUNNER_TEST(ScopedPtr_Operators)
+{
+ DPL::ScopedPtr<char> ptr(new char(7));
+
+ RUNNER_ASSERT(*ptr == *ptr.Get());
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_semaphore.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of semaphore tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/lexical_cast.h>
+#include <dpl/semaphore.h>
+#include <dpl/thread.h>
+#include <dpl/log/log.h>
+#include <string>
+#include <ctime>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class SemaphoreThread
+ : public DPL::Thread
+{
+ int m_delta;
+ int m_times;
+ int *m_value;
+ std::string m_semaphoreName;
+
+public:
+ SemaphoreThread(int delta,
+ int times,
+ int *value,
+ const std::string &semaphoreName)
+ : m_delta(delta),
+ m_times(times),
+ m_value(value),
+ m_semaphoreName(semaphoreName)
+ {
+ }
+
+protected:
+ virtual int ThreadEntry()
+ {
+ DPL::Semaphore semaphore(m_semaphoreName);
+
+ for (int i = 0; i < m_times; ++i)
+ {
+ // Take scoped semaphore lock
+ DPL::Semaphore::ScopedLock lock(&semaphore);
+ *m_value += m_delta;
+ }
+
+ return 0;
+ }
+};
+
+RUNNER_TEST(Semaphore_NamedIncrementDecrement)
+{
+ std::string semaphoreName =
+ "dpl_test_semaphore_" +
+ DPL::lexical_cast<std::string>(std::time(NULL));
+
+ int value = 0;
+ SemaphoreThread threadA(-1, 10000, &value, semaphoreName);
+ SemaphoreThread threadB(+1, 10000, &value, semaphoreName);
+
+ threadA.Run();
+ threadB.Run();
+
+ threadA.Quit();
+ threadB.Quit();
+
+ RUNNER_ASSERT_MSG(value == 0, "Final value is: " << value);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_address.cpp
+ * @author Tomasz Swierczek (t.swierczek@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of serialization tests
+ */
+
+#include <vector>
+#include <string>
+#include <list>
+#include <map>
+
+#include <dpl/test/test_runner.h>
+#include <dpl/serialization.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+// test stream class
+class BinaryStream : public DPL::IStream {
+ public:
+ virtual void Read(size_t num, void * bytes)
+ {
+ for (unsigned i = 0; i < num; ++i) {
+ ((unsigned char*)bytes)[i] = data[i + readPosition];
+ }
+ readPosition += num;
+ }
+ virtual void Write(size_t num, const void * bytes)
+ {
+ for (unsigned i = 0; i < num; ++i) {
+ data.push_back(((unsigned char*)bytes)[i]);
+ }
+ }
+ BinaryStream()
+ {
+ readPosition = 0;
+ }
+ virtual ~BinaryStream(){};
+
+ private:
+ std::vector<unsigned char> data;
+ unsigned readPosition;
+};
+
+//test ISerializable class
+class TestClass : public DPL::ISerializable {
+ public:
+ TestClass(int val, std::string str1, std::string str2)
+ {
+ a = val;
+ b = str1;
+ c.push_back(str1);
+ c.push_back(str2);
+ c.push_back(str1 + str2);
+ };
+ TestClass(DPL::IStream& stream)
+ {
+ DPL::Deserialization::Deserialize(stream,a);
+ DPL::Deserialization::Deserialize(stream,b);
+ DPL::Deserialization::Deserialize(stream,c);
+ };
+ virtual void Serialize(DPL::IStream& stream) const
+ {
+ DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream,b);
+ DPL::Serialization::Serialize(stream,c);
+ }
+ virtual ~TestClass(){}
+ virtual bool operator==(const TestClass& other)
+ {
+ return (a == other.a &&
+ b == other.b &&
+ c.size() == other.c.size() &&
+ c[0] == other.c[0] &&
+ c[1] == other.c[1] &&
+ c[2] == other.c[2]);
+ }
+ private:
+ int a;
+ std::string b;
+ std::vector<std::string> c;
+};
+
+RUNNER_TEST(Serialize_primitives)
+{
+ int a = 1;
+ bool b = true;
+ unsigned c = 23;
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream,b);
+ DPL::Serialization::Serialize(stream,c);
+ int test_int;
+ DPL::Deserialization::Deserialize(stream,test_int);
+ RUNNER_ASSERT(test_int == a);
+ bool test_bool;
+ DPL::Deserialization::Deserialize(stream,test_bool);
+ RUNNER_ASSERT(test_bool == b);
+ unsigned test_unsigned;
+ DPL::Deserialization::Deserialize(stream,test_unsigned);
+ RUNNER_ASSERT(test_unsigned == c);
+}
+
+RUNNER_TEST(Serialize_primitive_pointers)
+{
+ int a = 1;
+ bool b = true;
+ unsigned c = 23;
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,&a);
+ DPL::Serialization::Serialize(stream,&b);
+ DPL::Serialization::Serialize(stream,&c);
+ int* test_int;
+ DPL::Deserialization::Deserialize(stream,test_int);
+ RUNNER_ASSERT(test_int != NULL && *test_int == a);
+ bool* test_bool;
+ DPL::Deserialization::Deserialize(stream,test_bool);
+ RUNNER_ASSERT(test_bool != NULL && *test_bool == b);
+ unsigned* test_unsigned;
+ DPL::Deserialization::Deserialize(stream,test_unsigned);
+ RUNNER_ASSERT(test_unsigned != NULL && *test_unsigned == c);
+ delete test_int;
+ delete test_bool;
+ delete test_unsigned;
+}
+
+RUNNER_TEST(Serialize_strings)
+{
+ std::string str1 = "ALA MA KOTA";
+ std::string str2 = "MULTILINE\nTEST";
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,str1);
+ DPL::Serialization::Serialize(stream,str2);
+ std::string test_str1;
+ DPL::Deserialization::Deserialize(stream,test_str1);
+ RUNNER_ASSERT(test_str1 == str1);
+ std::string test_str2;
+ DPL::Deserialization::Deserialize(stream,test_str2);
+ RUNNER_ASSERT(test_str2 == str2);
+}
+
+RUNNER_TEST(Serialize_string_pointers)
+{
+ std::string str1 = "ALA MA KOTA";
+ std::string str2 = "MULTILINE\nTEST";
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,&str1);
+ DPL::Serialization::Serialize(stream,&str2);
+ std::string* test_str1;
+ DPL::Deserialization::Deserialize(stream,test_str1);
+ RUNNER_ASSERT(test_str1 != NULL && *test_str1 == str1);
+ std::string* test_str2;
+ DPL::Deserialization::Deserialize(stream,test_str2);
+ RUNNER_ASSERT(test_str2 != NULL && *test_str2 == str2);
+ delete test_str1;
+ delete test_str2;
+}
+
+RUNNER_TEST(Serialize_containers)
+{
+ std::vector<int> vec;
+ vec.push_back(134);
+ vec.push_back(265);
+ std::list<bool> list;
+ list.push_back(true);
+ list.push_back(false);
+ std::pair<int,unsigned> pair;
+ pair.first = -23;
+ pair.second = 1234;
+ std::map<int,std::string> map;
+ map.insert(std::pair<int,std::string>(45, "ALA MA CZARNEGO KOTA"));
+ map.insert(std::pair<int,std::string>(-78, "...A MOZE\nMA\nWIELE LINIJEK"));
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,vec);
+ DPL::Serialization::Serialize(stream,list);
+ DPL::Serialization::Serialize(stream,pair);
+ DPL::Serialization::Serialize(stream,map);
+ std::vector<int> test_vec;
+ DPL::Deserialization::Deserialize(stream,test_vec);
+ RUNNER_ASSERT(test_vec.size() == vec.size() &&
+ test_vec[0] == vec[0] && test_vec[1] == vec[1]);
+ std::list<bool> test_list;
+ DPL::Deserialization::Deserialize(stream,test_list);
+ RUNNER_ASSERT(test_list.size() == list.size() &&
+ test_list.front() == list.front() &&
+ test_list.back() == test_list.back());
+ std::pair<int,unsigned> test_pair;
+ DPL::Deserialization::Deserialize(stream,test_pair);
+ RUNNER_ASSERT(test_pair.first == pair.first &&
+ test_pair.second == pair.second);
+ std::map<int,std::string> test_map;
+ DPL::Deserialization::Deserialize(stream,test_map);
+ RUNNER_ASSERT(test_map.size() == map.size() &&
+ test_map.at(45) == map.at(45) &&
+ test_map.at(-78) == map.at(-78));
+}
+
+RUNNER_TEST(Serialize_objects)
+{
+ TestClass a(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"),
+ b(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8");
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream,b);
+ TestClass test_a(0,"",""), test_b(0,"","");
+ DPL::Deserialization::Deserialize(stream, test_a);
+ RUNNER_ASSERT(test_a == a);
+ DPL::Deserialization::Deserialize(stream, test_b);
+ RUNNER_ASSERT(test_b == b);
+}
+
+RUNNER_TEST(Serialize_all)
+{
+ std::map<std::string, std::vector<TestClass*> > map;
+ std::vector<TestClass*> vec;
+ vec.push_back(new TestClass(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"));
+ vec.push_back(new TestClass(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8"));
+ map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY1",vec));
+ map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY2",vec));
+ BinaryStream stream;
+
+ DPL::Serialization::Serialize(stream, map);
+
+ std::map<std::string, std::vector<TestClass*> > test_map;
+ DPL::Deserialization::Deserialize(stream,test_map);
+ RUNNER_ASSERT(map.size() == test_map.size());
+ std::vector<TestClass*> test_vec1,test_vec2;
+ test_vec1 = map.at("KEY1");
+ test_vec2 = test_map.at("KEY1");
+ RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
+ unsigned i;
+ for (i = 0; i < test_vec1.size(); ++i)
+ {
+ RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
+ }
+ test_vec1 = map.at("KEY2");
+ test_vec2 = test_map.at("KEY2");
+ RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
+ for (i = 0; i < test_vec1.size(); ++i)
+ {
+ RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_shared_ptr.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test shared ptr
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/shared_ptr.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(SharedPtr_Zero)
+{
+ DPL::SharedPtr<char> ptr;
+
+ RUNNER_ASSERT(!ptr);
+ RUNNER_ASSERT(!!!ptr);
+ RUNNER_ASSERT(ptr == DPL::SharedPtr<char>());
+}
+
+RUNNER_TEST(SharedPtr_NonZero)
+{
+ DPL::SharedPtr<char> ptr(new char(7));
+
+ RUNNER_ASSERT(ptr);
+ RUNNER_ASSERT(!!ptr);
+ RUNNER_ASSERT(ptr != DPL::SharedPtr<char>());
+}
+
+RUNNER_TEST(SharedPtr_Copy)
+{
+ DPL::SharedPtr<char> ptr1(new char(7));
+ DPL::SharedPtr<char> ptr2(new char(7));
+
+ RUNNER_ASSERT(ptr1 != ptr2);
+
+ ptr2 = ptr1;
+
+ RUNNER_ASSERT(ptr1 == ptr2);
+}
+
+RUNNER_TEST(SharedPtr_Reset)
+{
+ DPL::SharedPtr<char> ptr(new char(7));
+ ptr.Reset();
+
+ RUNNER_ASSERT(!ptr);
+
+ ptr.Reset(new char);
+ RUNNER_ASSERT(ptr);
+}
+
+RUNNER_TEST(SharedPtr_RefCounting)
+{
+ DPL::SharedPtr<char> ptr1(new char(7));
+ DPL::SharedPtr<char> ptr2;
+
+ ptr2 = ptr1;
+
+ RUNNER_ASSERT(ptr1 == ptr2);
+ RUNNER_ASSERT(ptr1.GetUseCount() == ptr2.GetUseCount());
+ RUNNER_ASSERT(ptr1.GetUseCount() == 2);
+}
+
+RUNNER_TEST(SharedPtr_Operators)
+{
+ DPL::SharedPtr<char> ptr(new char(7));
+
+ RUNNER_ASSERT(*ptr == *ptr.Get());
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_string.cpp
+ * @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of string tests
+ */
+#include <stdlib.h>
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <dpl/test/test_runner.h>
+#include <dpl/string.h>
+#include <dpl/sstream.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+unsigned char GetBaseCode(int index);
+unsigned char GetBaseCode(int index)
+{
+ /* aaaack but it's fast and const should make it shared text page. */
+ static const unsigned char pr2six[256] =
+ {
+ /* ASCII table */
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
+ 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
+ 64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
+ };
+ return pr2six[index];
+}
+
+
+/* Function adapted from APR library (http://apr.apache.org/) */
+int wbxml_base64_decode(const char *buffer, char **result);
+int wbxml_base64_decode(const char *buffer, char **result)
+{
+ int nbytesdecoded = 0, nprbytes = 0;
+ const char *bufin = NULL;
+ char *bufout = NULL;
+
+ if ((buffer == NULL) || (result == NULL))
+ return 0;
+
+ /* Initialize output buffer */
+ *result = NULL;
+
+ bufin = buffer;
+ while (GetBaseCode(*(bufin++)) <= 63) {}
+
+ nprbytes = (bufin - buffer) - 1;
+ nbytesdecoded = ((nprbytes + 3) / 4) * 3;
+
+ /* Malloc result buffer */
+ if ((*result = (char*) malloc(nbytesdecoded + 1)) == NULL)
+ return 0;
+ memset(*result, nbytesdecoded + 1, 0);
+
+ bufout = *result;
+ bufin = buffer;
+
+ while (nprbytes > 4)
+ {
+ *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
+ *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
+ *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
+ bufin += 4;
+ nprbytes -= 4;
+ }
+
+ /* Note: (nprbytes == 1) would be an error, so just ingore that case */
+ if (nprbytes > 1)
+ {
+ *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
+ }
+ if (nprbytes > 2)
+ {
+ *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
+ }
+ if (nprbytes > 3)
+ {
+ *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
+ }
+
+ nbytesdecoded -= (4 - nprbytes) & 3;
+
+ return nbytesdecoded;
+}
+
+//#define TEST_CONVERSION(in_string, out_string, buffer_type, function
+
+const char utf32Encoded[] =
+"RDAAAI0wAABvMAAAazAAAHswAAB4MAAAaDAAAAAwAABhMAAAijAAAGwwAACLMAAAkjAAAAAwAACP\
+MAAASzAAAIgwAABfMAAAjDAAAF0wAAAAMAAAZDAAAG0wAABqMAAAiTAAAIAwAAAAMAAARjAAAJAw\
+AABuMAAASjAAAE8wAACEMAAAfjAAAAAwAABRMAAAdTAAAFMwAABIMAAAZjAAAAAwAABCMAAAVTAA\
+AE0wAACGMAAAgTAAAH8wAABXMAAAADAAAJEwAAByMAAAgjAAAFswAABZMAAACgAAANsFAADaBQAA\
+IAAAANQFAADqBQAA6AUAAOEFAADnBQAAIAAAAOAFAADkBQAA5QUAACAAAADiBQAA3AUAACAAAADS\
+BQAA1QUAANYFAADcBQAAIAAAAOcFAADYBQAA3wUAACwAAAAgAAAA6QUAANMFAADXBQAA4wUAACAA\
+AADQBQAA6gUAACAAAADmBQAA0QUAANkFAAAgAAAA3AUAAN4FAADZBQAA3QUAAAoAAACk0AAApMIA\
+AFjHAAAgAAAA4KwAACDHAABwyAAAdKwAAEDHAAAgAAAAhccAACDCAAB8sAAArLkAACAAAADMuQAA\
+mLAAAHzFAAAgAAAAWNUAAOCsAAAgAAAAudIAAMS8AABc1QAAIAAAADCuAAAgwgAAQMcAACAAAABE\
+1QAAlMYAAFjOAAAgAAAASsUAAOSyAAAKAAAAUAAAAGMAAABoAAAAbgAAAAUBAAAHAQAAIAAAAHcA\
+AAAgAAAAdAAAABkBAAAgAAAAQgEAAPMAAABkAAAAegEAACAAAABqAAAAZQAAAHwBAABhAAAAIAAA\
+AGwAAAB1AAAAYgAAACAAAABvAAAAWwEAAG0AAAAgAAAAcwAAAGsAAAByAAAAegAAAHkAAABEAQAA\
+IAAAAGYAAABpAAAAZwAAAC4AAAAKAAAAQgAAAGwAAABvAAAAdwAAAHoAAAB5AAAAIAAAAG4AAABp\
+AAAAZwAAAGgAAAB0AAAALQAAAGYAAAByAAAAdQAAAG0AAABwAAAAcwAAACAAAAB2AAAAZQAAAHgA\
+AAAnAAAAZAAAACAAAABKAAAAYQAAAGMAAABrAAAAIAAAAFEAAAAuAAAACgAAAEYGAAA1BgAAIAAA\
+AC0GAABDBgAASgYAAEUGAAAgAAAARAYAAEcGAAAgAAAAMwYAADEGAAAgAAAAQgYAACcGAAA3BgAA\
+OQYAACAAAABIBgAAMAYAAEgGAAAgAAAANAYAACMGAABGBgAAIAAAADkGAAA4BgAASgYAAEUGAAAg\
+AAAARQYAAEMGAAAqBgAASAYAACgGAAAgAAAAOQYAAEQGAABJBgAAIAAAACsGAABIBgAAKAYAACAA\
+AAAjBgAALgYAADYGAAAxBgAAIAAAAEgGAABFBgAAOgYAAEQGAABBBgAAIAAAACgGAAAsBgAARAYA\
+AC8GAAAgAAAAIwYAADIGAAAxBgAAQgYAACAAAAAKAAAAEgQAACAAAABHBAAAMAQAAEkEAAAwBAAA\
+RQQAACAAAABOBAAAMwQAADAEAAAgAAAANgQAADgEAAA7BAAAIAAAADEEAABLBAAAIAAAAEYEAAA4\
+BAAAQgQAAEAEAABDBAAAQQQAAD8AAAAgAAAAFAQAADAEAAAsAAAAIAAAAD0EAAA+BAAAIAAAAEQE\
+AAAwBAAAOwQAAEwEAABIBAAAOAQAADIEAABLBAAAOQQAACAAAABNBAAAOgQAADcEAAA1BAAAPAQA\
+AD8EAAA7BAAATwQAAEAEAAAhAAAACgAAAKQDAACsAwAAxwMAALkDAADDAwAAxAMAALcDAAAgAAAA\
+sQMAALsDAADOAwAAwAMAALcDAAC+AwAAIAAAALIDAACxAwAAxgMAAK4DAADCAwAAIAAAAMgDAAC3\
+AwAAvAMAAK0DAAC9AwAAtwMAACAAAACzAwAAtwMAACwAAAAgAAAAtAMAAMEDAACxAwAAwwMAALoD\
+AAC1AwAAuwMAAK8DAAC2AwAAtQMAALkDAAAgAAAAxQMAAMADAACtAwAAwQMAACAAAAC9AwAAyQMA\
+ALgDAADBAwAAvwMAAM0DAAAgAAAAugMAAMUDAAC9AwAAzAMAAMIDAAAKAAAAVgAAAGkAAABjAAAA\
+dAAAAG8AAAByAAAAIAAAAGoAAABhAAAAZwAAAHQAAAAgAAAAegAAAHcAAAD2AAAAbAAAAGYAAAAg\
+AAAAQgAAAG8AAAB4AAAAawAAAOQAAABtAAAAcAAAAGYAAABlAAAAcgAAACAAAABxAAAAdQAAAGUA\
+AAByAAAAIAAAAPwAAABiAAAAZQAAAHIAAAAgAAAAZAAAAGUAAABuAAAAIAAAAGcAAAByAAAAbwAA\
+AN8AAABlAAAAbgAAACAAAABTAAAAeQAAAGwAAAB0AAAAZQAAAHIAAAAgAAAARAAAAGUAAABpAAAA\
+YwAAAGgAAAAKAAAAlokAAM6RAAAhcQAAUJYAAONeAAAM/wAAl3oAABZZAAAJZwAAzYUAAClZAAAK\
+AAAACgAAAAAAAAA=";
+
+const char utf8Encoded[] =
+"44GE44KN44Gv44Gr44G744G444Go44CA44Gh44KK44Gs44KL44KS44CA44KP44GL44KI44Gf44KM\
+44Gd44CA44Gk44Gt44Gq44KJ44KA44CA44GG44KQ44Gu44GK44GP44KE44G+44CA44GR44G144GT\
+44GI44Gm44CA44GC44GV44GN44KG44KB44G/44GX44CA44KR44Gy44KC44Gb44GZCteb15og15TX\
+qteo16HXpyDXoNek16Ug16LXnCDXkteV15bXnCDXp9eY158sINep15PXl9ejINeQ16og16bXkdeZ\
+INec157XmdedCu2CpOyKpOydmCDqs6DsnKDsobDqsbTsnYAg7J6F7Iig64G866asIOunjOuCmOyV\
+vCDtlZjqs6Ag7Yq567OE7ZWcIOq4sOyIoOydgCDtlYTsmpTsuZgg7JWK64ukClBjaG7EhcSHIHcg\
+dMSZIMWCw7NkxbogamXFvGEgbHViIG/Fm20gc2tyennFhCBmaWcuCkJsb3d6eSBuaWdodC1mcnVt\
+cHMgdmV4J2QgSmFjayBRLgrZhti1INit2YPZitmFINmE2Ycg2LPYsSDZgtin2LfYuSDZiNiw2Ygg\
+2LTYo9mGINi52LjZitmFINmF2YPYqtmI2Kgg2LnZhNmJINir2YjYqCDYo9iu2LbYsSDZiNmF2LrZ\
+hNmBINio2KzZhNivINij2LLYsdmCIArQkiDRh9Cw0YnQsNGFINGO0LPQsCDQttC40Lsg0LHRiyDR\
+htC40YLRgNGD0YE/INCU0LAsINC90L4g0YTQsNC70YzRiNC40LLRi9C5INGN0LrQt9C10LzQv9C7\
+0Y/RgCEKzqTOrM+HzrnPg8+EzrcgzrHOu8+Oz4DOt86+IM6yzrHPhs6uz4Igz4jOt868zq3Ovc63\
+IM6zzrcsIM60z4HOsc+DzrrOtc67zq/Ots61zrkgz4XPgM6tz4Egzr3Pic64z4HOv8+NIM66z4XO\
+vc+Mz4IKVmljdG9yIGphZ3QgenfDtmxmIEJveGvDpG1wZmVyIHF1ZXIgw7xiZXIgZGVuIGdyb8Of\
+ZW4gU3lsdGVyIERlaWNoCuimlumHjueEoemZkOW7o++8jOeql+WkluacieiXjeWkqQoKAA==";
+
+
+
+
+const char asciiEncodedIso1[] =
+"ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
+WltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fgA=";
+
+const char asciiEncodedUtf32[] =
+"IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
+AAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAD0A\
+AAA+AAAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAA\
+AEwAAABNAAAATgAAAE8AAABQAAAAUQAAAFIAAABTAAAAVAAAAFUAAABWAAAAVwAAAFgAAABZAAAA\
+WgAAAFsAAABcAAAAXQAAAF4AAABfAAAAYAAAAGEAAABiAAAAYwAAAGQAAABlAAAAZgAAAGcAAABo\
+AAAAaQAAAGoAAABrAAAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAcgAAAHMAAAB0AAAAdQAAAHYA\
+AAB3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAAAAAAA=";
+
+
+RUNNER_TEST(String_ConverterFromASCII)
+{
+ char* inStr = NULL;
+ int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
+ RUNNER_ASSERT(inSize > 0);
+ RUNNER_ASSERT(NULL != inStr);
+ inStr[inSize] = '\0';
+ {
+ DPL::String asciiString = DPL::FromASCIIString(inStr);
+
+ std::string result = DPL::ToUTF8String(asciiString);
+
+ RUNNER_ASSERT(strlen(inStr) == result.size());
+
+ RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
+ }
+
+ free(inStr);
+}
+
+RUNNER_TEST(String_ConverterFromUTF8)
+{
+ char* inStr = NULL;
+ int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
+ RUNNER_ASSERT(inSize > 0);
+ RUNNER_ASSERT(NULL != inStr);
+ {
+ DPL::String asciiString = DPL::FromUTF8String(inStr);
+
+ std::string result = DPL::ToUTF8String(asciiString);
+
+ RUNNER_ASSERT(strlen(inStr) == result.size());
+
+ RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
+ }
+
+ free(inStr);
+}
+
+RUNNER_TEST(String_ConverterFromUTF32)
+{
+ wchar_t* inStr = NULL;
+ int inSize = wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
+ RUNNER_ASSERT(inSize > 0);
+ RUNNER_ASSERT(NULL != inStr);
+ char* outStr = NULL;
+ int outSize = wbxml_base64_decode(utf8Encoded, &outStr);
+ RUNNER_ASSERT(outSize > 0);
+ RUNNER_ASSERT(NULL != outStr);
+ outStr[outSize] = '\0';
+ {
+ DPL::String utfString = DPL::FromUTF32String(inStr);
+ std::string result = DPL::ToUTF8String(utfString);
+
+ RUNNER_ASSERT(strlen(outStr) == result.size());
+ RUNNER_ASSERT(0 == memcmp(outStr, result.c_str(), result.size()));
+
+
+ RUNNER_ASSERT(inSize / sizeof(wchar_t) - 1 == utfString.size());
+ RUNNER_ASSERT(0 == memcmp(inStr, &(utfString[0]), utfString.size() * sizeof(wchar_t)));
+
+ }
+
+ free(inStr);
+}
+
+template<typename DelimiterType>
+void String_TokenizeReal(const DelimiterType& delimiter)
+{
+ DPL::String str(L".##..abc.#.");
+ std::vector<DPL::String> tokens;
+ DPL::Tokenize(str, delimiter, std::back_inserter(tokens));
+
+ std::vector<DPL::String> expectedTokens;
+ for ( int i = 0 ; i < 5 ; i++ )
+ expectedTokens.push_back(L"");
+ expectedTokens.push_back(L"abc");
+ for ( int i = 0 ; i < 3 ; i++ )
+ expectedTokens.push_back(L"");
+
+ RUNNER_ASSERT(expectedTokens == tokens);
+ tokens.clear();
+ expectedTokens.clear();
+
+ DPL::Tokenize(str, delimiter, std::back_inserter(tokens), true);
+ expectedTokens.push_back(L"abc");
+ RUNNER_ASSERT(expectedTokens == tokens);
+}
+
+RUNNER_TEST(String_Tokenize)
+{
+ String_TokenizeReal(L"#.");
+ String_TokenizeReal(L".#");
+ String_TokenizeReal(L".....####.###..");
+ String_TokenizeReal(DPL::String(L".#"));
+
+ std::vector<std::string> tokens;
+ DPL::Tokenize(std::string("abc.def"), '.', std::back_inserter(tokens));
+ std::vector<std::string> expectedTokens;
+ expectedTokens.push_back("abc");
+ expectedTokens.push_back("def");
+
+ RUNNER_ASSERT(tokens == expectedTokens);
+}
+
+template <typename TemplateArgumentCharTraits>
+void TestInStreams(
+ std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits> argumentInString,
+ std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits> argumentResultString)
+{
+ typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits>
+ String;
+ std::basic_istringstream<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits>
+ istream(argumentInString);
+ int intValue = 0;
+ double doubleValue = 0.0;
+ float floatValue = 0.0;
+ String stringValue;
+
+ istream >> intValue;
+ RUNNER_ASSERT(!istream.fail());
+ istream >> doubleValue;
+ RUNNER_ASSERT(!istream.fail());
+ istream >> floatValue;
+ RUNNER_ASSERT(!istream.fail());
+ istream >> stringValue;
+ RUNNER_ASSERT(!istream.fail());
+
+ RUNNER_ASSERT(1 == intValue);
+ RUNNER_ASSERT(fabs(1.1f - doubleValue) < 0.00001);
+ RUNNER_ASSERT(fabs(1.1f - floatValue) < 0.00001);
+ RUNNER_ASSERT(argumentResultString == stringValue);
+}
+
+template <typename TemplateArgumentCharTraits>
+void TestOutStreams(
+ std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits> argumentInString,
+ std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits> argumentResultString)
+{
+ typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits>
+ String;
+
+ std::basic_ostringstream<typename TemplateArgumentCharTraits::char_type,
+ TemplateArgumentCharTraits>
+ ostream;
+
+ int intValue = 1;
+ double doubleValue = 1.1;
+ float floatValue = 1.1f;
+ String stringValue = argumentInString;
+
+ ostream << intValue;
+ RUNNER_ASSERT(!ostream.fail());
+ ostream << doubleValue;
+ RUNNER_ASSERT(!ostream.fail());
+ ostream << floatValue;
+ RUNNER_ASSERT(!ostream.fail());
+ ostream << stringValue;
+ RUNNER_ASSERT(!ostream.fail());
+
+ RUNNER_ASSERT(ostream.str() == argumentResultString);
+}
+
+RUNNER_TEST(String_Streams)
+{
+ TestInStreams<std::char_traits<char> >("1 1.1 1.1 test", "test");
+ TestInStreams<std::char_traits<wchar_t> >(L"1 1.1 1.1 test", L"test");
+ TestInStreams<DPL::CharTraits>(L"1 1.1 1.1 test", L"test");
+ TestOutStreams<std::char_traits<char> >("test", "11.11.1test");
+ TestOutStreams<std::char_traits<wchar_t> >(L"test", L"11.11.1test");
+ TestOutStreams<DPL::CharTraits>(L"test", L"11.11.1test");
+}
+
+RUNNER_TEST(String_CompareCaseSensitive)
+{
+ RUNNER_ASSERT(
+ DPL::StringCompare(
+ DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
+ DPL::FromUTF32String(L"Ala Makota ma żołądkówkę")) == 0);
+}
+
+RUNNER_TEST(String_CompareCaseInsensitive)
+{
+ RUNNER_ASSERT(
+ DPL::StringCompare(
+ DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
+ DPL::FromUTF32String(L"AlA MakOTA ma ŻoŁąDKÓwkę"),
+ true) == 0);
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_thread.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of thread tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/thread.h>
+#include <dpl/log/log.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+bool g_wasFooDeleted;
+
+class Foo
+{
+public:
+ int id;
+ Foo(int i=0): id(i)
+ {
+ LogInfo("Foo: ctor: " << id);
+ }
+
+ ~Foo()
+ {
+ LogInfo("Foo: dtor: " << id);
+ g_wasFooDeleted = true;
+ }
+
+ void Bar()
+ {
+ LogInfo("Foo: bar");
+ }
+};
+
+typedef DPL::ThreadLocalVariable<Foo> TlsFoo;
+TlsFoo g_foo;
+
+class FooThread
+ : public DPL::Thread
+{
+protected:
+ virtual int ThreadEntry()
+ {
+ LogInfo("In thread");
+
+ RUNNER_ASSERT(!g_foo);
+ RUNNER_ASSERT(g_foo.IsNull());
+
+ g_foo = Foo();
+ g_foo->Bar();
+
+ return 0;
+ }
+};
+
+RUNNER_TEST(Thread_ThreadLocalVariable_FooDeletion)
+{
+ static TlsFoo staticFooForMain;
+ staticFooForMain = Foo(1);
+
+ TlsFoo fooForMain;
+ fooForMain = Foo(2);
+
+ RUNNER_ASSERT(!g_foo);
+ RUNNER_ASSERT(g_foo.IsNull());
+
+ g_wasFooDeleted = false;
+
+ FooThread thread1;
+ thread1.Run();
+ thread1.Quit();
+
+ RUNNER_ASSERT(!g_foo);
+ RUNNER_ASSERT(g_foo.IsNull());
+
+ RUNNER_ASSERT(g_wasFooDeleted == true);
+
+ FooThread thread2;
+ thread2.Run();
+ thread2.Quit();
+
+ RUNNER_ASSERT(!g_foo);
+ RUNNER_ASSERT(g_foo.IsNull());
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file test_type_list.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 0.1
+ * @brief
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/type_list.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(TypeList_TypeCount)
+{
+ typedef DPL::TypeListDecl<int, char, int[64]>::Type TestTypeList1;
+ typedef DPL::TypeListDecl<int>::Type TestTypeList2;
+ typedef DPL::TypeListDecl<>::Type TestTypeList3;
+ typedef DPL::TypeList<int, TestTypeList1> TestTypeList4;
+
+ RUNNER_ASSERT(TestTypeList1::Size == 3);
+ RUNNER_ASSERT(TestTypeList2::Size == 1);
+ RUNNER_ASSERT(TestTypeList3::Size == 0);
+ RUNNER_ASSERT(TestTypeList4::Size == 4);
+
+ RUNNER_ASSERT(TestTypeList4::Tail::Tail::Size == 2);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_zip_input.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of zip input tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/zip_input.h>
+#include <dpl/foreach.h>
+#include <dpl/abstract_waitable_input_adapter.h>
+#include <dpl/abstract_waitable_output_adapter.h>
+#include <dpl/binary_queue.h>
+#include <dpl/scoped_array.h>
+#include <dpl/copy.h>
+#include <dpl/log/log.h>
+
+namespace {
+const char* PATH_NO_FILE = "/opt/share/wrt/wrt-commons/tests/core/no_such_file";
+const char* PATH_ARCHIVE = "/opt/share/wrt/wrt-commons/tests/core/sample.zip";
+const char* ARCHIVED_FILE = "sample.txt";
+}
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(ZipInput_OpenFailed)
+{
+ bool opened = true;
+
+ Try
+ {
+ DPL::ZipInput zip(PATH_NO_FILE);
+ (void)zip;
+ }
+ Catch(DPL::ZipInput::Exception::OpenFailed)
+ {
+ opened = false;
+ }
+
+ RUNNER_ASSERT(opened == false);
+}
+
+RUNNER_TEST(ZipInput_OpenFile)
+{
+ DPL::ZipInput zip(PATH_ARCHIVE);
+
+ FOREACH(iter, zip)
+ {
+ LogDebug("---------");
+ LogDebug("FileInfo: ");
+#define FIELD(X) LogDebug(#X ": " << iter->X)
+ FIELD(name);
+ FIELD(comment);
+ FIELD(compressedSize);
+ FIELD(uncompressedSize);
+#undef FIELD
+ }
+}
+
+RUNNER_TEST(ZipInput_UnzipSingleFile)
+{
+ DPL::ZipInput zip(PATH_ARCHIVE);
+ DPL::ZipInput::File *file = zip.OpenFile(ARCHIVED_FILE);
+ DPL::AbstractWaitableInputAdapter fileAdapter(file);
+ DPL::BinaryQueue buffer;
+ DPL::AbstractWaitableOutputAdapter bufferAdapter(&buffer);
+
+ DPL::Copy(&fileAdapter, &bufferAdapter);
+
+ DPL::ScopedArray<char> data(new char[buffer.Size() + 1]);
+ buffer.Flatten(data.Get(), buffer.Size());
+ data[buffer.Size()] = '\0';
+
+ RUNNER_ASSERT(std::string(data.Get()) == "test");
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Lukasz Marek (l.marek@samsung.com)
+# @version 1.0
+# @brief
+#
+
+#
+# Test files
+#
+# Define all DPL tests sources.
+# Runner is responsible for runnint it all and
+# generating proper output files
+#
+
+SET(TARGET_NAME "dpl-tests-db")
+
+# Set DPL tests sources
+SET(DPL_TESTS_DB_SOURCES
+ ${TESTS_DPL_DIR}/db/main.cpp
+ ${TESTS_DPL_DIR}/db/test_orm.cpp
+ ${TESTS_DPL_DIR}/db/test_sql_connection.cpp
+)
+
+ADD_SUBDIRECTORY(orm)
+
+#include subdirectory
+WRT_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/orm)
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_DB_EFL})
+WRT_TEST_BUILD(${TARGET_NAME} ${DPL_TESTS_DB_SOURCES})
+WRT_TEST_INSTALL(${TARGET_NAME})
+
+INSTALL(FILES
+ ${TESTS_DPL_DIR}/db/orm/dpl_orm_test.db
+ DESTINATION /opt/share/wrt/wrt-commons/tests/db
+)
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file main.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main.
+ */
+
+#include <dpl/test/test_runner.h>
+
+int main(int argc, char *argv[])
+{
+ return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+}
--- /dev/null
+WRT_INTROSPECT_TARGET(db ${TARGET_DPL_DB_EFL})
+WRT_CONVERT_TO_GCC_LIST(db_INCLUDE_DIRS_GCC ${db_INCLUDE_DIRS})
+
+ADD_CUSTOM_COMMAND( OUTPUT dpl_orm_test_db.sql
+ COMMAND rm -f ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test.db
+ COMMAND C_INCLUDE_PATH=${db_INCLUDE_DIRS_GCC} gcc -Wall -E ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test_db_sql_generator.h | grep --invert-match "^#" > ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test_db.sql
+ COMMAND sqlite3 ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test.db ".read ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test_db.sql" || rm -f ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test.db
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test_db_sql_generator.h ${CMAKE_CURRENT_SOURCE_DIR}/dpl_orm_test_db
+)
+
+ADD_CUSTOM_TARGET( Sqlite3Db ALL DEPENDS dpl_orm_test_db.sql )
--- /dev/null
+
+CREATE_TABLE(TestTableInsert)
+ COLUMN(ColumnOptInt, INT,)
+ COLUMN(ColumnOptText, TEXT,)
+ COLUMN_NOT_NULL(ColumnInt, INT, DEFAULT 99)
+ COLUMN_NOT_NULL(ColumnInt2, INT,)
+ COLUMN_NOT_NULL(ColumnText, TEXT,)
+CREATE_TABLE_END()
+
+CREATE_TABLE(TestTableDelete)
+ COLUMN(ColumnOptInt, INT,)
+ COLUMN(ColumnOptText, TEXT,)
+ COLUMN_NOT_NULL(ColumnInt, INT, DEFAULT 99)
+ COLUMN_NOT_NULL(ColumnInt2, INT,)
+ COLUMN_NOT_NULL(ColumnText, TEXT,)
+CREATE_TABLE_END()
+
+SQL(
+ INSERT INTO TestTableDelete VALUES(1, "two", 3, 4, "five");
+ INSERT INTO TestTableDelete VALUES(6, "seven", 8, 9, "ten");
+ INSERT INTO TestTableDelete (ColumnInt2, ColumnText) VALUES(11, "twelve");
+ INSERT INTO TestTableDelete (ColumnInt2, ColumnText) VALUES(13, "fourteen");
+)
+
+CREATE_TABLE(TestTable)
+ COLUMN(ColumnOptInt, INT,)
+ COLUMN(ColumnOptText, TEXT,)
+ COLUMN_NOT_NULL(ColumnInt, INT, DEFAULT 99)
+ COLUMN_NOT_NULL(ColumnInt2, INT,)
+ COLUMN_NOT_NULL(ColumnText, TEXT,)
+CREATE_TABLE_END()
+
+SQL(
+ INSERT INTO TestTable VALUES(1, "two", 3, 4, "five");
+ INSERT INTO TestTable VALUES(6, "seven", 8, 9, "ten");
+ INSERT INTO TestTable (ColumnInt2, ColumnText) VALUES(11, "twelve");
+ INSERT INTO TestTable (ColumnInt2, ColumnText) VALUES(13, "fourteen");
+)
+
+CREATE_TABLE(TestTableJoin1)
+ COLUMN_NOT_NULL(TestID, INT)
+ COLUMN_NOT_NULL(TestText, TEXT)
+ COLUMN(TestNumber, INT)
+ TABLE_CONSTRAINTS(
+ PRIMARY KEY(TestID)
+ )
+CREATE_TABLE_END()
+
+CREATE_TABLE(TestTableJoin2)
+ COLUMN_NOT_NULL(TestID, INT)
+ COLUMN_NOT_NULL(TestText1, TEXT)
+ COLUMN_NOT_NULL(TestText2, TEXT)
+ TABLE_CONSTRAINTS(
+ PRIMARY KEY(TestID)
+ )
+CREATE_TABLE_END()
+
+CREATE_TABLE(TestTableJoin3)
+ COLUMN_NOT_NULL(TestID, INT)
+ COLUMN(Value3, INT)
+ COLUMN(TestText33, TEXT)
+ TABLE_CONSTRAINTS(
+ PRIMARY KEY(TestID)
+ )
+CREATE_TABLE_END()
+
+SQL(
+ INSERT INTO TestTableJoin1 VALUES(1, "text val 1", 111);
+ INSERT INTO TestTableJoin1 VALUES(2, "text val 2", 222);
+ INSERT INTO TestTableJoin1 VALUES(3, "text val 3", 333);
+ INSERT INTO TestTableJoin1 VALUES(4, "text val 4", 444);
+ INSERT INTO TestTableJoin1 VALUES(5, "text val 5", 555);
+ INSERT INTO TestTableJoin1 VALUES(6, "text val 6", 666);
+
+ INSERT INTO TestTableJoin2 VALUES(1, "01", "text2 1");
+ INSERT INTO TestTableJoin2 VALUES(2, "02", "text2 2");
+ INSERT INTO TestTableJoin2 VALUES(3, "03", "text2 3");
+ INSERT INTO TestTableJoin2 VALUES(4, " 4 ", "text2 4");
+ INSERT INTO TestTableJoin2 VALUES(5, "*5*", "text2 5");
+ INSERT INTO TestTableJoin2 VALUES(10, "6", "text2 6");
+
+ INSERT INTO TestTableJoin3 VALUES(1, 111, "test 1");
+ INSERT INTO TestTableJoin3 VALUES(2, 111, "test 2");
+ INSERT INTO TestTableJoin3 VALUES(3, 222, "test 3");
+ INSERT INTO TestTableJoin3 VALUES(6, 222, "test 4");
+ INSERT INTO TestTableJoin3 (TestID, TestText33) VALUES(7, "test 5");
+ INSERT INTO TestTableJoin3 (TestID, TestText33) VALUES(10, "test 6");
+)
\ No newline at end of file
--- /dev/null
+DATABASE_START(dpl_orm_test)
+
+#include "dpl_orm_test_db"
+
+DATABASE_END()
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file dpl_orm_test_db_sql_generator.h
+ * @author Lukasz Marek (l.marek@samsung.com)
+ * @version 1.0
+ * @brief Macro definitions for generating the SQL input file from database definition.
+ */
+
+//Do not include this file directly! It is used only for SQL code generation.
+
+#include <dpl/db/orm_macros.h>
+
+#include "dpl_orm_test_db_definitions"
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 ORM_GENERATOR_DPL_ORM_TEST_H
+#define ORM_GENERATOR_DPL_ORM_TEST_H
+
+#define ORM_GENERATOR_DATABASE_NAME dpl_orm_test_db_definitions
+#include <dpl/db/orm_generator.h>
+#undef ORM_GENERATOR_DATABASE_NAME
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <dpl/test/test_runner.h>
+#include <dpl/foreach.h>
+#include <dpl/db/thread_database_support.h>
+#include <generator_dpl_orm_test.h>
+#include <sstream>
+
+const char* PATH_DB = "/opt/share/wrt/wrt-commons/tests/db/dpl_orm_test.db";
+
+//utils
+
+#define TEST_REPETITION 16
+
+class SmartAttach
+{
+public:
+
+ SmartAttach(bool autoattach = true) :
+ m_interface(PATH_DB,
+ DPL::DB::SqlConnection::Flag::UseLucene),
+ m_autoattach(autoattach)
+ {
+ if (m_autoattach) {
+ m_interface.AttachToThread(DPL::DB::SqlConnection::Flag::RW);
+ }
+ }
+
+ ~SmartAttach()
+ {
+ if (m_autoattach) {
+ m_interface.DetachFromThread();
+ }
+ }
+
+ DPL::DB::ThreadDatabaseSupport* get()
+ {
+ return &m_interface;
+ }
+private:
+ DPL::DB::ThreadDatabaseSupport m_interface;
+ bool m_autoattach;
+};
+
+template<typename ContainerType1, typename ContainerType2>
+bool ContainerContentsEqual(const ContainerType1& container1, const ContainerType2& container2)
+{
+ using namespace DPL::DB::ORM::dpl_orm_test::TestTableInsert;
+ typedef std::set<typename ContainerType1::value_type> Set1;
+ typedef std::set<typename ContainerType2::value_type> Set2;
+ Set1 set1(container1.begin(), container1.end());
+ Set2 set2(container2.begin(), container2.end());
+
+ for (typename Set1::iterator it = set1.begin();
+ it != set1.end();
+ it++)
+ {
+ LogDebug("Set1 element: " << *it);
+ }
+
+ for (typename Set2::iterator it = set2.begin(); it != set2.end(); it++)
+ {
+ LogDebug("Set2 element: " << *it);
+ }
+
+ return set1 == set2;
+}
+
+template<typename T>
+std::list<T> makeList(const T& a, const T& b)
+{
+ std::list<T> list;
+ list.push_back(a);
+ list.push_back(b);
+ return list;
+}
+
+//tests
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(ORM_SelectSingleValue)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ //Getting each column
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ int result;
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ DPL::String result;
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptText>()) == L"seven", "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ int result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>()) == 8, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ int result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 9, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ DPL::String result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>()) == L"ten", "Got " << result);
+ }
+
+ //Where on each column
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnOptInt>(6));
+ int result;
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnOptText>(DPL::String(L"seven")));
+ DPL::String result;
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptText>()) == L"seven", "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ int result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>()) == 8, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt2>(9));
+ int result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 9, "Got " << result);
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnText>(L"ten"));
+ DPL::String result;
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>()) == L"ten", "Got " << result);
+ }
+}
+
+RUNNER_TEST(ORM_SelectSingleRow)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(3));
+ TestTable::Row result = select.GetSingleRow();
+ TestTable::Row expected;
+ expected.Set_ColumnOptInt(1);
+ expected.Set_ColumnOptText(DPL::String(L"two"));
+ expected.Set_ColumnInt(3);
+ expected.Set_ColumnInt2(4);
+ expected.Set_ColumnText(L"five");
+ RUNNER_ASSERT_MSG(result == expected, "Got " << result);
+ }
+
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnOptText>(DPL::String(L"seven")));
+ TestTable::Row result = select.GetSingleRow();
+ TestTable::Row expected;
+ expected.Set_ColumnOptInt(6);
+ expected.Set_ColumnOptText(DPL::String(L"seven"));
+ expected.Set_ColumnInt(8);
+ expected.Set_ColumnInt2(9);
+ expected.Set_ColumnText(L"ten");
+ RUNNER_ASSERT_MSG(result == expected, "Got " << result);
+ }
+}
+
+RUNNER_TEST(ORM_SelectRowList)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(3));
+ std::list<TestTable::Row> result = select.GetRowList();
+ RUNNER_ASSERT_MSG(result.size() == 1, "Got " << result.size());
+
+ TestTable::Row expected;
+ expected.Set_ColumnOptInt(1);
+ expected.Set_ColumnOptText(DPL::String(L"two"));
+ expected.Set_ColumnInt(3);
+ expected.Set_ColumnInt2(4);
+ expected.Set_ColumnText(L"five");
+ RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " << *(result.begin()) );
+ }
+
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnOptText>(DPL::String(L"seven")));
+ std::list<TestTable::Row> result = select.GetRowList();
+ RUNNER_ASSERT_MSG(result.size() == 1, "Got " << result.size());
+
+ TestTable::Row expected;
+ expected.Set_ColumnOptInt(6);
+ expected.Set_ColumnOptText(DPL::String(L"seven"));
+ expected.Set_ColumnInt(8);
+ expected.Set_ColumnInt2(9);
+ expected.Set_ColumnText(L"ten");
+ RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " << *(result.begin()) );
+ }
+
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Equals<TestTable::ColumnInt>(99));
+ std::list<TestTable::Row> result = select.GetRowList();
+
+ TestTable::Row expected1;
+ expected1.Set_ColumnInt(99);
+ expected1.Set_ColumnInt2(11);
+ expected1.Set_ColumnText(L"twelve");
+
+ TestTable::Row expected2;
+ expected2.Set_ColumnInt(99);
+ expected2.Set_ColumnInt2(13);
+ expected2.Set_ColumnText(L"fourteen");
+
+ RUNNER_ASSERT(ContainerContentsEqual(makeList(expected1, expected2), result));
+ }
+}
+
+RUNNER_TEST(ORM_SelectValueList)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ //Getting each column
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt>(),
+ makeList(99, 99)));
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
+ makeList(11, 13)));
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnText>(),
+ makeList(DPL::String(L"twelve"), DPL::String(L"fourteen"))));
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnOptText>(),
+ makeList(DPL::Optional<DPL::String>::Null,DPL::Optional<DPL::String>::Null)));
+ }
+
+ //Where on each column
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
+ makeList(11, 13)));
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnOptText>(DPL::Optional<DPL::String>::Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
+ makeList(11, 13)));
+ }
+ {
+ TestTable::Select select(interface.get());
+ select.Where(Is<TestTable::ColumnInt>(99));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
+ makeList(11, 13)));
+ }
+}
+
+RUNNER_TEST(ORM_MultipleCalls)
+{
+ for (int j = 0 ; j < TEST_REPETITION ; j++ )
+ {
+ for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ ORM_SelectSingleValue();
+
+ for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ ORM_SelectSingleRow();
+
+ for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ ORM_SelectRowList();
+
+ for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ ORM_SelectValueList();
+ }
+}
+
+RUNNER_TEST(ORM_Insert)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+
+ TestTableInsert::Select select1(interface.get());
+ std::list<int> resultList = select1.GetValueList<TestTableInsert::ColumnInt>();
+ RUNNER_ASSERT_MSG(resultList.size() == 0, "Returned list has wrong size: " << resultList.size());
+ std::list<TestTableInsert::Row> list;
+
+ TestTableInsert::Insert insert(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnOptInt(1);
+ row.Set_ColumnInt2(2);
+ row.Set_ColumnText(L"three");
+ insert.Values(row);
+ insert.Execute();
+
+ row.Set_ColumnInt(99);
+ list.push_back(row);
+ {
+ TestTableInsert::Select select2(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select2.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ TestTableInsert::Insert insert2(interface.get());
+ TestTableInsert::Row row2;
+ row2.Set_ColumnInt(4);
+ row2.Set_ColumnInt2(5);
+ row2.Set_ColumnText(L"six");
+ insert2.Values(row2);
+ insert2.Execute();
+
+ list.push_back(row2);
+ {
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ TestTableInsert::Insert insert3(interface.get());
+ TestTableInsert::Row row3;
+ row3.Set_ColumnOptInt(1);
+ row3.Set_ColumnInt2(7);
+ row3.Set_ColumnText(L"eight");
+ insert3.Values(row3);
+ insert3.Execute();
+
+ row3.Set_ColumnInt(99);
+ list.push_back(row3);
+ {
+ TestTableInsert::Select select3(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select3.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ TestTableInsert::Insert insert4(interface.get());
+ TestTableInsert::Row row4;
+ row4.Set_ColumnOptInt(9);
+ row4.Set_ColumnInt2(10);
+ row4.Set_ColumnText(L"eleven");
+ insert4.Values(row4);
+ insert4.Execute();
+
+ row4.Set_ColumnInt(99);
+ list.push_back(row4);
+ {
+ TestTableInsert::Select select4(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select4.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ // restore original table state
+ {
+ TestTableInsert::Delete del(interface.get());
+ del.Execute();
+
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT(select.GetRowList().size() == 0);
+ }
+}
+
+RUNNER_TEST(ORM_MultipleBindInsert)
+{
+ for ( int i = 0 ; i < TEST_REPETITION ; i++ )
+ {
+ ORM_Insert();
+ }
+}
+
+RUNNER_TEST(ORM_Delete)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ TestTableDelete::Select selectStart(interface.get());
+ selectStart.OrderBy("ColumnInt2 ASC");
+ std::list<TestTableDelete::Row> list = selectStart.GetRowList();
+ std::list<TestTableDelete::Row> originalList = list;
+
+ std::vector<TestTableDelete::Row> vector(list.begin(), list.end());
+ RUNNER_ASSERT_MSG(list.size() == 4, "Returned list has wrong size: " << list.size());
+
+ typedef DPL::String S;
+
+ //no-act deletes
+ {
+ TestTableDelete::Delete del(interface.get());
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(1), Equals<TestTableDelete::ColumnOptText>(S(L"seven"))));
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ {
+ TestTableDelete::Delete del(interface.get());
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6), Equals<TestTableDelete::ColumnOptText>(S(L"two"))));
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ {
+ TestTableDelete::Delete del(interface.get());
+ del.Where(Equals<TestTableDelete::ColumnInt2>(10));
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ //act deletes
+ {
+ list.remove(vector[1]);
+
+ TestTableDelete::Delete del(interface.get());
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6), Equals<TestTableDelete::ColumnText>(L"ten")));
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ {
+ list.remove(vector[2]);
+ list.remove(vector[3]);
+
+ TestTableDelete::Delete del(interface.get());
+ del.Where(Is<TestTableDelete::ColumnOptText>(DPL::Optional<DPL::String>::Null));
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ {
+ TestTableDelete::Delete del(interface.get());
+ del.Execute();
+
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(select.GetRowList().size() == 0, "Returned list is not empty");
+ }
+
+ // Restore original table state
+ // This also tests if multiple different binds for Insert are working properly
+ for (std::list<TestTableDelete::Row>::iterator i = originalList.begin(); i != originalList.end(); i++)
+ {
+ TestTableDelete::Insert insert(interface.get());
+ insert.Values(*i);
+ insert.Execute();
+ }
+
+ {
+ TestTableDelete::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), originalList), "Returned list doesn't match.");
+ }
+
+}
+
+RUNNER_TEST(ORM_MultipleBindDelete)
+{
+ for ( int i = 0 ; i < TEST_REPETITION ; i++ )
+ {
+ ORM_Delete();
+ }
+}
+
+RUNNER_TEST(ORM_MultipleBindWhere)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ {
+ TestTable::Select select(interface.get());
+ int result;
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+
+ select.Where(Equals<TestTable::ColumnInt>(3));
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 1, "Got " << result);
+
+ select.Where(Equals<TestTable::ColumnInt>(8));
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+
+ select.Where(Equals<TestTable::ColumnInt>(3));
+ RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 1, "Got " << result);
+ }
+
+ {
+ TestTable::Select select(interface.get());
+ int result;
+ select.Where(And(Equals<TestTable::ColumnInt>(99),
+ Equals<TestTable::ColumnText>(L"fourteen")));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnInt>(99),
+ Equals<TestTable::ColumnText>(L"twelve")));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnInt>(99),
+ Equals<TestTable::ColumnText>(L"fourteen")));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnInt>(99),
+ Equals<TestTable::ColumnText>(L"twelve")));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+ }
+
+ {
+ TestTable::Select select(interface.get());
+ int result;
+ select.Where(And(Equals<TestTable::ColumnText>(L"fourteen"),
+ Equals<TestTable::ColumnInt>(99)));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnText>(L"twelve"),
+ Equals<TestTable::ColumnInt>(99)));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnText>(L"fourteen"),
+ Equals<TestTable::ColumnInt>(99)));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+
+ select.Where(And(Equals<TestTable::ColumnText>(L"twelve"),
+ Equals<TestTable::ColumnInt>(99)));
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+
+ }
+
+}
+
+RUNNER_TEST(ORM_Update)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+
+ std::list<TestTableInsert::Row> list;
+
+ TestTableInsert::Delete del(interface.get());
+ del.Execute();
+
+ // INSERT
+ {
+ TestTableInsert::Insert insert(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnOptInt(5);
+ row.Set_ColumnInt2(2);
+ row.Set_ColumnText(L"two");
+ insert.Values(row);
+ insert.Execute();
+
+ row.Set_ColumnInt(99);
+ list.push_back(row);
+ }
+ {
+ TestTableInsert::Insert insert(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnOptInt(1);
+ row.Set_ColumnInt2(2);
+ row.Set_ColumnText(L"three");
+ insert.Values(row);
+ insert.Execute();
+
+ row.Set_ColumnInt(99);
+ list.push_back(row);
+ }
+ {
+ TestTableInsert::Insert insert(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnOptInt(2);
+ row.Set_ColumnInt2(3);
+ row.Set_ColumnText(L"three");
+ insert.Values(row);
+ insert.Execute();
+
+ row.Set_ColumnInt(99);
+ list.push_back(row);
+
+ // CHECK
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+ {
+ // UPDATE - no rows
+ TestTableInsert::Update update(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnInt2(4);
+ row.Set_ColumnText(L"four");
+ update.Values(row);
+ update.Where(Equals<TestTableInsert::ColumnInt2>(12));
+ update.Execute();
+
+ // CHECK
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+ {
+ // UPDATE - one row
+ TestTableInsert::Update update(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnInt2(2);
+ row.Set_ColumnText(L"four");
+ update.Values(row);
+ update.Where(Equals<TestTableInsert::ColumnInt2>(3));
+ update.Execute();
+
+ list.back().Set_ColumnInt2(2);
+ list.back().Set_ColumnText(L"four");
+
+ // CHECK
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ {
+ // UPDATE - multiple rows
+ TestTableInsert::Update update(interface.get());
+ TestTableInsert::Row row;
+ row.Set_ColumnText(L"dup");
+ update.Values(row);
+ update.Where(Equals<TestTableInsert::ColumnInt2>(2));
+ update.Execute();
+
+ FOREACH(it, list)
+ {
+ it->Set_ColumnText(L"dup");
+ }
+
+ // CHECK
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ }
+
+ // restore original table state
+ {
+ TestTableInsert::Delete del2(interface.get());
+ del2.Execute();
+
+ TestTableInsert::Select select(interface.get());
+ RUNNER_ASSERT(select.GetRowList().size() == 0);
+ }
+}
+
+RUNNER_TEST(ORM_MultipleBindUpdate)
+{
+ for ( int i = 0 ; i < TEST_REPETITION ; i++ )
+ {
+ ORM_Update();
+ }
+}
+
+RUNNER_TEST(ORM_transactions)
+{
+ SmartAttach interface;
+ DPL::DB::ORM::dpl_orm_test::ScopedTransaction transaction(interface.get());
+}
+
+RUNNER_TEST(ORM_MultiAttach)
+{
+ SmartAttach interface(false);
+ RUNNER_ASSERT_MSG(!interface.get()->IsAttached(), "Is attached, but shouldn't be.");
+ interface.get()->AttachToThread();
+ RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ interface.get()->AttachToThread();
+ RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ interface.get()->DetachFromThread();
+ RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ interface.get()->DetachFromThread();
+ RUNNER_ASSERT_MSG(!interface.get()->IsAttached(), "Is attached, but shouldn't be.");
+}
+
+RUNNER_TEST(ORM_Join)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin2::TestText2,
+ DPL::TypeListGuard>::Type JoinColumns;
+
+ /* Test for correct join:
+ * 5 ids from first table matches 5 ids from second table thus join result
+ * contains 5 rows */
+ TestTableJoin1::Select select(interface.get());
+ select.Join<JoinColumns>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestID>());
+ std::list<CustomRow<JoinColumns>> rowlist =
+ select.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
+
+ RUNNER_ASSERT_MSG(rowlist.size() == 5, "Invalid number of rows fetched: " << rowlist.size());
+
+ std::string text;
+ std::ostringstream oss;
+ int cnt = 0;
+ FOREACH(rowit, rowlist)
+ {
+ cnt++;
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ oss << "text val " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
+ << text << " expected: " << oss.str());
+ oss.str(std::string());
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ oss << "text2 " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
+ << text << " expected: " << oss.str());
+ oss.str(std::string());
+ }
+ /* Test for empty join:
+ * None of number values from first table matches ids from second table
+ * - join result should be empty */
+ TestTableJoin1::Select select2(interface.get());
+ select2.Join<JoinColumns>(Equal<TestTableJoin1::TestNumber, TestTableJoin2::TestID>());
+ rowlist = select2.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
+
+ RUNNER_ASSERT_MSG(rowlist.empty(), "Result should be empty but it is not!");
+
+ /* Test for "converted" join:
+ * - join made with int column and text column as keys
+ * - expected 5 matching rows (one row of 6 should not be matched)*/
+ TestTableJoin1::Select select3(interface.get());
+ select3.Join<JoinColumns>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestText1>());
+ rowlist = select3.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
+ RUNNER_ASSERT_MSG(rowlist.size() == 5, "Expected 5 rows while received: " << rowlist.size());
+ cnt = 0;
+ FOREACH(rowit, rowlist)
+ {
+ cnt++;
+ // look at last two insertions into TestTableJoin2
+ // for this skip understanding
+ if(cnt == 5) {
+ cnt = 6;
+ }
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ oss << "text val " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ oss << "text2 " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+ }
+
+ /* Test for join with non-unique nullable columns given as keys*/
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin3::TestText33,
+ DPL::TypeListGuard>::Type JoinTables2;
+ TestTableJoin1::Select select4(interface.get());
+ select4.Join<JoinTables2>(Equal<TestTableJoin1::TestNumber, TestTableJoin3::Value3>());
+ std::list<CustomRow<JoinTables2>> rowlist2 = select4.GetCustomRowList<JoinTables2, CustomRow<JoinTables2>>();
+ RUNNER_ASSERT_MSG(rowlist2.size() == 4, "Expected 4 rows while received: " << rowlist.size());
+ cnt = 0;
+ DPL::Optional<DPL::String> optext;
+ FOREACH(rowit, rowlist2)
+ {
+ cnt++;
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ // values expected in subsequent (1,2,3,4) iterations: 1 1 2 2
+ oss << "text val " << (1+(int)(cnt/3));
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+
+ optext = (*rowit).GetColumnData<TestTableJoin3::TestText33>();
+ text = DPL::ToUTF8String(*optext);
+ oss << "test " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+ }
+
+ /* Test for join made on three tables:
+ * - 3 text columns selected for join
+ * - Equal made for TestID of (table1 and table2) and (table1 and table3) */
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin2::TestText2,
+ TestTableJoin3::TestText33, DPL::TypeListGuard>::Type Join3Tables;
+ TestTableJoin1::Select select5(interface.get());
+ select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestID>());
+ select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID, TestTableJoin3::TestID>());
+ std::list<CustomRow<Join3Tables>> rowlist3tab = select5.GetCustomRowList<Join3Tables, CustomRow<Join3Tables>>();
+ RUNNER_ASSERT_MSG(rowlist3tab.size() == 3, "Expected 3 rows while received: " << rowlist3tab.size());
+ cnt = 0;
+ FOREACH(rowit, rowlist3tab)
+ {
+ cnt++;
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ oss << "text val " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+
+ text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ oss << "text2 " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+
+ optext = (*rowit).GetColumnData<TestTableJoin3::TestText33>();
+ text = DPL::ToUTF8String(*optext);
+ oss << "test " << cnt;
+ RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
+ << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss.str(std::string());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_sql_connection.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of sql connection tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/db/sql_connection.h>
+#include <dpl/db/naive_synchronization_object.h>
+#include <memory>
+#include <dpl/log/log.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+
+extern const char* PATH_DB;
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class AbstractSynchronizationObjectGenerator
+{
+public:
+ virtual ~AbstractSynchronizationObjectGenerator() {}
+
+ virtual DPL::DB::SqlConnection::SynchronizationObject *Create() = 0;
+};
+
+class NaiveSynchronizationObjectGenerator
+ : public AbstractSynchronizationObjectGenerator
+{
+public:
+ virtual DPL::DB::SqlConnection::SynchronizationObject *Create()
+ {
+ return new DPL::DB::NaiveSynchronizationObject();
+ }
+};
+
+void MassiveReadWriteTest(AbstractSynchronizationObjectGenerator *generator);
+
+class StressGenerator
+ : public DPL::Thread
+{
+private:
+ size_t m_prefix;
+ std::string m_dbFileName;
+ AbstractSynchronizationObjectGenerator *m_generator;
+
+protected:
+ virtual int ThreadEntry()
+ {
+ DPL::DB::SqlConnection connection(
+ m_dbFileName,
+ DPL::DB::SqlConnection::Flag::None,
+ DPL::DB::SqlConnection::Flag::RW,
+ m_generator->Create());
+
+ DPL::DB::SqlConnection::DataCommandAutoPtr countCommand =
+ connection.PrepareDataCommand(
+ "SELECT COUNT(*) FROM test WHERE value=?");
+
+ for (size_t i = 0; i < 10; ++i)
+ {
+ std::ostringstream valueStream;
+
+ valueStream << "value_";
+ valueStream << static_cast<unsigned long>(m_prefix);
+ valueStream << "_";
+ valueStream << static_cast<unsigned long>(i);
+
+ std::string value = valueStream.str();
+
+ connection.ExecCommand(
+ "INSERT INTO test VALUES ('%s');",
+ value.c_str());
+
+ countCommand->BindString(1, value.c_str());
+
+ RUNNER_ASSERT(countCommand->Step());
+
+ RUNNER_ASSERT(countCommand->GetColumnString(0) == "1");
+
+ countCommand->Reset();
+ }
+
+ countCommand.reset();
+
+ return 0;
+ }
+
+public:
+ StressGenerator(size_t prefix,
+ const std::string &dbFileName,
+ AbstractSynchronizationObjectGenerator *generator)
+ : m_prefix(prefix),
+ m_dbFileName(dbFileName),
+ m_generator(generator)
+ {
+ }
+};
+
+typedef std::shared_ptr<DPL::Thread> ThreadPtr;
+
+void MassiveReadWriteTest(AbstractSynchronizationObjectGenerator *generator)
+{
+ DPL::DB::SqlConnection connection(PATH_DB,
+ DPL::DB::SqlConnection::Flag::UseLucene,
+ DPL::DB::SqlConnection::Flag::RW);
+
+ connection.ExecCommand("CREATE TABLE test(value TEXT);");
+
+ const size_t STRESS_GENERATOR_COUNT = 5;
+ ThreadPtr stressGenerators[STRESS_GENERATOR_COUNT];
+
+ for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i)
+ {
+ stressGenerators[i].reset(
+ new StressGenerator(i, PATH_DB, generator));
+
+ stressGenerators[i]->Run();
+ }
+
+ for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i)
+ stressGenerators[i]->Quit();
+
+ connection.ExecCommand("DROP TABLE test;");
+}
+
+RUNNER_TEST(SqlConnection_MassiveReadWrite_NaiveSynchronization)
+{
+ srand(time(NULL));
+
+ NaiveSynchronizationObjectGenerator m_generator;
+ MassiveReadWriteTest(&m_generator);
+}
+
+
+
+
+
+
+RUNNER_TEST(SqlConnection_Not_Connected_Lucene)
+{
+ Try {
+ DPL::DB::SqlConnection connection("/notexisitingdirectiory/foo",
+ DPL::DB::SqlConnection::Flag::UseLucene,
+ DPL::DB::SqlConnection::Flag::RW);
+ RUNNER_ASSERT_MSG(false,
+ "connection should throw on accessing "
+ "nonexistent file as a database");
+ }
+ Catch (DPL::DB::SqlConnection::Exception::ConnectionBroken)
+ {
+ RUNNER_ASSERT(true);
+ }
+ catch (DPL::Exception)
+ {
+ RUNNER_ASSERT_MSG(false, "Wrong exception found");
+ }
+}
+
+RUNNER_TEST(SqlConnection_Not_Connected)
+{
+ Try {
+ DPL::DB::SqlConnection connection("/notexisitingdirectiory/foo",
+ DPL::DB::SqlConnection::Flag::None,
+ DPL::DB::SqlConnection::Flag::RW);
+ RUNNER_ASSERT_MSG(false,
+ "connection should throw on accessing "
+ "nonexistent file as a database");
+ }
+ Catch (DPL::DB::SqlConnection::Exception::ConnectionBroken)
+ {
+ RUNNER_ASSERT(true);
+ }
+ catch (DPL::Exception)
+ {
+ RUNNER_ASSERT_MSG(false, "Wrong exception found");
+ }
+}
+
+RUNNER_TEST(SqlConnection_Null_Query)
+{
+ DPL::DB::SqlConnection connection(PATH_DB,
+ DPL::DB::SqlConnection::Flag::UseLucene,
+ DPL::DB::SqlConnection::Flag::RW);
+ Try
+ {
+ connection.ExecCommand(NULL);
+ RUNNER_ASSERT_MSG(false,
+ "Null pointer should not be accepted");
+ }
+ Catch (DPL::DB::SqlConnection::Exception::SyntaxError)
+ {
+ RUNNER_ASSERT(true);
+ }
+ catch (DPL::Exception)
+ {
+ RUNNER_ASSERT_MSG(false, "Wrong exception found");
+ }
+
+}
+
+RUNNER_TEST(SqlConnection_Bad_Query)
+{
+ DPL::DB::SqlConnection connection(PATH_DB,
+ DPL::DB::SqlConnection::Flag::UseLucene,
+ DPL::DB::SqlConnection::Flag::RW);
+ Try
+ {
+ connection.ExecCommand("Some stupid string");
+ RUNNER_ASSERT_MSG(false, "This string should not be accepted");
+ }
+ Catch (DPL::DB::SqlConnection::Exception::SyntaxError)
+ {
+ RUNNER_ASSERT(true);
+ }
+ catch (DPL::Exception)
+ {
+ RUNNER_ASSERT_MSG(false, "Wrong exception found");
+ }
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+INCLUDE(FindPkgConfig)
+
+PKG_CHECK_MODULES(DEPENDENCIES gthread-2.0 REQUIRED)
+
+SET(TARGET_DBUS_TESTS "dpl-tests-dbus")
+SET(TARGET_DBUS_TEST_SERVICE "dpl-dbus-test-service")
+
+SET(DBUS_TESTS_SRCS
+ ${TESTS_DPL_DIR}/dbus/main.cpp
+ ${TESTS_DPL_DIR}/dbus/test_cases.cpp
+ ${TESTS_DPL_DIR}/dbus/dbus_test.cpp
+ ${TESTS_COMMON_DIR}/src/loop_control.cpp
+)
+
+SET(DBUS_TEST_SERVICE_SRCS
+ ${TESTS_DPL_DIR}/dbus/test_service.cpp
+ ${TESTS_COMMON_DIR}/src/loop_control.cpp
+)
+
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_DBUS_TESTS} ${TARGET_DPL_DBUS_EFL})
+WRT_TEST_INCLUDE_DIRECTORIES(${TARGET_DBUS_TESTS}
+ ${TESTS_COMMON_DIR}/include
+ ${DEPENDENCIES_INCLUDE_DIRS}
+)
+WRT_TEST_LINK_DIRECTORIES(${TARGET_DBUS_TESTS} ${DEPENDENCIES_LIBRARY_DIRS})
+WRT_TEST_TARGET_LINK_LIBRARIES(${TARGET_DBUS_TESTS} ${DEPENDENCIES_LIBRARIES})
+WRT_TEST_BUILD(${TARGET_DBUS_TESTS} ${DBUS_TESTS_SRCS})
+WRT_TEST_INSTALL(${TARGET_DBUS_TESTS})
+
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_DBUS_TEST_SERVICE} ${TARGET_DPL_DBUS_EFL})
+WRT_TEST_INCLUDE_DIRECTORIES(${TARGET_DBUS_TEST_SERVICE}
+ ${TESTS_COMMON_DIR}/include
+ ${DEPENDENCIES_INCLUDE_DIRS}
+)
+WRT_TEST_LINK_DIRECTORIES(${TARGET_DBUS_TEST_SERVICE} ${DEPENDENCIES_LIBRARY_DIRS})
+WRT_TEST_TARGET_LINK_LIBRARIES(${TARGET_DBUS_TEST_SERVICE} ${DEPENDENCIES_LIBRARIES})
+WRT_TEST_BUILD(${TARGET_DBUS_TEST_SERVICE} ${DBUS_TEST_SERVICE_SRCS})
+WRT_TEST_INSTALL(${TARGET_DBUS_TEST_SERVICE})
+
+INSTALL(FILES
+ ${TESTS_DPL_DIR}/dbus/data/org.tizen.DBusTestService.service
+ DESTINATION /usr/share/dbus-1/services
+)
--- /dev/null
+[D-BUS Service]
+Name=org.tizen.DBusTestService
+Exec=/usr/bin/dpl-dbus-test-service
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file dbus_test.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @brief Implementation file for DBusTest and DBusTestManager.
+ */
+
+#include <dpl/test/test_runner.h>
+#include "loop_control.h"
+#include "dbus_test.h"
+
+DBusTest::DBusTest(const std::string& name)
+ : m_name(name),
+ m_status(Status::NONE)
+{
+}
+
+void DBusTest::run(unsigned int timeout)
+{
+ DPL::Event::ControllerEventHandler<TimeoutEvent>::Touch();
+ DPL::Event::ControllerEventHandler<QuitEvent>::Touch();
+
+ DPL::Event::ControllerEventHandler<TimeoutEvent>::PostTimedEvent(
+ TimeoutEvent(), timeout);
+
+ LoopControl::wrt_start_loop();
+
+ switch (m_status)
+ {
+ case Status::FAILED:
+ throw DPL::Test::TestRunner::TestFailed(m_name.c_str(),
+ __FILE__,
+ __LINE__,
+ m_message);
+
+ default:
+ break;
+ }
+}
+
+void DBusTest::quit()
+{
+ DPL::Event::ControllerEventHandler<QuitEvent>::PostEvent(QuitEvent());
+}
+
+void DBusTest::setStatus(Status status)
+{
+ m_status = status;
+}
+
+void DBusTest::setMessage(const std::string& message)
+{
+ m_message = message;
+}
+
+void DBusTest::success()
+{
+ m_status = Status::SUCCESS;
+}
+
+void DBusTest::fail(const std::string& message)
+{
+ m_status = Status::FAILED;
+ m_message = message;
+}
+
+void DBusTest::OnEventReceived(const TimeoutEvent& /*event*/)
+{
+ fail("Test timed out.");
+
+ // Saving one event dispatch since Quit and Timeout work on the same thread.
+ LoopControl::wrt_end_loop();
+}
+
+void DBusTest::OnEventReceived(const QuitEvent& /*event*/)
+{
+ LoopControl::wrt_end_loop();
+}
+
+DBusTestManager& DBusTestManager::getInstance()
+{
+ static DBusTestManager instance;
+ return instance;
+}
+
+DBusTestManager::DBusTestManager() : m_test(NULL) { }
+
+DBusTest& DBusTestManager::getCurrentTest() const
+{
+ Assert(NULL != m_test && "Test not set.");
+
+ return *m_test;
+}
+
+void DBusTestManager::setCurrentTest(DBusTest& test)
+{
+ m_test = &test;
+}
+
+void DBusTestManager::clear()
+{
+ m_test = NULL;
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file dbus_test.h
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @brief Header file for DBusTest and DBusTestManager.
+ */
+
+#ifndef WRT_TESTS_DBUS_TESTS_DBUS_TEST_H
+#define WRT_TESTS_DBUS_TESTS_DBUS_TEST_H
+
+#include <string>
+#include <dpl/event/controller.h>
+#include <dpl/generic_event.h>
+
+DECLARE_GENERIC_EVENT_0(QuitEvent)
+DECLARE_GENERIC_EVENT_0(TimeoutEvent)
+
+class DBusTest :
+ private DPL::Event::Controller<DPL::TypeListDecl<QuitEvent, TimeoutEvent>::Type>
+{
+public:
+ enum class Status
+ {
+ NONE,
+ SUCCESS,
+ FAILED
+ };
+
+ explicit DBusTest(const std::string& name);
+
+ void run(unsigned int timeout);
+ void quit();
+
+ void setStatus(Status status);
+ void setMessage(const std::string& message);
+
+ void success();
+ void fail(const std::string& message = std::string());
+
+private:
+ void OnEventReceived(const TimeoutEvent& event);
+ void OnEventReceived(const QuitEvent& event);
+
+ std::string m_name;
+ Status m_status;
+ std::string m_message;
+};
+
+class DBusTestManager : private DPL::Noncopyable
+{
+public:
+ static DBusTestManager& getInstance();
+
+ DBusTest& getCurrentTest() const;
+ void setCurrentTest(DBusTest& test);
+
+ void clear();
+
+private:
+ DBusTestManager();
+
+ DBusTest* m_test;
+};
+
+#define DBUS_TEST(TestProc) \
+ void DBus##TestProc(); \
+ RUNNER_TEST(TestProc) \
+ { \
+ DBusTest test(#TestProc); \
+ DBusTestManager::getInstance().setCurrentTest(test); \
+ DBus##TestProc(); \
+ DBusTestManager::getInstance().clear(); \
+ } \
+ void DBus##TestProc()
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file main.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main.
+ */
+
+#include "loop_control.h"
+#include <dpl/test/test_runner.h>
+#include <dpl/log/log.h>
+
+int main(int argc, char *argv[])
+{
+ LoopControl::init_loop(argc, argv);
+
+ LogInfo("Running tests");
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+
+ return status;
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file TestCases.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for test cases for DBus internal tests.
+ */
+
+#include <string>
+#include <dpl/test/test_runner.h>
+#include <dpl/event/event_listener.h>
+#include <dpl/dbus/exception.h>
+#include <dpl/dbus/connection.h>
+#include <dpl/dbus/interface.h>
+#include "dbus_test.h"
+
+namespace {
+const std::string dbusServiceName = "org.freedesktop.DBus";
+const std::string dbusObjectPath = "/";
+const std::string dbusInterfaceName = "org.freedesktop.DBus";
+const std::string dbusMethodGetId = "GetId";
+
+const std::string serviceName = "org.tizen.DBusTestService";
+const std::string objectPath = "/org/tizen/DBusTestService";
+const std::string interfaceName = "org.tizen.DBusTestService";
+const std::string methodNameEcho = "echo";
+const std::string methodNameQuit = "quit";
+const std::string nodeInfo =
+ "<?xml version='1.0'?>"
+ "<node>"
+ " <interface name='" + interfaceName + "'>"
+ " <method name='" + methodNameEcho + "'>"
+ " <arg type='s' name='challenge' direction='in'/>"
+ " <arg type='s' name='response' direction='out'/>"
+ " </method>"
+ " <method name='" + methodNameQuit + "'>"
+ " </method>"
+ " </interface>"
+ "</node>";
+
+const std::string challenge = "Hello world!";
+
+const int DEFAULT_TIMEOUT = 2; // in seconds
+}
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+RUNNER_TEST(AcquireSessionBus)
+{
+ try
+ {
+ DPL::DBus::Connection::sessionBus();
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
+
+RUNNER_TEST(AcquireSystemBus)
+{
+ try
+ {
+ DPL::DBus::Connection::systemBus();
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
+
+RUNNER_TEST(ParseNodeInfo)
+{
+ try
+ {
+ auto ifaces = DPL::DBus::Interface::fromXMLString(nodeInfo);
+ RUNNER_ASSERT(!ifaces.empty());
+
+ auto iface = ifaces.at(0);
+ RUNNER_ASSERT(NULL != iface->getVTable());
+ RUNNER_ASSERT(NULL != iface->getInfo());
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
+
+RUNNER_TEST(InvokeRemoteMethod)
+{
+ try
+ {
+ auto connection = DPL::DBus::Connection::systemBus();
+ auto freedesktop = connection->createObjectProxy(dbusServiceName,
+ dbusObjectPath);
+ auto getId = freedesktop->createMethodProxy<std::string>
+ (dbusInterfaceName, dbusMethodGetId);
+ RUNNER_ASSERT(!getId().empty());
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
+
+class RegisterServiceListener :
+ public DPL::Event::EventListener<DPL::DBus::ConnectionEvents::ServiceNameAcquiredEvent>
+{
+public:
+ void OnEventReceived(
+ const DPL::DBus::ConnectionEvents::ServiceNameAcquiredEvent& event)
+ {
+ DBusTest& test = DBusTestManager::getInstance().getCurrentTest();
+
+ auto name = event.GetArg0();
+ if (serviceName == name)
+ {
+ test.success();
+ }
+ else
+ {
+ test.fail("Acquired service name: " + name);
+ }
+ test.quit();
+ }
+};
+
+DBUS_TEST(RegisterService)
+{
+ try
+ {
+ RegisterServiceListener listener;
+
+ auto connection = DPL::DBus::Connection::sessionBus();
+ connection->DPL::Event::EventSupport<DPL::DBus::ConnectionEvents::
+ ServiceNameAcquiredEvent>::AddListener(&listener);
+ connection->registerService(serviceName);
+
+ DBusTestManager::getInstance().getCurrentTest().run(DEFAULT_TIMEOUT);
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
+
+/**
+ * This test checks:
+ * - object registration (done on the wrt-dbus-test-service side)
+ * - service registration (done on the wrt-dbus-test-service side)
+ * - dispatching method calls (done on the wrt-dbus-test-service side)
+ * - launching dbus service on demand
+ * - invoking remote method(s)
+ */
+DBUS_TEST(InvokeTestService)
+{
+ try
+ {
+ auto connection = DPL::DBus::Connection::sessionBus();
+ auto testService = connection->createObjectProxy(serviceName,
+ objectPath);
+ auto echo = testService->createMethodProxy<std::string, std::string>
+ (interfaceName, methodNameEcho);
+ auto response = echo(challenge);
+
+ testService->createMethodProxy<void>(interfaceName, methodNameQuit)();
+
+ RUNNER_ASSERT_MSG(response == challenge,
+ "[challenge = " << challenge <<
+ ", response = " << response << "]");
+ }
+ catch (const DPL::DBus::Exception& ex)
+ {
+ RUNNER_ASSERT_MSG(false, ex.DumpToString());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file test_service.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @brief Implementation file for wrt-dbus-test-service.
+ */
+
+#include <string>
+#include <dpl/dbus/connection.h>
+#include <dpl/dbus/object.h>
+#include <dpl/dbus/interface.h>
+#include <dpl/dbus/dispatcher.h>
+#include <loop_control.h>
+
+namespace {
+const std::string serviceName = "org.tizen.DBusTestService";
+const std::string objectPath = "/org/tizen/DBusTestService";
+const std::string interfaceName = "org.tizen.DBusTestService";
+const std::string methodNameEcho = "echo";
+const std::string methodNameQuit = "quit";
+const std::string nodeInfo =
+ "<?xml version='1.0'?>"
+ "<node>"
+ " <interface name='" + interfaceName + "'>"
+ " <method name='" + methodNameEcho + "'>"
+ " <arg type='s' name='challenge' direction='in'/>"
+ " <arg type='s' name='response' direction='out'/>"
+ " </method>"
+ " <method name='" + methodNameQuit + "'>"
+ " </method>"
+ " </interface>"
+ "</node>";
+}
+
+class TestServiceDispatcher : public DPL::DBus::Dispatcher
+{
+private:
+ void onMethodCall(GDBusConnection* /*connection*/,
+ const gchar* /*sender*/,
+ const gchar* /*objectPath*/,
+ const gchar* /*interfaceName*/,
+ const gchar* methodName,
+ GVariant* parameters,
+ GDBusMethodInvocation* invocation)
+ {
+ if (methodNameEcho == methodName)
+ {
+ LogDebug("Echo");
+ g_dbus_method_invocation_return_value(invocation,
+ parameters);
+ }
+ else if (methodNameQuit == methodName)
+ {
+ LogDebug("Quit");
+ g_dbus_method_invocation_return_value(invocation, NULL);
+ LoopControl::wrt_end_loop();
+ }
+ }
+};
+
+int main(int argc, char* argv[])
+{
+ LoopControl::init_loop(argc, argv);
+ TestServiceDispatcher dispatcher;
+
+ auto iface = DPL::DBus::Interface::fromXMLString(nodeInfo).at(0);
+ iface->setDispatcher(&dispatcher);
+ auto object = DPL::DBus::Object::create(objectPath, iface);
+ auto connection = DPL::DBus::Connection::sessionBus();
+ connection->registerObject(object);
+ connection->registerService(serviceName);
+ LoopControl::wrt_start_loop();
+
+ return 0;
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+#
+# Test files
+#
+# Define all DPL tests sources.
+# Runner is responsible for runnint it all and
+# generating proper output files
+#
+
+SET(TARGET_NAME "dpl-tests-event")
+
+# Set DPL tests sources
+SET(DPL_TESTS_EVENT_SOURCES
+ ${TESTS_DPL_DIR}/event/main.cpp
+ ${TESTS_DPL_DIR}/event/test_controller.cpp
+ ${TESTS_DPL_DIR}/event/test_event_support.cpp
+ ${TESTS_DPL_DIR}/event/test_ic_delegate.cpp
+ ${TESTS_DPL_DIR}/event/test_property.cpp
+)
+
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_EVENT_EFL})
+WRT_TEST_BUILD(${TARGET_NAME} ${DPL_TESTS_EVENT_SOURCES})
+WRT_TEST_INSTALL(${TARGET_NAME})
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file main.cpp
+ * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main.
+ */
+
+#include <dpl/test/test_runner.h>
+
+int main(int argc, char *argv[])
+{
+ return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_controller.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test controller
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/event/controller.h>
+#include <dpl/thread.h>
+#include <dpl/generic_event.h>
+#include <dpl/waitable_handle.h>
+#include <dpl/waitable_event.h>
+#include <dpl/type_list.h>
+#include <dpl/application.h>
+#include <dpl/atomic.h>
+#include <list>
+#include <vector>
+#include <memory>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class IntController
+ : public DPL::Event::Controller<DPL::TypeListDecl<int>::Type>
+{
+private:
+ int m_value;
+
+protected:
+ virtual void OnEventReceived(const int &event)
+ {
+ m_value = event;
+ }
+
+public:
+ IntController()
+ : m_value(-1)
+ {
+ }
+
+ int Value() const
+ {
+ return m_value;
+ }
+};
+
+DECLARE_GENERIC_EVENT_1(DoneSignalEvent, DPL::WaitableEvent *)
+
+class ThreadController
+ : public DPL::Event::Controller<DPL::TypeListDecl<DoneSignalEvent>::Type>
+{
+private:
+ DPL::Thread *m_value;
+
+protected:
+ virtual void OnEventReceived(const DoneSignalEvent &event)
+ {
+ m_value = DPL::Thread::GetCurrentThread();
+ event.GetArg0()->Signal();
+ }
+
+public:
+ ThreadController()
+ : m_value(NULL)
+ {
+ }
+
+ DPL::Thread *Value() const
+ {
+ return m_value;
+ }
+};
+
+struct StrangeStruct
+{
+ int a;
+ float b;
+ double c;
+};
+
+class StrangeController
+ : public DPL::Event::Controller<DPL::TypeListDecl<char, short, int, long,
+ unsigned char, unsigned short, unsigned int, unsigned long,
+ float, double, StrangeStruct>::Type>
+{
+protected:
+ virtual void OnEventReceived(const char &event) { (void)event; }
+ virtual void OnEventReceived(const short &event) { (void)event; }
+ virtual void OnEventReceived(const int &event) { (void)event; }
+ virtual void OnEventReceived(const long &event) { (void)event; }
+ virtual void OnEventReceived(const unsigned char &event) { (void)event; }
+ virtual void OnEventReceived(const unsigned short &event) { (void)event; }
+ virtual void OnEventReceived(const unsigned int &event) { (void)event; }
+ virtual void OnEventReceived(const unsigned long &event) { (void)event; }
+ virtual void OnEventReceived(const float &event) { (void)event; }
+ virtual void OnEventReceived(const double &event) { (void)event; }
+ virtual void OnEventReceived(const StrangeStruct &event) { (void)event; }
+};
+
+RUNNER_TEST(Controller_InitSimple)
+{
+ IntController controller;
+ controller.Touch();
+ RUNNER_ASSERT(controller.Value() == -1);
+}
+
+RUNNER_TEST(Controller_InitStrange)
+{
+ StrangeController controller;
+ controller.Touch();
+}
+
+RUNNER_TEST(Controller_PostEventToThread)
+{
+ ThreadController controller;
+ controller.Touch();
+
+ DPL::Thread thread;
+ thread.Run();
+
+ controller.SwitchToThread(&thread);
+
+ DPL::WaitableEvent waitHandle;
+
+ controller.PostEvent(DoneSignalEvent(&waitHandle));
+
+ DPL::WaitForSingleHandle(waitHandle.GetHandle());
+
+ controller.SwitchToThread(NULL);
+
+ RUNNER_ASSERT(controller.Value() == &thread);
+}
+
+RUNNER_TEST(Controller_PostTimedEventToThread)
+{
+ ThreadController controller;
+ controller.Touch();
+
+ DPL::Thread thread;
+ thread.Run();
+
+ controller.SwitchToThread(&thread);
+
+ DPL::WaitableEvent waitHandle;
+
+ controller.PostTimedEvent(DoneSignalEvent(&waitHandle), 0.5);
+
+ DPL::WaitForSingleHandle(waitHandle.GetHandle());
+
+ controller.SwitchToThread(NULL);
+
+ RUNNER_ASSERT(controller.Value() == &thread);
+}
+
+DECLARE_GENERIC_EVENT_2(TouchInThread, DPL::WaitableEvent *, DPL::Thread **)
+DECLARE_GENERIC_EVENT_2(TouchedControllerSignal, DPL::WaitableEvent *, DPL::Thread **)
+
+class TouchInThreadController
+ : public DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type>,
+ private DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::Type>
+{
+public:
+ typedef DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type> PublicController;
+ typedef DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::Type> PrivateController;
+
+ virtual void OnEventReceived(const TouchInThread &event)
+ {
+ // Touch controller in thread
+ PrivateController::Touch();
+
+ // Post signal
+ PrivateController::PostEvent(TouchedControllerSignal(event.GetArg0(), event.GetArg1()));
+ }
+
+ virtual void OnEventReceived(const TouchedControllerSignal &event)
+ {
+ // Return touched thread
+ *event.GetArg1() = DPL::Thread::GetCurrentThread();
+
+ // Signal waitable event
+ event.GetArg0()->Signal();
+ }
+};
+
+RUNNER_TEST(Controller_TouchInThread)
+{
+ TouchInThreadController controller;
+ controller.PublicController::Touch();
+
+ DPL::Thread thread;
+ thread.Run();
+
+ controller.PublicController::SwitchToThread(&thread);
+
+ DPL::WaitableEvent waitHandle;
+ DPL::Thread *touchedThread = NULL;
+
+ controller.PublicController::PostEvent(TouchInThread(&waitHandle, &touchedThread));
+
+ DPL::WaitForSingleHandle(waitHandle.GetHandle());
+
+ controller.PublicController::SwitchToThread(NULL);
+
+ RUNNER_ASSERT(touchedThread == &thread);
+}
+
+RUNNER_TEST(Controller_SynchronizedEvent)
+{
+ IntController controller;
+ controller.Touch();
+
+ DPL::Thread thread;
+ thread.Run();
+
+ controller.SwitchToThread(&thread);
+ controller.PostSyncEvent(12345);
+ controller.SwitchToThread(NULL);
+
+ RUNNER_ASSERT(controller.Value() == 12345);
+}
+
+const int ControllersNumber = 5;
+const int MaxEventsPerController = 1;
+const int MaxEvents = ControllersNumber * MaxEventsPerController;
+const int ControllersPerThread = 1;
+
+class TestController; //Forward Declaration
+
+typedef std::shared_ptr<TestController> ControllerPtr;
+typedef std::shared_ptr<DPL::Thread> ThreadPtr;
+typedef std::vector<ControllerPtr> ControllerList;
+typedef std::list<ThreadPtr> ThreadList;
+
+DECLARE_GENERIC_EVENT_0(QuitEvent)
+class QuitController
+ : public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
+{
+public:
+ explicit QuitController( ) : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
+protected:
+ virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+};
+
+struct TestContext
+{
+ ControllerList controllers;
+ ThreadList threads;
+ QuitController quitter;
+ DPL::Atomic g_ReceivedCounter;
+ DPL::Atomic g_SentCounter;
+};
+typedef std::unique_ptr<TestContext> TestContextPtr;
+TestContextPtr testContextPtr;
+
+DECLARE_GENERIC_EVENT_0(StartSendEvent)
+DECLARE_GENERIC_EVENT_0(RandomEvent)
+class TestController
+ : public DPL::Event::Controller<DPL::TypeListDecl<RandomEvent, StartSendEvent>::Type>
+{
+public:
+ explicit TestController() { Touch(); }
+protected:
+ virtual void OnEventReceived(const RandomEvent &)
+ {
+ ++testContextPtr->g_ReceivedCounter;
+ if(testContextPtr->g_ReceivedCounter == MaxEvents)
+ {
+ testContextPtr->quitter.DPL::Event::ControllerEventHandler<QuitEvent>::PostEvent(QuitEvent());
+ return;
+ }
+ }
+ virtual void OnEventReceived(const StartSendEvent &)
+ {
+ for (int i=0 ; i<MaxEventsPerController ;++i)
+ {
+ if(testContextPtr->g_SentCounter > MaxEvents)
+ {
+ return;
+ }
+ ++testContextPtr->g_SentCounter;
+ int id = rand() % static_cast<int>(testContextPtr->controllers.size());
+ testContextPtr->controllers.at(id)->DPL::Event::ControllerEventHandler<RandomEvent>::PostEvent(RandomEvent());
+ }
+ }
+};
+
+RUNNER_TEST(Controllers_MultipleEvents)
+{
+ srand ( time(NULL) );
+
+ testContextPtr.reset(new TestContext());
+ testContextPtr->controllers.reserve(ControllersNumber);
+
+ for (int i = 0; i < ControllersNumber ; ++i)
+ {
+ if(testContextPtr->controllers.size() % ControllersPerThread ==0)
+ {
+ ThreadPtr thread = ThreadPtr(new DPL::Thread());
+ testContextPtr->threads.push_back(thread);
+ thread->Run();
+ }
+
+ ControllerPtr controller = ControllerPtr(new TestController());
+ testContextPtr->controllers.push_back(controller);
+ if(testContextPtr->controllers.size() % 2 == 0)
+ {
+ //This controller is being switched to thread (otherwise it is touched to main thread)
+ ThreadPtr thread = testContextPtr->threads.back();
+ controller->SwitchToThread(thread.get());
+ }
+ controller->DPL::Event::ControllerEventHandler<StartSendEvent>::PostEvent(StartSendEvent());
+ }
+ testContextPtr->quitter.Exec();
+ RUNNER_ASSERT(testContextPtr->g_SentCounter == testContextPtr->g_ReceivedCounter);
+ testContextPtr.reset();
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_event_support.cpp
+ * @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains test for event support
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/generic_event.h>
+#include <dpl/event/event_listener.h>
+#include <dpl/event/event_support.h>
+#include <dpl/application.h>
+#include <dpl/event/controller.h>
+#include <dpl/fast_delegate.h>
+#include <dpl/log/log.h>
+
+DECLARE_GENERIC_EVENT_0(TestEvent)
+
+class TestListener: public DPL::Event::EventListener<TestEvent>
+{
+public:
+ explicit TestListener() : m_dummyVar(0) { }
+ void OnEventReceived(const TestEvent &) { m_dummyVar = 1; }
+ int GetDummyVar() const { return m_dummyVar; }
+ void ZeroDummyVar() { m_dummyVar = 0; }
+
+private:
+ int m_dummyVar;
+};
+
+class TestEventSupport
+ : public DPL::Event::EventSupport<TestEvent>
+{
+public:
+ void TestEmitEvent() { EmitEvent(TestEvent()); }
+};
+
+DECLARE_GENERIC_EVENT_0(QuitEvent)
+
+class QuitController
+ : public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
+{
+public:
+ QuitController() : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
+
+protected:
+ virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+};
+
+RUNNER_TEST(EventSupport_DestroyBeforeProcessing)
+{
+ QuitController quitter;
+ quitter.PostTimedEvent(QuitEvent(), 1.0);
+
+ TestListener eventListener;
+ {
+ TestEventSupport eventSupport;
+ eventSupport.AddListener(&eventListener);
+ eventSupport.TestEmitEvent();
+ eventSupport.RemoveListener(&eventListener);
+ }
+ eventListener.ZeroDummyVar();
+
+ quitter.Exec();
+ RUNNER_ASSERT(eventListener.GetDummyVar() == 0);
+}
+
+int g_delegateTest;
+
+void OnDelegateTest(const int &k);
+
+void OnDelegateTest(const int &k)
+{
+ LogInfo("Got delegate call");
+ g_delegateTest = k;
+}
+
+class DelegateTestSupport
+ : public DPL::Event::EventSupport<int>
+{
+public:
+ void Test()
+ {
+ EmitEvent(7);
+ }
+};
+
+RUNNER_TEST(EventSupport_BindDelegate)
+{
+ g_delegateTest = 0;
+
+ DelegateTestSupport support;
+ support.AddListener(&OnDelegateTest);
+
+ QuitController quitter;
+ quitter.PostTimedEvent(QuitEvent(), 1.0);
+
+ support.Test();
+
+ quitter.Exec();
+
+ support.RemoveListener(&OnDelegateTest);
+
+ RUNNER_ASSERT(g_delegateTest == 7);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_ic_delegate.cpp
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @author Lukasz Wrzosek (l.wrzosek@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of fast delegate tests.
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/application.h>
+#include <dpl/event/controller.h>
+#include <dpl/log/log.h>
+#include <dpl/fast_delegate.h>
+#include <dpl/event/inter_context_delegate.h>
+#include <dpl/thread.h>
+#include <dpl/waitable_event.h>
+#include <dpl/assert.h>
+#include <dpl/mutex.h>
+#include <dpl/type_list.h>
+#include <memory>
+RUNNER_TEST_GROUP_INIT(DPL)
+
+const int IntVal = 123;
+const std::string StringVal = "someString";
+
+typedef DPL::Event::ICDelegate<> GetNothingDlpType;
+typedef DPL::Event::ICDelegate<int> GetIntDlgType;
+typedef DPL::Event::ICDelegate<int, std::string> GetIntAndStringDlgType;
+DECLARE_GENERIC_EVENT_1(GetNothingEvent, GetNothingDlpType)
+DECLARE_GENERIC_EVENT_1(GetIntEvent, GetIntDlgType)
+DECLARE_GENERIC_EVENT_1(GetIntAndStringEvent, GetIntAndStringDlgType)
+
+class ICTestController
+: public DPL::Event::Controller<DPL::TypeListDecl<GetNothingEvent,
+ GetIntEvent,
+ GetIntAndStringEvent>::Type>
+{
+ public:
+ ICTestController() { }
+
+ protected:
+ virtual void OnEventReceived(const GetNothingEvent& event)
+ {
+ event.GetArg0()(); //calling intercontext delegate
+ }
+ virtual void OnEventReceived(const GetIntEvent& event)
+ {
+ event.GetArg0()(IntVal); //calling intercontext delegate
+ }
+
+ virtual void OnEventReceived(const GetIntAndStringEvent& event)
+ {
+ event.GetArg0()(IntVal, StringVal); //calling intercontext delegate
+ }
+};
+
+struct TestResult
+{
+ TestResult() :
+ m_correctThread0(false),
+ m_correctThread1(false),
+ m_correctThread2(false),
+ m_int(-1),
+ m_int2(-1),
+ m_string("")
+ {
+ }
+
+ void TestEventsPassed()
+ {
+ RUNNER_ASSERT(m_correctThread0);
+ RUNNER_ASSERT(m_correctThread1);
+ RUNNER_ASSERT(m_int == IntVal);
+ RUNNER_ASSERT(m_correctThread2);
+ RUNNER_ASSERT(m_int2 == IntVal);
+ RUNNER_ASSERT(m_string == StringVal);
+ }
+
+ void TestEventsDidNotPass()
+ {
+ RUNNER_ASSERT(!m_correctThread0);
+ RUNNER_ASSERT(!m_correctThread1);
+ RUNNER_ASSERT(m_int == -1);
+ RUNNER_ASSERT(!m_correctThread2);
+ RUNNER_ASSERT(m_int2 == -1);
+ RUNNER_ASSERT(m_string == "");
+ }
+
+ bool m_correctThread0;
+ bool m_correctThread1;
+ bool m_correctThread2;
+ int m_int;
+ int m_int2;
+ std::string m_string;
+};
+
+class TestContextFreeClass :
+ protected DPL::Thread,
+ public DPL::Event::ICDelegateSupport<TestContextFreeClass>
+{
+ public:
+ TestContextFreeClass(ICTestController* controller, TestResult* result) :
+ Thread(),
+ m_testResult(result),
+ m_controller(controller)
+ {
+ LogDebug("Context thread id = " << this);
+ }
+
+ void Run()
+ {
+ LogDebug("Running Context Free thread");
+ Thread::Run();
+ }
+
+ void Quit()
+ {
+ LogDebug("Exiting Context Free thread");
+ Thread::Quit();
+ }
+
+
+ void Wait()
+ {
+ LogDebug("Waiting for thread");
+ DPL::WaitForSingleHandle(m_waitable.GetHandle());
+ }
+
+ protected:
+ void OnNothing()
+ {
+ LogDebug("Received nothing in thread = " << GetCurrentThread());
+ m_testResult->m_correctThread0 = (GetCurrentThread() == this);
+ }
+
+ void OnIntReceive(int val)
+ {
+ LogDebug("Received int in thread = " << GetCurrentThread());
+ m_testResult->m_correctThread1 = (GetCurrentThread() == this);
+ m_testResult->m_int = val;
+ }
+
+ void OnIntAndStringReceive(int val, std::string stringval)
+ {
+ LogDebug("Received int and string in thread = " << GetCurrentThread());
+ m_testResult->m_correctThread2 = (GetCurrentThread() == this);
+ m_testResult->m_int2 = val;
+ m_testResult->m_string = stringval;
+ m_waitable.Signal();
+ }
+
+ virtual int ThreadEntry()
+ {
+ GetNothingEvent getNothingEvent(
+ makeICDelegate(
+ &TestContextFreeClass::OnNothing));
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ getNothingEvent);
+
+ GetIntEvent getIntEvent(
+ makeICDelegate(
+ &TestContextFreeClass::OnIntReceive));
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ getIntEvent);
+
+ GetIntAndStringEvent getIntAndStringEvent(
+ makeICDelegate(
+ &TestContextFreeClass::OnIntAndStringReceive));
+ m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ getIntAndStringEvent);
+
+ return Thread::ThreadEntry();
+ }
+
+ private:
+ TestResult* m_testResult;
+ DPL::WaitableEvent m_waitable;
+ ICTestController* m_controller;
+};
+
+RUNNER_TEST(ICDelegate_0)
+{
+ DPL::Thread thread;
+ thread.Run();
+ LogDebug("Controller thread id = " << &thread);
+
+ ICTestController testController;
+ testController.Touch();
+ testController.SwitchToThread(&thread);
+
+ TestResult result;
+ TestContextFreeClass* contextFree =
+ new TestContextFreeClass(&testController, &result);
+ result.TestEventsDidNotPass();
+
+ thread.Run();
+ contextFree->Run();
+ contextFree->Wait();
+ contextFree->Quit();
+ thread.Quit();
+
+ delete contextFree;
+
+ result.TestEventsPassed();
+}
+
+RUNNER_TEST(ICDelegate_1)
+{
+ DPL::Thread thread;
+ LogDebug("Controller thread id = " << &thread);
+
+ ICTestController testController;
+ testController.Touch();
+ testController.SwitchToThread(&thread);
+
+ TestResult result;
+ TestContextFreeClass* contextFree =
+ new TestContextFreeClass(&testController, &result);
+ result.TestEventsDidNotPass();
+
+ contextFree->Run();
+ contextFree->Quit();
+ delete contextFree; //deleting Delegates before actual Events are worked out
+ thread.Run();
+ thread.Quit();
+
+ result.TestEventsDidNotPass();
+}
+
+class TestContextFree;
+class TestRunnerInThread;
+
+namespace
+{
+const int ControllersPerThread = 40;
+const int ContextFreePerThread = 180;
+const int TestsPerController = 110;
+const int TestThreads = 23;
+const int TestsPerThread = 100;
+const int NumberOfEvents = 230;
+
+typedef std::shared_ptr<ICTestController> ICTestControllerPtr;
+typedef std::shared_ptr<TestContextFree> TestContextFreePtr;
+typedef std::shared_ptr<TestRunnerInThread> TestRunnerInThreadPtr;
+typedef std::shared_ptr<DPL::Thread> ThreadPtr;
+
+DPL::Mutex mutex;
+std::list<TestContextFreePtr> frees;
+std::list<ICTestControllerPtr> ctrls;
+std::list<TestRunnerInThreadPtr> frees_threads;
+std::list<ThreadPtr> ctrls_threads;
+
+}
+
+class TestContextFree : public DPL::Event::ICDelegateSupport<TestContextFree>
+{
+ public:
+ TestContextFree(ICTestController* controller,
+ int eventsCount) :
+ m_controller(controller),
+ m_eventsCount(eventsCount)
+ {
+ }
+
+ void Wait()
+ {
+ LogDebug("Waiting for thread");
+ DPL::WaitForSingleHandle(m_waitable.GetHandle());
+ }
+
+
+ void OnNothing()
+ {
+ LogDebug("Got");
+ m_eventsCount--;
+ if (m_eventsCount > 0) {
+ LogDebug("posting next event");
+ GetIntAndStringEvent getIntAndStringEvent(
+ makeICDelegate(
+ &TestContextFree::OnIntAndStringReceive));
+ LogDebug("posting next event ...");
+ m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ getIntAndStringEvent);
+ LogDebug("posting next event done");
+ } else {
+ LogDebug("test finished");
+ m_waitable.Signal();
+ }
+ }
+
+ void OnIntReceive(int)
+ {
+ LogDebug("Got");
+ m_eventsCount--;
+ if (m_eventsCount > 0) {
+ LogDebug("posting next event");
+ GetNothingEvent getNothingEvent(
+ makeICDelegate(
+ &TestContextFree::OnNothing));
+ LogDebug("posting next event ...");
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ getNothingEvent);
+ LogDebug("posting next event done");
+ } else {
+ LogDebug("test finished");
+ m_waitable.Signal();
+ }
+ }
+
+ void OnIntAndStringReceive(int, std::string)
+ {
+ LogDebug("Got");
+ m_eventsCount--;
+ if (m_eventsCount > 0) {
+ LogDebug("posting next event");
+
+ GetIntEvent getIntEvent(
+ makeICDelegate(
+ &TestContextFree::OnIntReceive));
+ LogDebug("posting next event ...");
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ getIntEvent);
+ LogDebug("posting next event done");
+ } else {
+ LogDebug("test finished");
+ m_waitable.Signal();
+ }
+ }
+
+ void StartTestOnNothing()
+ {
+ GetNothingEvent getNothingEvent(
+ makeICDelegate(
+ &TestContextFree::OnNothing));
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ getNothingEvent);
+ }
+
+ void StartTestOnInt()
+ {
+ GetIntEvent getIntEvent(
+ makeICDelegate(
+ &TestContextFree::OnIntReceive));
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ getIntEvent);
+ }
+
+ void StartTestOnIntAndString()
+ {
+ GetIntAndStringEvent getIntAndStringEvent(
+ makeICDelegate(
+ &TestContextFree::OnIntAndStringReceive));
+ m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ getIntAndStringEvent);
+ }
+
+ bool CheckTest()
+ {
+ LogDebug("Checking test result");
+ return m_eventsCount == 0;
+ }
+
+ private:
+ ICTestController* m_controller;
+ int m_eventsCount;
+ DPL::WaitableEvent m_waitable;
+};
+
+class TestRunnerInThread : public DPL::Thread
+{
+ public:
+ TestRunnerInThread(int events, int tests) :
+ m_eventsCount(events),
+ m_tests(tests) {}
+
+ void WaitForInit()
+ {
+ LogDebug("Waiting for thread");
+ DPL::WaitForSingleHandle(m_init.GetHandle());
+ }
+
+ protected:
+ virtual int ThreadEntry()
+ {
+ LogDebug("Thread starts");
+ {
+ DPL::Mutex::ScopedLock lock(&mutex);
+ for (int i = 0; i < m_tests; ++i)
+ {
+ if (i % TestsPerController == 0) {
+ if (ctrls.size() % ControllersPerThread == 0) {
+ ThreadPtr thread(new DPL::Thread());
+ thread->Run();
+ ctrls_threads.push_back(thread);
+ }
+ ICTestControllerPtr ptr(new ICTestController());
+ ptr->Touch();
+ ptr->SwitchToThread(ctrls_threads.back().get());
+ ctrls.push_back(ptr);
+
+ TestContextFreePtr t(new TestContextFree(ctrls.back().get(),
+ m_eventsCount));
+ t->StartTestOnNothing();
+ LogDebug("");
+ frees.push_back(t);
+ }
+ }
+ }
+ m_init.Signal();
+ LogDebug("Thread starts loop");
+ return DPL::Thread::ThreadEntry();
+ }
+
+ private:
+ DPL::WaitableEvent m_init;
+ int m_eventsCount;
+ int m_tests;
+};
+
+RUNNER_TEST(ICDelegate_2)
+{
+ LogDebug("Creating test threads");
+ for (int i = 0; i < TestThreads; ++i)
+ {
+ TestRunnerInThreadPtr ptr(
+ new TestRunnerInThread(NumberOfEvents, TestsPerThread));
+ frees_threads.push_back(ptr);
+ frees_threads.back()->Run();
+ }
+
+ FOREACH(it, frees_threads) {
+ (*it)->WaitForInit();
+ }
+ LogDebug("Creating test threads done");
+
+ FOREACH(it, frees) {
+ LogDebug("...");
+ (*it)->Wait();
+ }
+
+ FOREACH(it, frees) {
+ RUNNER_ASSERT((*it)->CheckTest());
+ }
+
+ frees.clear();
+
+ FOREACH(it, frees_threads) {
+ (*it)->Quit();
+ }
+
+ frees_threads.clear();
+
+ FOREACH(it, ctrls) {
+ (*it)->SwitchToThread(NULL);
+ }
+
+ FOREACH(it, ctrls_threads) {
+ (*it)->Quit();
+ }
+
+ ctrls.clear();
+ ctrls_threads.clear();
+}
+
+namespace ReuseCheck {
+const int ReuseCount = 5;
+typedef DPL::Event::ICDelegate<> GetNothingDlpType;
+DECLARE_GENERIC_EVENT_1(ReuseCountEvent, GetNothingDlpType)
+
+class ICReuseTestController
+: public DPL::Event::Controller<DPL::TypeListDecl<ReuseCountEvent>::Type>
+{
+ public:
+ ICReuseTestController() { m_reuseCount = 0; }
+
+ protected:
+ virtual void OnEventReceived(const ReuseCountEvent& event)
+ {
+ event.GetArg0()(); //calling intercontext delegate
+ if(++m_reuseCount < ReuseCount){
+ LogInfo("[Send] Reuse: " << m_reuseCount);
+ DPL::Event::ControllerEventHandler<ReuseCountEvent>::PostEvent(event);
+ }
+ }
+
+ int m_reuseCount;
+};
+
+class ReuseTestContextFreeClass :
+ protected DPL::Thread,
+ public DPL::Event::ICDelegateSupport<ReuseTestContextFreeClass>
+{
+ public:
+ ReuseTestContextFreeClass(ICReuseTestController* controller) :
+ Thread(),
+ m_controller(controller),
+ m_reuseCount(0)
+ { }
+
+ void Run() { Thread::Run(); }
+ void Quit() { Thread::Quit(); }
+ void Wait() { DPL::WaitForSingleHandle(m_waitable.GetHandle()); }
+
+ protected:
+ void OnReuseReceive()
+ {
+ LogDebug("[Received] : " << ++m_reuseCount);
+ if(m_reuseCount == ReuseCount)
+ m_waitable.Signal();
+ }
+
+ virtual int ThreadEntry()
+ {
+ ReuseCountEvent reuseEvent(
+ makeICDelegate(
+ &ReuseTestContextFreeClass::OnReuseReceive,
+ DPL::Event::ICD::Reuse::Yes));
+ m_controller->DPL::Event::ControllerEventHandler<ReuseCountEvent>::PostEvent(
+ reuseEvent);
+
+ return Thread::ThreadEntry();
+ }
+
+ private:
+ DPL::WaitableEvent m_waitable;
+ ICReuseTestController* m_controller;
+ int m_reuseCount;
+};
+
+RUNNER_TEST(ICDelegate_3)
+{
+ DPL::Thread thread;
+ thread.Run();
+ LogDebug("Controller thread id = " << &thread);
+
+ ICReuseTestController testController;
+ testController.Touch();
+ testController.SwitchToThread(&thread);
+
+ ReuseTestContextFreeClass* contextFree =
+ new ReuseTestContextFreeClass(&testController);
+
+ thread.Run();
+ contextFree->Run();
+ contextFree->Wait();
+ contextFree->Quit();
+ thread.Quit();
+
+ delete contextFree;
+
+ RUNNER_ASSERT(true);
+}
+} //namespace ReuseCheck
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_property.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test property
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/event/property.h>
+#include <dpl/event/model.h>
+#include <string>
+
+namespace {
+const int PROPERTY_VALUE_INT = 2;
+const std::string PROPERTY_VALUE_STRING = "aaa";
+}
+
+int ReadSomething2(DPL::Event::Model */*model*/);
+int ReadSomething2(DPL::Event::Model */*model*/)
+{
+ return PROPERTY_VALUE_INT;
+}
+
+std::string ReadSomething(DPL::Event::Model */*model*/);
+std::string ReadSomething(DPL::Event::Model */*model*/)
+{
+ return PROPERTY_VALUE_STRING;
+}
+
+void WriteSomething(const std::string &/*value*/, DPL::Event::Model */*model*/);
+void WriteSomething(const std::string &/*value*/, DPL::Event::Model */*model*/)
+{
+}
+
+class MyModel
+ : public DPL::Event::Model
+{
+public:
+ ~MyModel() {}
+
+ DPL::Event::Property<std::string>
+ Caption;
+
+ DPL::Event::Property<std::string>
+ Testproperty0;
+
+ DPL::Event::Property<std::string, DPL::Event::PropertyReadOnly>
+ Testproperty1;
+
+ DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite>
+ Testproperty2;
+
+ DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite,
+ DPL::Event::PropertyStorageCached> Testproperty3;
+
+ DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite,
+ DPL::Event::PropertyStorageDynamic> Testproperty4;
+
+ DPL::Event::Property<int, DPL::Event::PropertyReadOnly,
+ DPL::Event::PropertyStorageDynamicCached> Testproperty5;
+
+ MyModel()
+ : Caption(this, "Foo caption"),
+ Testproperty0(this, "", &ReadSomething),
+ Testproperty1(this),
+ Testproperty2(this),
+ Testproperty3(this),
+ Testproperty4(this, "test", &ReadSomething, &WriteSomething),
+ Testproperty5(this, &ReadSomething2)
+ {
+ }
+};
+
+std::string g_caption;
+
+void OnNameChanged(const DPL::Event::PropertyEvent<std::string> &event);
+void OnNameChanged(const DPL::Event::PropertyEvent<std::string> &event)
+{
+ g_caption = event.value;
+}
+
+RUNNER_TEST(Model_Test)
+{
+ MyModel model;
+
+ g_caption = "It is a bad caption";
+
+ model.Caption.AddListener(&OnNameChanged);
+ model.Caption.Set("Test name");
+
+ RUNNER_ASSERT(model.Testproperty4.Get() == PROPERTY_VALUE_STRING);
+ RUNNER_ASSERT(PROPERTY_VALUE_INT == model.Testproperty5.Get());
+ RUNNER_ASSERT(g_caption == "Test name");
+ RUNNER_ASSERT(model.Caption.Get() == "Test name");
+
+ model.Caption.RemoveListener(&OnNameChanged);
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+# @version 1.0
+# @brief
+#
+
+#
+# Test files
+#
+# Define all DPL tests sources.
+# Runner is responsible for runnint it all and
+# generating proper output files
+#
+
+SET(TARGET_LOC "dpl-tests-loc")
+
+SET(LOC_TESTS_SOURCES
+ ${DPL_TESTS_DIR}/localization/test_localization.cpp
+ ${DPL_TESTS_DIR}/localization/test_suite01.cpp
+ #${DPL_TESTS_DIR}/localization/mockup_src/widget_dao.cpp
+ #${PROJECT_SOURCE_DIR}/modules/localization/src/localization_utils.cpp
+ #${PROJECT_SOURCE_DIR}/modules/localization/src/w3c_file_localization.cpp
+)
+
+#WRT_INCLUDE_DIRECTORIES(
+ #${SYS_EFL_INCLUDE_DIRS}
+ #${DPL_TEST_INCLUDE_DIR}
+ #${DPL_TESTS_DIR}/localization/mockup_include
+ #${PROJECT_SOURCE_DIR}/modules/localization/include
+#)
+
+#LINK_DIRECTORIES(${SYS_EFL_LIBRARY_DIRS})
+
+WRT_TEST_BUILD(${TARGET_LOC} ${LOC_TESTS_SOURCES})
+WRT_TEST_INSTALL(${TARGET_LOC})
+
+ADD_SUBDIRECTORY(files)
--- /dev/null
+INSTALL(FILES
+ ${DPL_TESTS_DIR}/localization/files/one
+ DESTINATION
+ /opt/share/widget/tests/localization/widget1/locales/pl-en
+ )
+
+INSTALL(FILES
+ ${DPL_TESTS_DIR}/localization/files/one
+ ${DPL_TESTS_DIR}/localization/files/two
+ DESTINATION
+ /opt/share/widget/tests/localization/widget2/locales/pl-en
+ )
+
+INSTALL(FILES
+ ${DPL_TESTS_DIR}/localization/files/two
+ DESTINATION
+ /opt/share/widget/tests/localization/widget2/locales/en-en
+ )
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ *
+ * @file common_dao_types.h
+ * @author Michal Ciepielski (m.ciepielski@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of common data types for wrtdb
+ */
+
+#ifndef WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
+#define WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
+
+#include <set>
+#include <string>
+#include <map>
+#include <vector>
+#include <list>
+#include <dpl/optional_typedefs.h>
+#include <memory>
+
+namespace WrtDB {
+namespace Powder {
+
+typedef std::set<DPL::String> StringSet;
+//! Widget description
+struct Description
+{
+ //!Content level
+ typedef enum
+ {
+ Level0 = 0,
+ Level1,
+ Level2,
+ Level3,
+ Level4,
+ Level5,
+ LevelUnknown
+ } LevelEnum;
+ struct LevelEntry
+ {
+ LevelEnum level; //!< content level
+
+ typedef StringSet Context;
+
+ //! POWDER context
+ //! xa This material appears in an artistic context
+ //! xb This material appears in an educational context
+ //! xc This material appears in a medical context
+ //! xd This material appears in a sports context
+ //! xe This material appears in a violent context
+ Context context;
+ explicit LevelEntry(LevelEnum level = LevelUnknown);
+ //! Function checks if context is valid
+ //! \param[in] level POWDER content level
+ //! \param[in] context POWDER context
+ bool isContextValid(LevelEnum level,
+ const DPL::OptionalString& context) const;
+ };
+
+ struct CategoryEntry
+ {
+ //! Levels entries for POWDER description
+ typedef std::vector <LevelEntry> LevelsContainer;
+ LevelsContainer levels;
+ //! Function checks if context is valid
+ //! \param[out] reason set if context invalid
+ //! \param[in] level POWDER content level
+ //! \param[in] context POWDER context
+ bool isCategoryValid(LevelEntry& reason,
+ LevelEnum level,
+ const DPL::OptionalString& context) const;
+ };
+
+ //! POWDER Category -> Category entry map for Widget
+ //!
+ //! nu Nudity
+ //! se Sex
+ //! vi Violence
+ //! la Potentially offensive language
+ //! dr Drug use
+ //! ga Gambling
+ //! ha Hate or harmful activities
+ //! ug Use of user-generated content
+ typedef std::map<DPL::String, CategoryEntry> CategoryEntries;
+
+ CategoryEntries categories;
+
+ //! Age rating for widget
+ //! If Null not set
+ DPL::OptionalInt ageRating;
+};
+} // namespace Powder
+
+namespace ChildProtection {
+
+//! Blacklist with forbidden URLs
+//! It should be stored in WidgetDAO
+typedef std::vector<DPL::String> BlackList;
+
+//! Widget Child protection record
+//! Record should be stored in WingetDAO
+struct Record
+{
+ //! Child protection enabled
+ bool enabled;
+ explicit Record(bool enabled) :
+ enabled(enabled)
+ {
+ }
+};
+
+//! Powder processing
+struct PowderRules
+{
+ //! Rule set by parent about forbidden category
+ //! Powder category
+ //! nu Nudity
+ //! se Sex
+ //! vi Violence
+ //! la Potentially offensive language
+ //! dr Drug use
+ //! ga Gambling
+ //! ha Hate or harmful activities
+ //! ug Use of user-generated content
+ //! Powder context
+ //! xa This material appears in an artistic conteaxt
+ //! xb This material appears in an educational context
+ //! xc This material appears in a medical context
+ //! xd This material appears in a sports context
+ //! xe This material appears in a violent context
+ struct CategoryRule
+ {
+ DPL::String category;
+ Powder::Description::LevelEnum level;
+ DPL::OptionalString context;
+ explicit CategoryRule(const DPL::String& category = DPL::String(),
+ Powder::Description::LevelEnum level =
+ Powder::Description::LevelUnknown,
+ const DPL::OptionalString& context = DPL::OptionalString());
+ };
+
+ struct PowderResult
+ {
+ //! Reasoning outcome: part of POWDER description used to invalidate
+ Powder::Description::LevelEntry invalidDescription;
+ //! Reasoning outcome: rule set by parent not full filed by description
+ CategoryRule invalidRule;
+
+ //! Reasoning outcome: type of invalidity
+ enum InvalidReason
+ {
+ InvalidRule, //!< One of rules was not fulfilled
+ InvalidAge, //!< Age is invalid
+ AgeRatingNotSet, //!< Age rating for widget is not set
+ Valid //!< Description valid
+ };
+ InvalidReason reason;
+ explicit PowderResult(InvalidReason reason = Valid,
+ const Powder::Description::LevelEntry& invalidDescription =
+ Powder::Description::LevelEntry(),
+ const CategoryRule& invalidRule = CategoryRule());
+ };
+
+ typedef std::pair<bool, PowderResult> ResultPair;
+
+ //! Function checks if rule is fulfilled by description
+ //! \param[in] rule checked rule
+ //! \param[in] description
+ //! \retval true rule is valid
+ //! \retval false rule is invalid
+ ResultPair isRuleValidForDescription(const CategoryRule& rule,
+ const Powder::Description& description) const;
+ //! Function checks if age limit is fulfilled by description
+ //! \param[in] description
+ //! \retval true age is valid
+ //! \retval false age is invalid
+ ResultPair isAgeValidForDescription(
+ const Powder::Description& description) const;
+
+ //! It is the maximum age rating valid for child
+ //! Uniform age is stored in WidgetDAO
+ DPL::OptionalInt ageLimit;
+
+ //! Set to true if age rating is required
+ //! If ageLimit is not set value is ignored
+ bool isAgeRatingRequired;
+
+ //! Set of rules configured by parent
+ //! Rules are stored in WidgetDAO and are uniform for all widgets
+ typedef std::vector<CategoryRule> RulesContainer;
+ RulesContainer rules;
+
+ //! Function check if Widget description is valid for ChildProtection
+ //! configuration
+ //! \param description widget description
+ //! \retval true widget is valid
+ //! \retval false widget is invalid
+ ResultPair isDescriptionValid(const Powder::Description& description)
+ const;
+
+ PowderRules() :
+ isAgeRatingRequired(false)
+ {
+ }
+};
+} // namespace ChildProtection
+
+class PluginMetafileData
+{
+ public:
+ struct Feature
+ {
+ std::string m_name;
+ std::set<std::string> m_deviceCapabilities;
+
+ bool operator< (const Feature& obj) const
+ {
+ return m_name < obj.m_name;
+ }
+ };
+ typedef std::set<Feature> FeatureContainer;
+
+ public:
+
+ PluginMetafileData()
+ {
+ }
+
+ std::string m_libraryName;
+ std::string m_featuresInstallURI;
+ std::string m_featuresKeyCN;
+ std::string m_featuresRootCN;
+ std::string m_featuresRootFingerprint;
+
+ FeatureContainer m_featureContainer;
+};
+
+class PluginObjectsDAO
+{
+ public:
+ typedef std::set<std::string> Objects;
+ typedef std::shared_ptr<Objects> ObjectsPtr;
+
+ public:
+ explicit PluginObjectsDAO() {}
+
+ protected:
+ ObjectsPtr m_implemented;
+ ObjectsPtr m_dependent;
+};
+
+/**
+ * @brief Widget id describes web-runtime global widget identifier.
+ *
+ * Notice that only up to one widget can exist at the same time.
+ * DbWidgetHandle can be translated into corresponding WidgetModel by invoking
+ * FindWidgetModel routine.
+ */
+typedef int DbWidgetHandle;
+
+/**
+ * @brief Structure to hold the information of widget's size
+ */
+struct DbWidgetSize
+{
+ DPL::OptionalInt width;
+ DPL::OptionalInt height;
+
+ DbWidgetSize(DPL::OptionalInt w = DPL::OptionalInt::Null,
+ DPL::OptionalInt h = DPL::OptionalInt::Null) :
+ width(w),
+ height(h)
+ {
+ }
+};
+
+inline bool operator ==(const DbWidgetSize &objA, const DbWidgetSize &objB)
+{
+ if (!objA.height || !objA.width || !objB.width || !objB.height) {
+ return false;
+ } else {
+ return *objA.height == *objB.height && *objA.width == *objB.width;
+ }
+}
+
+/**
+ * Widget [G]lobal [U]nique [ID]entifier
+ * Orginated from appstore ID
+ */
+typedef DPL::OptionalString WidgetGUID;
+
+struct WidgetAccessInfo
+{
+ DPL::String strIRI; /* origin iri */
+ bool bSubDomains; /* do we want access to subdomains ? */
+
+ bool operator ==(const WidgetAccessInfo& info) const
+ {
+ return info.strIRI == strIRI &&
+ info.bSubDomains == bSubDomains;
+ }
+};
+
+typedef std::list<WidgetAccessInfo> WidgetAccessInfoList;
+
+typedef std::list<DPL::String> WindowModeList;
+
+/**
+ * @brief Widget configuration parameter key
+ */
+typedef DPL::String WidgetParamKey;
+
+/**
+ * @brief Widget configuration parameter value
+ */
+typedef DPL::String WidgetParamValue;
+
+/**
+ * @brief A map of widget configuration parameters.
+ *
+ * Widget configuration parameters are read from database and are stored
+ * along with feature that they describe.
+ */
+typedef std::multimap<WidgetParamKey, WidgetParamValue> WidgetParamMap;
+
+/**
+ * @brief Widget feature host information about possible javascript extensions
+ * that widget may use
+ *
+ * Widget features are declared in configuration file in widget installation
+ * package. Each declared special feature is contained in some wrt-plugin that
+ * declares to implement it. After widget launch wrt searches for proper plugin
+ * libraries and load needed features.
+ *
+ * Widget features can be required or optional. It is possible to start widget
+ * without missing feature. When required feature cannot be loaded widget will
+ * not start.
+ */
+
+enum {
+ INVALID_PLUGIN_HANDLE = -1
+};
+typedef int DbPluginHandle;
+
+struct DbWidgetFeature
+{
+ DPL::String name; /// Feature name
+ bool required; /// Whether feature is required
+ DbPluginHandle pluginId; /// Plugin id that implement this feature
+ WidgetParamMap params; /// Widget's params
+
+ DbWidgetFeature() :
+ required(false),
+ pluginId(INVALID_PLUGIN_HANDLE)
+ {
+ }
+};
+
+inline bool operator < (const DbWidgetFeature &objA,
+ const DbWidgetFeature &objB)
+{
+ return objA.name.compare(objB.name) < 0;
+}
+
+inline bool operator==(const DbWidgetFeature &featureA,
+ const DbWidgetFeature &featureB)
+{
+ return featureA.name == featureB.name &&
+ featureA.required == featureB.required &&
+ featureA.pluginId == featureB.pluginId;
+}
+
+/**
+ * @brief Default container for features list
+ */
+typedef std::multiset<DbWidgetFeature> DbWidgetFeatureSet;
+
+/**
+ * @brief Default container with DbWidgetHandle's
+ */
+typedef std::list<DbWidgetHandle> DbWidgetHandleList;
+
+/**
+ * @brief Widget specific type
+ *
+ * Widget type describes belowed in WAC, TIZEN WebApp
+ */
+enum AppType
+{
+ APP_TYPE_UNKNOWN = 0, // unknown
+ APP_TYPE_WAC20, // WAC 2.0
+ APP_TYPE_TIZENWEBAPP, // slp webapp
+};
+
+class WidgetType
+{
+ public:
+ WidgetType()
+ :appType(APP_TYPE_UNKNOWN)
+ {
+ }
+ WidgetType(const AppType type)
+ :appType(type)
+ {
+ }
+ bool operator== (const AppType& other) const
+ {
+ return appType == other;
+ }
+ std::string getApptypeToString()
+ {
+ switch (appType) {
+#define X(x) case x: return #x;
+ X(APP_TYPE_UNKNOWN)
+ X(APP_TYPE_WAC20)
+ X(APP_TYPE_TIZENWEBAPP)
+#undef X
+ default:
+ return "UNKNOWN";
+ }
+ }
+
+ AppType appType;
+};
+
+} // namespace WrtDB
+
+struct WidgetSetting
+{
+ DPL::String settingName;
+ DPL::String settingValue;
+
+ bool operator ==(const WidgetSetting& info) const
+ {
+ return (info.settingName == settingName &&
+ info.settingValue == settingValue);
+ }
+ bool operator !=(const WidgetSetting& info) const
+ {
+ return (info.settingName != settingName ||
+ info.settingValue != settingValue);
+ }
+};
+
+typedef std::list<WidgetSetting> WidgetSettings;
+
+/**
+ * @brief Widget Application Service
+ *
+ * Application sercvice describes details of behaviour
+ * when widget receives aul bundle data.
+ */
+struct WidgetApplicationService
+{
+ public:
+ DPL::String src; /* start uri */
+ DPL::String operation; /* service name */
+ DPL::String scheme; /* scheme type*/
+ DPL::String mime; /* mime type */
+
+ bool operator== (const WidgetApplicationService& other) const
+ {
+ return src == other.src &&
+ operation == other.operation &&
+ scheme == other.scheme &&
+ mime == other.mime;
+ }
+};
+
+typedef std::list<WidgetApplicationService> WidgetApplicationServiceList;
+#endif /* WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of widget dao class.
+ *
+ * @file widget_dao_read_only.h
+ * @author Yang Jie (jie2.yang@samsung.com)
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of widget dao
+ */
+
+#ifndef _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
+#define _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
+
+#include <time.h>
+
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+
+#include <dpl/string.h>
+#include <dpl/exception.h>
+#include <dpl/optional_typedefs.h>
+
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+//#include "../wrt-dao-ro/common_dao_types.h"
+
+typedef DPL::OptionalString WidgetGUID;
+
+namespace ConfigParserData {
+
+struct Icon
+{
+ Icon(const DPL::String& src) : src(src)
+ {
+ }
+ DPL::String src;
+ DPL::OptionalInt width;
+ DPL::OptionalInt height;
+ bool operator==(const Icon&) const;
+ bool operator!=(const Icon&) const;
+ bool operator >(const Icon&) const;
+ bool operator>=(const Icon&) const;
+ bool operator <(const Icon&) const;
+ bool operator<=(const Icon&) const;
+};
+} // namespace ConfigParserData
+namespace WrtDB {
+
+typedef std::list<DPL::String> StringList;
+
+struct WidgetLocalizedInfo
+{
+ DPL::OptionalString name;
+ DPL::OptionalString shortName;
+ DPL::OptionalString description;
+ DPL::OptionalString license;
+ DPL::OptionalString licenseHref;
+};
+
+typedef std::list<DPL::String> LanguageTagList;
+
+class WidgetDAO
+{
+ public:
+ /**
+ * WidgetDAO Exception classes
+ */
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
+ DECLARE_EXCEPTION_TYPE(Base, ReadOnlyProperty)
+ DECLARE_EXCEPTION_TYPE(Base, GUIDisNull)
+ DECLARE_EXCEPTION_TYPE(Base, UnexpectedEmptyResult)
+ DECLARE_EXCEPTION_TYPE(Base, WidgetNotExist)
+ DECLARE_EXCEPTION_TYPE(Base, AlreadyRegistered)
+ };
+
+ protected:
+ DbWidgetHandle m_widgetHandle;
+
+ public:
+ struct WidgetLocalizedIconRow
+ {
+ int appId;
+ int iconId;
+ DPL::String widgetLocale;
+ };
+ typedef std::list<WidgetLocalizedIconRow> WidgetLocalizedIconList;
+
+ struct WidgetIconRow
+ {
+ int iconId;
+ int appId;
+ DPL::String iconSrc;
+ DPL::OptionalInt iconWidth;
+ DPL::OptionalInt iconHeight;
+ };
+ typedef std::list<WidgetIconRow> WidgetIconList;
+
+ struct WidgetStartFileRow
+ {
+ int startFileId;
+ int appId;
+ DPL::String src;
+ };
+ typedef std::list<WidgetStartFileRow> WidgetStartFileList;
+
+ struct WidgetLocalizedStartFileRow
+ {
+ int startFileId;
+ int appId;
+ DPL::String widgetLocale;
+ DPL::String type;
+ DPL::String encoding;
+ };
+ typedef std::list<WidgetLocalizedStartFileRow> LocalizedStartFileList;
+
+
+ /**
+ * This is a constructor.
+ *
+ * @param[in] widgetHandle application id of widget.
+ */
+ WidgetDAO(DbWidgetHandle widgetHandle)
+ : m_widgetHandle(widgetHandle)
+ {}
+
+ /**
+ * Destructor
+ */
+ virtual ~WidgetDAO(){}
+
+ /**
+ * This method returns widget handle(m_widgetHandle).
+ *
+ * @return widget handle(m_widgetHandle).
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
+ */
+ DbWidgetHandle getHandle() const { return m_widgetHandle; }
+ DbWidgetHandle getHandle(const WidgetGUID GUID) const;
+ static DbWidgetHandle getHandle(const DPL::String pkgName);
+
+ /**
+ * This method returns the root directory of widget resource.
+ *
+ * @return path name of root directory.
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ DPL::String getPath() const;
+ void setPath(const DPL::String &path) const;
+
+ /**
+ * This method returns the defaultlocale for the widget.
+ *
+ * @return defaultlocale
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ DPL::OptionalString getDefaultlocale() const;
+
+ /**
+ * This method returns list of localized icons files;
+ *
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ WidgetLocalizedIconList getLocalizedIconList() const;
+
+ /**
+ * This method returns list of icons files;
+ *
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ WidgetIconList getIconList() const;
+
+ /**
+ * This method returns list of localized start files;
+ *
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ LocalizedStartFileList getLocalizedStartFileList() const;
+ void setLocalizedStartFileList(const LocalizedStartFileList &list) const;
+ /**
+ * This method returns list of start files;
+ *
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ WidgetStartFileList getStartFileList() const;
+ void setStartFileList(const WidgetStartFileList &list) const;
+
+ WidgetLocalizedInfo getLocalizedInfo(const DPL::String& languageTag) const;
+ protected:
+ static std::map<DbWidgetHandle,WidgetStartFileList> s_startFileMap;
+ static std::map<DbWidgetHandle,LocalizedStartFileList> s_localizedStartFileMap;
+ static std::map<DbWidgetHandle,DPL::String> s_pathMap;
+};
+
+} // namespace WrtDB
+
+#endif // _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of widget dao class.
+ *
+ * @file widget_dao_read_only.cpp
+ * @author Yang Jie (jie2.yang@samsung.com)
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @author Pawel Sikorski (p.sikorski@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of widget dao
+ */
+
+//#include "../mockup_include/dpl/wrt-dao-rw/widget_dao.h"
+#include <dpl/wrt-dao-rw/widget_dao.h>
+
+#include <sstream>
+#include <dpl/foreach.h>
+#include <dpl/log/log.h>
+#include <dpl/sstream.h>
+
+namespace WrtDB {
+
+std::map<DbWidgetHandle,WidgetDAO::WidgetStartFileList> WidgetDAO::s_startFileMap;
+std::map<DbWidgetHandle,WidgetDAO::LocalizedStartFileList> WidgetDAO::s_localizedStartFileMap;
+std::map<DbWidgetHandle,DPL::String> WidgetDAO::s_pathMap;
+
+DbWidgetHandle WidgetDAO::getHandle(const WidgetGUID /* GUID */) const
+{
+ LogError("Not impleneted!");
+ return 0;
+}
+
+DbWidgetHandle WidgetDAO::getHandle(const DPL::String /* pkgName */)
+{
+ LogError("Not implemented!");
+ return 0;
+}
+
+DPL::String WidgetDAO::getPath() const
+{
+ return s_pathMap[m_widgetHandle];
+}
+
+void WidgetDAO::setPath(const DPL::String &path) const
+{
+ s_pathMap[m_widgetHandle] = path;
+}
+
+WidgetLocalizedInfo
+ WidgetDAO::getLocalizedInfo(const DPL::String& /* languageTag */)
+ const
+{
+ LogError("Not implemented!");
+ return WidgetLocalizedInfo();
+}
+
+DPL::OptionalString WidgetDAO::getDefaultlocale() const
+{
+ LogError("Not implemented!");
+ return DPL::OptionalString();
+}
+
+WidgetDAO::WidgetLocalizedIconList WidgetDAO::getLocalizedIconList() const
+{
+ LogError("Not implemented!");
+ return WidgetLocalizedIconList();
+}
+
+WidgetDAO::WidgetIconList WidgetDAO::getIconList() const
+{
+ LogError("Not implemented!");
+ return WidgetIconList();
+}
+
+WidgetDAO::LocalizedStartFileList WidgetDAO::getLocalizedStartFileList() const
+{
+ return s_localizedStartFileMap[m_widgetHandle];
+}
+
+void WidgetDAO::setLocalizedStartFileList(const LocalizedStartFileList &list) const {
+ s_localizedStartFileMap[m_widgetHandle] = list;
+}
+
+WidgetDAO::WidgetStartFileList WidgetDAO::getStartFileList() const
+{
+ return s_startFileMap[m_widgetHandle];
+}
+
+void WidgetDAO::setStartFileList(const WidgetStartFileList &list) const
+{
+ s_startFileMap[m_widgetHandle] = list;
+}
+
+} // namespace WrtDB
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file main.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main
+ */
+#include <dpl/test/test_runner.h>
+
+int main(int argc, char *argv[])
+{
+ return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * This file contains the declaration of widget dao class.
+ *
+ * @file test_suite01.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+
+#include <dpl/log/log.h>
+#include <dpl/test/test_runner.h>
+
+//#include "mockup_include/dpl/wrt-dao-rw/widget_dao.h"
+#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <dpl/localization/w3c_file_localization.h>
+
+namespace {
+
+WrtDB::LanguageTagList generateLanguageTags(){
+ WrtDB::LanguageTagList tags;
+ tags.push_back(L"pl-pl");
+ tags.push_back(L"en-en");
+ tags.push_back(L"pl-en");
+ return tags;
+}
+
+static const WrtDB::LanguageTagList languageTags = generateLanguageTags();
+static const DPL::String widget1Path = L"/opt/share/widget/tests/localization/widget1/";
+static const DPL::String widget2Path = L"/opt/share/widget/tests/localization/widget2/";
+
+} // anonymous namespace
+
+RUNNER_TEST(test01_getFilePathInWidgetPackageFromUrl){
+ const int widgetHandle = 1;
+ WrtDB::WidgetDAO dao(widgetHandle);
+ //dao.setPath(widget1Path);
+
+ auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ widgetHandle,
+ languageTags,
+ L"widget://one");
+
+ RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget1/locales/pl-en/one");
+}
+
+RUNNER_TEST(test02_getFilePathInWidgetPackageFromUrl){
+ const int widgetHandle = 2;
+ WrtDB::WidgetDAO dao(widgetHandle);
+ //dao.setPath(widget2Path);
+
+ auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ widgetHandle,
+ languageTags,
+ L"widget://one");
+
+ RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget2/locales/pl-en/one");
+}
+
+RUNNER_TEST(test03_getFilePathInWidgetPackageFromUrl){
+ const int widgetHandle = 2;
+ WrtDB::WidgetDAO dao(widgetHandle);
+ //dao.setPath(widget2Path);
+
+ auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ widgetHandle,
+ languageTags,
+ L"widget://two");
+
+ RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget2/locales/en-en/two");
+}
+
+RUNNER_TEST(test04_getFilePathInWidgetPackage){
+ const int widgetHandle = 1;
+ WrtDB::WidgetDAO dao(widgetHandle);
+ //dao.setPath(widget1Path);
+
+ auto result = W3CFileLocalization::getFilePathInWidgetPackage(
+ widgetHandle,
+ languageTags,
+ L"one");
+
+ RUNNER_ASSERT(*result == L"locales/pl-en/one");
+}
+
+RUNNER_TEST(test05_getFilePathInWidgetPackage){
+ const int widgetHandle = 2;
+ WrtDB::WidgetDAO dao(widgetHandle);
+ //dao.setPath(widget2Path);
+
+ auto result = W3CFileLocalization::getFilePathInWidgetPackage(
+ widgetHandle,
+ languageTags,
+ L"two");
+
+ RUNNER_ASSERT(*result == L"locales/en-en/two");
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_address.cpp
+ * @author Tomasz Swierczek (t.swierczek@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of caller tests
+ */
+
+#include <dpl/test_runner.h>
+#include <dpl/serialization.h>
+#include <dpl/caller.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+// test stream class
+class BinaryStream : public DPL::IStream {
+ public:
+ virtual void Read(size_t num, void * bytes)
+ {
+ for (unsigned i = 0; i < num; ++i) {
+ ((unsigned char*)bytes)[i] = data[i + readPosition];
+ }
+ readPosition += num;
+ }
+ virtual void Write(size_t num, const void * bytes)
+ {
+ for (unsigned i = 0; i < num; ++i) {
+ data.push_back(((unsigned char*)bytes)[i]);
+ }
+ }
+ BinaryStream()
+ {
+ readPosition = 0;
+ }
+ virtual ~BinaryStream(){};
+
+ private:
+ std::vector<unsigned char> data;
+ unsigned readPosition;
+};
+
+static int return_func(int a, bool b)
+{
+ if (b) {
+ return a;
+ } else {
+ return 0;
+ }
+}
+
+static int called = 0;
+
+static void void_func(int a)
+{
+ called = a;
+}
+
+static struct VoidDelegate
+{
+ void operator()(int a)
+ {
+ called = a;
+ }
+} voidDelegate;
+
+static struct ReturnDelegate
+{
+ int operator()(int a)
+ {
+ return a;
+ }
+} returnDelegate;
+
+RUNNER_TEST(Caller_function_void)
+{
+ int a = 23;
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,a);
+ called = 0;
+ DPL::Caller::Call(stream,void_func);
+ RUNNER_ASSERT(called == a);
+}
+
+RUNNER_TEST(Caller_function_return)
+{
+ int a = 23;
+ bool b = true;
+ BinaryStream stream;
+ DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream,b);
+ int result = DPL::Caller::Call(stream,return_func);
+ RUNNER_ASSERT(result == a);
+}
+
+RUNNER_TEST(Caller_delegate_void)
+{
+ int a = 23;
+ BinaryStream stream;
+ called = 0;
+ DPL::Serialization::Serialize(stream,a);
+ DPL::Caller::CallDelegate(stream,voidDelegate);
+ RUNNER_ASSERT(called == a);
+}
+
+RUNNER_TEST(Caller_delegate_return)
+{
+ int a = 23;
+ BinaryStream stream;
+ called = 0;
+ DPL::Serialization::Serialize(stream,a);
+ int result = 0;
+ DPL::Caller::CallDelegate(stream,returnDelegate,result);
+ RUNNER_ASSERT(result == a);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_crypto_hash.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test crypto hash
+ */
+#include <dpl/test_runner.h>
+#include <dpl/crypto_hash.h>
+RUNNER_TEST_GROUP_INIT(DPL)
+
+#define TEST_CRYPTO_HASH(Class, Input, Output) \
+ Class crypto; \
+ crypto.Append(Input); \
+ crypto.Finish(); \
+ RUNNER_ASSERT(crypto.ToString() == Output);
+
+RUNNER_TEST(CryptoHash_MD2)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD2, "sample_input_string", "c9f26439c9882cccc98467dbdf07b1fc");
+}
+
+RUNNER_TEST(CryptoHash_MD4)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD4, "sample_input_string", "8cd0720f7ec98c8e5f008afb54054677");
+}
+
+RUNNER_TEST(CryptoHash_MD5)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD5, "sample_input_string", "eb7ae4f28fecbd1fd777d9b7495fc8ec");
+}
+
+RUNNER_TEST(CryptoHash_SHA)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA, "sample_input_string", "0a5725f3586616a4049730f3ba14c8aeda79ab21");
+}
+
+RUNNER_TEST(CryptoHash_SHA1)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA1, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_DSS)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_DSS1)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS1, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_ECDSA)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::ECDSA, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_SHA224)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA224, "sample_input_string", "d4dde2370eb869f6e790133b94d58e45417392b9d899af883a274011");
+}
+
+RUNNER_TEST(CryptoHash_SHA256)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA256, "sample_input_string", "a470ec7c783ac51f9eb1772132e6bde1a053bbc81650719dd0ac62ecd93caf12");
+}
+
+RUNNER_TEST(CryptoHash_SHA384)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA384, "sample_input_string", "63d8bfa95c95c6906d1816965431c065278a655c60f786c9b246c1f73ba7ac557007f5064ba54ebd3a1988e6f37baa97");
+}
+
+RUNNER_TEST(CryptoHash_SHA512)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA512, "sample_input_string", "799317a140741937d9e5d8dbf9d3045d2c220de5ac33b3d5897acf873291ed14379eb15ef406d2284313d40edb0e01affac8efeb01cb47c2042e3e62a4a83d7d");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_message_queue.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of message queue tests
+ */
+#include <dpl/test_runner.h>
+#include <dpl/abstract_waitable_input_adapter.h>
+#include <dpl/abstract_waitable_output_adapter.h>
+#include <dpl/message_queue.h>
+#include <dpl/binary_queue.h>
+#include <dpl/copy.h>
+#include <dpl/log.h>
+#include <dpl/application.h>
+#include <dpl/controller.h>
+#include <dpl/generic_event.h>
+
+DECLARE_GENERIC_EVENT_0(QuitEvent)
+
+class QuitController
+ : public DPL::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
+{
+public:
+ QuitController() : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
+
+protected:
+ virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+};
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class CopyThread
+ : public DPL::Thread
+{
+private:
+ bool m_success;
+ DPL::AbstractWaitableInput *m_input;
+ DPL::AbstractWaitableOutput *m_output;
+ std::size_t m_dataSize;
+
+public:
+ CopyThread(DPL::AbstractWaitableInput *input,
+ DPL::AbstractWaitableOutput *output,
+ std::size_t dataSize)
+ : m_success(true),
+ m_input(input),
+ m_output(output),
+ m_dataSize(dataSize)
+ {
+ LogInfo("Thread created");
+ }
+
+protected:
+ virtual int ThreadEntry()
+ {
+ LogInfo("Entering copy thread");
+
+ Try
+ {
+ DPL::Copy(m_input, m_output, m_dataSize);
+ }
+ Catch (DPL::CopyFailed)
+ {
+ m_success = false;
+
+ LogWarning("Copy failed!");
+ return 0;
+ }
+
+ LogInfo("Copy finished");
+ return 0;
+ }
+};
+
+inline std::string BinaryQueueToString(const DPL::BinaryQueue &queue)
+{
+ char *buffer = new char[queue.Size()];
+ queue.Flatten(buffer, queue.Size());
+ std::string result = std::string(buffer, buffer + queue.Size());
+ delete [] buffer;
+ return result;
+}
+
+RUNNER_TEST(MessageQueue_DoubleCopy)
+{
+ DPL::BinaryQueue dataA;
+ DPL::MessageQueue dataB("/test_mqueue_dataB", true, false, 0660, true);
+ DPL::MessageQueue dataC("/test_mqueue_dataC", true, false, 0660, true);
+ DPL::BinaryQueue dataD;
+
+ DPL::AbstractWaitableInputAdapter dataAdapterA(&dataA);
+ DPL::AbstractWaitableOutputAdapter dataAdapterD(&dataD);
+
+ const std::string testData =
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+ "Cras elementum venenatis velit, sit amet vehicula odio gravida a."
+ "Curabitur id nibh id ante adipiscing sollicitudin."
+ "Maecenas in tellus vel augue vehicula pharetra hendrerit cursus est."
+ ""
+ "Ut malesuada quam porttitor dui euismod lacinia."
+ "Phasellus quis lectus sed lectus dictum tincidunt et vitae leo."
+ "Fusce id est massa, condimentum bibendum urna."
+ "Donec venenatis quam eget sapien vulputate egestas."
+ "Maecenas scelerisque lorem a neque molestie a varius erat condimentum."
+ "Maecenas varius hendrerit ligula, sed iaculis justo pretium id."
+ "Nunc sit amet nisl vitae justo tristique suscipit id eget tortor."
+ ""
+ "Pellentesque sollicitudin nulla at metus dapibus tincidunt."
+ "Integer consequat justo eget dui imperdiet iaculis."
+ "Sed vestibulum ipsum vitae libero accumsan non molestie metus adipiscing."
+ ""
+ "Vivamus quis dui enim, in blandit urna."
+ "In imperdiet lacus at orci elementum a scelerisque dui blandit."
+ "Donec vulputate enim metus, eget convallis ante."
+ "Etiam mollis enim eget eros pulvinar nec sagittis justo fermentum."
+ ""
+ "Vestibulum sed nunc eu leo lobortis ultrices."
+ "Nullam placerat nulla et est blandit nec interdum nunc pulvinar."
+ "Vivamus a lectus eget dui fermentum hendrerit.";
+
+ QuitController quitter;
+ quitter.PostTimedEvent(QuitEvent(), 1.0);
+
+ CopyThread threadA(&dataAdapterA, &dataB, testData.size());
+ CopyThread threadB(&dataB, &dataC, testData.size());
+ CopyThread threadC(&dataC, &dataAdapterD, testData.size());
+
+ dataA.AppendCopy(testData.c_str(), testData.size());
+
+ threadA.Run();
+ threadB.Run();
+ threadC.Run();
+
+ quitter.Exec();
+
+ threadA.Quit();
+ threadB.Quit();
+ threadC.Quit();
+
+ // Now, test data should be in dataD
+ RUNNER_ASSERT(BinaryQueueToString(dataD) == testData);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_shm.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for test cases for shared data framework
+ */
+
+#include <stdlib.h>
+#include <ctime>
+#include <sys/shm.h>
+#include <dpl/semaphore.h>
+#include <dpl/test_runner.h>
+#include <dpl/thread.h>
+#include <dpl/controller.h>
+#include <dpl/generic_event.h>
+#include <dpl/log.h>
+#include <dpl/shared_object.h>
+#include <dpl/shared_property.h>
+#include <memory>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+using namespace DPL;
+
+namespace {
+const SharedMemory::Key SHM_KEY = 12345;
+const char* SEM_NAME = "/wrt_engine_shared_object_semaphore";
+const size_t VERSION = 1;
+
+const size_t MAX_THREADS = 10;
+const size_t TEST_AND_SET_REPEATS = 100;
+
+const size_t SHARED_PROP_REPEATS = 3;
+
+const size_t SINGLETON_TEST_REPEATS = 3;
+
+// maximum random delay in singleton listener addition/removal
+const size_t MAX_SINGLETON_LISTENER_DELAY = 50;
+
+const int SINGLE_PROCESS_REPEATS = 50;
+
+/*
+ * 5 seconds expected timeout for waitable events
+ * 30 seconds unexpected timeout for waitable events
+ * We don't want to block tests
+ */
+const size_t EXPECTED_WAITABLE_TIMEOUT = 5*1000;
+const size_t UNEXPECTED_WAITABLE_TIMEOUT = 30*1000;
+
+bool g_enumTestCorrect = false;
+bool g_enumTestIncorrect = false;
+size_t g_delegateCalls = 0;
+
+void Wait(DPL::WaitableEvent& event, bool expectedTimeout = false)
+{
+ LogDebug("WaitForSingleHandle...");
+ DPL::WaitableHandleIndexList list = DPL::WaitForSingleHandle(
+ event.GetHandle(),
+ expectedTimeout ?
+ EXPECTED_WAITABLE_TIMEOUT : UNEXPECTED_WAITABLE_TIMEOUT);
+ if (list.size() == 0) {
+ LogDebug("...timeout.");
+ }
+ else {
+ LogDebug("...signaled.");
+ event.Reset();
+ }
+
+ if (expectedTimeout) {
+ RUNNER_ASSERT(list.size() == 0);
+ } else {
+ RUNNER_ASSERT(list.size() == 1);
+ }
+}
+
+void RemoveIpcs()
+{
+ Try {
+ SharedMemory::Remove(SHM_KEY);
+ }
+ Catch(SharedMemory::Exception::RemoveFailed) {
+ // ignore
+ }
+
+ Try {
+ DPL::Semaphore::Remove(SEM_NAME);
+ }
+ Catch(DPL::Semaphore::Exception::RemoveFailed) {
+ // ignore
+ }
+}
+
+typedef DPL::TypeListDecl<int, int, char, int[64]>::Type TestTypeList;
+typedef DPL::TypeListDecl<int, int, char, int[63]>::Type TestTypeList2;
+typedef DPL::TypeListDecl<int, int, char, int[63], int>::Type TestTypeList3;
+
+typedef SharedObject<TestTypeList> TestSharedObject;
+typedef SharedObject<TestTypeList2> TestSharedObject2;
+typedef SharedObject<TestTypeList3> TestSharedObject3;
+
+typedef std::shared_ptr<TestSharedObject> TestSharedObjectPtr;
+
+const int INIT_EVENT = 0;
+const int DESTROY_EVENT = 1;
+
+int g_values[TestTypeList::Size];
+
+/*
+ * helper listening controller
+ */
+template <typename SharedType>
+class ListeningController :
+ public DPL::Controller<DPL::TypeListDecl<int>::Type>
+{
+ public:
+ explicit ListeningController(DPL::WaitableEvent* waitable);
+ ~ListeningController();
+
+ virtual void OnEventReceived(const int &event);
+
+ virtual void OnEvent(const int /*event*/) {}
+
+ protected:
+ std::shared_ptr<SharedType> m_so;
+ DPL::Thread m_thread;
+ DPL::WaitableEvent* m_waitable;
+};
+
+template <typename SharedType>
+ListeningController<SharedType>::ListeningController(
+ DPL::WaitableEvent* waitable) :
+ m_waitable(waitable)
+{
+ Touch();
+ m_thread.Run();
+ SwitchToThread(&m_thread);
+ PostEvent(INIT_EVENT);
+}
+
+template <typename SharedType>
+ListeningController<SharedType>::~ListeningController()
+{
+ m_thread.Quit();
+}
+
+template <typename SharedType>
+void ListeningController<SharedType>::OnEventReceived(const int& event)
+{
+ if (event == INIT_EVENT) {
+ m_so = SharedObjectFactory<SharedType>::Create(SHM_KEY, SEM_NAME);
+ OnEvent(event);
+ m_waitable->Signal();
+ }
+ else if (event == DESTROY_EVENT) {
+ LogDebug("Destroying shared object");
+ OnEvent(event);
+
+ // deregister, destroy ad notify main thread
+ m_so.Reset();
+ LogDebug("4");
+ m_waitable->Signal();
+ LogDebug("5");
+ }
+ else {
+ OnEvent(event);
+ }
+}
+
+typedef DPL::TypeListDecl<size_t, bool>::Type SharedTypeList;
+
+class TestSharedObject4;
+typedef std::shared_ptr<TestSharedObject4> TestSharedObject4Ptr;
+
+class TestSharedObject4 : public SharedObject<SharedTypeList>
+{
+ public:
+ enum
+ {
+ SIZE_T,
+ BOOLEAN
+ };
+
+ static TestSharedObject4Ptr Create()
+ {
+ return SharedObjectFactory<TestSharedObject4>::Create(SHM_KEY, SEM_NAME);
+ }
+
+ ~TestSharedObject4()
+ {
+ LogDebug("dtor");
+ }
+
+ protected:
+ explicit TestSharedObject4(const std::string& semaphore) :
+ SharedObject<SharedTypeList>(semaphore)
+ {
+ }
+
+ private:
+ void Init()
+ {
+ SetPropertyInternal<BOOLEAN>(false);
+ }
+ friend class SharedObjectFactory<TestSharedObject4>;
+};
+
+
+
+} // anonymus namespace
+
+//////////////////////////////////////////////
+
+RUNNER_TEST(SharedMemory_002_AccessByType)
+{
+ RemoveIpcs();
+
+ SharedData<TestTypeList> str;
+
+ // access by type
+ str.Embedded<0, int>::value = 4;
+ str.Embedded<1, int>::value = 5;
+ str.Embedded<2, char>::value = 'd';
+ str.Embedded<3, int[64]>::value[0] = 1;
+ str.Embedded<3, int[64]>::value[1] = 20;
+
+ RUNNER_ASSERT((str.Embedded<0, int>::value) == 4);
+ RUNNER_ASSERT((str.Embedded<1, int>::value) == 5);
+ RUNNER_ASSERT((str.Embedded<2, char>::value) == 'd');
+ RUNNER_ASSERT((str.Embedded<3, int[64]>::value[0]) == 1);
+ RUNNER_ASSERT((str.Embedded<3, int[64]>::value[1]) == 20);
+}
+
+//////////////////////////////////////////////
+
+RUNNER_TEST(SharedMemory_003_AccessByIndex)
+{
+ RemoveIpcs();
+
+ SharedData<TestTypeList> str;
+ // access by enum
+ str.Embedded<0, TestTypeList::Element<0>::Type>::value = 4;
+ str.Embedded<1, TestTypeList::Element<1>::Type>::value = 5;
+ str.Embedded<2, TestTypeList::Element<2>::Type>::value = 'd';
+ str.Embedded<3, TestTypeList::Element<3>::Type>::value[0] = 1;
+ str.Embedded<3, TestTypeList::Element<3>::Type>::value[1] = 20;
+
+ RUNNER_ASSERT(
+ (str.Embedded<0, TestTypeList::Element<0>::Type>::value) == 4);
+ RUNNER_ASSERT(
+ (str.Embedded<1, TestTypeList::Element<1>::Type>::value) == 5);
+ RUNNER_ASSERT(
+ (str.Embedded<2, TestTypeList::Element<2>::Type>::value) == 'd');
+ RUNNER_ASSERT(
+ (str.Embedded<3, TestTypeList::Element<3>::Type>::value[0]) == 1);
+ RUNNER_ASSERT(
+ (str.Embedded<3, TestTypeList::Element<3>::Type>::value[1]) == 20);
+}
+
+//////////////////////////////////////////////
+
+RUNNER_TEST(SharedMemory_004_SimplifiedAccess)
+{
+ RemoveIpcs();
+
+ SharedData<TestTypeList> str;
+
+ // access via PropertyRef
+ str.PropertyRef<1>() = 3;
+ RUNNER_ASSERT(str.PropertyRef<1>() == 3);
+
+ int (&array)[64] = str.PropertyRef<3>();
+ array[0] = 2;
+ RUNNER_ASSERT(str.PropertyRef<3>()[0] == 2);
+
+ str.PropertyRef<3>()[1] = 19;
+ RUNNER_ASSERT(str.PropertyRef<3>()[1] == 19);
+
+ // access via macro
+ str.SHARED_PROPERTY(0) = 2;
+ RUNNER_ASSERT(str.SHARED_PROPERTY(0) == 2);
+
+ str.SHARED_PROPERTY(2) = 'c';
+ RUNNER_ASSERT(str.SHARED_PROPERTY(2) == 'c');
+
+ str.SHARED_PROPERTY(3)[2] = 10;
+ RUNNER_ASSERT(str.SHARED_PROPERTY(3)[2] == 10);
+
+ // old style check
+ RUNNER_ASSERT((str.Embedded<0, int>::value) == 2);
+ RUNNER_ASSERT((str.Embedded<1, int>::value) == 3);
+ RUNNER_ASSERT((str.Embedded<2, char>::value) == 'c');
+ RUNNER_ASSERT((str.Embedded<3, int[64]>::value[0]) == 2);
+ RUNNER_ASSERT((str.Embedded<3, int[64]>::value[1]) == 19);
+ RUNNER_ASSERT((str.Embedded<3, int[64]>::value[2]) == 10);
+}
+
+//////////////////////////////////////////////
+
+struct SharedStruct
+{
+ int a;
+ int b;
+ char c;
+ int d[64];
+};
+
+typedef std::shared_ptr<SharedMemory::Segment<SharedStruct> > SharedStructPtr;
+
+RUNNER_TEST(SharedMemory_010_BaseShmTest)
+{
+ RemoveIpcs();
+
+ typedef std::unique_ptr<SharedMemory> SharedMemoryPtr;
+
+ // write
+ SharedMemoryPtr shm;
+ Try {
+ shm.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, false));
+ }
+ Catch (SharedMemory::Exception::NotFound) {
+ shm.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, true, true));
+ }
+
+ SharedStructPtr str = shm->Attach<SharedStruct>();
+
+ str->Data()->a = 1;
+ str->Data()->b = 2;
+ str->Data()->c = '3';
+ str->Data()->d[0] = 4;
+ str->Data()->d[1] = 5;
+
+ // read
+ SharedMemoryPtr shm2;
+ Try {
+ shm2.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, false));
+ }
+ Catch (SharedMemory::Exception::NotFound) {
+ shm2.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, true, true));
+ }
+
+ SharedStructPtr str2 = shm2->Attach<SharedStruct>();
+ SharedStructPtr str3 = shm2->Attach<SharedStruct>();
+
+ RUNNER_ASSERT(str2->Data()->a == 1);
+ RUNNER_ASSERT(str2->Data()->b == 2);
+ RUNNER_ASSERT(str2->Data()->c == '3');
+ RUNNER_ASSERT(str2->Data()->d[0] == 4);
+ RUNNER_ASSERT(str2->Data()->d[1] == 5);
+
+ RUNNER_ASSERT(str3->Data()->a == 1);
+ RUNNER_ASSERT(str3->Data()->b == 2);
+ RUNNER_ASSERT(str3->Data()->c == '3');
+ RUNNER_ASSERT(str3->Data()->d[0] == 4);
+ RUNNER_ASSERT(str3->Data()->d[1] == 5);
+
+ str2->Data()->b = 4;
+ str2->Data()->c = 'c';
+ str2->Data()->d[0] = 0;
+ RUNNER_ASSERT(str3->Data()->a == 1);
+ RUNNER_ASSERT(str3->Data()->b == 4);
+ RUNNER_ASSERT(str3->Data()->c == 'c');
+ RUNNER_ASSERT(str3->Data()->d[0] == 0);
+ RUNNER_ASSERT(str3->Data()->d[1] == 5);
+}
+
+//////////////////////////////////////////////
+
+RUNNER_TEST(SharedMemory_020_SharedObjectTest)
+{
+ RemoveIpcs();
+
+ typedef SharedObject<SharedTypeList> MySharedObj;
+
+ MySharedObj::Ptr so =
+ SharedObjectFactory<MySharedObj>::Create(SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT((so->GetProperty<0, size_t>()) == 0);
+ so->SetProperty<0,size_t>(4);
+ RUNNER_ASSERT((so->GetProperty<0, size_t>()) == 4);
+}
+
+//////////////////////////////////////////////
+
+class InitTestSharedObject : public TestSharedObject
+{
+ protected:
+ explicit InitTestSharedObject(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ virtual void Init(); // from SharedObject
+
+ private:
+ friend class SharedObjectFactory<InitTestSharedObject>;
+};
+
+void InitTestSharedObject::Init()
+{
+ SetPropertyInternal<0>(1);
+ SetPropertyInternal<1>(2);
+ SetPropertyInternal<2>('c');
+}
+
+RUNNER_TEST(SharedMemory_021_InitTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ std::shared_ptr<InitTestSharedObject> sho =
+ SharedObjectFactory<InitTestSharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+ RUNNER_ASSERT((sho->GetProperty<0,int>()) == 1);
+ RUNNER_ASSERT((sho->GetProperty<1,int>()) == 2);
+ RUNNER_ASSERT((sho->GetProperty<2,char>()) == 'c');
+}
+
+//////////////////////////////////////////////
+
+class VersionTestSO1 : public TestSharedObject
+{
+ protected:
+ explicit VersionTestSO1(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ virtual SizeType GetVersion() const { return 1; } // from SharedObject
+
+ private:
+ friend class SharedObjectFactory<VersionTestSO1>;
+};
+
+class VersionTestSO2 : public TestSharedObject
+{
+ protected:
+ explicit VersionTestSO2(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ virtual SizeType GetVersion() const { return 2; } // from SharedObject
+
+ private:
+ friend class SharedObjectFactory<VersionTestSO2>;
+};
+
+RUNNER_TEST(SharedMemory_022_InvalidVersionTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ std::shared_ptr<VersionTestSO1> sho =
+ SharedObjectFactory<VersionTestSO1>::Create(SHM_KEY, SEM_NAME);
+
+ Try {
+ std::shared_ptr<VersionTestSO2> sho2 =
+ SharedObjectFactory<VersionTestSO2>::Create(SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT_MSG(false, "Invalid shm version has been accepted");
+ }
+ Catch(SharedObjectBase::Exception::InvalidVersion) {
+ RUNNER_ASSERT(true);
+ }
+}
+
+//////////////////////////////////////////////
+
+RUNNER_TEST(SharedMemory_023_InvalidSizeTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ typedef SharedObject<TestTypeList> SO1;
+ typedef SharedObject<TestTypeList2> SO2;
+
+ SO1::Ptr sho = SharedObjectFactory<SO1>::Create(SHM_KEY, SEM_NAME);
+
+ Try {
+ SO2::Ptr sho2 = SharedObjectFactory<SO2>::Create(SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT_MSG(false, "Invalid shm size has been accepted");
+ }
+ Catch(SharedObjectBase::Exception::InvalidSize) {
+ RUNNER_ASSERT(true);
+ }
+}
+
+//////////////////////////////////////////////
+
+class MagicTestSO1 : public TestSharedObject
+{
+ protected:
+ explicit MagicTestSO1(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ // from SharedObject
+ virtual MagicType GetMagicNumber() const { return 661; }
+
+ private:
+ friend class SharedObjectFactory<MagicTestSO1>;
+};
+
+class MagicTestSO2 : public TestSharedObject
+{
+ protected:
+ explicit MagicTestSO2(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ // from SharedObject
+ virtual MagicType GetMagicNumber() const { return 662; }
+
+ private:
+ friend class SharedObjectFactory<MagicTestSO2>;
+};
+
+RUNNER_TEST(SharedMemory_024_InvalidMagicTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ std::shared_ptr<MagicTestSO1> sho =
+ SharedObjectFactory<MagicTestSO1>::Create(SHM_KEY, SEM_NAME);
+
+ Try {
+ std::shared_ptr<MagicTestSO2> sho2 =
+ SharedObjectFactory<MagicTestSO2>::Create(SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT_MSG(false, "Invalid shm magic number has been accepted");
+ }
+ Catch(SharedObjectBase::Exception::InvalidMagicNumber) {
+ RUNNER_ASSERT(true);
+ }
+}
+
+//////////////////////////////////////////////
+
+/*
+ * Listening shared object
+ */
+class EnumTestSO1 : public TestSharedObject
+{
+ public:
+ void SetWaitable(DPL::WaitableEvent* waitable) { m_waitable = waitable; }
+
+ protected:
+ explicit EnumTestSO1(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ virtual void PropertyChanged(size_t propertyEnum);
+
+ private:
+ friend class SharedObjectFactory<EnumTestSO1>;
+
+ DPL::WaitableEvent* m_waitable;
+};
+
+void EnumTestSO1::PropertyChanged(size_t propertyEnum)
+{
+ if (propertyEnum == 1)
+ {
+ LogDebug("Property enum " << propertyEnum << " correctly set");
+ g_enumTestCorrect = true;
+ }
+ if (propertyEnum == 4)
+ {
+ // This is bad. We only have 4 types
+ LogError("Property enum " << propertyEnum << " should be skipped");
+ g_enumTestIncorrect = true;
+ }
+ // confirm property change notification
+ m_waitable->Signal();
+}
+
+class EnumController : public ListeningController<EnumTestSO1>
+{
+ public:
+ explicit EnumController(DPL::WaitableEvent* waitable) :
+ ListeningController<EnumTestSO1>(waitable) {}
+
+ virtual void OnEvent(const int event);
+};
+
+void EnumController::OnEvent(const int event)
+{
+ if (event == INIT_EVENT) {
+ m_so->SetWaitable(m_waitable);
+ }
+}
+
+/*
+ * Writing shared object with correct size but different number of types
+ */
+class EnumTestSO2 : public TestSharedObject3
+{
+ protected:
+ explicit EnumTestSO2(const std::string& semaphore) :
+ TestSharedObject3(semaphore) {}
+
+ private:
+ friend class SharedObjectFactory<EnumTestSO2>;
+};
+
+RUNNER_TEST(SharedMemory_025_InvalidEnumTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ g_enumTestCorrect = false;
+ g_enumTestIncorrect = false;
+
+ DPL::WaitableEvent waitable;
+
+ // create listening controller and wait until it registers
+ EnumController controller(&waitable);
+ Wait(waitable);
+ LogDebug("Listening controller created");
+
+ // create writing shared object
+ std::shared_ptr<EnumTestSO2> sho2 =
+ SharedObjectFactory<EnumTestSO2>::Create(SHM_KEY, SEM_NAME);
+ DPL::WaitableHandleIndexList list;
+
+ // write property and wait for confirmation
+ sho2->SetProperty<1>(2);
+ Wait(waitable);
+
+ // write incorrect property and wait for confirmation
+ // we expect timeout
+ sho2->SetProperty<4>(2);
+ Wait(waitable, true);
+
+ // schedule listener deregistration and wait for confirmation
+ controller.PostEvent(DESTROY_EVENT);
+ Wait(waitable);
+
+ // check results
+ RUNNER_ASSERT(g_enumTestCorrect == true);
+ RUNNER_ASSERT(g_enumTestIncorrect == false);
+}
+
+//////////////////////////////////////////////
+
+class MultiThreadSO : public TestSharedObject
+{
+ public:
+ void TestAndSetProperty();
+
+ protected:
+ explicit MultiThreadSO(const std::string& semaphore) :
+ TestSharedObject(semaphore) {}
+
+ private:
+ friend class SharedObjectFactory<MultiThreadSO>;
+};
+
+void MultiThreadSO::TestAndSetProperty()
+{
+ ScopedFlaggedLock lock(*this);
+
+ int value = PropertyRef<0,int>();
+ DPL::Thread::MicroSleep(100);
+ SetPropertyInternal<0>(value+1);
+}
+
+class ShmController : public ListeningController<MultiThreadSO>
+{
+ public:
+ explicit ShmController(DPL::WaitableEvent* event) :
+ ListeningController<MultiThreadSO>(event), m_counter(0)
+ {}
+
+ virtual void OnEventReceived(const int& event);
+
+ private:
+ size_t m_counter;
+};
+
+void ShmController::OnEventReceived(const int& event)
+{
+ if (event == INIT_EVENT) {
+ m_so = SharedObjectFactory<MultiThreadSO>::Create(SHM_KEY, SEM_NAME);
+ PostEvent(2);
+ }
+ else if (event == DESTROY_EVENT) {
+ LogDebug("Destroying shared object");
+ // deregister, destroy ad notify main thread
+ m_so.Reset();
+ m_waitable->Signal();
+ }
+ else if (event == 2){
+ m_so->TestAndSetProperty();
+ m_counter++;
+ if (m_counter >= TEST_AND_SET_REPEATS) {
+ LogDebug("Max tests reached. Finishing thread");
+ PostEvent(DESTROY_EVENT);
+ return;
+ }
+ PostEvent(2);
+ }
+}
+
+RUNNER_TEST(SharedMemory_030_MultithreadTest)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ typedef SharedObject<TestTypeList> SHO;
+ SHO::Ptr sho = SharedObjectFactory<SHO>::Create(SHM_KEY, SEM_NAME);
+
+ ShmController* controller[MAX_THREADS];
+ DPL::WaitableEvent finalEvent[MAX_THREADS];
+
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ controller[i] = new ShmController(&finalEvent[i]);
+ }
+
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ Wait(finalEvent[i]);
+ }
+
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ delete controller[i];
+ controller[i] = NULL;
+ }
+
+ int value = sho->GetProperty<0,int>();
+ LogDebug("Final value is " << value << ", expected " <<
+ MAX_THREADS * TEST_AND_SET_REPEATS);
+ RUNNER_ASSERT(value == MAX_THREADS * TEST_AND_SET_REPEATS);
+}
+
+//////////////////////////////////////////////
+
+class MyModel10: public DPL::Model
+{
+ public:
+ explicit MyModel10(const TestSharedObject4Ptr& shared_object)
+ : DPL::Model(), boolValue(this, shared_object) {}
+
+ SharedProperty<bool, TestSharedObject4::BOOLEAN, TestSharedObject4>
+ boolValue;
+};
+
+/*
+ * Listening controller
+ */
+class ShmController3: public ListeningController<TestSharedObject4>
+{
+ public:
+ explicit ShmController3(DPL::WaitableEvent* event) :
+ ListeningController<TestSharedObject4>(event)
+ {}
+
+ virtual void OnEvent(const int event);
+
+ void OnValueChanged(const DPL::PropertyEvent<bool>& event);
+
+ private:
+ typedef std::unique_ptr<MyModel10> MyModelPtr;
+
+ // model with property bound to shared object
+ MyModelPtr m_model;
+};
+
+void ShmController3::OnEvent(const int event)
+{
+ if (event == INIT_EVENT) {
+ m_model.Reset(new MyModel10(m_so));
+ m_model->boolValue.AddListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
+ this,
+ &ShmController3::OnValueChanged));
+ } else if (event == DESTROY_EVENT) {
+ m_model->boolValue.RemoveListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
+ this,
+ &ShmController3::OnValueChanged));
+ m_model.Reset();
+ }
+}
+
+void ShmController3::OnValueChanged(const DPL::PropertyEvent<bool>& event)
+{
+ if (event.value) {
+ // change back
+ m_model->boolValue.Set(false);
+ } else {
+ LogError("Expected value = true, got false");
+ }
+
+ m_waitable->Signal();
+}
+
+RUNNER_TEST(SharedMemory_050_SharedProperty)
+{
+ RemoveIpcs();
+
+ bool result = true;
+ DPL::WaitableEvent waitable;
+ // listener controller
+ ShmController3 controller(&waitable);
+ Wait(waitable);
+
+ TestSharedObject4Ptr sharedObject = TestSharedObject4::Create();
+
+ for (size_t i = 0; i < SHARED_PROP_REPEATS; ++i) {
+ sharedObject->SetProperty<TestSharedObject4::BOOLEAN>(true);
+ Wait(waitable);
+ result = sharedObject->GetProperty<TestSharedObject4::BOOLEAN,
+ bool>();
+ RUNNER_ASSERT(result == false);
+ }
+ controller.PostEvent(DESTROY_EVENT);
+ Wait(waitable);
+}
+
+//////////////////////////////////////////////
+
+class MyModel2: public DPL::Model
+{
+ public:
+ explicit MyModel2(const TestSharedObjectPtr& shared_object) :
+ counter(this, shared_object) {}
+
+ SharedProperty<int, 0, TestSharedObject> counter;
+};
+
+class SPController : public ListeningController<TestSharedObject>
+{
+ public:
+ explicit SPController(DPL::WaitableEvent* event) :
+ ListeningController<TestSharedObject>(event), m_repeats(1) {}
+
+ virtual void OnEvent(const int event);
+
+ void OnValueChanged1(const DPL::PropertyEvent<int>& event);
+ void OnValueChanged2(const DPL::PropertyEvent<int>& event);
+
+ private:
+ std::unique_ptr<MyModel2> m_model1;
+ std::unique_ptr<MyModel2> m_model2;
+
+ int m_repeats;
+ std::shared_ptr<TestSharedObject> m_so2;
+};
+
+void SPController::OnEvent(const int event)
+{
+ if (event == INIT_EVENT) {
+ m_so2 = SharedObjectFactory<TestSharedObject>::Create(SHM_KEY,
+ SEM_NAME);
+
+ // create and register 2 models sharing the same property
+ m_model1.Reset(new MyModel2(m_so));
+ m_model2.Reset(new MyModel2(m_so2));
+ m_model1->counter.AddListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged1));
+ m_model2->counter.AddListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged2));
+ m_model1->counter.Set(1);
+ }
+ else if (event == DESTROY_EVENT) {
+ m_model1->counter.RemoveListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged1));
+ m_model2->counter.RemoveListener(
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged2));
+
+ m_model1.Reset();
+ m_model2.Reset();
+ m_so2.Reset();
+ }
+}
+
+void SPController::OnValueChanged1(const DPL::PropertyEvent<int>& event)
+{
+ if (m_repeats >= SINGLE_PROCESS_REPEATS) {
+ PostEvent(DESTROY_EVENT);
+ return;
+ }
+
+ LogDebug("[1] Value changed to " << event.value);
+ m_repeats++;
+ m_model1->counter.Set(event.value+1);
+}
+
+void SPController::OnValueChanged2(const DPL::PropertyEvent<int>& event)
+{
+ if (m_repeats >= SINGLE_PROCESS_REPEATS) {
+ PostEvent(DESTROY_EVENT);
+ return;
+ }
+
+ LogDebug("[2] Value changed to " << event.value);
+ m_repeats++;
+ m_model2->counter.Set(event.value+1);
+}
+
+RUNNER_TEST(SharedMemory_060_SingleProcess)
+{
+ RemoveIpcs();
+
+ DPL::WaitableEvent waitable;
+ SPController controller(&waitable);
+ TestSharedObjectPtr sho = SharedObjectFactory<TestSharedObject>::Create(
+ SHM_KEY,
+ SEM_NAME);
+
+ // wait for creation
+ Wait(waitable);
+
+ // wait for destruction
+ Wait(waitable);
+
+ int value = sho->GetProperty<0,int>();
+
+ LogDebug("final value: " << value);
+
+ // check value
+ RUNNER_ASSERT(value == SINGLE_PROCESS_REPEATS);
+}
+
+//////////////////////////////////////////////
+
+class ListenerTestController: public ListeningController<TestSharedObject>,
+ public ISharedObjectListener<0,int>,
+ public ISharedObjectListener<1,int>,
+ public ISharedObjectListener<2,char>,
+ public ISharedObjectListener<3,int[64]>
+{
+ public:
+ explicit ListenerTestController(DPL::WaitableEvent* event) :
+ ListeningController<TestSharedObject>(event) {}
+
+ ~ListenerTestController();
+
+ virtual void OnEvent(const int event);
+
+ virtual void ValueChanged(size_t propertyEnum,
+ const int& value,
+ const void* info = NULL);
+ virtual void ValueChanged(size_t propertyEnum,
+ const char& value,
+ const void* info = NULL);
+ virtual void ValueChanged(size_t propertyEnum,
+ const int(& value)[64],
+ const void* info = NULL);
+};
+
+ListenerTestController::~ListenerTestController()
+{}
+
+void ListenerTestController::OnEvent(const int event)
+{
+ if (event == INIT_EVENT) {
+ // add self as a listener to shared object
+ m_so->AddListener<0,int>(this);
+ m_so->AddListener<1,int>(this);
+ m_so->AddListener<2,char>(this);
+ m_so->AddListener<3,int[64]>(this);
+ }
+ else if (event == DESTROY_EVENT) {
+ // remove self from listener list
+ m_so->RemoveListener<0,int>(this);
+ m_so->RemoveListener<1,int>(this);
+ m_so->RemoveListener<2,char>(this);
+ m_so->RemoveListener<3,int[64]>(this);
+ }
+}
+
+void ListenerTestController::ValueChanged(size_t propertyEnum,
+ const int& value,
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(int) " << propertyEnum << " " << value);
+ if ((propertyEnum == 0 && value == 1) || (propertyEnum == 1 && value == 2))
+ {
+ g_values[propertyEnum]++;
+ if (g_values[propertyEnum] == 3) {
+ m_waitable->Signal();
+ }
+ }
+}
+
+void ListenerTestController::ValueChanged(size_t propertyEnum,
+ const char& value,
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(char) " << propertyEnum << " " << value);
+ if (propertyEnum == 2 && value == 'c')
+ {
+ g_values[propertyEnum]++;
+ if (g_values[propertyEnum] == 3) {
+ m_waitable->Signal();
+ }
+ }
+}
+
+void ListenerTestController::ValueChanged(size_t propertyEnum,
+ const int(& value)[64],
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(int[64]) " << propertyEnum << " " << value[5]);
+ if (propertyEnum == 3 && value[5] == 5)
+ {
+ g_values[propertyEnum]++;
+ if (g_values[propertyEnum] == 3) {
+ m_waitable->Signal();
+ }
+ }
+}
+
+RUNNER_TEST(SharedMemory_070_SharedObjectListeners)
+{
+ RemoveIpcs();
+
+ // setup global flags
+ for (size_t i=0;i<TestTypeList::Size;++i) {
+ g_values[i] = 0;
+ }
+
+ // create shared object
+ TestSharedObjectPtr sho = SharedObjectFactory<TestSharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+
+ // create 1st listener and wait for it
+ DPL::WaitableEvent waitable;
+ ListenerTestController c1(&waitable);
+ Wait(waitable);
+
+ // create 2nd listener and wait for it
+ ListenerTestController c2(&waitable);
+ Wait(waitable);
+
+ // create 3rd listener and wait for it
+ ListenerTestController c3(&waitable);
+ Wait(waitable);
+
+ // set properties and wait for result
+ sho->SetProperty<0,int>(1);
+ Wait(waitable);
+
+ RUNNER_ASSERT(g_values[0] == 3);
+
+ sho->SetProperty<1,int>(2);
+ Wait(waitable);
+
+ RUNNER_ASSERT(g_values[1] == 3);
+
+ sho->SetProperty<2,char>('c');
+ Wait(waitable);
+
+ RUNNER_ASSERT(g_values[2] == 3);
+
+ int array[64];
+ memset(array,64*sizeof(array[0]),0);
+ array[5] = 5;
+ sho->SetProperty<3,int[64]>(array);
+ Wait(waitable);
+
+ RUNNER_ASSERT(g_values[3] == 3);
+
+ // finalize listeners
+ c1.PostEvent(DESTROY_EVENT);
+ Wait(waitable);
+
+ c2.PostEvent(DESTROY_EVENT);
+ Wait(waitable);
+
+ c3.PostEvent(DESTROY_EVENT);
+ Wait(waitable);
+}
+
+//////////////////////////////////////////////
+
+/*
+ * class simulating DB access
+ */
+class DAO : public DPL::Noncopyable
+{
+ public:
+ DAO() : m_boolValue(false) {}
+
+ void SetBoolValue(const bool& value) { m_boolValue = value; }
+
+ bool GetBoolValue() const { return m_boolValue; }
+
+ private:
+ bool m_boolValue;
+};
+
+/*
+ * Model with property having set delegate defined
+ */
+class MyModel3: public DPL::Model
+{
+ public:
+ typedef SharedPropertyEx<bool,
+ TestSharedObject4::BOOLEAN,
+ TestSharedObject4> PropertyType;
+
+ MyModel3(const TestSharedObject4Ptr& shared_object, DAO* dao) :
+ boolValue(this,
+ shared_object,
+ PropertyType::SetDelegate(dao, &DAO::SetBoolValue))
+ {
+ }
+
+ PropertyType boolValue;
+};
+
+RUNNER_TEST(SharedMemory_090_SetPropertyDelegate)
+{
+ RemoveIpcs();
+
+ // dao object
+ DAO dao;
+
+ // create shared object
+ TestSharedObject4Ptr sho = TestSharedObject4::Create();
+
+ // set property but call dao delegate within semaphore
+ sho->SetProperty<TestSharedObject4::BOOLEAN>(
+ true,
+ MyModel3::PropertyType::SetDelegate(&dao, &DAO::SetBoolValue));
+
+ // check dao value
+ RUNNER_ASSERT(dao.GetBoolValue() == true);
+
+ // check shared object value
+ bool shoValue = sho->GetProperty<TestSharedObject4::BOOLEAN, bool>();
+ RUNNER_ASSERT(shoValue == true);
+
+ // try the same with shared property
+ MyModel3 model(sho, &dao);
+
+ // set property
+ model.boolValue.Set(false);
+
+ // check dao value
+ RUNNER_ASSERT(dao.GetBoolValue() == false);
+
+ // check sho value
+ shoValue = sho->GetProperty<TestSharedObject4::BOOLEAN, bool>();
+ RUNNER_ASSERT(shoValue == false);
+
+ // check property value
+ RUNNER_ASSERT(model.boolValue.Get() == false);
+}
+
+//////////////////////////////////////////////
+
+/*
+ * Lazy initialization test shared object
+ */
+class LazySharedObject : public SharedObject<TestTypeList>
+{
+ public:
+ explicit LazySharedObject(const std::string& semaphore) :
+ SharedObject<TestTypeList>(semaphore)
+ ,m_read(false)
+ {
+ }
+
+ void Init();
+
+ bool IsRead() const { return m_read; }
+
+ private:
+ friend class SharedObjectFactory<LazySharedObject>;
+
+ bool m_read;
+};
+
+void LazySharedObject::Init()
+{
+ SetPropertyInternal<0>(42);
+ m_read = true;
+}
+
+RUNNER_TEST(SharedMemory_100_LazyInit)
+{
+ RemoveIpcs();
+
+ typedef std::shared_ptr<LazySharedObject> LazySharedObjectPtr;
+
+ // create shared object
+ LazySharedObjectPtr sho = SharedObjectFactory<LazySharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT(sho->IsRead() == false);
+
+ // get property causing lazy init
+ int value = sho->GetProperty<0, int>();
+
+ RUNNER_ASSERT(sho->IsRead() == true);
+ RUNNER_ASSERT(value == 42);
+
+ // create another object
+ LazySharedObjectPtr sho2 = SharedObjectFactory<LazySharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT(sho2->IsRead() == false);
+
+ // get property NOT causing lazy init
+ value = sho2->GetProperty<0, int>();
+
+ RUNNER_ASSERT(sho2->IsRead() == false);
+ RUNNER_ASSERT(value == 42);
+
+ // destroy both objects
+ sho.Reset();
+ sho2.Reset();
+
+ // create shared object
+ LazySharedObjectPtr sho3 = SharedObjectFactory<LazySharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+
+ RUNNER_ASSERT(sho3->IsRead() == false);
+
+ // set property causing lazy init
+ sho3->SetProperty<0>(43);
+ value = sho3->GetProperty<0, int>();
+
+ RUNNER_ASSERT(sho3->IsRead() == true);
+ RUNNER_ASSERT(value == 43);
+
+}
+
+//////////////////////////////////////////////
+
+bool SetCondition(const int& readValue, int& setValue);
+bool SetCondition(const int& readValue, int& setValue)
+{
+ LogDebug("Condition delegate called with read value = " << readValue <<
+ " and set value = " << setValue);
+
+ if (readValue > 3) {
+ LogDebug("Condition is false");
+ return false;
+ }
+
+ LogDebug("Condition is true");
+ if (4 == setValue) {
+ setValue = 10;
+ LogDebug("Changing set value to " << setValue);
+ }
+ return true;
+}
+
+void SetDelegate(const int& readValue);
+void SetDelegate(const int& readValue)
+{
+ LogDebug("Set delegate called " << readValue);
+ g_delegateCalls++;
+}
+
+RUNNER_TEST(SharedMemory_120_ConditionalSet)
+{
+ RemoveIpcs();
+
+ TestSharedObjectPtr sho = SharedObjectFactory<TestSharedObject>::Create(
+ SHM_KEY,
+ SEM_NAME);
+
+ g_delegateCalls = 0;
+
+ RUNNER_ASSERT(0 == (sho->GetProperty<0,int>()));
+
+ DPL::FastDelegate<bool (const int&, int&)> condition(&SetCondition);
+ DPL::FastDelegate<void (const int&)> delegate(&SetDelegate);
+
+ bool succeeded = false;
+
+ succeeded = sho->ConditionalSetProperty<0>(-2, condition);
+
+ RUNNER_ASSERT(succeeded);
+ RUNNER_ASSERT(-2 == (sho->GetProperty<0,int>()));
+
+ succeeded = sho->ConditionalSetProperty<0>(4, condition, delegate);
+
+ RUNNER_ASSERT(succeeded);
+ RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(1 == g_delegateCalls);
+
+ succeeded = sho->ConditionalSetProperty<0>(5, condition);
+
+ RUNNER_ASSERT(!succeeded);
+ RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+
+ succeeded = sho->ConditionalSetProperty<0>(666, condition, delegate);
+
+ RUNNER_ASSERT(!succeeded);
+ RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(1 == g_delegateCalls);
+}
+
+//////////////////////////////////////////////
+
+/*
+ * Shared object used by multiple threads as a singleton.
+ */
+class MTSharedObject : public SharedObject<TestTypeList>
+{
+ public:
+ explicit MTSharedObject(const std::string& semaphore) :
+ SharedObject<TestTypeList>(semaphore)
+ {
+ }
+
+ void Clear();
+
+ private:
+ friend class SharedObjectFactory<MTSharedObject>;
+};
+
+typedef std::shared_ptr<MTSharedObject> MTSharedObjectPtr;
+
+void MTSharedObject::Clear()
+{
+ int array[64] = {};
+ SetProperty<0>(0);
+ SetProperty<1>(0);
+ SetProperty<2>(static_cast<char>(0));
+ SetProperty<3>(array);
+}
+
+/*
+ * Shared object singleton
+ */
+class SharedObjectSingleton
+{
+ public:
+ static MTSharedObjectPtr Instance();
+ static void Destroy();
+
+ private:
+ static MTSharedObjectPtr m_sho;
+ static DPL::Mutex m_mutex;
+};
+
+MTSharedObjectPtr SharedObjectSingleton::m_sho;
+DPL::Mutex SharedObjectSingleton::m_mutex;
+
+MTSharedObjectPtr SharedObjectSingleton::Instance()
+{
+ DPL::Mutex::ScopedLock lock(&m_mutex);
+ if (!m_sho) {
+ m_sho = SharedObjectFactory<MTSharedObject>::Create(SHM_KEY, SEM_NAME);
+ }
+ return m_sho;
+}
+
+void SharedObjectSingleton::Destroy()
+{
+ DPL::Mutex::ScopedLock lock(&m_mutex);
+ m_sho.Reset();
+}
+
+/*
+ * Listening controller
+ */
+class ShmController4 : public ListeningController<MTSharedObject>,
+ public ISharedObjectListener<0,int>,
+ public ISharedObjectListener<1,int>,
+ public ISharedObjectListener<2,char>,
+ public ISharedObjectListener<3,int[64]>
+{
+ public:
+ enum {
+ ADD_LISTENERS = 2,
+ REMOVE_LISTENERS = 3,
+ DESTROY_SINGLETON = 4
+ };
+
+ explicit ShmController4(DPL::WaitableEvent* event) :
+ ListeningController<MTSharedObject>(event)
+ {}
+
+ virtual void OnEventReceived(const int& event);
+
+ virtual void ValueChanged(size_t propertyEnum,
+ const int& value,
+ const void* info = NULL);
+ virtual void ValueChanged(size_t propertyEnum,
+ const char& value,
+ const void* info = NULL);
+ virtual void ValueChanged(size_t propertyEnum,
+ const int(& value)[64],
+ const void* info = NULL);
+
+ bool NotRegistered();
+
+ private:
+ void Sleep();
+
+ size_t m_counter;
+};
+
+void ShmController4::ValueChanged(size_t propertyEnum,
+ const int& value,
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(int) " << propertyEnum << " " << value);
+ if ((propertyEnum == 0 && value == 1) ||
+ (propertyEnum == 1 && value == 11))
+ {
+ m_waitable->Signal();
+ }
+}
+
+void ShmController4::ValueChanged(size_t propertyEnum,
+ const char& value,
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(char) " << propertyEnum << " " << value);
+ if (propertyEnum == 2 && value == 'a') {
+ m_waitable->Signal();
+ }
+}
+
+void ShmController4::ValueChanged(size_t propertyEnum,
+ const int(& value)[64],
+ const void* /*info*/)
+{
+ LogDebug("ValueChanged(int[64]) " << propertyEnum << " " << value[5]);
+ if (propertyEnum == 3 && value[0] == 0 && value[1] == 1 && value[2] == 2) {
+ m_waitable->Signal();
+ }
+}
+
+void ShmController4::Sleep()
+{
+ DPL::Thread::GetCurrentThread()->MiliSleep(
+ rand() % MAX_SINGLETON_LISTENER_DELAY);
+}
+
+void ShmController4::OnEventReceived(const int& event)
+{
+ switch (event) {
+ case INIT_EVENT:
+ m_so = SharedObjectSingleton::Instance();
+ m_waitable->Signal();
+ break;
+
+ case DESTROY_EVENT:
+ LogDebug("Destroying shared object");
+ // deregister, destroy and notify main thread
+ m_so.Reset();
+ m_waitable->Signal();
+ break;
+
+ case ADD_LISTENERS:
+ // add listener and notify
+ m_so->AddListener<0,int>(this);
+ Sleep();
+ m_so->AddListener<1,int>(this);
+ Sleep();
+ m_so->AddListener<2,char>(this);
+ Sleep();
+ m_so->AddListener<3,int[64]>(this);
+ Sleep();
+ m_waitable->Signal();
+ break;
+
+ case REMOVE_LISTENERS:
+ // remove listener and notify
+ m_so->RemoveListener<0,int>(this);
+ Sleep();
+ m_so->RemoveListener<1,int>(this);
+ Sleep();
+ m_so->RemoveListener<2,char>(this);
+ Sleep();
+ m_so->RemoveListener<3,int[64]>(this);
+ Sleep();
+ m_waitable->Signal();
+ break;
+
+ case DESTROY_SINGLETON:
+ SharedObjectSingleton::Destroy();
+ m_waitable->Signal();
+ break;
+
+ default:
+ LogError("Unsupported event received: " << event);
+ }
+}
+
+void MultipleWait(DPL::WaitableEvent (& event)[MAX_THREADS]);
+void MultipleWait(DPL::WaitableEvent (& event)[MAX_THREADS])
+{
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ Wait(event[i]);
+ }
+}
+
+/*
+ * Try to remove property listener. If there's no such listener an exception
+ * should be thrown.
+ */
+#define LISTENER_ASSERT(property) \
+ Try { \
+ singleton->RemoveListener<(property)>(controller[i]); \
+ LogError("Controller " << i << " is still listening for property " \
+ << #property); \
+ RUNNER_ASSERT_MSG(false, "No listeners expected"); \
+ } \
+ Catch (MTSharedObject::Exception::ListenerNotFound) { \
+ RUNNER_ASSERT(true); \
+ } \
+
+// test
+RUNNER_TEST(SharedMemory_130_SharedObjectSingleton)
+{
+ RemoveIpcs(); // we need non existing shm
+
+ srand(time(NULL));
+
+ // writer shared object
+ TestSharedObjectPtr sho = SharedObjectFactory<TestSharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+
+ ShmController4* controller[MAX_THREADS];
+ DPL::WaitableEvent waitable[MAX_THREADS];
+
+ const int array[64] = {0,1,2};
+
+ // Create and wait for notification. Make sure that the thread/controller 0
+ // is created first
+ LogInfo("Creating controllers");
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ controller[i] = new ShmController4(&waitable[i]);
+ Wait(waitable[i]);
+ }
+
+ // singleton will be created by thread/controller 0 by now
+ MTSharedObjectPtr singleton = SharedObjectSingleton::Instance();
+
+ for (size_t repeats = 0;repeats < SINGLETON_TEST_REPEATS;++repeats) {
+ LogInfo("%%%%%%%%%%%%%%%%%%%%%");
+ LogInfo("Iteration " << repeats+1 << " of " << SINGLETON_TEST_REPEATS);
+ singleton->Clear();
+
+ // add listeners
+ LogInfo("Adding listeners");
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ controller[i]->PostEvent(ShmController4::ADD_LISTENERS);
+ }
+ // wait for listeners
+ MultipleWait(waitable);
+
+ RUNNER_ASSERT((singleton->GetProperty<0,int>()) == 0);
+ RUNNER_ASSERT((singleton->GetProperty<1,int>()) == 0);
+ RUNNER_ASSERT((singleton->GetProperty<2,char>()) == 0);
+
+ int checkArray[64] = {};
+ singleton->GetProperty<3>(checkArray);
+ RUNNER_ASSERT(checkArray[0] == 0);
+ RUNNER_ASSERT(checkArray[1] == 0);
+ RUNNER_ASSERT(checkArray[2] == 0);
+
+ // change
+ LogInfo("Setting property 0");
+ sho->SetProperty<0>(1);
+ // wait for confirmations
+ MultipleWait(waitable);
+
+ // change
+ LogInfo("Setting property 1");
+ sho->SetProperty<1>(11);
+ // wait for confirmations
+ MultipleWait(waitable);
+
+ // change
+ LogInfo("Setting property 2");
+ sho->SetProperty<2>('a');
+ // wait for confirmations
+ MultipleWait(waitable);
+
+ // change
+ LogInfo("Setting property 3");
+ sho->SetProperty<3>(array);
+ // wait for confirmations
+ MultipleWait(waitable);
+
+ // remove listeners
+ LogInfo("Removing listeners");
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ controller[i]->PostEvent(ShmController4::REMOVE_LISTENERS);
+ }
+ // wait for listeners
+ MultipleWait(waitable);
+
+ // check if listeners array is empty
+ LogInfo("Checking listeners");
+ for (size_t i=0;i<MAX_THREADS;++i) {
+ LISTENER_ASSERT(0);
+ LISTENER_ASSERT(1);
+ LISTENER_ASSERT(2);
+ LISTENER_ASSERT(3);
+ }
+
+ RUNNER_ASSERT((singleton->GetProperty<0,int>()) == 1);
+ RUNNER_ASSERT((singleton->GetProperty<1,int>()) == 11);
+ RUNNER_ASSERT((singleton->GetProperty<2,char>()) == 'a');
+ singleton->GetProperty<3>(checkArray);
+ RUNNER_ASSERT(checkArray[0] == 0);
+ RUNNER_ASSERT(checkArray[1] == 1);
+ RUNNER_ASSERT(checkArray[2] == 2);
+ }
+
+ singleton.Reset();
+
+ // Destroy controllers and wait for confirmation. Make sure that
+ // thread/controller 0 is destroyed in the end
+ LogInfo("Destroying controllers");
+ for (int i=MAX_THREADS-1;i>=0;--i) {
+ controller[i]->PostEvent(DESTROY_EVENT);
+ Wait(waitable[i]);
+ if (i==0) {
+ /*
+ * Destroy singleton before thread that created it finishes.
+ * This is to properly close all waitable handles opened by
+ * SharedObject in thread 0.
+ */
+ LogInfo("Destroying singleton");
+ controller[i]->PostEvent(ShmController4::DESTROY_SINGLETON);
+ Wait(waitable[i]);
+ }
+ delete controller[i];
+ }
+}
+
+#undef LISTENER_ASSERT
+
+/*
+ * test preconditions & postconditions:
+ * - no existing shared memory with given SHM_KEY
+ * - no existing semaphore of given SEM_NAME
+ */
+RUNNER_TEST(SharedMemory_001_Preconditions) {
+ RemoveIpcs();
+}
+
+RUNNER_TEST(SharedMemory_999_Postconditions) {
+ RemoveIpcs();
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_sql_connection.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of sql connection tests
+ */
+
+
+/*
+
+This test has been saved from original test_sql_connection.cpp in wrt-commons project.
+
+*/
+
+#include <dpl/naive_synchronization_object.h>
+
+RUNNER_TEST(SqlConnection_MassiveReadWrite_SemaphoreSynchronization)
+{
+ srand(time(NULL));
+
+ std::ostringstream dbSemaporeFileNameStream;
+ dbSemaporeFileNameStream << "dpl_tests_dbso_sem_";
+ dbSemaporeFileNameStream << rand() << ".sem";
+
+ std::string dbSemaphoreFileName = dbSemaporeFileNameStream.str();
+
+ SemaphoreSynchronizationObjectGenerator m_generator(dbSemaphoreFileName);
+ MassiveReadWriteTest(&m_generator);
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file test_task.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of task tests
+ */
+#include <dpl/test_runner.h>
+#include <dpl/task.h>
+#include <dpl/log.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+class MySingleTask
+ : public DPL::TaskDecl<MySingleTask>
+{
+protected:
+ void StepOne()
+ {
+ }
+
+public:
+ MySingleTask()
+ : DPL::TaskDecl<MySingleTask>(this)
+ {
+ AddStep(&MySingleTask::StepOne);
+ }
+};
+
+class MyMultiTask
+ : public DPL::MultiTaskDecl<MyMultiTask>
+{
+protected:
+ typedef DPL::MultiTaskDecl<MyMultiTask> BaseType;
+
+ void StepOne()
+ {
+ LogInfo("Step one");
+ }
+
+ void StepTwo()
+ {
+ LogInfo("Step two");
+ }
+
+ void StepThree()
+ {
+ LogInfo("Step three");
+ }
+
+public:
+ MyMultiTask()
+ : BaseType(this, 2)
+ {
+ BaseType::StepList depListStepThree;
+ depListStepThree.push_back(&MyMultiTask::StepOne);
+ depListStepThree.push_back(&MyMultiTask::StepTwo);
+ AddStep(&MyMultiTask::StepThree, depListStepThree);
+
+ BaseType::StepList depListStepTwo;
+ depListStepTwo.push_back(&MyMultiTask::StepOne);
+ AddStep(&MyMultiTask::StepTwo, depListStepTwo);
+
+ BaseType::StepList depListStepOne;
+ AddStep(&MyMultiTask::StepOne, depListStepOne);
+ }
+};
+
+RUNNER_TEST(Task_SingleTask)
+{
+ MySingleTask task;
+ while (task.NextStep());
+}
+
+RUNNER_TEST(Task_MultiTask)
+{
+ MyMultiTask task;
+ while (task.NextStep());
+}
--- /dev/null
+# Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+#
+# 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.
+#
+# @file CMakeLists.txt
+# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+# @version 1.0
+# @brief
+#
+
+SET(TARGET_NAME "dpl-tests-utils")
+
+# Set DPL tests sources
+SET(DPL_TESTS_UTIL_SOURCES
+ ${TESTS_DPL_DIR}/utils/main.cpp
+ ${TESTS_DPL_DIR}/utils/widget_version.cpp
+ ${TESTS_DPL_DIR}/utils/bash_utils.cpp
+ ${TESTS_DPL_DIR}/utils/wrt_utility.cpp
+)
+
+#WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_UTILS_EFL})
+WRT_TEST_BUILD(${TARGET_NAME} ${DPL_TESTS_UTIL_SOURCES})
+WRT_TEST_INSTALL(${TARGET_NAME})
--- /dev/null
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file bash_utils.cpp
+ * @author Iwanek Tomasz
+ * @version 1.0
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/utils/bash_utils.h>
+#include <dpl/log/log.h>
+
+using namespace BashUtils;
+
+RUNNER_TEST_GROUP_INIT(DPL_BASH_UTILS)
+
+RUNNER_TEST(Bash_Utils_escape_arg)
+{
+ RUNNER_ASSERT_MSG(escape_arg(std::string("valid")) == "\"valid\"", "Valid argument failed");
+ LogDebug("\"val\\!d\"" << " " << escape_arg(std::string("val!d")));
+ RUNNER_ASSERT_MSG(escape_arg(std::string("val!d")) == "\"val\\!d\"", "Single escaped character in argument failed");
+ LogDebug("\"v\\$l\\$\\$\"" << " " << escape_arg(std::string("v$l$$")));
+ RUNNER_ASSERT_MSG(escape_arg(std::string("v$l$$")) == "\"v\\$l\\$\\$\"", "Multiple occurences of single special character in argument failed");
+ LogDebug("\"v\\`\\$\\\"\\!d\\`\"" << " " << escape_arg(std::string("v`$\"!d`")));
+ RUNNER_ASSERT_MSG(escape_arg(std::string("v`$\"!d`")) == "\"v\\`\\$\\\"\\!d\\`\"", "Multiple occurences of multiple special character in argument failed");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file main.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main
+ */
+#include <dpl/test/test_runner.h>
+
+int main(int argc, char *argv[])
+{
+ return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file widget_version.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for test cases for engine internal tests
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/utils/widget_version.h>
+
+RUNNER_TEST_GROUP_INIT(DPL_WIDGET_VERSION)
+
+RUNNER_TEST(WidgetVersion_M2_O0)
+{
+ DPL::String raw(L"1.2");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O0_nonwac_1)
+{
+ DPL::String raw(L"a1.2");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O0_nonwac_2)
+{
+ DPL::String raw(L"1.2a");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O0_nonwac_3)
+{
+ DPL::String raw(L"aaa1.2bbb");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O0_nonwac_4)
+{
+ DPL::String raw(L"1a.a2");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O0_long)
+{
+ DPL::String raw(L"123456789012345678901234567890.98765432109876543210987654321");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"123456789012345678901234567890"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"98765432109876543210987654321"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O0)
+{
+ DPL::String raw(L"1.2.3");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O0_nonwac_1)
+{
+ DPL::String raw(L"a1a.2.3");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O0_nonwac_2)
+{
+ DPL::String raw(L"1.b2.3");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O0_nonwac_3)
+{
+ DPL::String raw(L"1.2.3c");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O0_nonwac_4)
+{
+ DPL::String raw(L"1.2.3a");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O1_1)
+{
+ DPL::String raw(L"1.2.3 test111");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"test111"));
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O1_2)
+{
+ DPL::String raw(L"1.2.3 111");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"111"));
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M3_O1_3)
+{
+ DPL::String raw(L"1.2.3 ");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_M2_O1_1)
+{
+ DPL::String raw(L"1.2 t");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == true);
+ RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
+ RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
+ RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
+ RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"t"));
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_0)
+{
+ DPL::String raw(L"1");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_1)
+{
+ DPL::String raw(L".1");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_2)
+{
+ DPL::String raw(L"..1");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_3)
+{
+ DPL::String raw(L"...1");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_4)
+{
+ DPL::String raw(L"qwerty");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Strange_5)
+{
+ DPL::String raw(L"!@#$%^&*()_+ ^&%^*&%$^*&%*()& JHKJLHKJLH 685685687");
+ WidgetVersion version(raw);
+
+ RUNNER_ASSERT(version.IsWac() == false);
+ RUNNER_ASSERT(version.Raw() == raw);
+}
+
+RUNNER_TEST(WidgetVersion_Compare_0)
+{
+ RUNNER_ASSERT(WidgetVersion(L"1.1") < WidgetVersion(L"1.2"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_1)
+{
+ RUNNER_ASSERT(WidgetVersion(L"01.001") < WidgetVersion(L"0001.002"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_2)
+{
+ RUNNER_ASSERT(WidgetVersion(L"0.1") == WidgetVersion(L"00.1"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_3)
+{
+ RUNNER_ASSERT(WidgetVersion(L"1.00000000000000") >= WidgetVersion(L"1.0 test"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_4)
+{
+ RUNNER_ASSERT(WidgetVersion(L"19647963733338932479072098437089778943732432.00000000000000004324324324324321") > WidgetVersion(L"4324324324324324324321.000432"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_5)
+{
+ RUNNER_ASSERT(WidgetVersion(L"12345.1") == WidgetVersion(L"12345.1"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_6)
+{
+ RUNNER_ASSERT(WidgetVersion(L"1.1") != WidgetVersion(L"1.11"));
+}
+
+RUNNER_TEST(WidgetVersion_Compare_7)
+{
+ RUNNER_ASSERT(WidgetVersion(L"000123000.0 notatest") == WidgetVersion(L"00123000.0 testtesttest"));
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/*
+ * @file wrt_utility.cpp
+ * @author Janusz Majnert (j.majnert@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for test cases for wrt_utility functions
+ */
+#include <string>
+#include <fstream>
+#include <errno.h>
+#include <pwd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <dpl/test/test_runner.h>
+#include <dpl/utils/wrt_utility.h>
+#include <dpl/log/log.h>
+
+RUNNER_TEST_GROUP_INIT(DPL_WRT_UTILITY)
+
+RUNNER_TEST(wrt_utility_WrtUtilJoinPaths)
+{
+ std::string result;
+
+ WrtUtilJoinPaths(result, "a/b/c/", "e/f/g.asd");
+ RUNNER_ASSERT(result == "a/b/c/e/f/g.asd");
+
+ WrtUtilJoinPaths(result, "/a/b/c", "/e/f/g/");
+ RUNNER_ASSERT(result == "/a/b/c/e/f/g/");
+
+ WrtUtilJoinPaths(result, "/a/b/c/", "/e/f/g/");
+ RUNNER_ASSERT(result == "/a/b/c/e/f/g/");
+
+ WrtUtilJoinPaths(result, "/a/b/c", "e/f/g/");
+ RUNNER_ASSERT(result == "/a/b/c/e/f/g/");
+}
+
+/**
+ * Create recursive path with specified permissions.
+ * Check if folders exist.
+ * Check if permissions are set.
+ */
+RUNNER_TEST(wrt_utility_WrtUtilMakeDir)
+{
+ struct stat st;
+ //First delete the dir if it exists
+ WrtUtilRemove("/tmp/test");
+ WrtUtilMakeDir("/tmp/test/1/2/3/4/5/6/7/8/9", 0755);
+ if (stat("/tmp/test/1/2/3/4/5/6/7/8/9", &st) == 0) {
+ RUNNER_ASSERT_MSG(st.st_mode & S_IRWXU,
+ "read, write, execute/search by owner");
+ RUNNER_ASSERT_MSG(st.st_mode & S_IXGRP,
+ "execute/search permission, group");
+ RUNNER_ASSERT_MSG(st.st_mode & S_IRGRP, "read permission, group");
+ RUNNER_ASSERT_MSG(!(st.st_mode & S_IWGRP),
+ "NO write permission, group ");
+ RUNNER_ASSERT_MSG(st.st_mode & S_IXOTH,
+ "execute/search permission, others");
+ RUNNER_ASSERT_MSG(st.st_mode & S_IROTH, "read permission, others");
+ RUNNER_ASSERT_MSG(!(st.st_mode & S_IWOTH),
+ "NO write permission, others ");
+ } else {
+ RUNNER_ASSERT_MSG(false, "Cannot stat folder");
+ }
+}
+
+/**
+ * Create directory without permission to write.
+ */
+RUNNER_TEST(wrt_utility_WrtUtilMakeDir_PermissionError)
+{
+ if (0 == getuid()) {
+ //Change UID to execute the test correctly
+ errno = 0;
+ struct passwd *p = getpwnam("app");
+ if (p == NULL) {
+ int error = errno;
+ RUNNER_ASSERT_MSG(false, "Getting app user UID failed: "
+ << (error == 0 ? "No error detected" : strerror(error)));
+ }
+ if (setuid(p->pw_uid) != 0) {
+ int error = errno;
+ RUNNER_ASSERT_MSG(false, "Changing to app user's UID failed: "
+ << (error == 0 ? "No error detected" : strerror(error)));
+ }
+ }
+ RUNNER_ASSERT_MSG(WrtUtilMakeDir("/tmp/test2/1", 0055) == false,
+ "Creating directory '1' in /temp/test2/ should have failed");
+ //Going back to root UID
+ if (setuid(0) != 0) {
+ int error = errno;
+ LogWarning("Changing back to root UID failed: "
+ << (error == 0 ? "No error detected" : strerror(error)));
+ }
+
+}
+
+/**
+ * Create directory with file inside.
+ * Check if file was removed with directory.
+ */
+RUNNER_TEST(wrt_utility_WrtUtilRemoveDir) {
+ RUNNER_ASSERT_MSG(WrtUtilMakeDir("/tmp/test3/", 0755) == true,
+ "Could not set up directory for test");
+
+ std::ofstream file;
+ file.open("/tmp/test3/example.txt");
+ file.close();
+ struct stat tmp;
+ RUNNER_ASSERT_MSG(stat("/tmp/test3/example.txt",&tmp) == 0,
+ "Couldn't create the test file");
+
+ WrtUtilRemove("/tmp/test3");
+ if (stat("/tmp/test3", &tmp) != 0) {
+ int error=errno;
+ RUNNER_ASSERT(error == ENOENT);
+ return;
+ }
+ RUNNER_ASSERT(false);
+}
+
+/**
+ * Try to remove not existing folder.
+ */
+RUNNER_TEST(wrt_utility_WrtUtilRemoveDir_NoDirError)
+{
+ //First making sure the test dir doesn't exist
+ WrtUtilRemove("/tmp/NOT_EXISTING");
+
+ RUNNER_ASSERT_MSG(WrtUtilRemove("/tmp/NOT_EXISTING") == false,
+ "Removing non existing directory returned success");
+}
+
+RUNNER_TEST(wrt_utility_WrtUtilFileExists)
+{
+ std::ofstream file;
+ file.open("/tmp/test_file1");
+ file.close();
+ RUNNER_ASSERT(WrtUtilFileExists("/tmp/test_file1"));
+
+ WrtUtilRemove("/tmp/test_file1");
+ RUNNER_ASSERT(WrtUtilFileExists("/tmp/test_file1") == false);
+}
+
+RUNNER_TEST(wrt_utility_WrtUtilDirExists)
+{
+ RUNNER_ASSERT(WrtUtilDirExists("/tmp"));
+ RUNNER_ASSERT(WrtUtilDirExists("/UNAVAILABLE_DIR") == false);
+}
--- /dev/null
+wrt-commons:
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ 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.
+
+
+3rdparty/fastdelegate :
+License
+
+The source code attached to this article is released into the public domain.
+You may use it for any purpose. Frankly, writing the article was about ten
+times as much work as writing the code. Of course, if you create great software
+using the code, I would be interested to hear about it. And submissions are always welcome.
+
+
+3rdparty/minizip :
+MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson
+
+Introduction
+---------------------
+MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html )
+
+When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0.
+All possible work was done for compatibility.
+
+
+Background
+---------------------
+When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64
+support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ )
+
+That was used as a starting point. And after that ZIP64 support was added to zip.c
+some refactoring and code cleanup was also done.
+
+
+Changed from MiniZip 1.0 to MiniZip 1.1
+---------------------------------------
+* Added ZIP64 support for unzip ( by Even Rouault )
+* Added ZIP64 support for zip ( by Mathias Svensson )
+* Reverted some changed that Even Rouault did.
+* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users.
+* Added unzip patch for BZIP Compression method (patch create by Daniel Borca)
+* Added BZIP Compress method for zip
+* Did some refactoring and code cleanup
+
+
+Credits
+
+ Gilles Vollant - Original MiniZip author
+ Even Rouault - ZIP64 unzip Support
+ Daniel Borca - BZip Compression method support in unzip
+ Mathias Svensson - ZIP64 zip support
+ Mathias Svensson - BZip Compression method support in zip
+
+ Resources
+
+ ZipLayout http://result42.com/projects/ZipFileLayout
+ Command line tool for Windows that shows the layout and information of the headers in a zip archive.
+ Used when debugging and validating the creation of zip files using MiniZip64
+
+
+ ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+ Zip File specification
+
+
+Notes.
+ * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined.
+
+License
+----------------------------------------------------------
+ Condition of use and distribution are the same than zlib :
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+----------------------------------------------------------
+
--- /dev/null
+<manifest>
+ <define>
+ <domain name="wrt-commons"/>
+ <provide>
+ <label name="wrt-commons::db_wrt"/>
+ <label name="wrt-commons::db_wrt_autosave"/>
+ <label name="wrt-commons::db_wrt_custom_handler"/>
+ </provide>
+ </define>
+ <request>
+ <domain name="_"/>
+ </request>
+</manifest>
projects / framework / web / wrt-commons.git / commitdiff