Remove timer in favor of sdeventplus/utility/timer

This removes the custom timer implementation and moves to the
sdeventplus utility. Functionally this should make no change

Tested:
    Built and run through the unit test suite.

Change-Id: Ib7ee90d489d5db72496aaaca91c3cf5490ad47d6
Signed-off-by: William A. Kennington III <wak@google.com>

3 files changed, 0 insertions, 351 deletions

diff --git a/test/.gitignore b/test/.gitignore
deleted file mode 100644
index 0e55de9..0000000
--- a/test/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/timertest
diff --git a/test/Makefile.am b/test/Makefile.am
deleted file mode 100644
index c4cd77d..0000000
--- a/test/Makefile.am
+++ /dev/null
@@ -1,13 +0,0 @@
-AM_CPPFLAGS = -I$(top_srcdir)
-
-# Run all 'check' test programs
-TESTS = $(check_PROGRAMS)
-
-# # Build/add timertest to test suite
-check_PROGRAMS = timertest
-timertest_CPPFLAGS = -Igtest $(GTEST_CPPFLAGS) $(AM_CPPFLAGS)
-timertest_CXXFLAGS = $(PTHREAD_CFLAGS) ${PHOSPHOR_DBUS_INTERFACES_CFLAGS}
-timertest_LDFLAGS = -lgtest_main -lgtest $(PTHREAD_LIBS) $(OESDK_TESTCASE_FLAGS) \
-                    $(SYSTEMD_LIBS) ${SDBUSPLUS_LIBS} $(SDEVENTPLUS_LIBS) ${PHOSPHOR_DBUS_INTERFACES_LIBS}
-timertest_SOURCES = timertest.cpp
-timertest_LDADD = $(top_builddir)/timer.o
diff --git a/test/timertest.cpp b/test/timertest.cpp
deleted file mode 100644
index 845a0e1..0000000
--- a/test/timertest.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-/**
- * Copyright © 2017 IBM Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <iostream>
-#include <chrono>
-#include <gtest/gtest.h>
-#include <sdeventplus/event.hpp>
-#include "timer.hpp"
-
-/**
- * Testcases for the Timer class
- */
-
-using namespace phosphor::fan::util;
-using namespace std::chrono;
-
-
-/**
- * Class to ensure sd_events are correctly
- * setup and destroyed.
- */
-class TimerTest : public ::testing::Test
-{
-    public:
-        // event loop
-        sdeventplus::Event event;
-
-        // Gets called as part of each TEST_F construction
-        TimerTest() : event(sdeventplus::Event::get_default())
-        { }
-};
-
-/**
- * Helper class to hande tracking timer expirations
- * via callback functions.
- */
-class CallbackTester
-{
-    public:
-
-        CallbackTester() {}
-
-        size_t getCount()
-        {
-            return _count;
-        }
-
-        void callbackFunction()
-        {
-            _count++;
-            _gotCallback = true;
-        }
-
-        bool gotCallback()
-        {
-            return _gotCallback;
-        }
-
-    private:
-        bool _gotCallback = false;
-        size_t _count = 0;
-};
-
-
-/**
- * Helper class that more closely mimics real usage,
- * which is another class containing a timer and using
- * one of its member functions as the callback.
- */
-class CallbackTesterWithTimer : public CallbackTester
-{
-    public:
-        CallbackTesterWithTimer(const sdeventplus::Event& event) :
-            _timer(event,
-                   std::bind(&CallbackTesterWithTimer::callbackFunction,
-                             this))
-        {
-        }
-
-        void callbackFunction()
-        {
-            //restart the timer once from the callback
-            if (!_restarted)
-            {
-                _restarted = true;
-                auto time = duration_cast<microseconds>(seconds(1));
-                _timer.start(time, Timer::TimerType::oneshot);
-            }
-
-            CallbackTester::callbackFunction();
-        }
-
-        Timer& getTimer()
-        {
-            return _timer;
-        }
-
-        inline bool restarted() const
-        {
-            return _restarted;
-        }
-
-    private:
-
-        Timer _timer;
-        bool _restarted = false;
-};
-
-
-/**
- * Test that a callback will occur after 2 seconds.
- */
-TEST_F(TimerTest, timerExpiresAfter2seconds)
-{
-    CallbackTester tester;
-
-    Timer timer(event,
-                std::bind(&CallbackTester::callbackFunction, &tester));
-
-
-    auto time = duration_cast<microseconds>(seconds(2));
-
-    EXPECT_EQ(false, timer.running());
-
-    timer.start(time, Timer::TimerType::oneshot);
-    EXPECT_EQ(false, tester.gotCallback());
-    EXPECT_EQ(true, timer.running());
-
-    int count = 0;
-
-    //Wait for 2 1s timeouts
-    while (count < 2)
-    {
-        // Returns 0 on timeout and positive number on dispatch
-        if (event.run(seconds(1)) == 0)
-        {
-            count++;
-        }
-    }
-
-    EXPECT_EQ(true, tester.gotCallback());
-    EXPECT_EQ(1, tester.getCount());
-    EXPECT_EQ(false, timer.running());
-}
-
-/**
- * Test that a timer can be restarted.
- */
-TEST_F(TimerTest, timerRestart)
-{
-    CallbackTester tester;
-
-    Timer timer(event,
-                std::bind(&CallbackTester::callbackFunction, &tester));
-
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    timer.start(time, Timer::TimerType::oneshot);
-
-    //wait for a second
-    auto rc = event.run(seconds(1));
-
-    //expect the timeout, not the dispatch
-    //and the timer should still be running
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(true, timer.running());
-
-    //Restart it
-    timer.start(time, Timer::TimerType::oneshot);
-
-    //Wait just 1s, make sure not done
-    rc = event.run(seconds(1));
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(true, timer.running());
-    EXPECT_EQ(false, tester.gotCallback());
-
-    //Wait 1 more second, this time expecting a dispatch
-    int count = 0;
-    while (count < 1)
-    {
-        // Returns 0 on timeout and positive number on dispatch
-        if (event.run(seconds(1)) == 0)
-        {
-            count++;
-        }
-    }
-
-    EXPECT_EQ(true, tester.gotCallback());
-    EXPECT_EQ(1, tester.getCount());
-    EXPECT_EQ(false, timer.running());
-}
-
-
-/**
- * Test that a timer can be stopped.
- */
-TEST_F(TimerTest, timerStop)
-{
-    CallbackTester tester;
-
-    Timer timer(event,
-                std::bind(&CallbackTester::callbackFunction, &tester));
-
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    timer.start(time, Timer::TimerType::oneshot);
-
-    //wait 1s
-    auto rc = event.run(seconds(1));
-
-    //expect the timeout, not the dispatch
-    EXPECT_EQ(rc, 0);
-    EXPECT_EQ(true, timer.running());
-
-    timer.stop();
-
-    EXPECT_EQ(false, timer.running());
-    EXPECT_EQ(false, tester.gotCallback());
-
-    //Wait another 2s, make sure no callbacks happened
-    rc = event.run(seconds(2));
-
-    EXPECT_EQ(rc, 0);
-    EXPECT_EQ(false, timer.running());
-    EXPECT_EQ(false, tester.gotCallback());
-}
-
-
-/**
- * Test that the timer can be restarted from within
- * a callback function.
- */
-TEST_F(TimerTest, timerRestartFromCallback)
-{
-    CallbackTesterWithTimer tester(event);
-
-    auto& timer = tester.getTimer();
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    timer.start(time, Timer::TimerType::oneshot);
-
-    //after running for 2 seconds, the timer will get restarted
-    //for another 1s
-
-    int count = 0;
-    while (count < 3)
-    {
-        // Returns 0 on timeout and positive number on dispatch
-        if (event.run(seconds(1)) == 0)
-        {
-            count++;
-        }
-    }
-
-    EXPECT_EQ(false, timer.running());
-    EXPECT_EQ(true, tester.gotCallback());
-    EXPECT_EQ(2, tester.getCount()); //2 callbacks
-    EXPECT_EQ(true, tester.restarted());
-}
-
-/**
- * This shows what happens when the timer expires but
- * sd_event_run never got called.
- */
-TEST_F(TimerTest, timerNoEventRun)
-{
-    CallbackTester tester;
-
-    Timer timer(event,
-                std::bind(&CallbackTester::callbackFunction, &tester));
-
-
-    auto time = duration_cast<microseconds>(milliseconds(500));
-
-    timer.start(time, Timer::TimerType::oneshot);
-
-    sleep(1);
-
-    //The timer should have expired, but with no event processing
-    //it will still think it's running.
-
-    EXPECT_EQ(true, timer.running());
-    EXPECT_EQ(false, tester.gotCallback());
-
-    //Now process an event
-    auto rc = event.run(milliseconds(5));
-
-    EXPECT_GT(rc, 0);
-    EXPECT_EQ(false, timer.running());
-    EXPECT_EQ(true, tester.gotCallback());
-}
-
-
-/**
- * Tests that a timer in repeating mode will keep calling
- * the callback.
- */
-TEST_F(TimerTest, RepeatingTimer)
-{
-    CallbackTester tester;
-
-    Timer timer(event,
-                std::bind(&CallbackTester::callbackFunction, &tester));
-
-    auto time = duration_cast<microseconds>(seconds(1));
-    timer.start(time, Timer::TimerType::repeating);
-
-    int count = 0;
-
-    while (count < 5)
-    {
-        if (event.run(milliseconds(500)) == 0)
-        {
-            count++;
-        }
-    }
-
-    EXPECT_EQ(true, timer.running());
-    EXPECT_EQ(true, tester.gotCallback());
-    EXPECT_EQ(4, tester.getCount());
-
-    timer.stop();
-
-    EXPECT_EQ(false, timer.running());
-}