[Libreoffice-commits] core.git: vcl/Module_vcl.mk vcl/qa

[Ashod Nakashian]

 vcl/Module_vcl.mk        |    7 +++
 vcl/qa/cppunit/timer.cxx |  109 +++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 112 insertions(+), 4 deletions(-)

New commits:
commit b103e7d786f5b7ec6cfe4f53f2ca317f06ceabc5
Author: Ashod Nakashian <ashodnakashian at yahoo.com>
Date:   Thu Aug 20 21:06:06 2015 -0400

    vcl: unittests for Timer and AutoTimer.
    
    Enabled VCL Timer unittests on Windows builds and added two unittests to
    detect misfiring of timer events.
    
    Due to the nature of timer events having virtually no guarantees on
    non-realtime operating systems, the tests may fail randomly under
    different system loads.  The tests repeat a few times in such cases, but
    still there are no guarantees.
    
    These tests are added to detect gross breaks in the timer algorithms and
    to improve certain corner cases.  They are designed to minimize any
    random failures.
    
    Posterity might hate me for committing such unittests, so I added
    TEST_TIMERPRECISION directive to include/exclude the tests at compile
    time. It should be enabled if it causes more harm than good.
    
    Change-Id: If2856f194cb4732c84900113bdb969f397f67d5a
    Reviewed-on: https://gerrit.libreoffice.org/17906
    Reviewed-by: Thorsten Behrens <Thorsten.Behrens at CIB.de>
    Tested-by: Thorsten Behrens <Thorsten.Behrens at CIB.de>

diff --git a/vcl/Module_vcl.mk b/vcl/Module_vcl.mk
index c3e84e6..c949f42 100644
--- a/vcl/Module_vcl.mk
+++ b/vcl/Module_vcl.mk
@@ -123,4 +123,11 @@ $(eval $(call gb_Module_add_check_targets,vcl,\
 	CppunitTest_vcl_timer \
 ))
 endif
+
+# Is any configuration missing?
+ifeq ($(OS),WNT)
+$(eval $(call gb_Module_add_check_targets,vcl,\
+	CppunitTest_vcl_timer \
+))
+endif
 # vim: set noet sw=4 ts=4:
diff --git a/vcl/qa/cppunit/timer.cxx b/vcl/qa/cppunit/timer.cxx
index 88807fc..85dc9ac 100644
--- a/vcl/qa/cppunit/timer.cxx
+++ b/vcl/qa/cppunit/timer.cxx
@@ -22,6 +22,8 @@
 #include "salinst.hxx"
 
 // #define TEST_WATCHDOG
+// Comment if UT fails randomly.
+#define TEST_TIMERPRECISION
 
 /// Avoid our timer tests just wedging the build if they fail.
 class WatchDog : public osl::Thread
@@ -44,7 +46,7 @@ public:
     }
 };
 
-static WatchDog aWatchDog( 10 /* 10 secs should be enough */);
+static WatchDog aWatchDog( 12 /* 12 secs should be enough */);
 
 class TimerTest : public test::BootstrapFixture
 {
@@ -58,6 +60,7 @@ public:
 #endif
     void testDurations();
     void testAutoTimer();
+    void testMultiAutoTimers();
     void testRecursiveTimer();
     void testSlowTimerCallback();
 
@@ -69,6 +72,7 @@ public:
 #endif
     CPPUNIT_TEST(testDurations);
     CPPUNIT_TEST(testAutoTimer);
+    CPPUNIT_TEST(testMultiAutoTimers);
     CPPUNIT_TEST(testRecursiveTimer);
     CPPUNIT_TEST(testSlowTimerCallback);
 
@@ -117,6 +121,7 @@ void TimerTest::testIdle()
 // tdf#91727
 void TimerTest::testIdleMainloop()
 {
+#ifndef WNT
     bool bTriggered = false;
     IdleBool aTest( bTriggered );
     // coverity[loop_top] - Application::Yield allows the timer to fire and toggle bDone
@@ -131,6 +136,7 @@ void TimerTest::testIdleMainloop()
         pSVData->maAppData.mnDispatchLevel--;
     }
     CPPUNIT_ASSERT_MESSAGE("mainloop idle triggered", bTriggered);
+#endif
 }
 
 // --------------------------------------------------------------------
