Initial commit for AGL cluster api library

This source code is AGL instrument cluster common API library.
Currently, this source code is missing author information, license and other.
Will be add by author.

Author: Nozomu Abe (nozo_abe@nippon-seiki.co.jp)

Committed by Naoto Yamaguchi.
Signed-off-by: Naoto Yamaguchi <naoto.yamaguchi@aisin.co.jp>

27 files changed, 2364 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ac53bc8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+build*
+cmakeBuild
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..0f4faed
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,36 @@
+project(cluster_api C)
+
+cmake_minimum_required(VERSION 2.8)
+
+set(CLUSTER_API_LIBRARY_VERSION "1.0.0")
+
+# Name of library API
+set(TARGET_NAME cluster_api)
+
+find_package(PkgConfig)
+
+# Build option for DEBUG
+option(DEBUG_BUILD "This is debug build." OFF)
+
+# set gcc flags
+set(CMAKE_C_FLAGS "-Wall -O2")
+
+if(DEBUG_BUILD)
+    add_definitions(-DDEBUG)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g")
+    set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR}/installdir/usr CACHE PATH "..." FORCE)
+endif()
+
+include(GNUInstallDirs)
+
+# Subdirectories
+add_subdirectory(src)
+if(DEBUG_BUILD)
+    add_subdirectory(test/client_test)
+endif()
+
+configure_file(cluster_api.pc.in cluster_api.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cluster_api.pc
+    DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
diff --git a/Readme.md b/Readme.md
new file mode 100644
index 0000000..f83891a
--- /dev/null
+++ b/Readme.md
@@ -0,0 +1,138 @@
+# IC service Cluster API
+
+## Overview
+
+This repository has 3 main elements:
+
+* Cluster API library code: ./src ./include
+* Test app for client: ./test/client_test
+
+## How to build
+
+```bash
+# ipc library is required by cluster_api, so please check ipc library and headers are installed in the system.
+$ ./buildtest.sh
+```
+
+## How to run
+
+* For client_test
+
+```bash
+$ ./buildtest.sh -d
+$ cd cmakeBuild/test/client_test
+$ ./client_test
+
+
+     CUnit - A Unit testing framework for C - Version 2.1-2
+             http://cunit.sourceforge.net/
+
+
+***************** CUNIT CONSOLE - MAIN MENU ******************************
+(R)un  (S)elect  (L)ist  (A)ctivate  (F)ailures  (O)ptions  (H)elp  (Q)uit
+Enter command: ★rを入力すると全テスト自動実行。 ★q入力で終了
+```
+
+# ソース構成
+
+- cluster_api/
+    - include/
+        - 外部公開ヘッダ一式
+    - src/
+        - cluster_apiライブラリ実装ソース
+    - test/
+        - client_test/
+            - Cluster APIテスト環境実装ソース
+
+# 生成物構成
+
+以下、./buildtest.sh を実行した場合の生成物を示す。
+
+- cluster_api/
+    - cmakeBuild/
+        - src/
+            - 以下、Cluster APIのライブラリ
+                ```bash
+                libcluster_api.so -> libcluster_api.so.1
+                libcluster_api.so.1 -> libcluster_api.so.1.0.0
+                libcluster_api.so.1.0.0
+                ```
+        - test/
+            - client_test/
+                - Cluster APIテスト実行ファイル
+                    ```bash
+                    client_test
+                    dummy_server
+                    ```
+
+# Cluster API実装内容
+
+- アプリ向けのI/FとなるAPI関数は IC-Service_API_rev0.4.docx の通りに実装した。
+- 主な実装処理は、IC-Service用サーバから送信されたデータを管理しておき、アプリからAPIが呼ばれたら、管理しているデータから該当データだけを取り出すこと。
+- IC-Service_API_rev0.4.docx に加え、以下の2つのAPIを追加実装した。
+    - bool clusterInit(void)
+        - Cluster APIを使用するための初期化処理。
+        - このAPIによりIC-Service用のサーバと接続するので、サーバが起動済みであることが前提。
+        - 処理成功時をtrueとしたbool値を返す。
+    - bool clusterTerm(void)
+        - Cluster API終了処理。
+        - IC-Service用サーバとの接続を切断するために使用。
+        - 処理成功時をtrueとしたbool値を返す。
+- アプリはcluster_api.hをincludeし、libcluster_api.soとリンクすることで、各種APIを呼び出すことが可能となる。
+
+# client_test テスト内容
+
+Cluster APIの各種APIに対する動作テストを実施する。構成は以下の通り。
+
+- テストは実行ファイルclient_testとdummy_serverの2つで構成される。
+    - client_test : Cluster APIテスト本体
+    - dummy_server : Cluster APIテストに使用する疑似IC-Serviceサーバ
+- テスト実行時はclient_testだけ実行すれば良い。
+- dummy_serverはclient_test内から自動で起動される。
+- dummy_serverの起動待ち、dummy_serverからの送信待ちについては10msecとしている。  
+  (別プロセスで非同期であることから、全く待ちがないと意図通りに動作しない)
+- client_testはCUnitを用いて実装した自動テストプログラムである。CUnitの仕様通り全項目テスト、単体項目テスト、いずれも可能である。
+- ※プロセス間通信のタイミングの関係上、稀にテストがFAILすることがある。  
+(テスト全156項目を20周繰り返して1項目FAILする程度)
+
+実施するテスト項目については以下の通り。
+
+1. InitAndTerm (5項目)
+    - clusterInit()とclusterTerm()が意図通り動作することを確認する。
+        - IC-Service用サーバが存在する状態でclusterInit()とclusterTerm()を順に呼ぶ時の動作を確認する(正常系)
+        - APIの呼び出し順誤りでエラーになることを確認する。
+            - clusterInit()2連続呼び出し。
+            - clusterInit()後、clusterTerm()を2連続呼び出し。
+            - clusterInit()を呼ばずにclusterTerm()を呼び出し。
+        - IC-Service用サーバが存在しない状態でのclusterInit()呼び出しでエラーになることを確認する。
+2. Telltale (52項目)
+    - IC-Service_API_rev0.4.docx の 3-4 Telltale に記載されている各種APIで意図通りの値が取得できることを確認する。
+        - 各API 1パターンずつ実施。
+3. ShiftPosition (2項目)
+    - IC-Service_API_rev0.4.docx の 3-5 ShiftPosition に記載されている各種APIで意図通りの値が取得できることを確認する。
+        - 各API 1パターンずつ実施。
+4. Speed (2項目)
+    - IC-Service_API_rev0.4.docx の 3-6 Speed に記載されている各種APIで意図通りの値が取得できることを確認する。
+        - 各API 1パターンずつ実施。
+5. Tacho (1項目)
+    - IC-Service_API_rev0.4.docx の 3-7 Tacho に記載されている各種APIで意図通りの値が取得できることを確認する。
+        - 各API 1パターンずつ実施。
+6. TripComputer (20項目)
+    - IC-Service_API_rev0.4.docx の 3-8 TripComputer に記載されている各種APIで意図通りの値が取得できることを確認する。
+        - 各API 1パターンずつ実施。
+7. RegisterAndNotify (74項目)
+    - IC-Service_API_rev0.4.docx の 3-9 Register/Notify にある registerIcHmi()の動作が意図通りであることを確認する。
+        - 第1引数 arg_1 に IC_HMI_TT_ALL を指定した時のテスト。
+            - 3-2-1 TellTaleに記載された34種のどのシグナルが変化してもコールバック関数が呼ばれることを確認する。
+            - 3-2-1 TellTaleに記載された34種いずれのシグナルも変化していなければコールバック関数が呼ばれないことを確認する。
+            - 3-2-1 TellTaleに記載された34種のシグナル以外が変化してもコールバック関数が呼ばれないことを確認する。
+        - 第1引数 arg_1 に 0 を指定した場合に、3-2-1 TellTaleに記載された34種のどのシグナルが変化してもコールバック関数が呼ばれないことを確認する。
+        - 第1引数 arg_1 に 3-2-1-1～3-2-1-34 に示されたフラグ以外全てをセットした場合に、3-2-1 TellTaleに記載された34種のどのシグナルが変化してもコールバック関数が呼ばれないことを確認する。
+        - 第2引数 addr にNULLが指定された場合にエラーとなることを確認する。
+        - 第1引数 arg_1 に 3-2-1-1～3-2-1-34 のいずれか1つをセットした値を指定した場合について以下の2つを実施する。
+            - 指定したフラグに該当するシグナルが変化した時だけコールバック関数が呼ばれることを確認する。
+            - 他の33種のシグナルが変化してもコールバック関数が呼ばれないことを確認する。
+        - 第1引数 arg_1 に 3-2-1-1～3-2-1-34 のいずれか1つのフラグだけクリアした値を指定した場合について以下の2つを実施する。
+            - クリアしたフラグに該当するシグナルが変化しても、コールバック関数が呼ばれないことを確認する。
+            - 他の33種のシグナルが変化しても、誤ってクリアしたフラグに関するコールバック通知が行われないことを確認する。  
+            (他のシグナル変化へのコールバック通知は行われること)
diff --git a/cluster_api.pc.in b/cluster_api.pc.in
new file mode 100644
index 0000000..d9bcf80
--- /dev/null
+++ b/cluster_api.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+
+Name: @TARGET_NAME@
+Description: cluster api library using ipc library
+Version: @CLUSTER_API_LIBRARY_VERSION@
+
+Requires: ipc
+Cflags: -I${includedir}
+Libs: -L${libdir} -lcluster_api
\ No newline at end of file
diff --git a/include/cluster_api.h b/include/cluster_api.h
new file mode 100644
index 0000000..792495e
--- /dev/null
+++ b/include/cluster_api.h
@@ -0,0 +1,22 @@
+#ifndef CLUSTER_API_H
+#define CLUSTER_API_H
+
+typedef enum {
+    IC_HMI_OFF = 0,
+    IC_HMI_ON,
+} IC_HMI_ON_OFF;
+
+#include <cluster_api_telltale.h>
+#include <cluster_api_shiftposition.h>
+#include <cluster_api_speed.h>
+#include <cluster_api_tacho.h>
+#include <cluster_api_tripcomputer.h>
+#include <cluster_api_registernotify.h>
+
+bool clusterInit(void);
+bool clusterTerm(void);
+
+// Callback function pointer type
+typedef void (*IC_HMI_FUNC_NOTIFY_IC_HMI)(unsigned long long arg_1, IC_HMI_ON_OFF arg_2);
+
+#endif // CLUSTER_API_H
diff --git a/include/cluster_api_registernotify.h b/include/cluster_api_registernotify.h
new file mode 100644
index 0000000..6f64d8a
--- /dev/null
+++ b/include/cluster_api_registernotify.h
@@ -0,0 +1,10 @@
+#ifndef CLUSTER_API_REGISTERNOTIFY_H
+#define CLUSTER_API_REGISTERNOTIFY_H
+
+#include <stdbool.h>
+
+typedef void(* IC_HMI_FUNC_NOTIFY_IC_HMI)(unsigned long long arg_1, IC_HMI_ON_OFF arg_2);
+
+bool registerIcHmi(unsigned long long arg_1, IC_HMI_FUNC_NOTIFY_IC_HMI addr);
+
+#endif // CLUSTER_API_REGISTERNOTIFY_H
diff --git a/include/cluster_api_shiftposition.h b/include/cluster_api_shiftposition.h
new file mode 100644
index 0000000..88d5671
--- /dev/null
+++ b/include/cluster_api_shiftposition.h
@@ -0,0 +1,37 @@
+#ifndef CLUSTER_API_SHIFTPOSITION_H
+#define CLUSTER_API_SHIFTPOSITION_H
+
+typedef enum
+{
+    IC_HMI_AT_OFF = 0,
+    IC_HMI_AT_PARKING,
+    IC_HMI_AT_REVERSE,
+    IC_HMI_AT_NEUTRAL,
+    IC_HMI_AT_DRIVE,
+    IC_HMI_AT_SECOND,
+    IC_HMI_AT_LOW_GEAR,
+    IC_HMI_AT_FIRST,
+    IC_HMI_AT_MANUAL,
+    IC_HMI_AT_BRAKE,
+    IC_HMI_AT_ALL_ON,
+    IC_HMI_AT_ALL_OFF,
+    IC_HMI_AT_UNUSED,
+} IC_HMI_GEAR_AT_VAL;
+
+typedef enum
+{
+    IC_HMI_MT_OFF = 0,
+    IC_HMI_MT_FIRST,
+    IC_HMI_MT_SECOND,
+    IC_HMI_MT_THIRD,
+    IC_HMI_MT_FOURTH,
+    IC_HMI_MT_FIFTH,
+    IC_HMI_MT_SIXTH,
+    IC_HMI_MT_SEVENTH,
+    IC_HMI_MT_EIGHTTH,
+} IC_HMI_GEAR_MT_VAL;
+
+IC_HMI_GEAR_AT_VAL getGearAtVal(void);
+IC_HMI_GEAR_MT_VAL getGearMtVal(void);
+
+#endif // CLUSTER_API_SHIFTPOSITION_H
diff --git a/include/cluster_api_speed.h b/include/cluster_api_speed.h
new file mode 100644
index 0000000..164db9d
--- /dev/null
+++ b/include/cluster_api_speed.h
@@ -0,0 +1,13 @@
+#ifndef CLUSTER_API_SPEED_H
+#define CLUSTER_API_SPEED_H
+
+typedef enum
+{
+    IC_HMI_SP_KM_H = 0,
+    IC_HMI_SP_MPH = 1,
+} IC_HMI_SP_UNIT_VAL;
+
+unsigned long getSpAnalogVal(void);
+IC_HMI_SP_UNIT_VAL getSpAnaDigUnitVal(void);
+
+#endif // CLUSTER_API_SPEED_H
diff --git a/include/cluster_api_tacho.h b/include/cluster_api_tacho.h
new file mode 100644
index 0000000..38d2ddd
--- /dev/null
+++ b/include/cluster_api_tacho.h
@@ -0,0 +1,6 @@
+#ifndef CLUSTER_API_TACHO_H
+#define CLUSTER_API_TACHO_H
+
+unsigned long getTaAnalogVal(void);
+
+#endif // CLUSTER_API_TACHO_H
\ No newline at end of file
diff --git a/include/cluster_api_telltale.h b/include/cluster_api_telltale.h
new file mode 100644
index 0000000..17d69d2
--- /dev/null
+++ b/include/cluster_api_telltale.h
@@ -0,0 +1,94 @@
+#ifndef CLUSTER_API_TELLTALE_H
+#define CLUSTER_API_TELLTALE_H
+
+// Signal flags
+#define IC_HMI_TT_TURN_R                0x0000000000000001ULL
+#define IC_HMI_TT_TURN_L                0x0000000000000002ULL
+#define IC_HMI_TT_BRAKE                 0x0000000000000004ULL
+#define IC_HMI_TT_SEATBELT              0x0000000000000008ULL
+#define IC_HMI_TT_HIGHBEAM              0x0000000000000010ULL
+#define IC_HMI_TT_DOOR                  0x0000000000000020ULL
+#define IC_HMI_TT_EPS                   0x0000000000000040ULL
+#define IC_HMI_TT_SRS_AIRBAG            0x0000000000000080ULL
+#define IC_HMI_TT_ABS                   0x0000000000000100ULL
+#define IC_HMI_TT_LOW_BATTERY           0x0000000000000200ULL
+#define IC_HMI_TT_OIL_PRESS             0x0000000000000400ULL
+#define IC_HMI_TT_ENGINE                0x0000000000000800ULL
+#define IC_HMI_TT_FUEL                  0x0000000000001000ULL
+#define IC_HMI_TT_IMMOBI                0x0000000000002000ULL
+#define IC_HMI_TT_TM_FAIL               0x0000000000004000ULL
+#define IC_HMI_TT_ESP_ACT               0x0000000000008000ULL
+#define IC_HMI_TT_ESP_OFF               0x0000000000010000ULL
+#define IC_HMI_TT_ADAPTING_LIGHTING     0x0000000000020000ULL
+#define IC_HMI_TT_AUTO_STOP             0x0000000000040000ULL
+#define IC_HMI_TT_AUTO_STOP_FAIL        0x0000000000080000ULL
+#define IC_HMI_TT_PARKING_LIGHTS        0x0000000000100000ULL
+#define IC_HMI_TT_FRONT_FOG             0x0000000000200000ULL
+#define IC_HMI_TT_EXTERIOR_LIGHT_FAULT  0x0000000000400000ULL
+#define IC_HMI_TT_ACC_FAIL              0x0000000000800000ULL
+#define IC_HMI_TT_LDW_OFF               0x0000000001000000ULL
+#define IC_HMI_TT_HILL_DESCENT          0x0000000002000000ULL
+#define IC_HMI_TT_AUTO_HI_BEAM_GREEN    0x0000000004000000ULL
+#define IC_HMI_TT_AUTO_HI_BEAM_AMBER    0x0000000008000000ULL
+#define IC_HMI_TT_LDW_OPERATE           0x0000000010000000ULL
+#define IC_HMI_TT_GENERAL_WARN          0x0000000020000000ULL
+#define IC_HMI_TT_SPORTS_MODE           0x0000000040000000ULL
+#define IC_HMI_TT_DRIVING_POWER_MODE    0x0000000080000000ULL
+#define IC_HMI_TT_HOT_TEMP              0x0000000100000000ULL
+#define IC_HMI_TT_LOW_TEMP              0x0000000200000000ULL
+#define IC_HMI_TT_ALL                   0xFFFFFFFFFFFFFFFFULL
+
+IC_HMI_ON_OFF getTurnR(void);
+IC_HMI_ON_OFF getTurnL(void);
+IC_HMI_ON_OFF getBrake(void);
+IC_HMI_ON_OFF getSeatbelt(void);
+IC_HMI_ON_OFF getFrontRightSeatbelt(void);
+IC_HMI_ON_OFF getFrontCenterSeatbelt(void);
+IC_HMI_ON_OFF getFrontLeftSeatbelt(void);
+IC_HMI_ON_OFF getMid1RightSeatbelt(void);
+IC_HMI_ON_OFF getMid1CenterSeatbelt(void);
+IC_HMI_ON_OFF getMid1LeftSeatbelt(void);
+IC_HMI_ON_OFF getMid2RightSeatbelt(void);
+IC_HMI_ON_OFF getMid2CenterSeatbelt(void);
+IC_HMI_ON_OFF getMid2LeftSeatbelt(void);
+IC_HMI_ON_OFF getRearRightSeatbelt(void);
+IC_HMI_ON_OFF getRearCenterSeatbelt(void);
+IC_HMI_ON_OFF getRearLeftSeatbelt(void);
+IC_HMI_ON_OFF getHighbeam(void);
+IC_HMI_ON_OFF getDoor(void);
+IC_HMI_ON_OFF getFrontRightDoor(void);
+IC_HMI_ON_OFF getFrontLeftDoor(void);
+IC_HMI_ON_OFF getRearRightDoor(void);
+IC_HMI_ON_OFF getRearLeftDoor(void);
+IC_HMI_ON_OFF getTrunkDoor(void);
+IC_HMI_ON_OFF getHoodDoor(void);
+IC_HMI_ON_OFF getEps(void);
+IC_HMI_ON_OFF getSrsAirbag(void);
+IC_HMI_ON_OFF getAbs(void);
+IC_HMI_ON_OFF getLowBattery(void);
+IC_HMI_ON_OFF getOilPress(void);
+IC_HMI_ON_OFF getEngine(void);
+IC_HMI_ON_OFF getFuel(void);
+IC_HMI_ON_OFF getImmobi(void);
+IC_HMI_ON_OFF getTMFail(void);
+IC_HMI_ON_OFF getEspAct(void);
+IC_HMI_ON_OFF getEspOff(void);
+IC_HMI_ON_OFF getAdaptingLighting(void);
+IC_HMI_ON_OFF getAutoStop(void);
+IC_HMI_ON_OFF getAutoStopFail(void);
+IC_HMI_ON_OFF getParkingLights(void);
+IC_HMI_ON_OFF getFrontFog(void);
+IC_HMI_ON_OFF getExteriorLightFault(void);
+IC_HMI_ON_OFF getAccFail(void);
+IC_HMI_ON_OFF getLdwOff(void);
+IC_HMI_ON_OFF getHillDescent(void);
+IC_HMI_ON_OFF getAutoHiBeamGreen(void);
+IC_HMI_ON_OFF getAutoHiBeamAmber(void);
+IC_HMI_ON_OFF getSportsMode(void);
+IC_HMI_ON_OFF getLdwOperate(void);
+IC_HMI_ON_OFF getGeneralWarn(void);
+IC_HMI_ON_OFF getDriverPowerMode(void);
+IC_HMI_ON_OFF getHotTemp(void);
+IC_HMI_ON_OFF getLowTemp(void);
+
+#endif // CLUSTER_API_TELLTALE_H
diff --git a/include/cluster_api_tripcomputer.h b/include/cluster_api_tripcomputer.h
new file mode 100644
index 0000000..7f79d39
--- /dev/null
+++ b/include/cluster_api_tripcomputer.h
@@ -0,0 +1,50 @@
+#ifndef CLUSTER_API_TRIPCOMPUTER_H
+#define CLUSTER_API_TRIPCOMPUTER_H
+
+typedef enum
+{
+    IC_HMI_TRCOM_KM = 0,
+    IC_HMI_TRCOM_MILE = 1,
+} IC_HMI_TRCOM_UNIT_VAL;
+
+typedef enum
+{
+    IC_HMI_FUEL_KM_L = 0,
+    IC_HMI_FUEL_MPG_US,
+    IC_HMI_FUEL_MPG_IG,
+    IC_HMI_FUEL_L_100KM,
+    IC_HMI_FUEL_MILE_KWH,
+    IC_HMI_FUEL_KM_KWH,
+    IC_HMI_FUEL_MILE_KG,
+    IC_HMI_FUEL_KM_KG,
+    IC_HMI_FUEL_KWH_100KM,
+} IC_HMI_FUEL_ECONOMY_UNIT_VAL;
+
+typedef enum
+{
+    IC_HMI_OTEMP_UNIT_C = 0,
+    IC_HMI_OTEMP_UNIT_K = 1,
+} IC_HMI_OTEMP_UNIT_VAL;
+
+unsigned long getTrcomTripAVal(void);
+unsigned long getTrcomTripBVal(void);
+unsigned long getTrcomOdoVal(void);
+IC_HMI_TRCOM_UNIT_VAL getTrcomUnitVal(void);
+unsigned short getAvgSpeedAVal(void);
+unsigned short getAvgSpeedBVal(void);
+unsigned short getHourAVal(void);
+unsigned short getHourBVal(void);
+unsigned char getMinuteAVal(void);
+unsigned char getMinuteBVal(void);
+unsigned char getSecondAVal(void);
+unsigned char getSecondBVal(void);
+signed short getOTempVal(void);
+IC_HMI_OTEMP_UNIT_VAL getOTempUnitVal(void);
+unsigned short getCruRangeVal(void);
+unsigned short getAvgFuelAVal(void);
+unsigned short getAvgFuelBVal(void);
+unsigned short getInsFuelAVal(void);
+unsigned short getInsFuelBVal(void);
+IC_HMI_FUEL_ECONOMY_UNIT_VAL getFuelEconomyUnitVal(void);
+
+#endif // CLUSTER_API_TRIPCOMPUTER_H
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..f6bbca1
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,46 @@
+
+# Define project Targets
+add_library(${TARGET_NAME} SHARED
+    cluster_api.c
+)
+
+pkg_check_modules(IPC REQUIRED ipc)
+
+# Include directories
+target_include_directories(${TARGET_NAME} PRIVATE
+    ./
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+    $<BUILD_INTERFACE:${IPC_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:/include>
+)
+
+# find thread library
+find_package(Threads REQUIRED)
+target_link_libraries(${TARGET_NAME} INTERFACE
+    Threads::Threads
+    ${IPC_LIBRARIES})
+
+set_target_properties(${TARGET_NAME}
+    PROPERTIES
+    VERSION ${CLUSTER_API_LIBRARY_VERSION}
+    SOVERSION 1
+)
+
+set(CLUSTER_API_HEADERS
+    ../include/cluster_api.h ../include/cluster_api_registernotify.h
+    ../include/cluster_api_shiftposition.h
+    ../include/cluster_api_speed.h
+    ../include/cluster_api_tacho.h
+    ../include/cluster_api_telltale.h
+    ../include/cluster_api_tripcomputer.h
+    )
+
+# make install
+install(
+    TARGETS ${TARGET_NAME}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}
+)
+
+install (
+    FILES ${CLUSTER_API_HEADERS} DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR}
+)
\ No newline at end of file
diff --git a/src/cluster_api.c b/src/cluster_api.c
new file mode 100644
index 0000000..095a416
--- /dev/null
+++ b/src/cluster_api.c
@@ -0,0 +1,605 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <ipc.h>
+
+#include <cluster_api.h>
+#include <cluster_api_internal.h>
+
+static IPC_DATA_IC_SERVICE_S gAllSigData;
+static unsigned long long gRegisteredSignals = 0x0000000000000000ULL;
+static IC_HMI_FUNC_NOTIFY_IC_HMI gNotifyIcHmiCB;
+
+static IPC_RET_E clusterClientStart(void);
+static IPC_RET_E clusterReadDataPool(void);
+static IPC_RET_E clusterRegisterCallback(void);
+static IPC_RET_E clusterClientStop(void);
+static void notifyCheck(void* pData, signed int size, int kind);
+
+// == Internal functions ==
+static IPC_RET_E clusterClientStart(void)
+{
+    IPC_RET_E ret;
+
+    ret = ipcClientStart(IPC_USAGE_TYPE_IC_SERVICE);
+    E_CHECK(ret == IPC_RET_OK, ret, end);
+
+end:
+    return ret;
+}
+
+static IPC_RET_E clusterRegisterCallback(void)
+{
+    IPC_RET_E ret;
+
+    ret = ipcRegisterCallback(IPC_USAGE_TYPE_IC_SERVICE, &notifyCheck);
+    E_CHECK(ret == IPC_RET_OK, ret, end);
+
+end:
+    return ret;
+}
+
+static void notifyCheck(void* pData, signed int size, int kind)
+{
+    IC_HMI_ON_OFF data = 0;
+
+    if (gNotifyIcHmiCB == NULL) {
+        return;
+    }
+
+    // If signal is registered, notify IC HMI
+    if (gSigTable[kind] == (gSigTable[kind] & gRegisteredSignals))
+    {
+        memcpy(&data, pData, size);
+        gNotifyIcHmiCB(gSigTable[kind], data);
+    }
+}
+
+static IPC_RET_E clusterClientStop(void)
+{
+    IPC_RET_E ret;
+
+    ret = ipcClientStop(IPC_USAGE_TYPE_IC_SERVICE);
+    E_CHECK(ret == IPC_RET_OK, ret, end);
+
+  end:
+    return ret;
+}
+
+static IPC_RET_E clusterReadDataPool()
+{
+    IPC_RET_E ret;
+    int sigDataSize = sizeof(gAllSigData);
+
+    ret = ipcReadDataPool(IPC_USAGE_TYPE_IC_SERVICE, &gAllSigData, &sigDataSize);
+    E_CHECK(ret == IPC_RET_OK, ret, end);
+    E_CHECK(sigDataSize == sizeof(gAllSigData), sigDataSize, end);
+
+    ret = IPC_RET_OK;
+
+end:
+    return ret;
+}
+
+// == API functions for apps ==
+// === Initialize/Terminate ===
+bool clusterInit(void)
+{
+    bool ret = false;
+    IPC_RET_E rc;
+
+    memset(&gAllSigData, 0x00, sizeof(gAllSigData));
+    gRegisteredSignals = 0x0000000000000000ULL;
+    gNotifyIcHmiCB = NULL;
+
+    rc = clusterClientStart();
+    E_CHECK(rc == IPC_RET_OK, rc, end);
+
+    rc = clusterRegisterCallback();
+    E_CHECK(rc == IPC_RET_OK, rc, end);
+
+    ret = true;
+end:
+    return ret;
+}
+
+bool clusterTerm(void)
+{
+    bool ret = false;
+    IPC_RET_E rc;
+
+    rc = clusterClientStop();
+    E_CHECK(rc == IPC_RET_OK, rc, end);
+
+    memset(&gAllSigData, 0x00, sizeof(gAllSigData));
+    gRegisteredSignals = 0x0000000000000000ULL;
+    gNotifyIcHmiCB = NULL;
+
+    ret = true;
+end:
+    return ret;
+}
+
+// === Register/Notify ===
+bool registerIcHmi(unsigned long long arg_1, IC_HMI_FUNC_NOTIFY_IC_HMI addr)
+{
+    if (addr == NULL) {
+        return false;
+    }
+
+    gNotifyIcHmiCB = addr;
+    gRegisteredSignals = (gRegisteredSignals | arg_1);
+
+    return true;
+}
+
+
+// === Telltale ===
+IC_HMI_ON_OFF getTurnR(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.turnR;
+}
+
+IC_HMI_ON_OFF getTurnL(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.turnL;
+}
+
+IC_HMI_ON_OFF getBrake(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.brake;
+}
+
+IC_HMI_ON_OFF getSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.seatbelt;
+}
+
+IC_HMI_ON_OFF getFrontRightSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontRightSeatbelt;
+}
+
+IC_HMI_ON_OFF getFrontCenterSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontCenterSeatbelt;
+}
+
+IC_HMI_ON_OFF getFrontLeftSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontLeftSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid1RightSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid1RightSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid1CenterSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid1CenterSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid1LeftSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid1LeftSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid2RightSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid2RightSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid2CenterSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid2CenterSeatbelt;
+}
+
+IC_HMI_ON_OFF getMid2LeftSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.mid2LeftSeatbelt;
+}
+
+IC_HMI_ON_OFF getRearRightSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.rearRightSeatbelt;
+}
+
+IC_HMI_ON_OFF getRearCenterSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.rearCenterSeatbelt;
+}
+
+IC_HMI_ON_OFF getRearLeftSeatbelt(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.rearLeftSeatbelt;
+}
+
+IC_HMI_ON_OFF getHighbeam(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.highbeam;
+}
+
+IC_HMI_ON_OFF getDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.door;
+}
+
+IC_HMI_ON_OFF getFrontRightDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontRightDoor;
+}
+
+IC_HMI_ON_OFF getFrontLeftDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontLeftDoor;
+}
+
+IC_HMI_ON_OFF getRearRightDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.rearRightDoor;
+}
+
+IC_HMI_ON_OFF getRearLeftDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.rearLeftDoor;
+}
+
+IC_HMI_ON_OFF getTrunkDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.trunkDoor;
+}
+
+IC_HMI_ON_OFF getHoodDoor(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.hoodDoor;
+}
+
+IC_HMI_ON_OFF getEps(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.eps;
+}
+
+IC_HMI_ON_OFF getSrsAirbag(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.srsAirbag;
+}
+
+IC_HMI_ON_OFF getAbs(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.abs;
+}
+
+IC_HMI_ON_OFF getLowBattery(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.lowBattery;
+}
+
+IC_HMI_ON_OFF getOilPress(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.oilPress;
+}
+
+IC_HMI_ON_OFF getEngine(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.engine;
+}
+
+IC_HMI_ON_OFF getFuel(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.fuel;
+}
+
+IC_HMI_ON_OFF getImmobi(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.immobi;
+}
+
+IC_HMI_ON_OFF getTMFail(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.tmFail;
+}
+
+IC_HMI_ON_OFF getEspAct(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.espAct;
+}
+
+IC_HMI_ON_OFF getEspOff(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.espOff;
+}
+
+IC_HMI_ON_OFF getAdaptingLighting(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.adaptingLighting;
+}
+
+IC_HMI_ON_OFF getAutoStop(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.autoStop;
+}
+
+IC_HMI_ON_OFF getAutoStopFail(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.autoStopFail;
+}
+
+IC_HMI_ON_OFF getParkingLights(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.parkingLights;
+}
+
+IC_HMI_ON_OFF getFrontFog(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.frontFog;
+}
+
+IC_HMI_ON_OFF getExteriorLightFault(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.exteriorLightFault;
+}
+
+IC_HMI_ON_OFF getAccFail(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.accFail;
+}
+
+IC_HMI_ON_OFF getLdwOff(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.ldwOff;
+}
+
+IC_HMI_ON_OFF getHillDescent(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.hillDescent;
+}
+
+IC_HMI_ON_OFF getAutoHiBeamGreen(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.autoHiBeamGreen;
+}
+
+IC_HMI_ON_OFF getAutoHiBeamAmber(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.autoHiBeamAmber;
+}
+
+IC_HMI_ON_OFF getSportsMode(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.sportsMode;
+}
+
+IC_HMI_ON_OFF getLdwOperate(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.ldwOperate;
+}
+
+IC_HMI_ON_OFF getGeneralWarn(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.generalWarn;
+}
+
+IC_HMI_ON_OFF getDriverPowerMode(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.drivingPowerMode;
+}
+
+IC_HMI_ON_OFF getHotTemp(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.hotTemp;
+}
+
+IC_HMI_ON_OFF getLowTemp(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.lowTemp;
+}
+
+// === TripComputer ===
+unsigned long getTrcomTripAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.trcomTripAVal;
+}
+
+unsigned long getTrcomTripBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.trcomTripBVal;
+}
+
+unsigned long getTrcomOdoVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.trcomOdoVal;
+}
+
+IC_HMI_TRCOM_UNIT_VAL getTrcomUnitVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.trcomUnitVal;
+}
+
+unsigned short getAvgSpeedAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.avgSpeedAVal;
+}
+
+unsigned short getAvgSpeedBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.avgSpeedBVal;
+}
+
+unsigned short getHourAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.hourAVal;
+}
+
+unsigned short getHourBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.hourBVal;
+}
+
+unsigned char getMinuteAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.minuteAVal;
+}
+
+unsigned char getMinuteBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.minuteBVal;
+}
+
+unsigned char getSecondAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.secondAVal;
+}
+
+unsigned char getSecondBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.secondBVal;
+}
+
+signed short getOTempVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.oTempVal;
+}
+
+IC_HMI_OTEMP_UNIT_VAL getOTempUnitVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.oTempUnitVal;
+}
+
+unsigned short getCruRangeVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.cruRangeVal;
+}
+
+unsigned short getAvgFuelAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.avgFuelAVal;
+}
+
+unsigned short getAvgFuelBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.avgFuelBVal;
+}
+
+unsigned short getInsFuelAVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.insFuelAVal;
+}
+
+unsigned short getInsFuelBVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.insFuelBVal;
+}
+
+IC_HMI_FUEL_ECONOMY_UNIT_VAL getFuelEconomyUnitVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.fuelEconomyUnitVal;
+}
+
+// === ShiftPosition ===
+IC_HMI_GEAR_AT_VAL getGearAtVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.gearAtVal;
+}
+
+IC_HMI_GEAR_MT_VAL getGearMtVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.gearMtVal;
+}
+
+// === Speed ===
+unsigned long getSpAnalogVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.spAnalogVal;
+}
+
+IC_HMI_SP_UNIT_VAL getSpAnaDigUnitVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.spAnaDigUnitVal;
+}
+
+// === Tacho ===
+unsigned long getTaAnalogVal(void)
+{
+    clusterReadDataPool();
+    return gAllSigData.taAnalogVal;
+}
+
diff --git a/src/cluster_api_internal.h b/src/cluster_api_internal.h
new file mode 100644
index 0000000..da7a3c1
--- /dev/null
+++ b/src/cluster_api_internal.h
@@ -0,0 +1,50 @@
+#ifndef CLUSTER_API_INTERNAL_H
+#define CLUSTER_API_INTERNAL_H
+
+#define E_CHECK(condition, value, label) \
+    do { \
+        if (!(condition)) { \
+            printf("%s:%d ERROR:%s %s:%d\n", __func__, __LINE__, #condition, #value, (int)value); \
+            goto label; \
+        } \
+    } while(0)
+
+// Table with signal bits (defined to fit IPC_KIND_IC_SERVICE_E from ipc_protocol.h)
+const unsigned long long gSigTable[] = {
+    IC_HMI_TT_TURN_R,
+    IC_HMI_TT_TURN_L,
+    IC_HMI_TT_BRAKE,
+    IC_HMI_TT_SEATBELT,
+    IC_HMI_TT_HIGHBEAM,
+    IC_HMI_TT_DOOR,
+    IC_HMI_TT_EPS,
+    IC_HMI_TT_SRS_AIRBAG,
+    IC_HMI_TT_ABS,
+    IC_HMI_TT_LOW_BATTERY,
+    IC_HMI_TT_OIL_PRESS,
+    IC_HMI_TT_ENGINE,
+    IC_HMI_TT_FUEL,
+    IC_HMI_TT_IMMOBI,
+    IC_HMI_TT_TM_FAIL,
+    IC_HMI_TT_ESP_ACT,
+    IC_HMI_TT_ESP_OFF,
+    IC_HMI_TT_ADAPTING_LIGHTING,
+    IC_HMI_TT_AUTO_STOP,
+    IC_HMI_TT_AUTO_STOP_FAIL,
+    IC_HMI_TT_PARKING_LIGHTS,
+    IC_HMI_TT_FRONT_FOG,
+    IC_HMI_TT_EXTERIOR_LIGHT_FAULT,
+    IC_HMI_TT_ACC_FAIL,
+    IC_HMI_TT_LDW_OFF,
+    IC_HMI_TT_HILL_DESCENT,
+    IC_HMI_TT_AUTO_HI_BEAM_GREEN,
+    IC_HMI_TT_AUTO_HI_BEAM_AMBER,
+    IC_HMI_TT_LDW_OPERATE,
+    IC_HMI_TT_GENERAL_WARN,
+    IC_HMI_TT_SPORTS_MODE,
+    IC_HMI_TT_DRIVING_POWER_MODE,
+    IC_HMI_TT_HOT_TEMP,
+    IC_HMI_TT_LOW_TEMP
+};
+
+#endif // CLUSTER_API_INTERNAL_H
diff --git a/test/client_test/CMakeLists.txt b/test/client_test/CMakeLists.txt
new file mode 100644
index 0000000..940326b
--- /dev/null
+++ b/test/client_test/CMakeLists.txt
@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 2.8)
+
+pkg_check_modules(IPC REQUIRED ipc)
+
+# use the variable <RESULTNAME>_INCLUDE_DIRS to get include paths
+include_directories(
+    ${IPC_INCLUDE_DIRS}
+    ../../include
+    )
+
+# Define project Targets
+set(CLIENT_TEST_BINARY_NAME client_test)
+add_executable(${CLIENT_TEST_BINARY_NAME}
+    client_main.c
+    client_test_common.c
+    client_test_init_term.c
+    client_test_telltale.c
+    client_test_shiftposition.c
+    client_test_speed.c
+    client_test_tacho.c
+    client_test_tripcomputer.c
+    client_test_register_notify.c
+    )
+
+# use the variable <RESULTNAME>_LIBRARIES to get library paths
+target_link_libraries(${CLIENT_TEST_BINARY_NAME}
+    ${IPC_LIBRARIES}
+    ${TARGET_NAME}
+    pthread
+    cunit
+    )
+
+# Define project Targets
+set(DUMMY_SERVER_BINARY_NAME dummy_server)
+add_executable(${DUMMY_SERVER_BINARY_NAME} dummy_server.c)
+
+target_link_libraries(${DUMMY_SERVER_BINARY_NAME}
+    ${IPC_LIBRARIES}
+    pthread
+    )
+
diff --git a/test/client_test/client_main.c b/test/client_test/client_main.c
new file mode 100644
index 0000000..aca9d55
--- /dev/null
+++ b/test/client_test/client_main.c
@@ -0,0 +1,47 @@
+// Test program for IC-service IPC inplementation
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <CUnit/CUnit.h>
+#include <CUnit/Console.h>
+
+#include <ipc.h>
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+#include "client_test_suites.h"
+
+int main(int argc, char *argv[])
+{
+    pid_t child;
+
+    setenv(IPC_ENV_DOMAIN_SOCKET_PATH, IPC_TEST_DOMAIN_PATH, 1);
+
+    setExeFilePath(argv[0]);
+    if ((child = fork()) < 0) {
+        fprintf(stderr, "client_main:%d Failed to fork() : %d\n", __LINE__, child);
+        exit(EXIT_FAILURE);
+    }
+
+    startDummyServer(child);
+    connectToDummyServer();
+
+    CU_initialize_registry();
+
+    SetTestSuiteInitAndTerm();
+    SetTestSuiteTelltale();
+    SetTestSuiteShiftPosition();
+    SetTestSuiteSpeed();
+    SetTestSuiteTacho();
+    SetTestSuiteTripComputer();
+    SetTestSuiteRegisterAndNotify();
+
+    CU_console_run_tests();
+
+    CU_cleanup_registry();
+
+    stopDummyServer();
+
+    return 0;
+}
diff --git a/test/client_test/client_test_common.c b/test/client_test/client_test_common.c
new file mode 100644
index 0000000..5b71630
--- /dev/null
+++ b/test/client_test/client_test_common.c
@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define CLUSTER_TEST_WAIT_TIME (10000)
+
+static int g_dummyServerFd = -1;
+static char g_dummyServerExeFilePath[256];
+
+void setExeFilePath(const char *exeFilePath)
+{
+    char *pCh;
+
+    // dummy_server in the same path as client_test.
+    strcpy(g_dummyServerExeFilePath, exeFilePath);
+    pCh = strrchr(g_dummyServerExeFilePath, '/');
+    pCh = pCh != NULL ? pCh + 1: g_dummyServerExeFilePath;
+    strcpy(pCh, "dummy_server");
+}
+
+void startDummyServer(pid_t child)
+{
+    if (child == 0) {
+        int rc;
+        char *argv[2] = {NULL, NULL};
+
+        argv[0] = g_dummyServerExeFilePath;
+
+        rc = execv(argv[0], argv);
+        if (rc < 0) {
+            ERRNO_LOG(execv);
+        }
+    }
+    else {
+        usleep(CLUSTER_TEST_WAIT_TIME);
+    }
+}
+
+void stopDummyServer(void)
+{
+    if (g_dummyServerFd >= 0) {
+        shutdown(g_dummyServerFd, SHUT_RDWR);
+        close(g_dummyServerFd);
+    }
+    unlink(CLUSTER_TEST_SENDDATA_FILE);
+    sleep(1);
+}
+
+void connectToDummyServer(void)
+{
+    int rc;
+    int fd;
+    struct sockaddr_un unixAddr;
+    int len;
+
+    fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd < 0) {
+        ERRNO_LOG(socket);
+        return;
+    }
+    unixAddr.sun_family = AF_UNIX;
+    strcpy(unixAddr.sun_path, CLUSTER_TEST_DOMAIN_PATH);
+    len = sizeof(unixAddr.sun_family)+strlen(unixAddr.sun_path);
+    rc = connect(fd, (struct sockaddr *)&unixAddr, len);
+    if (rc != 0) {
+        ERRNO_LOG(connect);
+        shutdown(fd, SHUT_RDWR);
+        close(fd);
+        return;
+    }
+
+    g_dummyServerFd = fd;
+}
+
+void requestSendData(IPC_DATA_IC_SERVICE_S *pSendData)
+{
+    FILE *fp = NULL;
+    int dummy = 1;
+    int size;
+
+    fp = fopen(CLUSTER_TEST_SENDDATA_FILE, "wb");
+    if (fp != NULL) {
+        size = fwrite(pSendData, 1, sizeof(IPC_DATA_IC_SERVICE_S), fp);
+        if (size < sizeof(IPC_DATA_IC_SERVICE_S)) {
+            ERRNO_LOG(fwrite);
+        }
+        fclose(fp);
+
+        size = write(g_dummyServerFd, &dummy, sizeof(dummy));
+        if (size < 0) {
+            ERRNO_LOG(write);
+        }
+        usleep(CLUSTER_TEST_WAIT_TIME);
+    }
+}
+
diff --git a/test/client_test/client_test_common.h b/test/client_test/client_test_common.h
new file mode 100644
index 0000000..36a990f
--- /dev/null
+++ b/test/client_test/client_test_common.h
@@ -0,0 +1,24 @@
+#ifndef CLIENT_TEST_COMMON_H
+#define CLIENT_TEST_COMMON_H
+
+#include <unistd.h>
+#include <ipc.h>
+
+#define IPC_TEST_DOMAIN_PATH "./"
+
+#define CLUSTER_TEST_DOMAIN_PATH "cluster_test_domain"
+#define CLUSTER_TEST_SENDDATA_FILE "cluster_test.dat"
+
+#define ERRNO_LOG(func) \
+  do { \
+      perror(#func "()"); \
+      fprintf(stderr, "%s:%d Failed to %s()\n", __FILE__, __LINE__, #func); \
+  }while(0)
+
+void setExeFilePath(const char *exeFilePath);
+void startDummyServer(pid_t child);
+void stopDummyServer(void);
+void connectToDummyServer(void);
+void requestSendData(IPC_DATA_IC_SERVICE_S *pSendData);
+
+#endif // CLIENT_TEST_COMMON_H
diff --git a/test/client_test/client_test_init_term.c b/test/client_test/client_test_init_term.c
new file mode 100644
index 0000000..00f2f13
--- /dev/null
+++ b/test/client_test/client_test_init_term.c
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+// OK case. Calling the APIs of Init and Term while the server is already started.
+static void TestInitAndTermOK(void)
+{
+    CU_ASSERT(clusterInit() == true);
+    CU_ASSERT(clusterTerm() == true);
+}
+
+// NG case. Call the API of Init function twice.
+static void TestInitAndTermNG1(void)
+{
+    CU_ASSERT(clusterInit() == true);
+    CU_ASSERT(clusterInit() == false);
+    CU_ASSERT(clusterTerm() == true);
+}
+
+// NG case. Call the API of Term function twice.
+static void TestInitAndTermNG2(void)
+{
+    CU_ASSERT(clusterInit() == true);
+    CU_ASSERT(clusterTerm() == true);
+    CU_ASSERT(clusterTerm() == false);
+}
+
+// NG case. Call the API of Term only.
+static void TestInitAndTermNG3(void)
+{
+    CU_ASSERT(clusterTerm() == false);
+}
+
+// NG case. Server is not ready.
+static void TestInitAndTermNG4(void)
+{
+    pid_t child;
+
+    stopDummyServer();
+    CU_ASSERT(clusterInit() == false);
+    CU_ASSERT(clusterTerm() == false);
+
+    if ((child = fork()) < 0) {
+        fprintf(stderr, "%s:%d Failed to fork() : %d\n", __FILE__, __LINE__, child);
+        exit(EXIT_FAILURE);
+    }
+
+    startDummyServer(child);
+    connectToDummyServer();
+}
+
+void SetTestSuiteInitAndTerm(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("InitAndTerm", NULL, NULL);
+    CU_add_test(testSuite, "InitAndTerm_OK", TestInitAndTermOK);
+    CU_add_test(testSuite, "InitAndTerm_NG_1", TestInitAndTermNG1);
+    CU_add_test(testSuite, "InitAndTerm_NG_2", TestInitAndTermNG2);
+    CU_add_test(testSuite, "InitAndTerm_NG_3", TestInitAndTermNG3);
+    CU_add_test(testSuite, "InitAndTerm_NG_4", TestInitAndTermNG4);
+}
+
diff --git a/test/client_test/client_test_register_notify.c b/test/client_test/client_test_register_notify.c
new file mode 100644
index 0000000..2458e73
--- /dev/null
+++ b/test/client_test/client_test_register_notify.c
@@ -0,0 +1,480 @@
+#include <string.h>
+#include <stdbool.h>
+
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+typedef struct {
+    IC_HMI_ON_OFF value;
+    bool isCallbacked;
+    const unsigned long long flag;
+    const char *name;
+} CLUSTER_TEST_CB_STORE_TABLE_S;
+
+#define CLUSTER_TEST_DECLARE_STORE_UNIT(flag) \
+    {IC_HMI_OFF, false, flag, #flag}
+
+static CLUSTER_TEST_CB_STORE_TABLE_S g_cbStoreTable[] = {
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_TURN_R),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_TURN_L),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_BRAKE),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_SEATBELT),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_HIGHBEAM),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_DOOR),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_EPS),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_SRS_AIRBAG),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ABS),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_LOW_BATTERY),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_OIL_PRESS),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ENGINE),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_FUEL),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_IMMOBI),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_TM_FAIL),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ESP_ACT),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ESP_OFF),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ADAPTING_LIGHTING),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_AUTO_STOP),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_AUTO_STOP_FAIL),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_PARKING_LIGHTS),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_FRONT_FOG),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_EXTERIOR_LIGHT_FAULT),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_ACC_FAIL),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_LDW_OFF),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_HILL_DESCENT),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_AUTO_HI_BEAM_GREEN),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_AUTO_HI_BEAM_AMBER),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_LDW_OPERATE),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_GENERAL_WARN),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_SPORTS_MODE),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_DRIVING_POWER_MODE),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_HOT_TEMP),
+    CLUSTER_TEST_DECLARE_STORE_UNIT(IC_HMI_TT_LOW_TEMP)
+};
+
+static bool g_isCalledCallback = false;
+
+#define CLUSTER_TEST_STORE_TABLE_SIZE (sizeof(g_cbStoreTable)/sizeof(g_cbStoreTable[0]))
+
+static void cleanStoreTable(void)
+{
+    int i;
+
+    for (i = 0; i < CLUSTER_TEST_STORE_TABLE_SIZE; i++) {
+        g_cbStoreTable[i].value = 0;
+        g_cbStoreTable[i].isCallbacked = false;
+    }
+}
+
+static bool checkValueFromStoreTable(const unsigned long long flag,
+                                     const bool expectedIsCallbacked,
+                                     const IC_HMI_ON_OFF expectedOnOff)
+{
+    bool ret = true;
+    int i;
+
+    for (i = 0; i < CLUSTER_TEST_STORE_TABLE_SIZE; i++) {
+        if (flag == g_cbStoreTable[i].flag) {
+            if (g_cbStoreTable[i].isCallbacked != expectedIsCallbacked) {
+                ret = false;
+                fprintf(stderr, "%s:%d [%s] isCallbacked == %d is false\n", __FILE__, __LINE__, g_cbStoreTable[i].name, expectedIsCallbacked);
+            }
+
+            if (expectedIsCallbacked == true && g_cbStoreTable[i].value != expectedOnOff) {
+                ret = false;
+                fprintf(stderr, "%s:%d [%s] value == %d is false\n", __FILE__, __LINE__, g_cbStoreTable[i].name, expectedOnOff);
+            }
+            return ret;
+        }
+    }
+
+    return false;
+}
+
+static void sendDataAllSet(IPC_DATA_IC_SERVICE_S *pSendData, IC_HMI_ON_OFF onOff)
+{
+    pSendData->turnR = onOff;
+    pSendData->turnL = onOff;
+    pSendData->brake = onOff;
+    pSendData->seatbelt = onOff;
+    pSendData->highbeam = onOff;
+    pSendData->door = onOff;
+    pSendData->eps = onOff;
+    pSendData->srsAirbag = onOff;
+    pSendData->abs = onOff;
+    pSendData->lowBattery = onOff;
+    pSendData->oilPress = onOff;
+    pSendData->engine = onOff;
+    pSendData->fuel = onOff;
+    pSendData->immobi = onOff;
+    pSendData->tmFail = onOff;
+    pSendData->espAct = onOff;
+    pSendData->espOff = onOff;
+    pSendData->adaptingLighting = onOff;
+    pSendData->autoStop = onOff;
+    pSendData->autoStopFail = onOff;
+    pSendData->parkingLights = onOff;
+    pSendData->frontFog = onOff;
+    pSendData->exteriorLightFault = onOff;
+    pSendData->accFail = onOff;
+    pSendData->ldwOff = onOff;
+    pSendData->hillDescent = onOff;
+    pSendData->autoHiBeamGreen = onOff;
+    pSendData->autoHiBeamAmber = onOff;
+    pSendData->ldwOperate = onOff;
+    pSendData->generalWarn = onOff;
+    pSendData->sportsMode = onOff;
+    pSendData->drivingPowerMode = onOff;
+    pSendData->hotTemp = onOff;
+    pSendData->lowTemp = onOff;
+}
+
+static void notifyIcHmi(unsigned long long arg_1, IC_HMI_ON_OFF arg_2)
+{
+    int i;
+
+    g_isCalledCallback = true;
+
+    for (i = 0; i < sizeof(g_cbStoreTable) / sizeof(g_cbStoreTable[0]); i++) {
+        if ((arg_1 & g_cbStoreTable[i].flag) == g_cbStoreTable[i].flag) {
+            g_cbStoreTable[i].value = arg_2;
+            g_cbStoreTable[i].isCallbacked = true;
+        }
+    }
+}
+
+static void TestregisterIcHmi_ALL_DifferentData() {
+    unsigned long long arg_1;
+    IPC_DATA_IC_SERVICE_S sendData;
+    int i;
+
+    CU_ASSERT(clusterInit() == true);
+
+    cleanStoreTable();
+    g_isCalledCallback = false;
+
+    arg_1 = IC_HMI_TT_ALL;
+    CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    memset(&sendData, 0x00, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_ON);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == true);
+    for (i = 0; i < CLUSTER_TEST_STORE_TABLE_SIZE; i++) {
+        CU_ASSERT(checkValueFromStoreTable(g_cbStoreTable[i].flag, true, IC_HMI_ON) == true);
+    }
+
+    g_isCalledCallback = false;
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == true);
+    for (i = 0; i < CLUSTER_TEST_STORE_TABLE_SIZE; i++) {
+        CU_ASSERT(checkValueFromStoreTable(g_cbStoreTable[i].flag, true, IC_HMI_OFF) == true);
+    }
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+static void TestregisterIcHmi_ALL_SameData() {
+    unsigned long long arg_1;
+    IPC_DATA_IC_SERVICE_S sendData;
+
+    CU_ASSERT(clusterInit() == true);
+
+    cleanStoreTable();
+    g_isCalledCallback = false;
+
+    arg_1 = IC_HMI_TT_ALL;
+    CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    // Send the data "different" from initial value.
+    memset(&sendData, 0x00, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    g_isCalledCallback = false;
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+static void TestregisterIcHmi_NullFunc() {
+    unsigned long long arg_1;
+
+    CU_ASSERT(clusterInit() == true);
+
+    arg_1 = IC_HMI_TT_ALL;
+    CU_ASSERT(registerIcHmi(arg_1, NULL) == false);
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+static void TestregisterIcHmi_ALL_OFF() {
+    unsigned long long arg_1;
+    IPC_DATA_IC_SERVICE_S sendData;
+
+    CU_ASSERT(clusterInit() == true);
+
+    cleanStoreTable();
+    g_isCalledCallback = false;
+
+    arg_1 = 0ULL;
+    CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    memset(&sendData, 0x00, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_ON);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    g_isCalledCallback = false;
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+static void TestregisterIcHmi_ALL_UnrelatedParams(void)
+{
+    unsigned long long arg_1;
+    IPC_DATA_IC_SERVICE_S sendData;
+
+    CU_ASSERT(clusterInit() == true);
+
+    cleanStoreTable();
+    g_isCalledCallback = false;
+
+    arg_1 = IC_HMI_TT_ALL;
+    CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    memset(&sendData, 0x01, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    g_isCalledCallback = false;
+    memset(&sendData, 0x00, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+static void TestregisterIcHmi_Set_UnusedFlag(void)
+{
+    unsigned long long arg_1;
+    IPC_DATA_IC_SERVICE_S sendData;
+    int i;
+
+    CU_ASSERT(clusterInit() == true);
+
+    cleanStoreTable();
+    g_isCalledCallback = false;
+
+    arg_1 = IC_HMI_TT_ALL;
+    for (i = 0; i < CLUSTER_TEST_STORE_TABLE_SIZE; i++) {
+        arg_1 &= ~(g_cbStoreTable[i].flag);
+    }
+    CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    memset(&sendData, 0x00, sizeof(sendData));
+    sendDataAllSet(&sendData, IC_HMI_ON);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    g_isCalledCallback = false;
+    sendDataAllSet(&sendData, IC_HMI_OFF);
+    requestSendData(&sendData);
+
+    CU_ASSERT(g_isCalledCallback == false);
+
+    CU_ASSERT(clusterTerm() == true);
+}
+
+#define REGISTER_NOTIFY_TEST_FUNC(flag, param) \
+    static void TestregisterIcHmi_ON_ ##flag(void) \
+    { \
+        unsigned long long arg_1; \
+        IPC_DATA_IC_SERVICE_S sendData; \
+ \
+        CU_ASSERT(clusterInit() == true); \
+ \
+        cleanStoreTable(); \
+        g_isCalledCallback = false; \
+ \
+        arg_1 = IC_HMI_ ##flag; \
+        CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true); \
+ \
+        CU_ASSERT(g_isCalledCallback == false); \
+ \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendDataAllSet(&sendData, IC_HMI_ON); \
+        sendData.param = IC_HMI_OFF; \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == false); \
+ \
+        g_isCalledCallback = false; \
+        sendData.param = IC_HMI_ON; \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == true); \
+        CU_ASSERT(checkValueFromStoreTable(IC_HMI_ ##flag, true, IC_HMI_ON) == true); \
+ \
+        g_isCalledCallback = false; \
+        sendData.param = IC_HMI_OFF; \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == true); \
+        CU_ASSERT(checkValueFromStoreTable(IC_HMI_ ##flag, true, IC_HMI_OFF) == true); \
+ \
+        CU_ASSERT(clusterTerm() == true); \
+    } \
+    static void TestregisterIcHmi_OFF_ ##flag(void) \
+    { \
+        unsigned long long arg_1; \
+        IPC_DATA_IC_SERVICE_S sendData; \
+ \
+        CU_ASSERT(clusterInit() == true); \
+ \
+        cleanStoreTable(); \
+        g_isCalledCallback = false; \
+ \
+        arg_1 = IC_HMI_TT_ALL & ~IC_HMI_ ##flag; \
+        CU_ASSERT(registerIcHmi(arg_1, notifyIcHmi) == true); \
+ \
+        CU_ASSERT(g_isCalledCallback == false); \
+ \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendDataAllSet(&sendData, IC_HMI_OFF); \
+        sendData.param = IC_HMI_ON; \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == false); \
+ \
+        g_isCalledCallback = false; \
+        sendData.param = IC_HMI_OFF; \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == false); \
+ \
+        g_isCalledCallback = false; \
+        sendDataAllSet(&sendData, IC_HMI_ON); \
+        requestSendData(&sendData); \
+ \
+        CU_ASSERT(g_isCalledCallback == true); \
+        CU_ASSERT(checkValueFromStoreTable(IC_HMI_ ##flag, false, IC_HMI_OFF) == true); \
+ \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define REGISTER_NOTIFY_ADD_TEST(testSuite, flag) \
+    CU_add_test(testSuite, "registerIcHmi_ON_" #flag, TestregisterIcHmi_ON_ ##flag); \
+    CU_add_test(testSuite, "registerIcHmi_OFF_" #flag, TestregisterIcHmi_OFF_ ##flag)
+
+REGISTER_NOTIFY_TEST_FUNC(TT_TURN_R, turnR)
+REGISTER_NOTIFY_TEST_FUNC(TT_TURN_L, turnL)
+REGISTER_NOTIFY_TEST_FUNC(TT_BRAKE, brake)
+REGISTER_NOTIFY_TEST_FUNC(TT_SEATBELT, seatbelt)
+REGISTER_NOTIFY_TEST_FUNC(TT_HIGHBEAM, highbeam)
+REGISTER_NOTIFY_TEST_FUNC(TT_DOOR, door)
+REGISTER_NOTIFY_TEST_FUNC(TT_EPS, eps)
+REGISTER_NOTIFY_TEST_FUNC(TT_SRS_AIRBAG, srsAirbag)
+REGISTER_NOTIFY_TEST_FUNC(TT_ABS, abs)
+REGISTER_NOTIFY_TEST_FUNC(TT_LOW_BATTERY, lowBattery)
+REGISTER_NOTIFY_TEST_FUNC(TT_OIL_PRESS, oilPress)
+REGISTER_NOTIFY_TEST_FUNC(TT_ENGINE, engine)
+REGISTER_NOTIFY_TEST_FUNC(TT_FUEL, fuel)
+REGISTER_NOTIFY_TEST_FUNC(TT_IMMOBI, immobi)
+REGISTER_NOTIFY_TEST_FUNC(TT_TM_FAIL, tmFail)
+REGISTER_NOTIFY_TEST_FUNC(TT_ESP_ACT, espAct)
+REGISTER_NOTIFY_TEST_FUNC(TT_ESP_OFF, espOff)
+REGISTER_NOTIFY_TEST_FUNC(TT_ADAPTING_LIGHTING, adaptingLighting)
+REGISTER_NOTIFY_TEST_FUNC(TT_AUTO_STOP, autoStop)
+REGISTER_NOTIFY_TEST_FUNC(TT_AUTO_STOP_FAIL, autoStopFail)
+REGISTER_NOTIFY_TEST_FUNC(TT_PARKING_LIGHTS, parkingLights)
+REGISTER_NOTIFY_TEST_FUNC(TT_FRONT_FOG, frontFog)
+REGISTER_NOTIFY_TEST_FUNC(TT_EXTERIOR_LIGHT_FAULT, exteriorLightFault)
+REGISTER_NOTIFY_TEST_FUNC(TT_ACC_FAIL, accFail)
+REGISTER_NOTIFY_TEST_FUNC(TT_LDW_OFF, ldwOff)
+REGISTER_NOTIFY_TEST_FUNC(TT_HILL_DESCENT, hillDescent)
+REGISTER_NOTIFY_TEST_FUNC(TT_AUTO_HI_BEAM_GREEN, autoHiBeamGreen)
+REGISTER_NOTIFY_TEST_FUNC(TT_AUTO_HI_BEAM_AMBER, autoHiBeamAmber)
+REGISTER_NOTIFY_TEST_FUNC(TT_LDW_OPERATE, ldwOperate)
+REGISTER_NOTIFY_TEST_FUNC(TT_GENERAL_WARN, generalWarn)
+REGISTER_NOTIFY_TEST_FUNC(TT_SPORTS_MODE, sportsMode)
+REGISTER_NOTIFY_TEST_FUNC(TT_DRIVING_POWER_MODE, drivingPowerMode)
+REGISTER_NOTIFY_TEST_FUNC(TT_HOT_TEMP, hotTemp)
+REGISTER_NOTIFY_TEST_FUNC(TT_LOW_TEMP, lowTemp)
+
+void SetTestSuiteRegisterAndNotify(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("RegisterAndNotify", NULL, NULL);
+    CU_add_test(testSuite, "registerIcHmi_ALL_DifferentData", TestregisterIcHmi_ALL_DifferentData);
+    CU_add_test(testSuite, "registerIcHmi_ALL_SameData", TestregisterIcHmi_ALL_SameData);
+    CU_add_test(testSuite, "registerIcHmi_ALL_UnrelatedParams", TestregisterIcHmi_ALL_UnrelatedParams);
+    CU_add_test(testSuite, "registerIcHmi_ALL_OFF", TestregisterIcHmi_ALL_OFF);
+    CU_add_test(testSuite, "registerIcHmi_Set_UnusedFlag", TestregisterIcHmi_Set_UnusedFlag);
+    CU_add_test(testSuite, "registerIcHmi_NullFunc", TestregisterIcHmi_NullFunc);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_TURN_R);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_TURN_L);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_BRAKE);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_SEATBELT);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_HIGHBEAM);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_DOOR);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_EPS);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_SRS_AIRBAG);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ABS);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_LOW_BATTERY);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_OIL_PRESS);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ENGINE);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_FUEL);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_IMMOBI);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_TM_FAIL);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ESP_ACT);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ESP_OFF);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ADAPTING_LIGHTING);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_AUTO_STOP);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_AUTO_STOP_FAIL);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_PARKING_LIGHTS);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_FRONT_FOG);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_EXTERIOR_LIGHT_FAULT);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_ACC_FAIL);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_LDW_OFF);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_HILL_DESCENT);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_AUTO_HI_BEAM_GREEN);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_AUTO_HI_BEAM_AMBER);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_LDW_OPERATE);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_GENERAL_WARN);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_SPORTS_MODE);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_DRIVING_POWER_MODE);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_HOT_TEMP);
+    REGISTER_NOTIFY_ADD_TEST(testSuite, TT_LOW_TEMP);
+}
diff --git a/test/client_test/client_test_shiftposition.c b/test/client_test/client_test_shiftposition.c
new file mode 100644
index 0000000..ead199c
--- /dev/null
+++ b/test/client_test/client_test_shiftposition.c
@@ -0,0 +1,31 @@
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define SHIFTPOSITION_TEST_FUNC(func, param, value) \
+    static void Test ##func() { \
+        IPC_DATA_IC_SERVICE_S sendData; \
+        CU_ASSERT(clusterInit() == true); \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendData.param = value; \
+        requestSendData(&sendData); \
+        CU_ASSERT(func() == value); \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define SHIFTPOSITION_ADD_TEST(testSuite, func) \
+    CU_add_test(testSuite, #func, Test ##func)
+
+SHIFTPOSITION_TEST_FUNC(getGearAtVal, gearAtVal, IC_HMI_AT_UNUSED)
+SHIFTPOSITION_TEST_FUNC(getGearMtVal, gearMtVal, IC_HMI_MT_EIGHTTH)
+
+void SetTestSuiteShiftPosition(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("ShiftPosition", NULL, NULL);
+    SHIFTPOSITION_ADD_TEST(testSuite, getGearAtVal);
+    SHIFTPOSITION_ADD_TEST(testSuite, getGearMtVal);
+}
diff --git a/test/client_test/client_test_speed.c b/test/client_test/client_test_speed.c
new file mode 100644
index 0000000..c30e2e2
--- /dev/null
+++ b/test/client_test/client_test_speed.c
@@ -0,0 +1,32 @@
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define SPEED_TEST_FUNC(func, param, value) \
+    static void Test ##func() { \
+        IPC_DATA_IC_SERVICE_S sendData; \
+        CU_ASSERT(clusterInit() == true); \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendData.param = value; \
+        requestSendData(&sendData); \
+        CU_ASSERT(func() == value); \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define SPEED_ADD_TEST(testSuite, func) \
+    CU_add_test(testSuite, #func, Test ##func)
+
+SPEED_TEST_FUNC(getSpAnalogVal, spAnalogVal, 0x00007530)
+SPEED_TEST_FUNC(getSpAnaDigUnitVal, spAnaDigUnitVal, IC_HMI_SP_MPH)
+
+void SetTestSuiteSpeed(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("Speed", NULL, NULL);
+    SPEED_ADD_TEST(testSuite, getSpAnalogVal);
+    SPEED_ADD_TEST(testSuite, getSpAnaDigUnitVal);
+}
+
diff --git a/test/client_test/client_test_suites.h b/test/client_test/client_test_suites.h
new file mode 100644
index 0000000..8306944
--- /dev/null
+++ b/test/client_test/client_test_suites.h
@@ -0,0 +1,13 @@
+#ifndef CLIENT_TEST_SUITES_H
+#define CLIENT_TEST_SUITES_H
+
+void SetTestSuiteInitAndTerm(void);
+void SetTestSuiteTelltale(void);
+void SetTestSuiteShiftPosition(void);
+void SetTestSuiteSpeed(void);
+void SetTestSuiteTacho(void);
+void SetTestSuiteTripComputer(void);
+void SetTestSuiteRegisterAndNotify(void);
+
+#endif // CLIENT_TEST_SUITES_H
+
diff --git a/test/client_test/client_test_tacho.c b/test/client_test/client_test_tacho.c
new file mode 100644
index 0000000..97b39e5
--- /dev/null
+++ b/test/client_test/client_test_tacho.c
@@ -0,0 +1,30 @@
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define TACHO_TEST_FUNC(func, param, value) \
+    static void Test ##func() { \
+        IPC_DATA_IC_SERVICE_S sendData; \
+        CU_ASSERT(clusterInit() == true); \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendData.param = value; \
+        requestSendData(&sendData); \
+        CU_ASSERT(func() == value); \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define TACHO_ADD_TEST(testSuite, func) \
+    CU_add_test(testSuite, #func, Test ##func)
+
+TACHO_TEST_FUNC(getTaAnalogVal, taAnalogVal, 0x00004E20)
+
+void SetTestSuiteTacho(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("Tacho", NULL, NULL);
+    TACHO_ADD_TEST(testSuite, getTaAnalogVal);
+}
+
diff --git a/test/client_test/client_test_telltale.c b/test/client_test/client_test_telltale.c
new file mode 100644
index 0000000..b5dd14a
--- /dev/null
+++ b/test/client_test/client_test_telltale.c
@@ -0,0 +1,132 @@
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define TELLTALE_TEST_FUNC(func, param) \
+    static void Test ##func() { \
+        IPC_DATA_IC_SERVICE_S sendData; \
+        CU_ASSERT(clusterInit() == true); \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendData.param = IC_HMI_ON; \
+        requestSendData(&sendData); \
+        CU_ASSERT(func() == IC_HMI_ON); \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define TELLTALE_ADD_TEST(testSuite, func) \
+    CU_add_test(testSuite, #func, Test ##func)
+
+TELLTALE_TEST_FUNC(getTurnR, turnR)
+TELLTALE_TEST_FUNC(getTurnL, turnL)
+TELLTALE_TEST_FUNC(getBrake, brake)
+TELLTALE_TEST_FUNC(getSeatbelt, seatbelt)
+TELLTALE_TEST_FUNC(getFrontRightSeatbelt, frontRightSeatbelt)
+TELLTALE_TEST_FUNC(getFrontCenterSeatbelt, frontCenterSeatbelt)
+TELLTALE_TEST_FUNC(getFrontLeftSeatbelt, frontLeftSeatbelt)
+TELLTALE_TEST_FUNC(getMid1RightSeatbelt, mid1RightSeatbelt)
+TELLTALE_TEST_FUNC(getMid1CenterSeatbelt, mid1CenterSeatbelt)
+TELLTALE_TEST_FUNC(getMid1LeftSeatbelt, mid1LeftSeatbelt)
+TELLTALE_TEST_FUNC(getMid2RightSeatbelt, mid2RightSeatbelt)
+TELLTALE_TEST_FUNC(getMid2CenterSeatbelt, mid2CenterSeatbelt)
+TELLTALE_TEST_FUNC(getMid2LeftSeatbelt, mid2LeftSeatbelt)
+TELLTALE_TEST_FUNC(getRearRightSeatbelt, rearRightSeatbelt)
+TELLTALE_TEST_FUNC(getRearCenterSeatbelt, rearCenterSeatbelt)
+TELLTALE_TEST_FUNC(getRearLeftSeatbelt, rearLeftSeatbelt)
+TELLTALE_TEST_FUNC(getHighbeam, highbeam)
+TELLTALE_TEST_FUNC(getDoor, door)
+TELLTALE_TEST_FUNC(getFrontRightDoor, frontRightDoor)
+TELLTALE_TEST_FUNC(getFrontLeftDoor, frontLeftDoor)
+TELLTALE_TEST_FUNC(getRearRightDoor, rearRightDoor)
+TELLTALE_TEST_FUNC(getRearLeftDoor, rearLeftDoor)
+TELLTALE_TEST_FUNC(getTrunkDoor, trunkDoor)
+TELLTALE_TEST_FUNC(getHoodDoor, hoodDoor)
+TELLTALE_TEST_FUNC(getEps, eps)
+TELLTALE_TEST_FUNC(getSrsAirbag, srsAirbag)
+TELLTALE_TEST_FUNC(getAbs, abs)
+TELLTALE_TEST_FUNC(getLowBattery, lowBattery)
+TELLTALE_TEST_FUNC(getOilPress, oilPress)
+TELLTALE_TEST_FUNC(getEngine, engine)
+TELLTALE_TEST_FUNC(getFuel, fuel)
+TELLTALE_TEST_FUNC(getImmobi, immobi)
+TELLTALE_TEST_FUNC(getTMFail, tmFail)
+TELLTALE_TEST_FUNC(getEspAct, espAct)
+TELLTALE_TEST_FUNC(getEspOff, espOff)
+TELLTALE_TEST_FUNC(getAdaptingLighting, adaptingLighting)
+TELLTALE_TEST_FUNC(getAutoStop, autoStop)
+TELLTALE_TEST_FUNC(getAutoStopFail, autoStopFail)
+TELLTALE_TEST_FUNC(getParkingLights, parkingLights)
+TELLTALE_TEST_FUNC(getFrontFog, frontFog)
+TELLTALE_TEST_FUNC(getExteriorLightFault, exteriorLightFault)
+TELLTALE_TEST_FUNC(getAccFail, accFail)
+TELLTALE_TEST_FUNC(getLdwOff, ldwOff)
+TELLTALE_TEST_FUNC(getHillDescent, hillDescent)
+TELLTALE_TEST_FUNC(getAutoHiBeamGreen, autoHiBeamGreen)
+TELLTALE_TEST_FUNC(getAutoHiBeamAmber, autoHiBeamAmber)
+TELLTALE_TEST_FUNC(getSportsMode, sportsMode)
+TELLTALE_TEST_FUNC(getLdwOperate, ldwOperate)
+TELLTALE_TEST_FUNC(getGeneralWarn, generalWarn)
+TELLTALE_TEST_FUNC(getDriverPowerMode, drivingPowerMode)
+TELLTALE_TEST_FUNC(getHotTemp, hotTemp)
+TELLTALE_TEST_FUNC(getLowTemp, lowTemp)
+
+void SetTestSuiteTelltale(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("Telltale", NULL, NULL);
+    TELLTALE_ADD_TEST(testSuite, getTurnR);
+    TELLTALE_ADD_TEST(testSuite, getTurnL);
+    TELLTALE_ADD_TEST(testSuite, getBrake);
+    TELLTALE_ADD_TEST(testSuite, getSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getFrontRightSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getFrontCenterSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getFrontLeftSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid1RightSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid1CenterSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid1LeftSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid2RightSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid2CenterSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getMid2LeftSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getRearRightSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getRearCenterSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getRearLeftSeatbelt);
+    TELLTALE_ADD_TEST(testSuite, getHighbeam);
+    TELLTALE_ADD_TEST(testSuite, getDoor);
+    TELLTALE_ADD_TEST(testSuite, getFrontRightDoor);
+    TELLTALE_ADD_TEST(testSuite, getFrontLeftDoor);
+    TELLTALE_ADD_TEST(testSuite, getRearRightDoor);
+    TELLTALE_ADD_TEST(testSuite, getRearLeftDoor);
+    TELLTALE_ADD_TEST(testSuite, getTrunkDoor);
+    TELLTALE_ADD_TEST(testSuite, getHoodDoor);
+    TELLTALE_ADD_TEST(testSuite, getEps);
+    TELLTALE_ADD_TEST(testSuite, getSrsAirbag);
+    TELLTALE_ADD_TEST(testSuite, getAbs);
+    TELLTALE_ADD_TEST(testSuite, getLowBattery);
+    TELLTALE_ADD_TEST(testSuite, getOilPress);
+    TELLTALE_ADD_TEST(testSuite, getEngine);
+    TELLTALE_ADD_TEST(testSuite, getFuel);
+    TELLTALE_ADD_TEST(testSuite, getImmobi);
+    TELLTALE_ADD_TEST(testSuite, getTMFail);
+    TELLTALE_ADD_TEST(testSuite, getEspAct);
+    TELLTALE_ADD_TEST(testSuite, getEspOff);
+    TELLTALE_ADD_TEST(testSuite, getAdaptingLighting);
+    TELLTALE_ADD_TEST(testSuite, getAutoStop);
+    TELLTALE_ADD_TEST(testSuite, getAutoStopFail);
+    TELLTALE_ADD_TEST(testSuite, getParkingLights);
+    TELLTALE_ADD_TEST(testSuite, getFrontFog);
+    TELLTALE_ADD_TEST(testSuite, getExteriorLightFault);
+    TELLTALE_ADD_TEST(testSuite, getAccFail);
+    TELLTALE_ADD_TEST(testSuite, getLdwOff);
+    TELLTALE_ADD_TEST(testSuite, getHillDescent);
+    TELLTALE_ADD_TEST(testSuite, getAutoHiBeamGreen);
+    TELLTALE_ADD_TEST(testSuite, getAutoHiBeamAmber);
+    TELLTALE_ADD_TEST(testSuite, getSportsMode);
+    TELLTALE_ADD_TEST(testSuite, getLdwOperate);
+    TELLTALE_ADD_TEST(testSuite, getGeneralWarn);
+    TELLTALE_ADD_TEST(testSuite, getDriverPowerMode);
+    TELLTALE_ADD_TEST(testSuite, getHotTemp);
+    TELLTALE_ADD_TEST(testSuite, getLowTemp);
+}
+
diff --git a/test/client_test/client_test_tripcomputer.c b/test/client_test/client_test_tripcomputer.c
new file mode 100644
index 0000000..a352230
--- /dev/null
+++ b/test/client_test/client_test_tripcomputer.c
@@ -0,0 +1,68 @@
+#include <CUnit/CUnit.h>
+
+#include <cluster_api.h>
+
+#include "client_test_common.h"
+
+#define TRIPCOMPUTER_TEST_FUNC(func, param, value) \
+    static void Test ##func() { \
+        IPC_DATA_IC_SERVICE_S sendData; \
+        CU_ASSERT(clusterInit() == true); \
+        memset(&sendData, 0x00, sizeof(sendData)); \
+        sendData.param = value; \
+        requestSendData(&sendData); \
+        CU_ASSERT(func() == value); \
+        CU_ASSERT(clusterTerm() == true); \
+    }
+
+#define TRIPCOMPUTER_ADD_TEST(testSuite, func) \
+    CU_add_test(testSuite, #func, Test ##func)
+
+TRIPCOMPUTER_TEST_FUNC(getTrcomTripAVal, trcomTripAVal, 0x0001869F)
+TRIPCOMPUTER_TEST_FUNC(getTrcomTripBVal, trcomTripBVal, 0x0001869F)
+TRIPCOMPUTER_TEST_FUNC(getTrcomOdoVal, trcomOdoVal, 0x000F423F)
+TRIPCOMPUTER_TEST_FUNC(getTrcomUnitVal, trcomUnitVal, IC_HMI_TRCOM_MILE)
+TRIPCOMPUTER_TEST_FUNC(getAvgSpeedAVal, avgSpeedAVal, 0x012C)
+TRIPCOMPUTER_TEST_FUNC(getAvgSpeedBVal, avgSpeedBVal, 0x012C)
+TRIPCOMPUTER_TEST_FUNC(getHourAVal, hourAVal, 0x03E7)
+TRIPCOMPUTER_TEST_FUNC(getHourBVal, hourBVal, 0x03E7)
+TRIPCOMPUTER_TEST_FUNC(getMinuteAVal, minuteAVal, 0x3B)
+TRIPCOMPUTER_TEST_FUNC(getMinuteBVal, minuteBVal, 0x3B)
+TRIPCOMPUTER_TEST_FUNC(getSecondAVal, secondAVal, 0x3B)
+TRIPCOMPUTER_TEST_FUNC(getSecondBVal, secondBVal, 0x3B)
+TRIPCOMPUTER_TEST_FUNC(getOTempVal, oTempVal, (signed short)0xFFD8)
+TRIPCOMPUTER_TEST_FUNC(getOTempUnitVal, oTempUnitVal, IC_HMI_OTEMP_UNIT_K)
+TRIPCOMPUTER_TEST_FUNC(getCruRangeVal, cruRangeVal, 0x064A)
+TRIPCOMPUTER_TEST_FUNC(getAvgFuelAVal, avgFuelAVal, 0x07CF)
+TRIPCOMPUTER_TEST_FUNC(getAvgFuelBVal, avgFuelBVal, 0x07CF)
+TRIPCOMPUTER_TEST_FUNC(getInsFuelAVal, insFuelAVal, 0x07CF)
+TRIPCOMPUTER_TEST_FUNC(getInsFuelBVal, insFuelBVal, 0x07CF)
+TRIPCOMPUTER_TEST_FUNC(getFuelEconomyUnitVal, fuelEconomyUnitVal, IC_HMI_FUEL_KWH_100KM)
+
+void SetTestSuiteTripComputer(void)
+{
+    CU_pSuite testSuite;
+
+    testSuite = CU_add_suite("TripComputer", NULL, NULL);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getTrcomTripAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getTrcomTripBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getTrcomOdoVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getTrcomUnitVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getAvgSpeedAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getAvgSpeedBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getHourAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getHourBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getMinuteAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getMinuteBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getSecondAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getSecondBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getOTempVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getOTempUnitVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getCruRangeVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getAvgFuelAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getAvgFuelBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getInsFuelAVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getInsFuelBVal);
+    TRIPCOMPUTER_ADD_TEST(testSuite, getFuelEconomyUnitVal);
+}
+
diff --git a/test/client_test/dummy_server.c b/test/client_test/dummy_server.c
new file mode 100644
index 0000000..987552a
--- /dev/null
+++ b/test/client_test/dummy_server.c
@@ -0,0 +1,176 @@
+#include "client_test_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/epoll.h>
+
+#include <ipc.h>
+
+#define CLUSTER_TEST_EPOLL_WAIT_NUM (2)
+
+int createEpoll(int waitNum)
+{
+    int fd = -1;
+
+    fd = epoll_create(waitNum);
+    if (fd < 0) {
+        ERRNO_LOG(epoll_create);
+        return -1;
+    }
+
+    return fd;
+}
+
+int createSocket(int epollFd, int *pOutTestFd)
+{
+    int rc;
+    int fd = -1;
+    int testFd = -1;
+    struct sockaddr_un unixAddr;
+    int len;
+    struct epoll_event epollEv;
+
+    fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd < 0) {
+        ERRNO_LOG(socket);
+        return -1;
+    }
+
+    unixAddr.sun_family = AF_UNIX;
+    strcpy(unixAddr.sun_path, CLUSTER_TEST_DOMAIN_PATH);
+    len = sizeof(unixAddr.sun_family)+strlen(unixAddr.sun_path);
+    rc = bind(fd, (struct sockaddr *)&unixAddr, len);
+    if (rc < 0) {
+        ERRNO_LOG(bind);
+        goto err;
+    }
+
+    rc = listen(fd, 1);
+    if (rc < 0) {
+        ERRNO_LOG(listen);
+        goto err;
+    }
+
+    testFd = accept(fd, (struct sockaddr*)&unixAddr, (socklen_t *)&len);
+    if (testFd < 0) {
+        ERRNO_LOG(accept);
+        goto err;
+    }
+
+    memset(&epollEv, 0, sizeof(epollEv));
+    epollEv.events = EPOLLIN;
+    epollEv.data.fd = fd;
+    epoll_ctl(epollFd, EPOLL_CTL_ADD, epollEv.data.fd, &epollEv);
+
+    epollEv.events = EPOLLIN | EPOLLRDHUP;
+    epollEv.data.fd = testFd;
+    epoll_ctl(epollFd, EPOLL_CTL_ADD, epollEv.data.fd, &epollEv);
+
+    *pOutTestFd = testFd;
+
+    return fd;
+err:
+    shutdown(fd, SHUT_RDWR);
+    close(fd);
+    unlink(CLUSTER_TEST_DOMAIN_PATH);
+    return -1;
+}
+
+void sendMessageLoop(void)
+{
+    int epollFd = -1;
+    int socketFd = -1;
+    int testFd = -1;
+    int fdNum;
+    int i;
+    struct epoll_event epEvents[CLUSTER_TEST_EPOLL_WAIT_NUM];
+    bool isRunning = true;
+    int dummyData;
+    FILE *fp;
+    IPC_DATA_IC_SERVICE_S sendData;
+    IPC_RET_E rc;
+    int size;
+
+    epollFd = createEpoll(CLUSTER_TEST_EPOLL_WAIT_NUM);
+    if (epollFd < 0) {
+        goto end;
+    }
+
+    socketFd = createSocket(epollFd, &testFd);
+    if (socketFd < 0) {
+        goto end;
+    }
+
+    while(isRunning == true) {
+        fdNum = epoll_wait(epollFd, epEvents, CLUSTER_TEST_EPOLL_WAIT_NUM, -1);
+
+        for (i = 0; i < fdNum; i++) {
+            if (epEvents[i].events & EPOLLRDHUP) {
+                isRunning = false;
+                break;
+            }
+            else if (epEvents[i].events & EPOLLIN) {
+                size = read(epEvents[i].data.fd, &dummyData, sizeof(dummyData));
+                if (size < 0) {
+                    ERRNO_LOG(read);
+                }
+                fp = fopen(CLUSTER_TEST_SENDDATA_FILE, "rb");
+                if (fp != NULL) {
+                    size = fread(&sendData, 1, sizeof(sendData), fp);
+                    if (size < sizeof(sendData) && ferror(fp)) {
+                        ERRNO_LOG(fread);
+                    }
+                    fclose(fp);
+                    rc = ipcSendMessage(IPC_USAGE_TYPE_IC_SERVICE, &sendData, sizeof(sendData));
+                    if (rc != IPC_RET_OK) {
+                        fprintf(stderr, "dummy_server:%d Failed to ipcSendMessage() : %d\n", __LINE__, rc);
+                    }
+                }
+            }
+        }
+    }
+
+end:
+    if (testFd >= 0) {
+        shutdown(testFd, SHUT_RDWR);
+        close(testFd);
+    }
+
+    if (socketFd >= 0) {
+        shutdown(socketFd, SHUT_RDWR);
+        close(socketFd);
+        unlink(CLUSTER_TEST_DOMAIN_PATH);
+    }
+
+    if (epollFd >= 0) {
+        close(epollFd);
+    }
+}
+
+int main(void)
+{
+    IPC_RET_E ret;
+
+    setenv(IPC_ENV_DOMAIN_SOCKET_PATH, IPC_TEST_DOMAIN_PATH, 1);
+
+    ret = ipcServerStart(IPC_USAGE_TYPE_IC_SERVICE);
+    if (ret != IPC_RET_OK) {
+        fprintf(stderr, "dummy_server:%d Failed to ipcServerStart() : %d\n", __LINE__, ret);
+        exit(EXIT_FAILURE);
+    }
+
+    sendMessageLoop();
+
+    ret = ipcServerStop(IPC_USAGE_TYPE_IC_SERVICE);
+    if (ret != IPC_RET_OK) {
+        fprintf(stderr, "dummy_server:%d Failed to ipcServerStop() : %d\n", __LINE__, ret);
+        exit(EXIT_FAILURE);
+    }
+
+    return 0;
+}
+