How to use the zhmcclient.TimeStatsKeeper function in zhmcclient

def test_ts_str(self):
        """Test Timestats.__str__()."""

        keeper = TimeStatsKeeper()
        timestats = TimeStats(keeper, "foo")

        s = str(timestats)
        assert s.startswith("TimeStats:"), \
            "Unexpected str(timestats): %r" % s
        num_lines = len(s.split('\n'))
        assert num_lines == 1, \
            "Unexpected str(timestats): %r" % s

def test_str_one(self):
        """Test TimestatsKeeper.__str__() for an enabled keeper with one data
        item."""

        keeper = TimeStatsKeeper()
        keeper.enable()

        duration = 0.1

        stats = keeper.get_stats('foo')

        # produce a data item
        stats.begin()
        time.sleep(duration)
        stats.end()

        s = str(keeper)
        assert s.startswith(PRINT_HEADER), \
            "Unexpected str(keeper): %r" % s
        num_lines = len(s.split('\n'))
        assert num_lines == 3, \

def test_str_disabled(self):
        """Test TimestatsKeeper.__str__() for a disabled keeper."""

        keeper = TimeStatsKeeper()
        s = str(keeper)
        assert s == PRINT_HEADER_DISABLED

def test_measure_disabled(self):
        """Test measuring time with disabled keeper."""

        keeper = TimeStatsKeeper()

        duration = 0.2

        stats = keeper.get_stats('foo')
        assert stats.name == 'disabled'

        stats.begin()
        time.sleep(duration)
        stats.end()

        stats_dict = keeper.snapshot()
        for op_name in stats_dict:
            stats = stats_dict[op_name]
            assert stats.count == 0
            assert stats.avg_time == 0
            assert stats.min_time == float('inf')

def test_only_end(self):
        """Test that invoking end() before begin() has ever been called raises
        a RuntimeError exception."""

        keeper = TimeStatsKeeper()
        keeper.enable()
        stats = keeper.get_stats('foo')

        with pytest.raises(RuntimeError):
            stats.end()

def test_get(self):
        """Test getting time statistics."""

        keeper = TimeStatsKeeper()
        snapshot_length = len(keeper.snapshot())
        assert snapshot_length == 0, \
            "Verify that initial state has no time statistics. " \
            "Actual number = %d" % snapshot_length

        stats = keeper.get_stats('foo')
        snapshot_length = len(keeper.snapshot())
        assert snapshot_length == 0, \
            "Verify that getting a new stats with a disabled keeper results " \
            "in no time statistics. Actual number = %d" % snapshot_length
        assert stats.keeper == keeper
        assert stats.name == "disabled"  # stats for disabled keeper
        assert stats.count == 0
        assert stats.avg_time == 0
        assert stats.min_time == float('inf')
        assert stats.max_time == 0

def test_end_after_end(self):
        """Test that invoking end() after a begin/end sequence raises
        a RuntimeError exception."""

        keeper = TimeStatsKeeper()
        keeper.enable()
        stats = keeper.get_stats('foo')

        stats.begin()
        time.sleep(0.01)
        stats.end()

        with pytest.raises(RuntimeError):
            stats.end()

def test_snapshot(self):
        """Test that snapshot() takes a stable snapshot."""

        keeper = TimeStatsKeeper()
        keeper.enable()

        duration = 0.2

        stats = keeper.get_stats('foo')

        # produce a first data item
        stats.begin()
        time.sleep(duration)
        stats.end()

        # take the snapshot
        snap_stats_dict = keeper.snapshot()

        # produce a second data item
        stats.begin()

def test_str_empty(self):
        """Test TimestatsKeeper.__str__() for an empty enabled keeper."""

        keeper = TimeStatsKeeper()
        keeper.enable()
        s = str(keeper)
        assert s == PRINT_HEADER

def test_measure_avg_min_max(self):
        """Test measuring avg min max values."""

        keeper = TimeStatsKeeper()
        keeper.enable()

        # TimeStatsKeeper on Windows has only a precision of 1/60 sec
        durations = (0.6, 1.2, 1.5)
        delta = 0.08
        count = len(durations)

        stats = keeper.get_stats('foo')
        m_durations = []
        for duration in durations:
            m_durations.append(measure(stats, duration))

        min_dur = min(m_durations)
        max_dur = max(m_durations)
        avg_dur = sum(m_durations) / float(count)