@@ -189,11 +195,106 @@ public:
 
 void TimerTest::testAutoTimer()
 {
+    const sal_Int32 nDurationMs = 30;
+    const sal_Int32 nEventsCount = 5;
+    const double exp = (nDurationMs * nEventsCount);
+
     sal_Int32 nCount = 0;
-    AutoTimerCount aCount(1, nCount);
-    while (nCount < 100) {
-        Application::Yield();
+    double dur = 0;
+    std::ostringstream msg;
+
+    // Repeat when we have random latencies.
+    // This is expected on non-realtime OSes.
+    for (int i = 0; i < 10; ++i)
+    {
+        const auto start = std::chrono::high_resolution_clock::now();
+        nCount = 0;
+        AutoTimerCount aCount(nDurationMs, nCount);
+        while (nCount < nEventsCount) {
+            Application::Yield();
+        }
+
+        const auto end = std::chrono::high_resolution_clock::now();
+        dur = std::chrono::duration<double, std::milli>(end - start).count();
+
+        msg << std::setprecision(2) << std::fixed
+            << "periodic multi-timer - dur: "
+            << dur << " (" << exp << ") ms." << std::endl;
+
+        // +/- 20% should be reasonable enough a margin.
+        if (dur >= (exp * 0.8) && dur <= (exp * 1.2))
+        {
+            // Success.
+            return;
+        }
+    }
+
+#ifdef TEST_TIMERPRECISION
+    CPPUNIT_FAIL(msg.str().c_str());
+#endif
+}
+
+void TimerTest::testMultiAutoTimers()
+{
+    // The behavior of the timers change drastically
+    // when multiple timers are present.
+    // The worst, in my tests, is when two
+    // timers with 1ms period exist with a
+    // third of much longer period.
+
+    const sal_Int32 nDurationMsX = 5;
+    const sal_Int32 nDurationMsY = 10;
+    const sal_Int32 nDurationMs = 40;
+    const sal_Int32 nEventsCount = 5;
+    const double exp = (nDurationMs * nEventsCount);
+    const double expX = (exp / nDurationMsX);
+    const double expY = (exp / nDurationMsY);
+
+    double dur = 0;
+    sal_Int32 nCountX = 0;
+    sal_Int32 nCountY = 0;
+    sal_Int32 nCount = 0;
+    std::ostringstream msg;
+
+    // Repeat when we have random latencies.
+    // This is expected on non-realtime OSes.
+    for (int i = 0; i < 10; ++i)
+    {
+        nCountX = 0;
+        nCountY = 0;
+        nCount = 0;
+
+        const auto start = std::chrono::high_resolution_clock::now();
+        AutoTimerCount aCountX(nDurationMsX, nCountX);
+        AutoTimerCount aCountY(nDurationMsY, nCountY);
+
+        AutoTimerCount aCount(nDurationMs, nCount);
+        while (nCount < nEventsCount) {
+            Application::Yield();
+        }
+
+        const auto end = std::chrono::high_resolution_clock::now();
+        dur = std::chrono::duration<double, std::milli>(end - start).count();
+
+        msg << std::setprecision(2) << std::fixed << "periodic multi-timer - dur: "
+            << dur << " (" << exp << ") ms, nCount: " << nCount
+            << " (" << nEventsCount << "), nCountX: " << nCountX
+            << " (" << expX << "), nCountY: " << nCountY
+            << " (" << expY << ")." << std::endl;
+
+        // +/- 20% should be reasonable enough a margin.
+        if (dur >= (exp * 0.8) && dur <= (exp * 1.2) &&
+            nCountX >= (expX * 0.8) && nCountX <= (expX * 1.2) &&
+            nCountY >= (expY * 0.8) && nCountY <= (expY * 1.2))
+        {
+            // Success.
+            return;
+        }
     }
+
+#ifdef TEST_TIMERPRECISION
+    CPPUNIT_FAIL(msg.str().c_str());
+#endif
 }
 
 // --------------------------------------------------------------------