2.0 beta init

diff --git a/CMakeLists.txt b/CMakeLists.txt
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/TC/_export_env.sh b/TC/_export_env.sh
new file mode 100755 (executable)
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 (executable)
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 (executable)
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 (executable)
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 100644 (file)
index 0000000..04684f0
--- /dev/null
+++ b/TC/config
@@ -0,0 +1,2 @@
+TET_INSTALL_HOST_PATH=/home/rookiejava/dts_tool/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/dts_tool/TETware

diff --git a/TC/execute.sh b/TC/execute.sh
new file mode 100755 (executable)
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 (executable)
index 0000000..eb04088
--- /dev/null
+++ b/TC/testcase/Makefile
@@ -0,0 +1,25 @@
+CC ?= gcc
+
+C_FILES = $(shell ls *.c)
+
+PKGS = capi-media-radio gthread-2.0
+
+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
+
+#TARGETS = $(C_FILES:%.c=tc-%)
+TCS := $(shell ls -1 *.c | cut -d. -f1)
+
+all: $(TCS)
+
+%: %.c
+       $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+clean:
+       rm -f $(TCS)

diff --git a/TC/testcase/tslist b/TC/testcase/tslist
new file mode 100644 (file)
index 0000000..34c1a92
--- /dev/null
+++ b/TC/testcase/tslist
@@ -0,0 +1 @@
+/testcase/utc_media_radio

diff --git a/TC/testcase/utc_media_radio b/TC/testcase/utc_media_radio
new file mode 100755 (executable)
index 0000000..0c02690
Binary files /dev/null and b/TC/testcase/utc_media_radio differ

