From 6a4b662fa078dd7caba09126244179311cfe9e6c Mon Sep 17 00:00:00 2001 From: Hyungdeuk Kim Date: Tue, 21 Aug 2012 21:15:58 +0900 Subject: [PATCH] tizen 2.0 upload --- CMakeLists.txt | 96 +++++++++ LICENSE | 206 +++++++++++++++++++ TC/_export_env.sh | 8 + TC/_export_target_env.sh | 7 + TC/build.sh | 16 ++ TC/clean.sh | 11 + TC/config | 2 + TC/execute.sh | 15 ++ TC/testcase/Makefile | 24 +++ TC/testcase/tslist | 1 + TC/testcase/utc_mime_type.c | 366 ++++++++++++++++++++++++++++++++++ TC/tet_scen | 7 + TC/tetbuild.cfg | 5 + TC/tetclean.cfg | 5 + TC/tetexec.cfg | 5 + capi-content-mime-type.pc.in | 15 ++ include/mime_type.h | 87 ++++++++ packaging/capi-content-mime-type.spec | 56 ++++++ src/mime_type.c | 175 ++++++++++++++++ 19 files changed, 1107 insertions(+) create mode 100755 CMakeLists.txt create mode 100755 LICENSE create mode 100755 TC/_export_env.sh create mode 100755 TC/_export_target_env.sh create mode 100755 TC/build.sh create mode 100755 TC/clean.sh create mode 100755 TC/config create mode 100755 TC/execute.sh create mode 100755 TC/testcase/Makefile create mode 100755 TC/testcase/tslist create mode 100755 TC/testcase/utc_mime_type.c create mode 100755 TC/tet_scen create mode 100755 TC/tetbuild.cfg create mode 100755 TC/tetclean.cfg create mode 100755 TC/tetexec.cfg create mode 100755 capi-content-mime-type.pc.in create mode 100755 include/mime_type.h create mode 100755 packaging/capi-content-mime-type.spec create mode 100755 src/mime_type.c diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..f1198f0 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,96 @@ + +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +SET(fw_name "capi-content-mime-type") + +PROJECT(${fw_name}) + +SET(CMAKE_INSTALL_PREFIX /usr) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) + +SET(INC_DIR include) +INCLUDE_DIRECTORIES(${INC_DIR}) + +SET(requires "dlog capi-base-common xdgmime") +SET(pc_requires "capi-base-common") + +INCLUDE(FindPkgConfig) +pkg_check_modules(${fw_name} REQUIRED ${requires}) +FOREACH(flag ${${fw_name}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") + +IF("${ARCH}" STREQUAL "arm") + ADD_DEFINITIONS("-DTARGET") +ENDIF("${ARCH}" STREQUAL "arm") + +ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") +ADD_DEFINITIONS("-DSLP_DEBUG") + +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib") + +aux_source_directory(src SOURCES) +ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) + +TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS}) + +SET_TARGET_PROPERTIES(${fw_name} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 +) + +INSTALL(TARGETS ${fw_name} DESTINATION lib) +INSTALL( + DIRECTORY ${INC_DIR}/ DESTINATION include/content + FILES_MATCHING + PATTERN "*_private.h" EXCLUDE + PATTERN "${INC_DIR}/*.h" + ) + +SET(PC_NAME ${fw_name}) +SET(PC_REQUIRED ${pc_requires}) +SET(PC_LDFLAGS -l${fw_name}) +SET(PC_CFLAGS -I\${includedir}/content) + +CONFIGURE_FILE( + capi-content-mime-type.pc.in + ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc + @ONLY +) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION lib/pkgconfig) + +IF(UNIX) + +ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution) +ADD_CUSTOM_COMMAND( + DEPENDS clean + COMMENT "distribution clean" + COMMAND find + ARGS . + -not -name config.cmake -and \( + -name tester.c -or + -name Testing -or + -name CMakeFiles -or + -name cmake.depends -or + -name cmake.check_depends -or + -name CMakeCache.txt -or + -name cmake.check_cache -or + -name *.cmake -or + -name Makefile -or + -name core -or + -name core.* -or + -name gmon.out -or + -name install_manifest.txt -or + -name *.pc -or + -name *~ \) + | grep -v TC | xargs rm -rf + TARGET distclean + VERBATIM +) + +ENDIF(UNIX) + diff --git a/LICENSE b/LICENSE new file mode 100755 index 0000000..bbe9d02 --- /dev/null +++ b/LICENSE @@ -0,0 +1,206 @@ +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. + + + diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..72a11ec --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..5ddaa53 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,7 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config b/TC/config new file mode 100755 index 0000000..6761a8b --- /dev/null +++ b/TC/config @@ -0,0 +1,2 @@ +TET_INSTALL_HOST_PATH=/home/junghyuk/workspace/TETware +TET_INSTALL_TARGET_PATH=/mnt/nfs/workspace/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..a4f6095 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100755 index 0000000..58896eb --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,24 @@ +CC ?= gcc + +C_FILES = $(shell ls *.c) + +PKGS = capi-content-mime-type capi-base-common + +LDFLAGS = `pkg-config --libs $(PKGS)` +LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS = -I. `pkg-config --cflags $(PKGS)` +CFLAGS += -I$(TET_ROOT)/inc/tet3 +CFLAGS += -Wall + +TCS := $(shell ls -1 *.c | cut -d. -f1) + +all: $(TCS) + +%: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TCS) \ No newline at end of file diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100755 index 0000000..f0be022 --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1 @@ +/testcase/utc_mime_type \ No newline at end of file diff --git a/TC/testcase/utc_mime_type.c b/TC/testcase/utc_mime_type.c new file mode 100755 index 0000000..9f011fe --- /dev/null +++ b/TC/testcase/utc_mime_type.c @@ -0,0 +1,366 @@ +/* + * 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 +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_mime_type_get_mime_type_positive1(void); +static void utc_mime_type_get_mime_type_positive2(void); +static void utc_mime_type_get_mime_type_positive3(void); +static void utc_mime_type_get_mime_type_positive4(void); +static void utc_mime_type_get_mime_type_positive5(void); +static void utc_mime_type_get_mime_type_positive5(void); + +static void utc_mime_type_get_mime_type_negative1(void); +static void utc_mime_type_get_mime_type_negative2(void); +static void utc_mime_type_get_mime_type_negative3(void); + +static void utc_mime_type_get_file_extension_positive1(void); +static void utc_mime_type_get_file_extension_positive2(void); + +static void utc_mime_type_get_file_extension_negative1(void); +static void utc_mime_type_get_file_extension_negative2(void); +static void utc_mime_type_get_file_extension_negative3(void); +static void utc_mime_type_get_file_extension_negative4(void); + +struct tet_testlist tet_testlist[] = { + {utc_mime_type_get_mime_type_positive1, 1}, + {utc_mime_type_get_mime_type_positive2, 1}, + {utc_mime_type_get_mime_type_positive3, 1}, + {utc_mime_type_get_mime_type_positive4, 1}, + {utc_mime_type_get_mime_type_positive5, 1}, + + {utc_mime_type_get_mime_type_negative1, 1}, + {utc_mime_type_get_mime_type_negative2, 1}, + {utc_mime_type_get_mime_type_negative3, 1}, + + {utc_mime_type_get_file_extension_positive1, 1}, + {utc_mime_type_get_file_extension_positive2, 1}, + + {utc_mime_type_get_file_extension_negative1, 1}, + {utc_mime_type_get_file_extension_negative2, 1}, + {utc_mime_type_get_file_extension_negative3, 1}, + {utc_mime_type_get_file_extension_negative4, 1}, + + {NULL, 0}, +}; + +static void startup(void) +{ + +} + +static void cleanup(void) +{ + /* end of TC */ +} + +void utc_mime_type_get_mime_type_positive1(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("png", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "image/png")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_positive2(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("jpg", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "image/jpeg")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_positive3(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("mpg", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "video/mpeg")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_positive4(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("mp3", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "audio/mpeg")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + + +void utc_mime_type_get_mime_type_positive5(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("bin", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "application/octet-stream")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_positive6(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("abcdef", &mime_type); + + if (retcode == MIME_TYPE_ERROR_NONE && !strcmp(mime_type, "application/octet-stream")) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + + +void utc_mime_type_get_mime_type_negative1(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type(NULL, &mime_type); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_negative2(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char *mime_type; + + retcode = mime_type_get_mime_type("", &mime_type); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_mime_type_negative3(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + + retcode = mime_type_get_mime_type("mp3", NULL); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + + +void utc_mime_type_get_file_extension_positive1(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char **file_extension; + int length; + + retcode = mime_type_get_file_extension("video/mpeg", &file_extension, &length); + + if (retcode == MIME_TYPE_ERROR_NONE && length > 0) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_file_extension_positive2(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char **file_extension; + int length; + + retcode = mime_type_get_file_extension("image/jpeg", &file_extension, &length); + + if (retcode == MIME_TYPE_ERROR_NONE && length > 0) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_file_extension_negative1(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char **file_extension; + int length; + + retcode = mime_type_get_file_extension(NULL, &file_extension, &length); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_file_extension_negative2(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char **file_extension; + int length; + + retcode = mime_type_get_file_extension("", &file_extension, &length); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_file_extension_negative3(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + int length; + + retcode = mime_type_get_file_extension("image/jpeg", NULL, &length); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} + +void utc_mime_type_get_file_extension_negative4(void) +{ + const char *TC_NAME = __FUNCTION__; + + int retcode; + char **file_extension; + + retcode = mime_type_get_file_extension("image/jpeg", &file_extension, NULL); + + if (retcode == MIME_TYPE_ERROR_INVALID_PARAMETER) + { + dts_pass(TC_NAME, "passed"); + } + else + { + dts_fail(TC_NAME, "failed"); + } +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100755 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100755 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100755 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/capi-content-mime-type.pc.in b/capi-content-mime-type.pc.in new file mode 100755 index 0000000..640d431 --- /dev/null +++ b/capi-content-mime-type.pc.in @@ -0,0 +1,15 @@ + +# Package Information for pkg-config + +prefix=@PREFIX@ +exec_prefix=/usr +libdir=/usr/lib +includedir=/usr/include/content + +Name: @PC_NAME@ +Description: @PACKAGE_DESCRIPTION@ +Version: @VERSION@ +Requires: @PC_REQUIRED@ +Libs: -L${libdir} @PC_LDFLAGS@ +Cflags: -I${includedir} + diff --git a/include/mime_type.h b/include/mime_type.h new file mode 100755 index 0000000..a1f4328 --- /dev/null +++ b/include/mime_type.h @@ -0,0 +1,87 @@ +/* + * 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 __TIZEN_CONTENT_MIME_TYPE_H__ +#define __TIZEN_CONTENT_MIME_TYPE_H__ + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * @addtogroup CAPI_CONTENT_MIME_TYPE_MODULE + * @{ + */ + + +/** + * @brief Enumeration of error code + */ +typedef enum +{ + MIME_TYPE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + MIME_TYPE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + MIME_TYPE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + MIME_TYPE_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR , /**< Internal I/O error */ +} mime_type_error_e; + + +/** + * @brief Gets the MIME type for the given file extension. + * + * @remarks The @a mime_type must be released with free() by you. + * @param [in] file_extension The file extension without the leading dot ('.') + * @param [out] mime_type The MIME type for the given file extension \n + * The MIME type is 'application/octet-stream' if the given file extension is not associated with specific file formats + * @return 0 on success, otherwise a negative error value. + * @retval #MIME_TYPE_ERROR_NONE Successful + * @retval #MIME_TYPE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #MIME_TYPE_ERROR_OUT_OF_MEMORY Out of memory + * @retval #MIME_TYPE_ERROR_IO_ERROR Internal I/O error + * @see mime_type_get_file_extension() + */ +int mime_type_get_mime_type(const char *file_extension, char **mime_type); + + +/** + * @brief Gets the file extensions for the given MIME type. + * + * @remarks The @a file_extension must be released with free() by you. + * @param [in] mime_type The MIME type + * @param [out] file_extension The array of file extension without the leading dot ('.') + * @param [out] length The length of the array of file extension or zero if there is none + * @return 0 on success, otherwise a negative error value. + * @retval #MIME_TYPE_ERROR_NONE Successful + * @retval #MIME_TYPE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #MIME_TYPE_ERROR_OUT_OF_MEMORY Out of memory + * @retval #MIME_TYPE_ERROR_IO_ERROR Internal I/O error + * @see mime_type_get_mime_type() + */ +int mime_type_get_file_extension(const char *mime_type, char *** file_extension, int *length); + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __TIZEN_CONTENT_MIME_TYPE_H__ */ diff --git a/packaging/capi-content-mime-type.spec b/packaging/capi-content-mime-type.spec new file mode 100755 index 0000000..9d92804 --- /dev/null +++ b/packaging/capi-content-mime-type.spec @@ -0,0 +1,56 @@ +Name: capi-content-mime-type +Summary: A MIME type library in Tizen C API +Version: 0.0.1 +Release: 1 +Group: TO_BE/FILLED_IN +License: TO BE FILLED IN +Source0: %{name}-%{version}.tar.gz +BuildRequires: cmake +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(xdgmime) +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + +%description + + +%package devel +Summary: A MIME type library in Tizen C API (Development) +Group: TO_BE/FILLED_IN +Requires: %{name} = %{version}-%{release} +Requires: pkgconfig(capi-base-common) + +%description devel + + + +%prep +%setup -q + + +%build +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} + + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%{_libdir}/lib*.so.* + +%files devel +%{_includedir}/content/*.h +%{_libdir}/pkgconfig/*.pc +%{_libdir}/lib*.so + + diff --git a/src/mime_type.c b/src/mime_type.c new file mode 100755 index 0000000..d5f22c3 --- /dev/null +++ b/src/mime_type.c @@ -0,0 +1,175 @@ +/* + * 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 +#include +#include + +#include +#include + +#include + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "TIZEN_N_MIME_TYPE" + +#define FILE_EXTENSION_DELIMITER '.' + +static const char* mime_type_error_to_string(mime_type_error_e error) +{ + switch (error) + { + case MIME_TYPE_ERROR_NONE: + return "NONE"; + + case MIME_TYPE_ERROR_INVALID_PARAMETER: + return "INVALID_PARAMETER"; + + case MIME_TYPE_ERROR_OUT_OF_MEMORY: + return "OUT_OF_MEMORY"; + + case MIME_TYPE_ERROR_IO_ERROR: + return "IO_ERROR"; + + default : + return "UNKNOWN"; + } +} + +static int mime_type_error(mime_type_error_e error, const char* function, const char *description) +{ + if (description) + { + LOGE("[%s] %s(0x%08x) : %s", function, mime_type_error_to_string(error), error, description); + } + else + { + LOGE("[%s] %s(0x%08x)", function, mime_type_error_to_string(error), error); + } + + return error; +} + + +int mime_type_get_mime_type(const char *file_extension, char **mime_type) +{ + char file_extension_with_dot[32] = {0, }; + const char *xdg_mime_type = NULL; + + if (file_extension == NULL || mime_type == NULL) + { + return mime_type_error(MIME_TYPE_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (file_extension[0] == '\0') + { + return mime_type_error(MIME_TYPE_ERROR_INVALID_PARAMETER, __FUNCTION__, "the given file extension is an empy string"); + } + + if (file_extension[0] == FILE_EXTENSION_DELIMITER) + { + return mime_type_error(MIME_TYPE_ERROR_INVALID_PARAMETER, __FUNCTION__, "the given file extension includes the leading dot ('.')"); + } + + snprintf(file_extension_with_dot, sizeof(file_extension_with_dot), ".%s", file_extension); + + xdg_mime_type = xdg_mime_get_mime_type_from_file_name(file_extension_with_dot); + + if (xdg_mime_type == NULL || xdg_mime_type == '\0') + { + return mime_type_error(MIME_TYPE_ERROR_IO_ERROR, __FUNCTION__, "failed to get the mime type from the shared MIME database"); + } + + if (xdg_mime_type != NULL) + { + char * mime_type_dup = NULL; + + mime_type_dup = strdup(xdg_mime_type); + + if (mime_type_dup == NULL) + { + return mime_type_error(MIME_TYPE_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *mime_type = mime_type_dup; + } + else + { + *mime_type = NULL; + } + + return MIME_TYPE_ERROR_NONE; +} + +int mime_type_get_file_extension(const char *mime_type, char *** file_extension, int *length) +{ + const char **xdg_file_extension = NULL; + int xdg_file_extension_length = 0; + char **file_extension_array = NULL; + int file_extension_array_index = 0; + + if (mime_type == NULL || file_extension == NULL || length == NULL) + { + return mime_type_error(MIME_TYPE_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (mime_type[0] == '\0') + { + return mime_type_error(MIME_TYPE_ERROR_INVALID_PARAMETER, __FUNCTION__, "the given MIME type is an empy string"); + } + + xdg_file_extension = xdg_mime_get_file_names_from_mime_type(mime_type); + + if (xdg_file_extension == NULL) + { + return mime_type_error(MIME_TYPE_ERROR_IO_ERROR, __FUNCTION__, "failed to get the file extensions from the shared MIME database"); + } + + while (xdg_file_extension[xdg_file_extension_length] != NULL) + { + xdg_file_extension_length++; + } + + file_extension_array = calloc(xdg_file_extension_length, sizeof(char*)); + + if (file_extension_array == NULL) + { + return mime_type_error(MIME_TYPE_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + for (xdg_file_extension_length = 0; xdg_file_extension[xdg_file_extension_length] != NULL; xdg_file_extension_length++) + { + char *entry = NULL; + + entry = strrchr(xdg_file_extension[xdg_file_extension_length], FILE_EXTENSION_DELIMITER); + + if (entry != NULL) + { + entry++; + file_extension_array[file_extension_array_index] = strdup(entry); + file_extension_array_index++; + } + } + + *file_extension = file_extension_array; + *length = file_extension_array_index; + + return MIME_TYPE_ERROR_NONE; +} + -- 2.7.4