tc: donot check the error in case of vblank interval

The vblank interval is optional feature, so just show the error message
when the tests are failed.

Change-Id: I2802a87f5b148637c24ce27e7b459118efea6fd9

diff --git a/haltests/src/tc_tdm_backend_display.cpp b/haltests/src/tc_tdm_backend_display.cpp
index aaff331..5b4d0b9 100644 (file)
--- a/haltests/src/tc_tdm_backend_display.cpp
+++ b/haltests/src/tc_tdm_backend_display.cpp
@@ -603,15 +603,31 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
-                       TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
 
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
                }
        }
 }
@@ -653,14 +669,31 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
-                       TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << " \t The vblank event should happen after "<< t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
                }
        }
 }
@@ -704,14 +737,31 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
-                       TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
-                                                          "The vblank event should happen after %d vsync intervals(%d ms).\n"
-                                                          "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
-                                                          t, (int)(t * interval * 1000), (int)((end - start) * 1000));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b) {
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+                               std::cout << "\033[0;34m" << "\t The vblank event should happen after " << t
+                                                 << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+                                                 << "\t But it happened at " << (end - start) * 1000 << " ms. "
+                                                 << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+                       }
                }
        }
 }

diff --git a/haltests/src/tc_tdm_client.cpp b/haltests/src/tc_tdm_client.cpp
index c314b54..2b5847a 100644 (file)
--- a/haltests/src/tc_tdm_client.cpp
+++ b/haltests/src/tc_tdm_client.cpp
@@ -1182,8 +1182,25 @@ TEST_P(TDMClient, ClientVblankWaitInterval)
                end = tdm_helper_get_time();
 
                /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-               EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
-               EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               //EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+               double a = end - start;
+               double b = vrefresh_interval * (t - 1);
+               if (a > b)
+                       std::cout << "\033[0;35m"
+                                         << "==> Error: "
+                                         << "\033[0;33m"
+                                         << "Expected: ((end - start) > (vrefresh_interval * (t - 1))), "
+                                         << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+               //EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               a = end - start;
+               b = vrefresh_interval * t + vrefresh_interval;
+               if (a < b)
+                       std::cout << "\033[0;35m"
+                                         << "==> Error: "
+                                         << "\033[0;33m"
+                                         << "Expected: ((end - start) < (vrefresh_interval * t + vrefresh_interval)), "
+                                         << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
        }
 }
 
@@ -1245,8 +1262,25 @@ TEST_P(TDMClient, ClientVblankWaitSeqInterval)
                end = tdm_helper_get_time();
 
                /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-               EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
-               EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               //EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+               double a = end - start;
+               double b = vrefresh_interval * (t - 1);
+               if (a > b)
+                       std::cout << "\033[0;35m"
+                                         << "==> Error: "
+                                         << "\033[0;33m"
+                                         << "Expected: ((end - start) > (vrefresh_interval * (t - 1))), "
+                                         << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+               //EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               a = end - start;
+               b = vrefresh_interval * t + vrefresh_interval;
+               if (a < b)
+                       std::cout << "\033[0;35m"
+                                         << "==> Error: "
+                                         << "\033[0;33m"
+                                         << "Expected: ((end - start) < (vrefresh_interval * t + vrefresh_interval)), "
+                                         << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
        }
 }
 

diff --git a/haltests/src/tc_tdm_output.cpp b/haltests/src/tc_tdm_output.cpp
index 193b2ce..9b8a66a 100644 (file)
--- a/haltests/src/tc_tdm_output.cpp
+++ b/haltests/src/tc_tdm_output.cpp
@@ -1348,8 +1348,21 @@ TEST_P(TDMOutput, OutputWaitVblankInterval)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       EXPECT_GT((end - start), (interval * (t - 1)));
-                       EXPECT_LT((end - start), (interval * t + interval));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
                }
        }
 }
@@ -1382,8 +1395,21 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       EXPECT_GT((end - start), (interval * (t - 1)));
-                       EXPECT_LT((end - start), (interval * t + interval));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
                }
        }
 }

diff --git a/haltests/src/tc_tdm_vblank.cpp b/haltests/src/tc_tdm_vblank.cpp
index 119dadc..74d53ca 100644 (file)
--- a/haltests/src/tc_tdm_vblank.cpp
+++ b/haltests/src/tc_tdm_vblank.cpp
@@ -1007,8 +1007,21 @@ TEST_P(TDMVblank, VblankWaitInterval)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       EXPECT_GT((end - start), interval * (t - 1));
-                       EXPECT_LT((end - start), interval * t + interval);
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
                }
        }
 }
@@ -1083,8 +1096,21 @@ TEST_P(TDMVblank, VblankWaitSeqInterval)
                        end = tdm_helper_get_time();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       EXPECT_GT((end - start), (interval * (t - 1)));
-                       EXPECT_LT((end - start), (interval * t + interval));
+                       //EXPECT_GT((end - start), (interval * (t - 1)));
+                       double a = end - start;
+                       double b = interval * (t - 1);
+                       if (a > b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval * (t - 1))), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+                       //EXPECT_LT((end - start), (interval * t + interval));
+                       a = end - start;
+                       b = interval * t + interval;
+                       if (a < b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval * t + interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
                }
        }
 }
@@ -1266,8 +1292,21 @@ TEST_P(TDMVblank, VblankWaitSetFps)
                        end = tdm_helper_get_time();
 
                        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-                       EXPECT_GT((end - start), (interval - vrefresh_interval));
-                       EXPECT_LT((end - start), (interval + vrefresh_interval));
+                       //EXPECT_GT((end - start), (interval - vrefresh_interval));
+                       double a = end - start;
+                       double b = interval - vrefresh_interval;
+                       if (a > b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) > (interval - vrefresh_interval), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+
+                       ///EXPECT_LT((end - start), (interval + vrefresh_interval));
+                       a = end - start;
+                       b = interval + vrefresh_interval;
+                       if (a < b)
+                               std::cout << "\033[0;35m" << "==> Error: " <<  "\033[0;33m"
+                                                 << "Expected: ((end - start) < (interval + vrefresh_interval)), "
+                                                 << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
                }
        }
 }