diff --git a/TC/testcase/utc_media_radio.c b/TC/testcase/utc_media_radio.c
new file mode 100644 (file)
index 0000000..21c40ca
--- /dev/null
+++ b/TC/testcase/utc_media_radio.c
@@ -0,0 +1,704 @@
+/*
+* 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 <tet_api.h>
+#include <media/radio.h>
+#include <glib.h>
+
+
+enum {
+       POSITIVE_TC_IDX = 0x01,
+       NEGATIVE_TC_IDX,
+};
+
+//keeping ret and radio global, since using startup function for all
+radio_h radio;
+int sRet;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_radio_create_p(void);
+static void utc_media_radio_create_n(void);
+static void utc_media_radio_destroy_p(void);
+static void utc_media_radio_destroy_n(void);
+static void utc_media_radio_get_state_p(void);
+static void utc_media_radio_get_state_n(void);
+static void utc_media_radio_start_p(void);
+static void utc_media_radio_start_n(void);
+static void utc_media_radio_stop_p(void);
+static void utc_media_radio_stop_n(void);
+static void utc_media_radio_seek_up_p(void);
+static void utc_media_radio_seek_up_n(void);
+static void utc_media_radio_seek_down_p(void);
+static void utc_media_radio_seek_down_n(void);
+static void utc_media_radio_set_frequency_p(void);
+static void utc_media_radio_set_frequency_n(void);
+static void utc_media_radio_get_frequency_p(void);
+static void utc_media_radio_get_frequency_n(void);
+static void utc_media_radio_scan_start_p(void);
+static void utc_media_radio_scan_start_n(void);
+static void utc_media_radio_scan_stop_p(void);
+static void utc_media_radio_scan_stop_n(void);
+static void utc_media_radio_set_mute_p(void);
+static void utc_media_radio_set_mute_n(void);
+static void utc_media_radio_is_muted_p(void);
+static void utc_media_radio_is_muted_n(void);
+static void utc_media_radio_set_scan_completed_callback_p(void);
+static void utc_media_radio_set_scan_completed_callback_n(void);
+static void utc_media_radio_unset_scan_completed_callback_p(void);
+static void utc_media_radio_unset_scan_completed_callback_n(void);
+static void utc_media_radio_set_interrupted_callback_p(void);
+static void utc_media_radio_set_interrupted_callback_n(void);
+static void utc_media_radio_unset_interrupted_callback_p(void);
+static void utc_media_radio_unset_interrupted_callback_n(void);
+
+struct tet_testlist tet_testlist[] = {
+       { utc_media_radio_create_p , POSITIVE_TC_IDX },
+       { utc_media_radio_create_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_destroy_p , POSITIVE_TC_IDX },
+       { utc_media_radio_destroy_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_get_state_p , POSITIVE_TC_IDX },
+       { utc_media_radio_get_state_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_start_p , POSITIVE_TC_IDX },
+       { utc_media_radio_start_n  , NEGATIVE_TC_IDX },
+       { utc_media_radio_stop_p , POSITIVE_TC_IDX },
+       { utc_media_radio_stop_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_seek_up_p , POSITIVE_TC_IDX },
+       { utc_media_radio_seek_up_n  , NEGATIVE_TC_IDX },
+       { utc_media_radio_seek_down_p , POSITIVE_TC_IDX },
+       { utc_media_radio_seek_down_n  , NEGATIVE_TC_IDX },
+       { utc_media_radio_set_frequency_p  , POSITIVE_TC_IDX },
+       { utc_media_radio_set_frequency_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_get_frequency_p , POSITIVE_TC_IDX },
+       { utc_media_radio_get_frequency_n  , NEGATIVE_TC_IDX },
+       { utc_media_radio_scan_start_p , POSITIVE_TC_IDX },
+       { utc_media_radio_scan_start_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_scan_stop_p  , POSITIVE_TC_IDX },
+       { utc_media_radio_scan_stop_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_set_mute_p , POSITIVE_TC_IDX },
+       { utc_media_radio_set_mute_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_is_muted_p  , POSITIVE_TC_IDX },
+       { utc_media_radio_is_muted_n, NEGATIVE_TC_IDX },
+       { utc_media_radio_set_scan_completed_callback_p , POSITIVE_TC_IDX },
+       { utc_media_radio_set_scan_completed_callback_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_unset_scan_completed_callback_p , POSITIVE_TC_IDX },
+       { utc_media_radio_unset_scan_completed_callback_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_set_interrupted_callback_p , POSITIVE_TC_IDX },
+       { utc_media_radio_set_interrupted_callback_n , NEGATIVE_TC_IDX },
+       { utc_media_radio_unset_interrupted_callback_p , POSITIVE_TC_IDX },
+       { utc_media_radio_unset_interrupted_callback_n , NEGATIVE_TC_IDX },
+       { NULL, 0 },
+};
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+
+gpointer GmainThread(gpointer data){
+       g_mainloop = g_main_loop_new (NULL, 0);
+       g_main_loop_run (g_mainloop);
+       
+       return NULL;
+}
+
+static void radio_completed_cb(int frequency, void *data)
+{
+       dts_message("RadiorEvent", "Radio scan info : %d!!!", frequency);
+}
+
+static void radio_interrupt_cb(radio_interrupted_code_e code, void *data)
+{
+       dts_message("RadiorEvent", "Radio Interrupted!!!");
+}
+
+static void startup(void)
+{
+       if( !g_thread_supported() )
+       {
+               g_thread_init(NULL);
+       }
+       
+       GError *gerr = NULL;
+       event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+
+       if ((sRet = radio_create(&radio)) != RADIO_ERROR_NONE)
+       {
+               dts_fail("startup failed");
+       }
+}
+
+static void cleanup(void)
+{
+       if ((sRet = radio_destroy(radio)) != RADIO_ERROR_NONE)
+       {
+               dts_fail("cleanup failed");
+       }
+       g_main_loop_quit (g_mainloop);
+       g_thread_join(event_thread);
+}
+
+static void utc_media_radio_create_p(void)
+{
+       char* api_name = "utc_media_radio_create_p";
+       radio_h radio2;
+       int ret = radio_create(&radio2);
+       if (ret != RADIO_ERROR_NONE)
+       {
+               dts_message(api_name, "Call log: %d", ret);
+               dts_fail(api_name);
+       }
+       else
+       {
+               radio_destroy(radio2);
+               dts_pass(api_name);
+       }
+}
+
+static void utc_media_radio_create_n(void)
+{
+       char* api_name = "utc_media_radio_create_n";
+       int ret = radio_create(NULL);
+       if (ret == RADIO_ERROR_NONE)
+       {
+               dts_message(api_name, "Call log: %d", ret);
+               dts_fail(api_name);
+       }
+       else
+       {
+               dts_pass(api_name);
+       }
+}
+
+static void utc_media_radio_destroy_p(void)
+{
+       char* api_name = "utc_media_radio_destroy_p";
+       radio_h radio2;
+       radio_create(&radio2);
+       int ret;
+       ret = radio_destroy(radio2);
+       if (ret != RADIO_ERROR_NONE)
+       {
+               dts_message(api_name, "Call log: %d", ret);
+               dts_fail(api_name);
+       }
+       else
+       {
+               dts_pass(api_name);
+       }
+}
+
+static void utc_media_radio_destroy_n(void)
+{
+       char* api_name = "utc_media_radio_destroy_n";
+       int ret = radio_destroy(NULL);
+       if (ret == RADIO_ERROR_NONE)
+       {
+               dts_message(api_name, "Call log: %d", ret);
+               dts_fail(api_name);
+       }
+       else
+       {
+               dts_pass(api_name);
+       }
+}
+
+static void utc_media_radio_get_state_p(void)
+{
+       char* api_name = "utc_media_radio_get_state_p";
+       int ret;
+       radio_state_e state;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_get_state(radio, &state)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_get_state_n(void)
+{
+       char* api_name = "utc_media_radio_get_state_n";
+       int ret;
+       radio_state_e state;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_get_state(NULL, &state)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_start_p(void)
+{
+       char* api_name = "utc_media_radio_start_p";
+       int ret;
+
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       radio_stop(radio);
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_start_n(void)
+{
+       char* api_name = "utc_media_radio_start_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_stop_p(void)
+{
+       char* api_name = "utc_media_radio_stop_p";
+       int ret;
+
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       if((ret = radio_stop(radio)) == RADIO_ERROR_NONE)
+                       {
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_stop_n(void)
+{
+       char* api_name = "utc_media_radio_stop_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_stop(NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_seek_up_p(void)
+{
+       char* api_name = "utc_media_radio_seek_up_p";
+       int ret;
+
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       if((ret = radio_seek_up(radio,NULL,NULL)) == RADIO_ERROR_NONE)
+                       {
+                               radio_stop(radio);
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_seek_up_n(void)
+{
+       char* api_name = "utc_media_radio_seek_up_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_seek_up(radio,NULL,NULL)) == RADIO_ERROR_INVALID_STATE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_seek_down_p(void)
+{
+       char* api_name = "utc_media_radio_seek_down_p";
+       int ret;
+
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       if((ret = radio_seek_down(radio,NULL,NULL)) == RADIO_ERROR_NONE)
+                       {
+                               radio_stop(radio);
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_seek_down_n(void)
+{
+       char* api_name = "utc_media_radio_seek_down_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_seek_down(radio,NULL,NULL)) == RADIO_ERROR_INVALID_STATE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_frequency_p(void)
+{
+       char* api_name = "utc_media_radio_set_frequency_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       if((ret = radio_set_frequency(radio, 91900)) == RADIO_ERROR_NONE)
+                       {
+                               radio_stop(radio);
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_frequency_n(void)
+{
+       char* api_name = "utc_media_radio_set_frequency_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if((ret = radio_set_frequency(radio, 100)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_get_frequency_p(void)
+{
+       char* api_name = "utc_media_radio_get_frequency_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_start(radio)) == RADIO_ERROR_NONE)
+               {
+                       int frequency;
+                       if((ret = radio_get_frequency(radio, &frequency)) == RADIO_ERROR_NONE)
+                       {
+                               radio_stop(radio);
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_get_frequency_n(void)
+{
+       char* api_name = "utc_media_radio_get_frequency_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if((ret = radio_get_frequency(NULL, NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_scan_start_p(void)
+{
+       char* api_name = "utc_media_radio_scan_start_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_scan_start(radio,NULL,NULL)) == RADIO_ERROR_NONE)
+               {
+                       radio_scan_stop(radio,NULL,NULL);
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_scan_start_n(void)
+{
+       char* api_name = "utc_media_radio_scan_start_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_scan_start(NULL,NULL,NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_scan_stop_p(void)
+{
+       char* api_name = "utc_media_radio_scan_stop_p";
+       int ret;
+       
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_scan_start(radio,NULL,NULL)) == RADIO_ERROR_NONE)
+               {
+                       if((ret = radio_scan_stop(radio,NULL,NULL)) == RADIO_ERROR_NONE)
+                       {
+                               dts_pass(api_name);
+                       }
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_scan_stop_n(void)
+{
+       char* api_name = "utc_media_radio_scan_stop_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_scan_stop(NULL,NULL,NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_mute_p(void)
+{
+       char* api_name = "utc_media_radio_set_mute_p";
+       int ret;
+       bool mute = TRUE;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_mute(radio, mute)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_mute_n(void)
+{
+       char* api_name = "utc_media_radio_set_mute_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_mute(NULL,TRUE)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_is_muted_p(void)
+{
+       char* api_name = "utc_media_radio_is_muted_p";
+       int ret;
+       bool mute;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_is_muted(radio,&mute)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_is_muted_n(void)
+{
+       char* api_name = "utc_media_radio_is_muted_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_is_muted(NULL,NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_scan_completed_callback_p(void)
+{
+       char* api_name = "utc_media_radio_set_scan_completed_callback_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_scan_completed_cb(radio, radio_completed_cb, NULL)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_scan_completed_callback_n(void)
+{
+       char* api_name = "utc_media_radio_set_scan_completed_callback_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_scan_completed_cb(radio, NULL, NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_unset_scan_completed_callback_p(void)
+{
+       char* api_name = "utc_media_radio_unset_scan_completed_callback_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_unset_scan_completed_cb(radio)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_unset_scan_completed_callback_n(void)
+{
+       char* api_name = "utc_media_radio_unset_scan_completed_callback_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_unset_scan_completed_cb(NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_interrupted_callback_p(void)
+{
+       char* api_name = "utc_media_radio_set_interrupted_callback_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_interrupted_cb(radio, radio_interrupt_cb, NULL)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_set_interrupted_callback_n(void)
+{
+       char* api_name = "utc_media_radio_set_interrupted_callback_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_set_interrupted_cb(radio, NULL, NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_unset_interrupted_callback_p(void)
+{
+       char* api_name = "utc_media_radio_unset_interrupted_callback_p";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_unset_interrupted_cb(radio)) == RADIO_ERROR_NONE)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+
+static void utc_media_radio_unset_interrupted_callback_n(void)
+{
+       char* api_name = "utc_media_radio_unset_interrupted_callback_n";
+       int ret;
+       if (sRet == RADIO_ERROR_NONE)
+       {
+               if ((ret = radio_unset_interrupted_cb(NULL)) == RADIO_ERROR_INVALID_PARAMETER)
+               {
+                       dts_pass(api_name);
+               }
+       }
+       dts_message(api_name, "Call log: %d %d", sRet, ret);
+       dts_fail(api_name);
+}
+

diff --git a/TC/tet_scen b/TC/tet_scen
new file mode 100755 (executable)
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 100644 (file)
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 100644 (file)
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 100644 (file)
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/debian/changelog b/debian/changelog
index 0c078a9..d7b112c 100644 (file)
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,29 +1,71 @@
+capi-media-radio (0.1.0-9) unstable; urgency=low
+
+  * fix build dependancy
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-9
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Mon, 30 Jul 2012 15:52:08 +0900
+
 capi-media-radio (0.1.0-8) unstable; urgency=low
 
   * Support to get signal strength 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Mon, 19 Mar 2012 17:44:22 +0900
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-8
+ 
+ -- Kangho Hur <kangho.hur@samsung.com>  Thu, 08 Mar 2012 15:49:04 +0900
 
 capi-media-radio (0.1.0-7) unstable; urgency=low
 
-  * Use 'static' to local function which is limited to the current source file. 
+  * Use 'static' to local function which is limited to the current source file.
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-7 
 
- -- Kangho Hur <kangho.hur@samsung.com>  Tue, 21 Feb 2012 10:25:39 +0900
+ -- Kangho Hur <kangho.hur@samsung.com>  Tue, 21 Feb 2012 10:09:32 +0900
 
 capi-media-radio (0.1.0-6) unstable; urgency=low
 
-  * Apply the SOVERSION 
+  * Apply the SOVERSION
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-6
 
- -- Kangho Hur <kangho.hur@samsung.com>  Tue, 14 Feb 2012 18:22:03 +0900
+ -- Kangho Hur <kangho.hur@samsung.com>  Tue, 14 Feb 2012 17:14:04 +0900
 
 capi-media-radio (0.1.0-5) unstable; urgency=low
 
-  * Apply the change of frequency unit 
+  * Apply the change of frequency unit
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-5
 
- -- Kangho Hur <kangho.hur@samsung.com>  Fri, 10 Feb 2012 15:21:06 +0900
+ -- Kangho Hur <kangho.hur@samsung.com>  Mon, 16 Jan 2012 20:24:09 +0900
 
 capi-media-radio (0.1.0-4) unstable; urgency=low
 
-  * Initial release.
+  * Changes the value of ERROR_NONE
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-4 
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Mon, 05 Dec 2011 11:27:59 +0900
+
+capi-media-radio (0.1.0-3) unstable; urgency=low
+
+  * Remove the unneccesary error code
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-3
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Wed, 30 Nov 2011 15:38:16 +0900
+
+capi-media-radio (0.1.0-2) unstable; urgency=low
+
+  * Apply the Tizen
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-2
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Wed, 23 Nov 2011 15:46:33 +0900
+
+capi-media-radio (0.1.0-1) unstable; urgency=low
+
+  * Initial Release
+  * Git: slp-source.sec.samsung.net:slp/api/radio
+  * Tag: capi-media-radio_0.1.0-1
 
- -- Kangho Hur <kangho.hur@samsung.com> Wed, 07 Dec 2011 12:57:07 +0900
+ -- Kangho Hur <kangho.hur@samsung.com>  Wed, 09 Nov 2011 13:50:55 +0900

diff --git a/packaging/capi-media-radio.spec b/packaging/capi-media-radio.spec
index 1d56ff6..cf417a8 100644 (file)
--- a/packaging/capi-media-radio.spec
+++ b/packaging/capi-media-radio.spec
@@ -1,9 +1,10 @@
+#sbs-git:slp/api/radio capi-media-radio 0.1.0 59dddd8ea3de373c44c66ce2a298ca81240305a8
 Name:       capi-media-radio
 Summary:    A Radio library in Tizen Native API
-Version:    0.1.0
-Release:    8
-Group:      TO_BE/FILLED_IN
-License:    Apache-2.0
+Version: 0.1.0
+Release:    9
+Group:      TO_BE_FILLED
+License:    TO_BE_FILLED
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  pkgconfig(dbus-glib-1)
 BuildRequires:  pkgconfig(dlog)