Skip to content
Snippets Groups Projects
Commit a9996217 authored by Kien Le's avatar Kien Le
Browse files

Add tests for functions in plottingData.py

parent 5c99a818
No related branches found
No related tags found
1 merge request!19Add tests for function in plottingData.py
Hide whitespace changes
Inline Side-by-side
sohstationviewer/controller/plottingData.py
+ 12
− 10
View file @ a9996217
......@@ -7,7 +7,6 @@ import math
from obspy import UTCDateTime
from sohstationviewer.conf import constants as const
maxInt = 1E100
maxFloat = 1.0E100
......@@ -36,10 +35,12 @@ def getMassposValueColors(rangeOpt, chan_id, cMode, processing_log,
if rangeOpt.lower() not in MassPosVoltRanges.keys():
processing_log.append(
f"{chan_id}: The current selected Mass Position color range is "
f"'{rangeOpt}' isn't allowable. The accept ranges are: "
f"{', '.join(MassPosVoltRanges.keys())}",
"error"
(
f"{chan_id}: The current selected Mass Position color range is"
f" '{rangeOpt}' isn't allowable. The accept ranges are: "
f"{', '.join(MassPosVoltRanges.keys())}",
"error"
)
)
return
massPosVoltRange = MassPosVoltRanges[rangeOpt]
......@@ -54,7 +55,8 @@ def getMassposValueColors(rangeOpt, chan_id, cMode, processing_log,
if i == len(massPosVoltRange) - 1:
if retType == 'str':
valueColors.append(
"%s:+%s" % (massPosVoltRange[i], massPosColorPallet[i+1]))
"%s:+%s" % (
massPosVoltRange[i], massPosColorPallet[i + 1]))
else:
valueColors.append(
(massPosVoltRange[i], massPosColorPallet[i + 1]))
......@@ -102,7 +104,7 @@ def getTitle(key, minTime, maxTime, dateMode):
:return: title for the plot - str
"""
diff = maxTime - minTime
hours = diff/3600
hours = diff / 3600
return ("%s %s to %s (%s)" %
(key,
formatTime(minTime, dateMode, "HH:MM:SS"),
......@@ -193,10 +195,10 @@ def getDayTicks():
"""
times = list(range(const.NO_5M_1H, const.NO_5M_DAY, const.NO_5M_1H))
majorTimes = list(range(4*const.NO_5M_1H,
majorTimes = list(range(4 * const.NO_5M_1H,
const.NO_5M_DAY,
4*const.NO_5M_1H))
majorTimeLabels = ["%02d" % int(t/const.NO_5M_1H) for t in majorTimes]
4 * const.NO_5M_1H))
majorTimeLabels = ["%02d" % int(t / const.NO_5M_1H) for t in majorTimes]
return times, majorTimes, majorTimeLabels
......
tests/test_controller/test_plotting_data.py 0 → 100644
+ 649
− 0
View file @ a9996217
"""Tests for functions defined in sohstationviewer.controller.plottingData"""
from unittest import TestCase
from obspy import UTCDateTime
from sohstationviewer.controller.plottingData import (
getMassposValueColors,
formatTime,
getTitle,
getGaps,
getTimeTicks,
getDayTicks,
getUnitBitweight
)
class TestGetGaps(TestCase):
"""Test suite for getGaps."""
def test_mixed_gap_sizes(self):
"""
Test getGaps - the given list of gaps contain both gaps that are too
short and gaps that are long enough.
"""
gaps = [(0, 60), (60, 180), (180, 360)]
min_gap = 3
self.assertListEqual(getGaps(gaps, min_gap), [(180, 360)])
def test_empty_gap_list(self):
"""
Test getGaps - the given list of gaps is empty.
"""
gaps = []
min_gap = 3
self.assertListEqual(getGaps(gaps, min_gap), [])
def test_all_gaps_are_too_short(self):
"""
Test getGaps - the given list of gaps only contain gaps that are too
short.
"""
gaps = [(0, 60), (60, 180)]
min_gap = 3
self.assertListEqual(getGaps(gaps, min_gap), [])
def test_all_gaps_are_long_enough(self):
"""
Test getGaps - the given list of gaps only contain gaps that are long
enough.
"""
gaps = [(0, 180), (180, 360)]
min_gap = 3
self.assertListEqual(getGaps(gaps, min_gap), [(0, 180), (180, 360)])
class TestGetDayTicks(TestCase):
"""Test suite for getDayTicks."""
def test_get_day_ticks(self):
"""Test getDayTicks."""
expected = (
[12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180,
192, 204, 216, 228, 240, 252, 264, 276],
[48, 96, 144, 192, 240],
['04', '08', '12', '16', '20']
)
self.assertTupleEqual(getDayTicks(), expected)
class TestGetMassposValue(TestCase):
"""Test suite for getMasspossValue"""
def test_string_output(self):
"""
Test basic functionality of getMassposValueColors - the range option
and color mode are correct, and the output is a string.
"""
expected_input_output_pairs = {
('regular', 'B'): '0.5:C|2.0:G|4.0:Y|7.0:R|7.0:+M',
('regular', 'W'): '0.5:B|2.0:B|4.0:B|7.0:B|7.0:+B',
('trillium', 'B'): '0.5:C|1.8:G|2.4:Y|3.5:R|3.5:+M',
('trillium', 'W'): '0.5:B|1.8:B|2.4:B|3.5:B|3.5:+B',
}
test_names = (
'test_regular_B',
'test_regular_W',
'test_trillium_B',
'test_trillium_W',
)
idx = 0
for input_val in expected_input_output_pairs:
with self.subTest(test_names[idx]):
self.assertEqual(
getMassposValueColors(input_val[0], '', input_val[1], []),
expected_input_output_pairs[input_val]
)
idx += 1
def test_list_output(self):
"""
Test basic functionality of getMassposValueColors - the range option
and color mode are correct, and the output is a list.
"""
expected_input_output_pairs = {
('regular', 'B'):
[(0.5, 'C'), (2.0, 'G'), (4.0, 'Y'), (7.0, 'R'), (7.0, 'M')],
('regular', 'W'):
[(0.5, 'B'), (2.0, 'B'), (4.0, 'B'), (7.0, 'B'), (7.0, 'B')],
('trillium', 'B'):
[(0.5, 'C'), (1.8, 'G'), (2.4, 'Y'), (3.5, 'R'), (3.5, 'M')],
('trillium', 'W'):
[(0.5, 'B'), (1.8, 'B'), (2.4, 'B'), (3.5, 'B'), (3.5, 'B')],
}
test_names = (
'test_regular_B',
'test_regular_W',
'test_trillium_B',
'test_trillium_W',
)
for i, input_val in enumerate(expected_input_output_pairs):
with self.subTest(test_names[i]):
self.assertListEqual(
getMassposValueColors(
input_val[0], '', input_val[1], [], retType=''),
expected_input_output_pairs[input_val]
)
def test_range_option_not_supported(self):
"""
Test basic functionality of getMassposValueColors - the range option
is not supported.
"""
errors = []
empty_color_option = ''
self.assertIsNone(
getMassposValueColors(empty_color_option, '', 'B', errors))
self.assertGreater(len(errors), 0)
errors = []
bad_color_option = 'unsupported'
self.assertIsNone(
getMassposValueColors(bad_color_option, '', 'B', errors))
self.assertGreater(len(errors), 0)
def test_color_mode_not_supported(self):
"""
Test basic functionality of getMassposValueColors - the color mode is
not supported.
"""
errors = []
empty_color_mode = ''
with self.assertRaises(KeyError):
getMassposValueColors('regular', '', empty_color_mode, errors)
errors = []
bad_color_mode = 'unsupported'
with self.assertRaises(KeyError):
getMassposValueColors('regular', '', bad_color_mode, errors)
class TestGetTimeTicks(TestCase):
"""Test suite for getTimeTicks."""
def setUp(self) -> None:
"""Set up text fixtures."""
self.label_cnt = 5
self.date_fmt = 'YYYYMMDD'
def test_expected_time_range(self):
"""
Test basic functionality of getTimeTicks - the given time range is
expected in the data.
"""
with self.subTest('test_less_than_a_minute'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 0, 0, 5).timestamp
expected = (
[1.0, 2.0, 3.0, 4.0],
[1.0, 2.0, 3.0, 4.0],
['19700101 00:00:01', '19700101 00:00:02',
'19700101 00:00:03', '19700101 00:00:04']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_at_least_a_minute'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 0, 5, 53).timestamp
expected = (
[60.0, 120.0, 180.0, 240.0, 300.0],
[60.0, 120.0, 180.0, 240.0, 300.0],
['19700101 00:01:00', '19700101 00:02:00', '19700101 00:03:00',
'19700101 00:04:00', '19700101 00:05:00']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_at_least_an_hour'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 7, 45, 51).timestamp
expected = (
[3600.0, 7200.0, 10800.0, 14400.0, 18000.0, 21600.0, 25200.0],
[3600.0, 10800.0, 18000.0, 25200.0],
['19700101 01:00', '19700101 03:00', '19700101 05:00',
'19700101 07:00']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_at_least_ten_days'):
# Exactly 10 days
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 11, 0, 0, 0).timestamp
expected = (
[86400.0, 172800.0, 259200.0, 345600.0, 432000.0,
518400.0, 604800.0, 691200.0, 777600.0],
[86400.0, 259200.0, 432000.0, 604800.0, 777600.0],
['19700102', '19700104', '19700106', '19700108', '19700110']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
# More than 10 days but fewer than 30 days
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 14, 3, 5, 21).timestamp
expected = (
[86400.0, 172800.0, 259200.0, 345600.0, 432000.0,
518400.0, 604800.0, 691200.0, 777600.0, 864000.0,
950400.0, 1036800.0, 1123200.0],
[86400.0, 345600.0, 604800.0, 864000.0, 1123200.0],
['19700102', '19700105', '19700108', '19700111', '19700114']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_at_least_thirty_days'):
# Exactly 30 days
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 31, 0, 0, 0).timestamp
expected = ([864000.0, 1728000.0],
[864000.0, 1728000.0],
['19700111', '19700121'])
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
# More than 30 days
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 3, 21, 21, 43, 53).timestamp
expected = (
[864000.0, 1728000.0, 2592000.0, 3456000.0, 4320000.0,
5184000.0, 6048000.0],
[864000.0, 2592000.0, 4320000.0, 6048000.0],
['19700111', '19700131', '19700220', '19700312']
)
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
def test_boundary_time_range(self):
"""
Test basic functionality of getTimeTicks - the given time range is
exactly 1 second, 1 minute, or 1 hour. Test the behavior where these
time ranges make getTimeTicks returns a tuple that contains empty
lists.
"""
expected = ([], [], [])
with self.subTest('test_exactly_one_second'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 0, 0, 1).timestamp
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_exactly_one_minute'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 0, 1, 0).timestamp
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
with self.subTest('test_exactly_one_hour'):
earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
latest = UTCDateTime(1970, 1, 1, 1, 0, 0).timestamp
self.assertTupleEqual(
getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
expected
)
def test_earliest_time_later_than_latest_time(self):
"""
Test basic functionality of getTimeTicks - the given latest time is
earlier than the earliest time.
"""
self.assertTupleEqual(
getTimeTicks(100, 0, self.date_fmt, self.label_cnt),
([], [], [])
)
def test_time_range_is_zero(self):
"""
Test basic functionality of getTimeTicks - the given time range is 0.
"""
self.assertTupleEqual(
getTimeTicks(0, 0, self.date_fmt, self.label_cnt),
([], [], [])
)
def test_get_time_ticks_no_label_displayed(self):
"""
Test basic functionality of getTimeTicks - no time label is requested
to be displayed.
"""
zero_label_cnt = 0
with self.assertRaises(ZeroDivisionError):
getTimeTicks(0, 1000, self.date_fmt, zero_label_cnt)
class TestFormatTimeAndGetTitle(TestCase):
"""Test suite for formatTime and getTitle"""
def setUp(self) -> None:
"""Set up text fixtures."""
self.positive_epoch_time = 67567567
self.positive_formatted_dates = {
'YYYY-MM-DD': '1972-02-22',
'YYYYMMDD': '19720222',
'YYYY:DOY': '1972:053',
}
self.positive_formatted_time = '00:46:07'
self.negative_epoch_time = -67567567
self.negative_formatted_dates = {
'YYYY-MM-DD': '1967-11-10',
'YYYYMMDD': '19671110',
'YYYY:DOY': '1967:314',
}
self.negative_formatted_time = '23:13:53'
def test_format_time_epoch_time_date_only(self):
"""
Test basic functionality of formatTime - given time is epoch time and
uses only a date format. Tests three cases for each date format: epoch
time is positive, negative, and zero.
"""
# formatter:off
test_name_to_date_mode_map = {
'test_year_month_day_format': 'YYYY-MM-DD',
'test_year_month_day_format_no_dash': 'YYYYMMDD',
'test_day_of_year_format': 'YYYY:DOY'
}
zero_epoch_formatted = {
'test_year_month_day_format': '1970-01-01',
'test_year_month_day_format_no_dash': '19700101',
'test_day_of_year_format': '1970:001',
}
# formatter:on
for test_name, date_mode in test_name_to_date_mode_map.items():
with self.subTest(test_name):
self.assertEqual(
formatTime(self.positive_epoch_time, date_mode),
self.positive_formatted_dates[date_mode])
self.assertEqual(
formatTime(self.negative_epoch_time, date_mode),
self.negative_formatted_dates[date_mode])
self.assertEqual(
formatTime(0, date_mode),
zero_epoch_formatted[test_name])
def test_format_time_epoch_time_date_and_time(self):
"""
Test basic functionality of formatTime - given time is epoch time and
both a time and a date format are used. Tests three cases for each date
format: epoch time is positive, negative, and zero.
"""
# formatter:off
test_name_to_date_mode_map = {
'test_year_month_day_format': 'YYYY-MM-DD',
'test_year_month_day_format_no_dash': 'YYYYMMDD',
'test_day_of_year_format': 'YYYY:DOY',
}
zero_epoch_formatted = {
'test_year_month_day_format': '1970-01-01 00:00:00',
'test_year_month_day_format_no_dash': '19700101 00:00:00',
'test_day_of_year_format': '1970:001 00:00:00',
}
# formatter:on
for test_name, date_mode in test_name_to_date_mode_map.items():
with self.subTest(test_name):
positive_time_expected = (
f'{self.positive_formatted_dates[date_mode]} '
f'{self.positive_formatted_time}'
)
negative_time_expected = (
f'{self.negative_formatted_dates[date_mode]} '
f'{self.negative_formatted_time}'
)
self.assertEqual(
formatTime(self.positive_epoch_time, date_mode,
'HH:MM:SS'),
positive_time_expected
)
self.assertEqual(
formatTime(self.negative_epoch_time, date_mode,
'HH:MM:SS'),
negative_time_expected
)
self.assertEqual(formatTime(0, date_mode, 'HH:MM:SS'),
zero_epoch_formatted[test_name])
def test_format_time_UTCDateTime_date_only(self):
"""
Test basic functionality of formatTime - given time is an UTCDateTime
instance and uses only a date format.
"""
test_name_to_date_mode_map = {
'test_year_month_day_format': 'YYYY-MM-DD',
'test_year_month_day_format_no_dash': 'YYYYMMDD',
'test_day_of_year_format': 'YYYY:DOY',
}
utc_date_time = UTCDateTime(self.positive_epoch_time)
expected_dates = self.positive_formatted_dates
for test_name, date_mode in test_name_to_date_mode_map.items():
with self.subTest(test_name):
self.assertEqual(formatTime(utc_date_time, date_mode),
expected_dates[date_mode])
def test_format_time_UTCDateTime_date_and_time(self):
"""
Test basic functionality of formatTime - given time is an UTCDateTime
instance and both a time and a date format are used.
"""
test_name_to_date_mode_map = {
'test_year_month_day_format': 'YYYY-MM-DD',
'test_year_month_day_format_no_dash': 'YYYYMMDD',
'test_day_of_year_format': 'YYYY:DOY',
}
test_time = UTCDateTime(self.positive_epoch_time)
expected_dates = self.positive_formatted_dates
expected_time = self.positive_formatted_time
for test_name, date_mode in test_name_to_date_mode_map.items():
with self.subTest('test_year_month_day_format'):
self.assertEqual(
formatTime(test_time, date_mode, 'HH:MM:SS'),
f'{expected_dates[date_mode]} {expected_time}'
)
def test_format_time_unsupported_date_format(self):
"""
Test basic functionality of formatTime - given date format is not
supported.
"""
test_time = self.positive_epoch_time
empty_format = ''
bad_format = 'bad_format'
with self.subTest('test_without_time_format'):
expected = ''
self.assertEqual(formatTime(test_time, empty_format),
expected)
self.assertEqual(formatTime(test_time, bad_format),
expected)
with self.subTest('test_with_time_format'):
expected = f' {self.positive_formatted_time}'
self.assertEqual(formatTime(test_time, empty_format, 'HH:MM:SS'),
expected)
self.assertEqual(formatTime(test_time, bad_format, 'HH:MM:SS'),
expected)
def test_format_time_unsupported_time_format(self):
"""
Test basic functionality of formatTime - given time format is not
supported.
"""
test_time = self.positive_epoch_time
date_format = 'YYYYMMDD'
empty_format = ''
bad_format = 'bad_format'
expected = self.positive_formatted_dates[date_format]
self.assertEqual(formatTime(test_time, date_format, empty_format),
expected)
self.assertEqual(formatTime(test_time, date_format, bad_format),
expected)
def test_format_time_unsupported_date_and_time_format(self):
"""
Test basic functionality of formatTime - both given date and time
format are unsupported.
"""
test_time = self.positive_epoch_time
expected = ''
bad_date_formats = ['', 'bad_date_format']
bad_time_format = ['', 'bad_time_format']
for date_format in bad_date_formats:
for time_format in bad_time_format:
self.assertEqual(
formatTime(test_time, date_format, time_format),
expected
)
def test_get_title(self):
"""Test basic functionality of getTitle."""
date_mode = 'YYYYMMDD'
min_time = 0
max_time = self.positive_epoch_time
formatted_max_time = (f'{self.positive_formatted_dates[date_mode]}'
f' {self.positive_formatted_time}')
with self.subTest('test_mseed'):
key = '3734'
expected = (f'3734 19700101 00:00:00 to '
f'{formatted_max_time} (18768.77)')
self.assertEqual(getTitle(key, min_time, max_time, date_mode),
expected)
with self.subTest('test_rt130'):
key = ('92EB', 25)
expected = (f"('92EB', 25) 19700101 00:00:00 to "
f"{formatted_max_time} (18768.77)")
self.assertEqual(getTitle(key, min_time, max_time, date_mode),
expected)
def test_get_title_max_time_earlier_than_min_time(self):
"""
Test basic functionality of getTitle - the given maximum time is
chronologically earlier than the given minimum time.
"""
date_mode = 'YYYYMMDD'
min_time = self.positive_epoch_time
max_time = 0
formatted_max_time = (f'{self.positive_formatted_dates[date_mode]}'
f' {self.positive_formatted_time}')
with self.subTest('test_mseed'):
key = '3734'
expected = (f'3734 {formatted_max_time} to '
f'19700101 00:00:00 (-18768.77)')
self.assertEqual(getTitle(key, min_time, max_time, date_mode),
expected)
with self.subTest('test_rt130'):
key = ('92EB', 25)
expected = (f"('92EB', 25) {formatted_max_time} to "
f"19700101 00:00:00 (-18768.77)")
self.assertEqual(getTitle(key, min_time, max_time, date_mode),
expected)
class TestGetUnitBitweight(TestCase):
"""Test suite for getUnitBitweight."""
def setUp(self) -> None:
"""Set up test fixtures."""
self.chan_info = {
'channel': 'Test Channel Name',
'fixPoint': 0,
'plotType': 'test_plot_type',
'unit': 'test_unit'
}
# In most cases, we do not care about the value of bitweightOpt. So, we
# give it a default value unless needed.
self.default_bitweight_opt = 'low'
def test_soh_channel_linesDots_linesSRate_linesMasspos_plot_type(self):
"""
Test basic functionality of getUnitBitweight - the given plot type is
linesDots, linesSRate, or linesMassposs.
"""
self.chan_info['plotType'] = 'linesDots'
with self.subTest('test_no_fix_point'):
self.assertEqual(
getUnitBitweight(self.chan_info, self.default_bitweight_opt),
'{}test_unit'
)
with self.subTest('test_have_fix_point'):
self.chan_info['fixPoint'] = 1
self.assertEqual(
getUnitBitweight(self.chan_info, self.default_bitweight_opt),
'{:.1f}test_unit'
)
def test_soh_channel_other_plot_type(self):
"""
Test basic functionality of getUnitBitweight - the given plot type is
not linesDots, linesSRate, or linesMassposs and the channel is not a
seismic data channel.
"""
self.assertEqual(
getUnitBitweight(self.chan_info, self.default_bitweight_opt),
''
)
def test_seismic_channel_have_fix_point(self):
"""
Test basic functionality of getUnitBitweight - the given plot type is
not linesDots, linesSRate, or linesMassposs, the channel is a
seismic data channel, and there is a fix point.
"""
self.chan_info['channel'] = 'SEISMIC'
self.chan_info['fixPoint'] = 1
self.assertEqual(
getUnitBitweight(self.chan_info, self.default_bitweight_opt),
'{:.1f}test_unit'
)
def test_seismic_channel_no_fix_point(self):
"""
Test basic functionality of getUnitBitweight - the given plot type is
not linesDots, linesSRate, or linesMassposs, the channel is a
seismic data channel, and there is no fix point.
"""
self.chan_info['channel'] = 'SEISMIC'
with self.subTest('test_no_bitweight_option'):
self.assertEqual(getUnitBitweight(self.chan_info, 'high'), '{}V')
with self.subTest('test_have_bitweight_option'):
self.assertEqual(getUnitBitweight(self.chan_info, ''),
'{}test_unit')
def test_no_fix_point(self):
"""
Test basic functionality of getUnitBitweight - the given channel info
does not contain a value for fixPoint.
"""
del self.chan_info['fixPoint']
# Asserts that an error is not raised. TestCase does not have a method
# to check that an exception was not raised so we have to use this
# workaround. For more discussion on this topic, see these
# stackoverflow questions and the answers
# https://stackoverflow.com/questions/6181555/pass-a-python-unittest-if-an-exception-isnt-raised?noredirect=1&lq=1 # noqa
# https://stackoverflow.com/questions/4319825/python-unittest-opposite-of-assertraises/4319870#4319870 # noqa:E501
# Some context for this code: in getUnitBitWeight, if chanDB does not
# have 'fix_point' as a key, then the value of fix_point defaults to 0.
# This is implemented by getting the value of 'fix_point' in chanDB and
# catching the resulting KeyError. So, in order to test that
# getUnitBitweight handles this case correctly, we assert that no
# exception was raised.
try:
getUnitBitweight(self.chan_info, '')
except KeyError:
self.fail()
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment