def test_readfrudatareq_encode_valid_req():
    m = pyipmi.msgs.fru.ReadFruDataReq()
    m.fru_id = 1
    m.offset = 0x302
    m.count = 4
    data = encode_message(m)
    eq_(data, '\x01\x02\x03\x04')

def test_writefrudatareq_encode_valid_req_wo_data():
    m = pyipmi.msgs.fru.WriteFruDataReq()
    m.fru_id = 1
    m.offset = 0x302
    m.data = array('B')
    data = encode_message(m)
    eq_(data, '\x01\x02\x03')

def test_readfrudatarsp_encode_valid_rsp():
    m = pyipmi.msgs.fru.ReadFruDataRsp()
    m.completion_code = 0
    m.count = 5
    m.data = array('B', b'\x01\x02\x03\x04\x05')
    data = encode_message(m)
    eq_(data, '\x00\x05\x01\x02\x03\x04\x05')

def test_setsensorthresholds_encode_req_set_unc():
    m = pyipmi.msgs.sensor.SetSensorThresholdsReq()
    m.sensor_number = 0x55
    m.set_mask.unc = 1
    m.threshold.unc = 0xaa
    data = encode_message(m)
    eq_(data, '\x55\x08\x00\x00\x00\xaa\x00\x00')

 def test_set_deactivation_lock_req(self):
     m = pyipmi.msgs.picmg.SetFruActivationPolicyReq()
     m.fru_id = 1
     m.mask.deactivation_locked = 1
     m.set.deactivation_locked = 1
     data = encode_message(m)
     self.assertEqual(data, '\x00\x01\x02\x02')

    def send_and_receive(self, msg):
        """Sends an IPMI request message and waits for its response.

        `msg` is a IPMI Message containing both the request and response.
        """

        log().debug('IPMI Request [%s]', msg)

        retries = 0
        while retries < self.max_retries:
            try:
                rx_data = self._send_and_receive_raw(msg.target, msg.lun,
                        msg.netfn, chr(msg.cmdid) + encode_message(msg))
                break
            except TimeoutError:
                pass

            retries += 1

        else:
            raise TimeoutError()

        msg = create_message(msg.cmdid, msg.netfn + 1)
        decode_message(msg, rx_data[5:-1])

        log().debug('IPMI Response [%s])', msg)

        return msg

 def test_encode_req_set_ucr(self):
     m = pyipmi.msgs.sensor.SetSensorThresholdsReq()
     m.sensor_number = 0x55
     m.set_mask.ucr = 1
     m.threshold.ucr = 0xaa
     data = encode_message(m)
     self.assertEqual(data, '\x55\x10\x00\x00\x00\x00\xaa\x00')

def test_chassiscontrol_encode_valid_req():
    m = pyipmi.msgs.chassis.ChassisControlReq()
    m.control.option = 1
    data = encode_message(m)
    eq_(m.__netfn__, 0)
    eq_(m.__cmdid__, 2)
    eq_(data, '\x01')

def test_setsensorhysteresis_encode_req():
    m = pyipmi.msgs.sensor.SetSensorHysteresisReq()
    m.sensor_number = 0xab
    m.positive_going_hysteresis = 0xaa
    m.negative_going_hysteresis = 0xbb
    data = encode_message(m)
    eq_(data, '\xab\xff\xaa\xbb')

def test_getselentry_encode_valid_rsp():
    m = pyipmi.msgs.sel.GetSelEntryRsp()
    m.completion_code = 0
    m.next_record_id = 0x0102
    m.record_data = array('B', b'\x01\x02\x03\x04')
    data = encode_message(m)
    eq_(data, b'\x00\x02\x01\x01\x02\x03\x04')

 def test_encode_valid_rsp(self):
     m = pyipmi.msgs.fru.ReadFruDataRsp()
     m.completion_code = 0
     m.count = 5
     m.data = array('B', '\x01\x02\x03\x04\x05')
     data = encode_message(m)
     self.assertEqual(data, '\x00\x05\x01\x02\x03\x04\x05')

 def test_clear_activation_lock_req(self):
     m = pyipmi.msgs.picmg.SetFruActivationPolicyReq()
     m.fru_id = 1
     m.mask.activation_locked = 1
     m.set.activation_locked = 0
     data = encode_message(m)
     self.assertEqual(data, "\x00\x01\x01\x00")

 def test_encode_valid_req_wo_data(self):
     m = pyipmi.msgs.fru.WriteFruDataReq()
     m.fru_id = 1
     m.offset = 0x302
     m.data = array('B')
     data = encode_message(m)
     self.assertEqual(data, '\x01\x02\x03')

 def test_encode_valid_req(self):
     m = pyipmi.msgs.fru.ReadFruDataReq()
     m.fru_id = 1
     m.offset = 0x302
     m.count = 4
     data = encode_message(m)
     self.assertEqual(data, '\x01\x02\x03\x04')

def test_clear_deactivation_lock_req():
    m = pyipmi.msgs.picmg.SetFruActivationPolicyReq()
    m.fru_id = 1
    m.mask.deactivation_locked = 1
    m.set.deactivation_locked = 0
    data = encode_message(m)
    eq_(data, b'\x00\x01\x02\x00')

def test_set_activation_lock_req():
    m = pyipmi.msgs.picmg.SetFruActivationPolicyReq()
    m.fru_id = 1
    m.mask.activation_locked = 1
    m.set.activation_locked = 1
    data = encode_message(m)
    eq_(data, b'\x00\x01\x01\x01')

 def test_encode_valid_rsp(self):
     m = pyipmi.msgs.sel.GetSelEntryRsp()
     m.completion_code = 0
     m.next_record_id = 0x0102
     m.record_data = array('B', '\x01\x02\x03\x04')
     data = encode_message(m)
     self.assertEqual(data, '\x00\x02\x01\x01\x02\x03\x04')

def test_get_session_challenge_req():
    m = pyipmi.msgs.device_messaging.GetSessionChallengeReq()
    m.authentication.type = 1
#    m.user_name = "helloworld"
    data = encode_message(m)
    eq_(m.cmdid, 0x39)
    eq_(m.netfn, 6)
    eq_(data,
        b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

    m.authentication.type = 1
    m.user_name = '0123456789abcdef'
    data = encode_message(m)
    eq_(m.cmdid, 0x39)
    eq_(m.netfn, 6)
    eq_(data, b'\x010123456789abcdef')

 def test_encode_req(self):
     m = pyipmi.msgs.sensor.SetSensorHysteresisReq()
     m.sensor_number = 0xab
     m.positive_going_hysteresis = 0xaa
     m.negative_going_hysteresis = 0xbb
     data = encode_message(m)
     self.assertEqual(data, '\xab\xff\xaa\xbb')

 def test_encode_event_enabled_req(self):
     m = pyipmi.msgs.sensor.SetSensorEventEnableReq()
     m.sensor_number = 0xab
     m.enable.config = 0
     m.enable.event_message = 1
     m.enable.sensor_scanning = 0
     data = encode_message(m)
     self.assertEqual(data, '\xab\x80')