debug-viewer/GstDebugViewer/tests/test_models.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8; mode: python; -*-
   3 #
   4 #  GStreamer Debug Viewer - View and analyze GStreamer debug log files
   5 #
   6 #  Copyright (C) 2007 René Stadler <mail@renestadler.de>
   7 #
   8 #  This program is free software; you can redistribute it and/or modify it
   9 #  under the terms of the GNU General Public License as published by the Free
  10 #  Software Foundation; either version 3 of the License, or (at your option)
  11 #  any later version.
  12 #
  13 #  This program is distributed in the hope that it will be useful, but WITHOUT
  14 #  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 #  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16 #  more details.
  17 #
  18 #  You should have received a copy of the GNU General Public License along with
  19 #  this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 """GStreamer Debug Viewer test suite for the custom tree models."""
  22
  23 import sys
  24 import os
  25 import os.path
  26 from glob import glob
  27
  28 from unittest import TestCase, main as test_main
  29
  30 from .. import Common, Data
  31 from .. GUI.filters import CategoryFilter, Filter
  32 from .. GUI.models import (FilteredLogModel,
  33                            LogModelBase,
  34                            SubRange,)
  35
  36
  37 class TestSubRange (TestCase):
  38
  39     def test_len(self):
  40
  41         values = list(range(20))
  42
  43         sr = SubRange(values, 0, 20)
  44         self.assertEqual(len(sr), 20)
  45
  46         sr = SubRange(values, 10, 20)
  47         self.assertEqual(len(sr), 10)
  48
  49         sr = SubRange(values, 0, 10)
  50         self.assertEqual(len(sr), 10)
  51
  52         sr = SubRange(values, 5, 15)
  53         self.assertEqual(len(sr), 10)
  54
  55     def test_iter(self):
  56
  57         values = list(range(20))
  58
  59         sr = SubRange(values, 0, 20)
  60         self.assertEqual(list(sr), values)
  61
  62         sr = SubRange(values, 10, 20)
  63         self.assertEqual(list(sr), list(range(10, 20)))
  64
  65         sr = SubRange(values, 0, 10)
  66         self.assertEqual(list(sr), list(range(0, 10)))
  67
  68         sr = SubRange(values, 5, 15)
  69         self.assertEqual(list(sr), list(range(5, 15)))
  70
  71
  72 class Model (LogModelBase):
  73
  74     def __init__(self):
  75
  76         LogModelBase.__init__(self)
  77
  78         for i in range(20):
  79             self.line_offsets.append(i * 100)
  80             self.line_levels.append(Data.debug_level_debug)
  81
  82     def ensure_cached(self, line_offset):
  83
  84         pid = line_offset // 100
  85         if pid % 2 == 0:
  86             category = b"EVEN"
  87         else:
  88             category = b"ODD"
  89
  90         line_fmt = (b"0:00:00.000000000 %5i 0x0000000 DEBUG "
  91                     b"%20s dummy.c:1:dummy: dummy")
  92         line_str = line_fmt % (pid, category,)
  93         log_line = Data.LogLine.parse_full(line_str)
  94         self.line_cache[line_offset] = log_line
  95
  96     def access_offset(self, line_offset):
  97
  98         return ""
  99
 100
 101 class IdentityFilter (Filter):
 102
 103     def __init__(self):
 104
 105         def filter_func(row):
 106             return True
 107         self.filter_func = filter_func
 108
 109
 110 class RandomFilter (Filter):
 111
 112     def __init__(self, seed):
 113
 114         import random
 115         rand = random.Random()
 116         rand.seed(seed)
 117
 118         def filter_func(row):
 119             return rand.choice((True, False,))
 120         self.filter_func = filter_func
 121
 122
 123 class TestDynamicFilter (TestCase):
 124
 125     def test_unset_filter_rerange(self):
 126
 127         full_model = Model()
 128         filtered_model = FilteredLogModel(full_model)
 129         row_list = self.__row_list
 130
 131         self.assertEqual(row_list(full_model), list(range(20)))
 132         self.assertEqual(row_list(filtered_model), list(range(20)))
 133
 134         filtered_model.set_range(5, 16)
 135
 136         self.assertEqual(row_list(filtered_model), list(range(5, 16)))
 137
 138     def test_identity_filter_rerange(self):
 139
 140         full_model = Model()
 141         filtered_model = FilteredLogModel(full_model)
 142         row_list = self.__row_list
 143
 144         self.assertEqual(row_list(full_model), list(range(20)))
 145         self.assertEqual(row_list(filtered_model), list(range(20)))
 146
 147         filtered_model.add_filter(IdentityFilter(),
 148                                   Common.Data.DefaultDispatcher())
 149         filtered_model.set_range(5, 16)
 150
 151         self.assertEqual(row_list(filtered_model), list(range(5, 16)))
 152
 153     def test_filtered_range_refilter_skip(self):
 154
 155         full_model = Model()
 156         filtered_model = FilteredLogModel(full_model)
 157
 158         row_list = self.__row_list
 159
 160         filtered_model.add_filter(CategoryFilter("EVEN"),
 161                                   Common.Data.DefaultDispatcher())
 162         self.__dump_model(filtered_model, "filtered")
 163
 164         self.assertEqual(row_list(filtered_model), list(range(1, 20, 2)))
 165         self.assertEqual([filtered_model.line_index_from_super(i)
 166                           for i in range(1, 20, 2)],
 167                          list(range(10)))
 168         self.assertEqual([filtered_model.line_index_to_super(i)
 169                           for i in range(10)],
 170                          list(range(1, 20, 2)))
 171
 172         filtered_model.set_range(1, 20)
 173         self.__dump_model(filtered_model, "ranged (1, 20)")
 174         self.__dump_model(filtered_model, "filtered range")
 175
 176         self.assertEqual([filtered_model.line_index_from_super(i)
 177                           for i in range(0, 19, 2)],
 178                          list(range(10)))
 179         self.assertEqual([filtered_model.line_index_to_super(i)
 180                           for i in range(10)],
 181                          list(range(1, 20, 2)))
 182
 183         filtered_model.set_range(2, 20)
 184         self.__dump_model(filtered_model, "ranged (2, 20)")
 185
 186         self.assertEqual(row_list(filtered_model), list(range(3, 20, 2)))
 187
 188     def test_filtered_range_refilter(self):
 189
 190         full_model = Model()
 191         filtered_model = FilteredLogModel(full_model)
 192
 193         row_list = self.__row_list
 194         rows = row_list(full_model)
 195         rows_filtered = row_list(filtered_model)
 196
 197         self.__dump_model(full_model, "full model")
 198
 199         self.assertEqual(rows, rows_filtered)
 200
 201         self.assertEqual([filtered_model.line_index_from_super(i)
 202                           for i in range(20)],
 203                          list(range(20)))
 204         self.assertEqual([filtered_model.line_index_to_super(i)
 205                           for i in range(20)],
 206                          list(range(20)))
 207
 208         filtered_model.set_range(5, 16)
 209         self.__dump_model(filtered_model, "ranged model (5, 16)")
 210
 211         rows_ranged = row_list(filtered_model)
 212         self.assertEqual(rows_ranged, list(range(5, 16)))
 213
 214         self.__dump_model(filtered_model, "filtered model (nofilter, 5, 15)")
 215
 216         filtered_model.add_filter(CategoryFilter("EVEN"),
 217                                   Common.Data.DefaultDispatcher())
 218         rows_filtered = row_list(filtered_model)
 219         self.assertEqual(rows_filtered, list(range(5, 16, 2)))
 220
 221         self.__dump_model(filtered_model, "filtered model")
 222
 223     def test_random_filtered_range_refilter(self):
 224
 225         full_model = Model()
 226         filtered_model = FilteredLogModel(full_model)
 227         row_list = self.__row_list
 228
 229         self.assertEqual(row_list(full_model), list(range(20)))
 230         self.assertEqual(row_list(filtered_model), list(range(20)))
 231
 232         filtered_model.add_filter(RandomFilter(538295943),
 233                                   Common.Data.DefaultDispatcher())
 234         random_rows = row_list(filtered_model)
 235
 236         self.__dump_model(filtered_model)
 237
 238         filtered_model = FilteredLogModel(full_model)
 239         filtered_model.add_filter(RandomFilter(538295943),
 240                                   Common.Data.DefaultDispatcher())
 241         self.__dump_model(filtered_model, "filtered model")
 242         self.assertEqual(row_list(filtered_model), random_rows)
 243
 244         filtered_model.set_range(1, 10)
 245         self.__dump_model(filtered_model)
 246         self.assertEqual(row_list(filtered_model), [
 247                          x for x in range(0, 10) if x in random_rows])
 248
 249     def __row_list(self, model):
 250
 251         return [row[Model.COL_PID] for row in model]
 252
 253     def __dump_model(self, model, comment=None):
 254
 255         # TODO: Provide a command line option to turn this on and off.
 256
 257         return
 258
 259         if not hasattr(model, "super_model"):
 260             # Top model.
 261             print("\t(%s)" % ("|".join([str(i).rjust(2)
 262                                         for i in self.__row_list(model)]),), end=' ')
 263         else:
 264             top_model = model.super_model
 265             if hasattr(top_model, "super_model"):
 266                 top_model = top_model.super_model
 267             top_indices = self.__row_list(top_model)
 268             positions = self.__row_list(model)
 269             output = ["  "] * len(top_indices)
 270             for i, position in enumerate(positions):
 271                 output[position] = str(i).rjust(2)
 272             print("\t(%s)" % ("|".join(output),), end=' ')
 273
 274         if comment is None:
 275             print()
 276         else:
 277             print(comment)
 278
 279
 280 if __name__ == "__main__":
 281     test_main()