#include "hw/touchscreen.h"
#include "hw/usb_client.h"
#include "hw/usb_gadget.h"
+#include "hw/bezel.h"
+#include "hw/touchsensitivity.h"
+#include "hw/board.h"
using namespace std;
#define LOWBATTERY "LowBattery"
struct hw_info *info;
+struct hw_board *board_dev;
struct battery_device *battery_dev;
struct cpu_device *cpu_dev;
struct display_device *display_dev;
struct usb_gadget *gadget_dev;
struct usb_gadget_id gadget_id;
struct usb_gadget_translator *gadget_translator;
+struct bezel_device *bezel_dev;
+struct touchsensitivity_device *touchsensitivity_dev;
+
/* Define Classes */
class BATTERYHalTest : public testing::Test
public:
virtual void SetUp()
{
+ int ret;
+ ret = system_info_get_platform_bool(FEATURE_THERMISTOR, &supported);
+ EXPECT_EQ(SYSTEM_INFO_ERROR_NONE, ret) << "system_info_get_platform_bool failed";
}
virtual void TearDown()
}
};
+class TOUCHSENSITIVITYHalTest : public testing::Test
+{
+ public:
+ virtual void SetUp()
+ {
+
+ }
+
+ virtual void TearDown()
+ {
+
+ }
+};
+
+class BOARDHalTest : public testing::Test
+{
+ public:
+ virtual void SetUp()
+ {
+
+ }
+
+ virtual void TearDown()
+ {
+
+ }
+};
+
+class BEZELHalTest : public testing::Test
+{
+ public:
+ virtual void SetUp()
+ {
+ int ret;
+
+ ret = system_info_get_platform_bool(FEATURE_BEZEL, &supported);
+ EXPECT_EQ(SYSTEM_INFO_ERROR_NONE, ret) << "system_info_get_platform_bool failed";
+ }
+
+ virtual void TearDown()
+ {
+
+ }
+};
+
class USBCLIENTHalTest : public testing::Test
{
public:
if (!supported)
return;
+ info = NULL;
ret = hw_get_info(BATTERY_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
EXPECT_EQ(ret, 0) << "Fail to load battery hal (" << ret << ")";
{
int ret;
+ info = NULL;
ret = hw_get_info(CPU_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
{
int ret;
+ info = NULL;
ret = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
{
int ret;
+ info = NULL;
ret = hw_get_info(EXTERNAL_CONNECTION_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
if (!supported)
return;
+ info = NULL;
ret = hw_get_info(IR_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
EXPECT_EQ(ret, 0) << "Fail to get hal for ir (" << ret << ")";
if (!supported)
return;
+ info = NULL;
ret = hw_get_info(LED_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
EXPECT_EQ(ret, 0) << "Fail to get hal for rgb (" << ret << ")";
{
int ret;
+ if (!supported)
+ return;
+
+ info = NULL;
ret = hw_get_info(THERMAL_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
EXPECT_EQ(ret, 0) << "Fail to open thermal device (" << ret << ")";
}
-TEST_F(THERMALHalTest, GetStateP)
+TEST_F(THERMALHalTest, GetInfoP)
{
struct thermal_info thermal;
int ret;
- if (!thermal_dev || !thermal_dev->get_state) {
- cout << "There is no function for get_state" << endl;
+ if (!supported)
+ return;
+
+ if (!thermal_dev || !thermal_dev->get_info) {
+ cout << "There is no function for get_info" << endl;
return;
}
- ret = thermal_dev->get_state(&thermal);
- EXPECT_EQ(ret, 0) << "Fail to get_state (" << ret << ")";
+ ret = thermal_dev->get_info(DEVICE_THERMAL_AP, &thermal);
+ EXPECT_EQ(ret, 0) << "Fail to get_info (" << ret << ")";
}
static void thermal_updated_cb(struct thermal_info *info, void *data)
{
int ret;
+ if (!supported)
+ return;
+
if (!thermal_dev || !thermal_dev->register_changed_event) {
cout << "There is no function for register_changed_event" << endl;
return;
TEST_F(THERMALHalTest, UnregisterChangedEventP)
{
+ if (!supported)
+ return;
+
if (!thermal_dev || !thermal_dev->unregister_changed_event) {
cout << "There is no function for unregister_changed_event" << endl;
return;
{
int ret;
+ if (!supported)
+ return;
+
if (!info || !info->close) {
cout << "There is no function for info close" << endl;
return;
{
int ret;
+ info = NULL;
ret = hw_get_info(TOUCHSCREEN_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
EXPECT_EQ(ret, 0) << "Fail to open touchscreen device (" << ret << ")";
}
-TEST_F(TOUCHSCREENHalTest, SetstateP)
+TEST_F(TOUCHSCREENHalTest, SetStateP)
{
enum touchscreen_state state = TOUCHSCREEN_ON;
int ret;
}
/*
- * Testcase for Client
+ * Testcase for Touchsensitivity
*/
-TEST_F(USBCLIENTHalTest, InitP)
+TEST_F(TOUCHSENSITIVITYHalTest, InitP)
{
int ret;
- if (!supported)
- return;
-
- ret = hw_get_info(USB_CLIENT_HARDWARE_DEVICE_ID,
+ info = NULL;
+ ret = hw_get_info(TOUCHSENSITIVITY_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
- cout << "There is no device for usb client" << ret << endl;
+ cout << "There is no device for touchsensitivity " << ret << endl;
return;
} else {
- EXPECT_EQ(ret, 0) << "Fail to get hal for usb client (" << ret << ")";
+ EXPECT_EQ(ret, 0) << "Fail to get hal for touchsensitivity (" << ret << ")";
}
+
if (!info || !info->open) {
cout << "There is no function for info open" << endl;
return;
}
- ret = info->open(info, NULL, (struct hw_common**)&client_dev);
- EXPECT_EQ(ret, 0) << "Fail to open usb client device (" << ret << ")";
- EXPECT_NE(client_dev, nullptr) << "Fail to get usb client device structure";
+ ret = info->open(info, NULL, (struct hw_common**)&touchsensitivity_dev);
+ EXPECT_EQ(ret, 0) << "Fail to open touchsensitivity device (" << ret << ")";
+}
- ret = hw_get_info(USB_GADGET_DEVICE_ID,
+TEST_F(TOUCHSENSITIVITYHalTest, GetStateP)
+{
+ int ret, state;
+
+ if (!touchsensitivity_dev || !touchsensitivity_dev->glove_mode_get_state) {
+ cout << "There is no function for glove_mode_get_state" << endl;
+ return;
+ }
+ ret = touchsensitivity_dev->glove_mode_get_state(&state);
+ EXPECT_EQ(ret, 0) << "Fail to get glove state (" << ret << ")";
+}
+
+TEST_F(TOUCHSENSITIVITYHalTest, SetStateP)
+{
+ int ret, state = TOUCHSENSITIVITY_GLOVE_MODE_ON;
+
+ if (!touchsensitivity_dev || !touchsensitivity_dev->glove_mode_set_state) {
+ cout << "There is no function for glove_mode_set_state" << endl;
+ return;
+ }
+ ret = touchsensitivity_dev->glove_mode_set_state(state);
+ EXPECT_EQ(ret, 0) << "Fail to set glove mode (" << ret << ")";
+}
+
+TEST_F(TOUCHSENSITIVITYHalTest, DeinitP)
+{
+ int ret;
+
+ if (!info || !info->close) {
+ cout << "There is no function for info close" << endl;
+ return;
+ }
+ ret = info->close((struct hw_common *)touchsensitivity_dev);
+ EXPECT_EQ(ret, 0) << "Fail to close touchscreen device (" << ret << ")";
+}
+
+/*
+ * Testcase for Board
+ */
+TEST_F(BOARDHalTest, InitP)
+{
+ int ret;
+
+ info = NULL;
+ ret = hw_get_info(BOARD_HARDWARE_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
- cout << "There is no device for usb gadget" << ret << endl;
+ cout << "There is no device for board " << ret << endl;
return;
} else {
- EXPECT_EQ(ret, 0) << "Fail to get hal for usb gadget (" << ret << ")";
+ EXPECT_EQ(ret, 0) << "Fail to get hal for board (" << ret << ")";
}
if (!info || !info->open) {
cout << "There is no function for info open" << endl;
return;
}
- ret = info->open(info, NULL, (struct hw_common**)&gadget_translator);
- EXPECT_EQ(ret, 0) << "Fail to open usb gadget device (" << ret << ")";
+ ret = info->open(info, NULL, (struct hw_common**)&board_dev);
+ EXPECT_EQ(ret, 0) << "Fail to open board device (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, EnableP)
+TEST_F(BOARDHalTest, GetDeviceSerialP)
{
int ret;
- char str[256];
+ char *serial;
- if (!supported)
+ if (!board_dev || !board_dev->get_device_serial) {
+ cout << "There is no function for get_device_serial" << endl;
return;
+ }
+ ret = board_dev->get_device_serial(&serial);
+ EXPECT_EQ(ret, 0) << "Fail to get device serial (" << ret << ")";
+}
- //dummy code to prevent error for not used function
- snprintf(str, 255, "%s,", _available_funcs[2]->name);
+TEST_F(BOARDHalTest, GetDeviceRevisionP)
+{
+ int ret, revision;
- if (!client_dev || !client_dev->enable) {
- cout << "There is no function for enable" << endl;
+ if (!board_dev || !board_dev->get_device_revision) {
+ cout << "There is no function for get_device_revision" << endl;
return;
}
- ret = client_dev->enable(client_dev);
- EXPECT_EQ(ret, 0) << "Fail to enable (" << ret << ")";
+ ret = board_dev->get_device_revision(&revision);
+ EXPECT_EQ(ret, 0) << "Fail to get device revision (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, ReConfigureGadgetP)
+TEST_F(BOARDHalTest, DeinitP)
+{
+ int ret;
+
+ if (!info || !info->close) {
+ cout << "There is no function for info close" << endl;
+ return;
+ }
+ ret = info->close((struct hw_common *)board_dev);
+ EXPECT_EQ(ret, 0) << "Fail to close board device (" << ret << ")";
+}
+
+/*
+ * Testcase for Bezel
+ */
+TEST_F(BEZELHalTest, InitP)
{
int ret;
if (!supported)
return;
- if (!gadget_translator || !gadget_translator->id_to_gadget) {
- cout << "There is no function for id_to_gadget" << endl;
+ info = NULL;
+ ret = hw_get_info(BEZEL_HARDWARE_DEVICE_ID,
+ (const struct hw_info **)&info);
+ if (ret < 0) {
+ cout << "There is no device for bezel" << ret << endl;
return;
+ } else {
+ EXPECT_EQ(ret, 0) << "Fail to get hal for bezel (" << ret << ")";
}
- gadget_id.function_mask = 7;
- ret = gadget_translator->id_to_gadget(&gadget_id, &gadget_dev);
- EXPECT_EQ(ret, 0) << "Fail to id_to_gadget (" << ret << ")";
- if (!client_dev || !client_dev->disable) {
- cout << "There is no function for disable" << endl;
+ if (!info || !info->open) {
+ cout << "There is no function for info open" << endl;
return;
}
- ret = client_dev->disable(client_dev);
- EXPECT_EQ(ret, 0) << "Fail to disable (" << ret << ")";
+ ret = info->open(info, NULL, (struct hw_common**)&bezel_dev);
+ EXPECT_EQ(ret, 0) << "Fail to open bezel device (" << ret << ")";
+}
- if (!client_dev || !client_dev->reconfigure_gadget) {
- cout << "There is no function for reconfigure_gadget" << endl;
+TEST_F(BEZELHalTest, GetStateP)
+{
+ enum bezel_state state;
+ int ret;
+
+ if (!supported)
+ return;
+
+ if (!bezel_dev || !bezel_dev->get_state) {
+ cout << "There is no function for get_info" << endl;
return;
}
- ret = client_dev->reconfigure_gadget(client_dev, gadget_dev);
- EXPECT_EQ(ret, 0) << "Fail to reconfigure_gadget (" << ret << ")";
+ ret = bezel_dev->get_state(&state);
+ EXPECT_EQ(ret, 0) << "Fail to get_state (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, IsGadgetSupportedP)
+TEST_F(BEZELHalTest, SetStateP)
{
- bool flag;
+ enum bezel_state state = BEZEL_TURNON;
+ int ret;
if (!supported)
return;
- if (!client_dev || !client_dev->is_gadget_supported) {
- cout << "There is no function for is_gadget_supported" << endl;
+ if (!bezel_dev || !bezel_dev->set_state) {
+ cout << "There is no function for set_state" << endl;
return;
}
- flag = client_dev->is_gadget_supported(client_dev, gadget_dev);
- EXPECT_EQ(flag, true) << "Fail to is_gadget_supported (" << flag << ")";
+ ret = bezel_dev->set_state(state);
+ EXPECT_EQ(ret, 0) << "Fail to get_state (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, IsFunctionSupportedP)
+TEST_F(BEZELHalTest, DeinitP)
{
- bool flag;
+ int ret;
if (!supported)
return;
- if (!client_dev || !client_dev->is_function_supported) {
- cout << "There is no function for is_function_supported" << endl;
+ if (!info || !info->close) {
+ cout << "There is no function for info close" << endl;
+ return;
+ }
+ ret = info->close((struct hw_common *)bezel_dev);
+ EXPECT_EQ(ret, 0) << "Fail to close bezel device (" << ret << ")";
+}
+
+/*
+ * Testcase for Client
+ */
+TEST_F(USBCLIENTHalTest, InitP)
+{
+ int ret;
+
+ if (!supported)
+ return;
+
+ info = NULL;
+ ret = hw_get_info(USB_CLIENT_HARDWARE_DEVICE_ID,
+ (const struct hw_info **)&info);
+ if (ret < 0) {
+ cout << "There is no device for usb client" << ret << endl;
+ return;
+ } else {
+ EXPECT_EQ(ret, 0) << "Fail to get hal for usb client (" << ret << ")";
+ }
+ if (!info || !info->open) {
+ cout << "There is no function for info open" << endl;
+ return;
+ }
+ ret = info->open(info, NULL, (struct hw_common**)&client_dev);
+ EXPECT_EQ(ret, 0) << "Fail to open usb client device (" << ret << ")";
+ EXPECT_NE(client_dev, nullptr) << "Fail to get usb client device structure";
+
+ ret = hw_get_info(USB_GADGET_DEVICE_ID,
+ (const struct hw_info **)&info);
+ if (ret < 0) {
+ cout << "There is no device for usb gadget" << ret << endl;
+ return;
+ } else {
+ EXPECT_EQ(ret, 0) << "Fail to get hal for usb gadget (" << ret << ")";
+ }
+
+ if (!info || !info->open) {
+ cout << "There is no function for info open" << endl;
return;
}
- flag = client_dev->is_function_supported(client_dev, *gadget_dev->funcs);
- EXPECT_EQ(flag, true) << "Fail to is_function_supported (" << flag << ")";
+ ret = info->open(info, NULL, (struct hw_common**)&gadget_translator);
+ EXPECT_EQ(ret, 0) << "Fail to open usb gadget device (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, GetCurrentGadgetP)
+TEST_F(USBCLIENTHalTest, EnableP)
{
int ret;
if (!supported)
return;
- if (!client_dev || !client_dev->get_current_gadget) {
- cout << "There is no function for get_current_gadget" << endl;
+ if (!client_dev || !client_dev->enable) {
+ cout << "There is no function for enable" << endl;
return;
}
- ret = client_dev->get_current_gadget(client_dev, &gadget_dev);
- EXPECT_EQ(ret, 0) << "Fail to get_current_gadget (" << ret << ")";
+ ret = client_dev->enable(client_dev);
+ EXPECT_EQ(ret, 0) << "Fail to enable (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, DisableP)
+TEST_F(USBCLIENTHalTest, ReConfigureGadgetP)
{
int ret;
if (!supported)
return;
+ if (!gadget_translator || !gadget_translator->id_to_gadget) {
+ cout << "There is no function for id_to_gadget" << endl;
+ return;
+ }
+ gadget_id.function_mask = 7;
+ ret = gadget_translator->id_to_gadget(&gadget_id, &gadget_dev);
+ EXPECT_EQ(ret, 0) << "Fail to id_to_gadget (" << ret << ")";
+
if (!client_dev || !client_dev->disable) {
cout << "There is no function for disable" << endl;
return;
}
ret = client_dev->disable(client_dev);
EXPECT_EQ(ret, 0) << "Fail to disable (" << ret << ")";
+
+ if (!client_dev || !client_dev->reconfigure_gadget) {
+ cout << "There is no function for reconfigure_gadget" << endl;
+ return;
+ }
+ ret = client_dev->reconfigure_gadget(client_dev, gadget_dev);
+ EXPECT_EQ(ret, 0) << "Fail to reconfigure_gadget (" << ret << ")";
}
-TEST_F(USBCLIENTHalTest, FreeGadgetP)
+TEST_F(USBCLIENTHalTest, DisableP)
{
+ int ret;
+
if (!supported)
return;
- if (!client_dev || !client_dev->free_gadget) {
- cout << "There is no function for free_gadget" << endl;
+ if (!client_dev || !client_dev->disable) {
+ cout << "There is no function for disable" << endl;
return;
}
- client_dev->free_gadget(gadget_dev);
+ ret = client_dev->disable(client_dev);
+ EXPECT_EQ(ret, 0) << "Fail to disable (" << ret << ")";
}
TEST_F(USBCLIENTHalTest, DeinitP)
{
int ret;
+ info = NULL;
ret = hw_get_info(USB_GADGET_DEVICE_ID,
(const struct hw_info **)&info);
if (ret < 0) {
{
struct usb_gadget_id gadget_id;
int ret;
- char str[256];
if (!gadget_translator || !gadget_translator->id_to_gadget) {
cout << "There is no function for id_to_gadget" << endl;
return;
}
- //dummy code to prevent error for not used function
- snprintf(str, 255, "%s,", _available_funcs[2]->name);
+
gadget_id.function_mask = 7;
ret = gadget_translator->id_to_gadget(&gadget_id, &gadget_dev);
EXPECT_EQ(ret, 0) << "Fail to id_to_gadget (" << ret << ")";
int main(int argc, char **argv)
{
- testing::InitGoogleTest(&argc, argv);
+ int ret = -1;
+
+ try {
+ testing::InitGoogleTest(&argc, argv);
+ } catch(...) {
+ std::cout << "Exception occurred." << std::endl;
+ }
+
+ try {
+ ret = RUN_ALL_TESTS();
+ } catch (const ::testing::internal::GoogleTestFailureException& e) {
+ ret = -1;
+ std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;
+ }
- return RUN_ALL_TESTS();
+ return ret;
}
projects / platform / core / system / libdevice-node.git / blobdiff