def test_decode_packed_bcd(self):
     """Test packed BCD decoder"""
     self.assertEqual(Utils.decode_packed_bcd(0x01), 1)
     self.assertEqual(Utils.decode_packed_bcd(0x10), 10)
     self.assertEqual(Utils.decode_packed_bcd(0x11), 11)
     self.assertEqual(Utils.decode_packed_bcd(0x25), 25)
     self.assertEqual(Utils.decode_packed_bcd(0x99), 99)

 def set_watchdog_prescale(self, val):
     val = Utils.to_int(val)
     wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
     if val not in wd_vals.keys():
         raise ValueError("must be one of %s" % list(wd_vals.keys()))
     self.msr[3] &= 0xf8
     self.msr[3] |= wd_vals[val]

 def set_osc_stable_delay(self, val):
     val = Utils.to_int(val)
     osc_vals = {4096: 0, 8192: 1, 16384: 2, 32768: 3}
     if val not in osc_vals.keys():
         raise ValueError("must be one of %s" % list(osc_vals.keys()))
     self.msr[0] &= 0xcf
     self.msr[0] |= osc_vals[val] << 4

 def test_to_int(self):
     """Test wrapped integer conversion"""
     self.assertEqual(Utils.to_int("2"), 2)
     self.assertEqual(Utils.to_int("0x10"), 16)
     with self.assertRaises(ValueError):
         Utils.to_int("a")
     with self.assertRaises(ValueError):
         Utils.to_int("")
     with self.assertRaises(ValueError):
         Utils.to_int(None)

 def set_ee_erase(self, val):
     val = Utils.to_bool(val)
     self.msr[0] &= 0xfd
     self.msr[0] |= 0x02 if val else 0x00

 def set_low_voltage(self, val):
     val = Utils.to_int(val)
     if val not in range(0, 4):
         raise ValueError("must be one of %s" % list(range(0, 4)))
     self.msr[2] &= 0xfc
     self.msr[2] |= 3 - val

 def set_ale(self, val):
     val = Utils.to_bool(val)
     self.msr &= 0xdf
     self.msr |= 0x20 if bool(val) else 0x00

 def set_t6(self, val):
     val = Utils.to_bool(val)
     self.msr &= 0xfe
     self.msr |= 0x01 if not bool(val) else 0x00

 def set_uart1_remap(self, val):
     val = Utils.to_bool(val)
     self.msr[1] &= 0xbf
     self.msr[1] |= 0x40 if val else 0x00

 def set_uart_passthrough(self, val):
     val = Utils.to_bool(val)
     self.msr[1] &= 0xef
     self.msr[1] |= 0x10 if val else 0x00

 def set_eeprom_lvd(self, val):
     val = Utils.to_bool(val)
     self.msr[1] &= 0x7f
     self.msr[1] |= 0x80 if val else 0x00

 def set_low_voltage_detect(self, val):
     val = Utils.to_bool(val)
     self.msr[0] &= 0xbf
     self.msr[0] |= 0x40 if not val else 0x00

 def set_reset_pin_enabled(self, val):
     val = Utils.to_bool(val)
     self.msr[0] &= 0xfe
     self.msr[0] |= 0x01 if bool(val) else 0x00

 def set_watchdog(self, val):
     val = Utils.to_bool(val)
     self.msr &= 0x7f
     self.msr |= 0x80 if not bool(val) else 0x00

 def set_xram(self, val):
     val = Utils.to_bool(val)
     self.msr &= 0xbf
     self.msr |= 0x40 if bool(val) else 0x00

 def set_pindetect(self, val):
     val = Utils.to_bool(val)
     self.msr[0] &= 0xfe
     self.msr[0] |= 0x01 if not val else 0x00

 def set_p20_state(self, val):
     val = Utils.to_bool(val)
     self.msr[1] &= 0xf7
     self.msr[1] |= 0x08 if val else 0x00

 def set_epwm_pp(self, val):
     val = Utils.to_bool(val)
     self.msr[1] &= 0xfb
     self.msr[1] |= 0x04 if val else 0x00

 def set_flash_split(self, val):
     num_val = Utils.to_int(val)
     if num_val < 512 or num_val > 65024 or (num_val % 512) != 0:
         raise ValueError("must be between 512 and 65024 bytes and a multiple of 512 bytes")
     self.msr[4] = num_val // 256

 def set_watchdog_idle(self, val):
     val = Utils.to_bool(val)
     self.msr[3] &= 0xf7
     self.msr[3] |= 0x08 if not val else 0x00