{
TDMDisplay::SetUp();
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
- ASSERT_GE(output_count, 0);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_GE(output_count, 0);
if (output_count > 0) {
outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
- ASSERT_NE(outputs, NULL);
+ EXPECT_NE(outputs, NULL);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
outputs[o] = output;
}
has_outputs = true;
{
if (outputs) {
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done3);
for (int o = 0; o < output_count; o++) {
tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
- ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetBackendModuleNullOther)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
+ EXPECT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
}
}
for (int o = 0; o < output_count; o++) {
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
- ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
+ EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetCapabilitiesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetModelInfo)
for (int o = 0; o < output_count; o++) {
const char *maker = NULL, *model = NULL, *name = NULL;
- ASSERT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
- ASSERT_NE(maker, NULL);
- ASSERT_NE(model, NULL);
- ASSERT_NE(name, NULL);
+ EXPECT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
+ EXPECT_NE(maker, NULL);
+ EXPECT_NE(model, NULL);
+ EXPECT_NE(name, NULL);
}
}
const char *model = (const char*)TDM_UT_INVALID_VALUE;
const char *name = (const char*)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetModelInfoNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetConnStatus)
for (int o = 0; o < output_count; o++) {
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
- ASSERT_NE(status, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
+ EXPECT_NE(status, TDM_UT_INVALID_VALUE);
}
}
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetConnStatusNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetOutputType)
for (int o = 0; o < output_count; o++) {
tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
- ASSERT_NE(type, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
+ EXPECT_NE(type, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetOutputTypeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetLayerCount)
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(count, 0);
} else {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetLayerCountNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetLayer)
int layer_count = TDM_UT_INVALID_VALUE;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(layer_count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(layer_count, 0);
layer = tdm_output_get_layer(outputs[o], 0, &ret);
- ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(layer, NULL);
} else {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
- ASSERT_GT(layer_count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
+ EXPECT_GT(layer_count, 0);
for (int l = 0; l < layer_count; l++) {
tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
}
}
}
tdm_error ret;
tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(layer, NULL);
}
TEST_P(TDMOutput, OutputGetLayerNullOther)
tdm_layer *layer;
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
layer = tdm_output_get_layer(outputs[0], 0, NULL);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(layer, NULL);
} else {
layer = tdm_output_get_layer(outputs[0], 0, NULL);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
}
}
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0)
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
}
}
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetAvailableModes)
int count = TDM_UT_INVALID_VALUE;
const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
- ASSERT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
+ EXPECT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
}
}
int count = TDM_UT_INVALID_VALUE;
const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailableModesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetAvailableSize)
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE);
}
}
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailableSizeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetCursorAvailableSize)
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5)) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5)) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5))
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion)
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major <= 1 && minor < 5) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
for (int o = 0; o < output_count; o++) {
unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
- ASSERT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
- ASSERT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
+ EXPECT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetSubpixel)
for (int o = 0; o < output_count; o++) {
unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
- ASSERT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
+ EXPECT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetSubpixelNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetPipe)
for (int o = 0; o < output_count; o++) {
unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
- ASSERT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
+ EXPECT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPipeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetPrimaryIndex)
int primary_index = TDM_UT_INVALID_VALUE;
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
- ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
+ EXPECT_NE(primary_index, TDM_UT_INVALID_VALUE);
} else
TDM_UT_SKIP_FLAG(0);
}
TDM_UT_SKIP_FLAG(has_outputs);
int primary_index = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(primary_index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(primary_index, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, DISABLED_OutputSetProperty)
{
tdm_value value = {.s32 = 0};
- ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetProperty)
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0) {
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
for (int i = 0; i < count; i++) {
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
- ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
+ EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPropertyNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullObject)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputRemoveChangeHandler)
for (int o = 0; o < output_count; o++) {
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
done2 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(done2, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(done2, true);
done3 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done3, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done3, true);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_NE(modes, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_NE(modes, NULL);
+ EXPECT_GT(count, 0);
for (int m = 0; m < count; m++)
- ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputSetModeNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_NE(modes, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_NE(modes, NULL);
+ EXPECT_GT(count, 0);
for (int m = 0; m < count; m++) {
const tdm_output_mode *current_mode;
- ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
- ASSERT_EQ(current_mode, modes + m);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(current_mode, modes + m);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
const tdm_output_mode *current_mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetModeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetModeNoSet)
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
- ASSERT_EQ(mode, NULL);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(mode, NULL);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (tc_tdm_output_is_aod_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
} else {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputSetDpmsNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMOutput, OutputSetDpmsAsync)
continue;
done1 = false;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
if (tc_tdm_output_is_aod_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
} else {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_dpms dpms_value = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetDpmsNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblank)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (interval + interval));
+ EXPECT_LT((end - start), (interval + interval));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
usleep(1100000);
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
+ EXPECT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankInterval)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (interval * (t - 1)));
- ASSERT_LT((end - start), (interval * t + interval));
+ EXPECT_GT((end - start), (interval * (t - 1)));
+ EXPECT_LT((end - start), (interval * t + interval));
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (interval * (t - 1)));
- ASSERT_LT((end - start), (interval * t + interval));
+ EXPECT_GT((end - start), (interval * (t - 1)));
+ EXPECT_LT((end - start), (interval * t + interval));
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
for (int t = 0; t < 10; t++) {
bool done = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
if (t == 9)
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
done1 = false;
start = tdm_helper_get_time();
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (interval + interval));
+ EXPECT_LT((end - start), (interval + interval));
} else
TDM_UT_SKIP_FLAG(0);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputCommitNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_aod_enable(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
for (int t = 0; t < 10; t++) {
done1 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
- ASSERT_NE(index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
+ EXPECT_NE(index, TDM_UT_INVALID_VALUE);
} else
TDM_UT_SKIP_FLAG(0);
layer = tdm_output_get_layer(outputs[o], index, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
else
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
}
}
for (int o = 0; o < output_count; o++) {
if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
projects / platform / core / uifw / libtdm.git / blobdiff