/*
* Check that sending RDM commands work.
* This all defer the running of the RDMCallback.
*/
void QueueingRDMControllerTest::testDelayedSendAndReceive() {
MockRDMController mock_controller;
ola::rdm::QueueingRDMController controller(&mock_controller, 10);
// Some mock frame data.
RDMFrame frame(MOCK_FRAME_DATA, arraysize(MOCK_FRAME_DATA));
RDMFrames frames;
frames.push_back(frame);
// test a simple request/response
RDMRequest *get_request = NewGetRequest(m_source, m_destination);
mock_controller.ExpectCallAndCapture(get_request);
RDMReply *expected_reply = new RDMReply(
ola::rdm::RDM_COMPLETED_OK,
NewGetResponse(m_destination, m_source),
frames);
controller.SendRDMRequest(
get_request,
ola::NewSingleCallback(
this,
&QueueingRDMControllerTest::VerifyResponse,
expected_reply));
// now run the callback
mock_controller.RunRDMCallback(expected_reply);
mock_controller.Verify();
}
/*
* Check that sending RDM commands work.
* This runs the RDMCallback immediately.
*/
void QueueingRDMControllerTest::testSendAndReceive() {
MockRDMController mock_controller;
ola::rdm::QueueingRDMController controller(&mock_controller, 10);
// Some mock frame data.
RDMFrame frame(MOCK_FRAME_DATA, arraysize(MOCK_FRAME_DATA));
RDMFrames frames;
frames.push_back(frame);
// test a simple request/response
RDMRequest *get_request = NewGetRequest(m_source, m_destination);
RDMReply *expected_reply = new RDMReply(
ola::rdm::RDM_COMPLETED_OK,
NewGetResponse(m_destination, m_source),
frames);
mock_controller.ExpectCallAndReplyWith(get_request, expected_reply);
controller.SendRDMRequest(
get_request,
ola::NewSingleCallback(
this,
&QueueingRDMControllerTest::VerifyResponse,
expected_reply));
// check a response where we return ok, but pass a null pointer
get_request = NewGetRequest(m_source, m_destination);
expected_reply = new RDMReply(ola::rdm::RDM_COMPLETED_OK,
NULL,
frames);
mock_controller.ExpectCallAndReplyWith(get_request, expected_reply);
controller.SendRDMRequest(
get_request,
ola::NewSingleCallback(
this,
&QueueingRDMControllerTest::VerifyResponse,
expected_reply));
// check a failed command
get_request = NewGetRequest(m_source, m_destination);
expected_reply = new RDMReply(ola::rdm::RDM_FAILED_TO_SEND);
mock_controller.ExpectCallAndReplyWith(get_request, expected_reply);
controller.SendRDMRequest(
get_request,
ola::NewSingleCallback(
this,
&QueueingRDMControllerTest::VerifyResponse,
expected_reply));
mock_controller.Verify();
}
RDMReply* RDMReply::FromFrame(const RDMFrame &frame,
const RDMRequest *request) {
RDMFrames frames;
frames.push_back(frame);
ola::rdm::RDMStatusCode status_code = RDM_INVALID_RESPONSE;
RDMResponse *response = NULL;
if (frame.data.size() > 1) {
// Skip over the start code.
response = ola::rdm::RDMResponse::InflateFromData(
frame.data.data() + 1, frame.data.size() - 1, &status_code,
request);
}
return new RDMReply(status_code, response, frames);
}
void RDMReplyTest::testReplyWithFrames() {
const uint8_t response_data[] = {
0xcc, 1, 28, // start code, sub code & length
0, 3, 0, 0, 0, 4, // dst uid
0, 1, 0, 0, 0, 2, // src uid
0, 1, 0, 0, 10, // transaction, port id, msg count & sub device
0x21, 1, 40, 4, // command, param id, param data length
0x5a, 0x5a, 0x5a, 0x5a, // param data
0, 0 // checksum, anoything is fine.
};
RDMFrame frame(response_data, arraysize(response_data));
frame.timing.response_time = 10000;
frame.timing.mark_time = 32000;
frame.timing.break_time = 8000;
frame.timing.data_time = 45000;
RDMFrames frames;
frames.push_back(frame);
RDMResponse *response = new RDMGetResponse(m_source,
m_destination,
0, // transaction #
0, // response type
0, // message count
10, // sub device
100, // param id
NULL, // data
0);
RDMReply reply(ola::rdm::RDM_COMPLETED_OK, response, frames);
OLA_ASSERT_EQ(ola::rdm::RDM_COMPLETED_OK, reply.StatusCode());
OLA_ASSERT_EQ(static_cast<const RDMResponse*>(response), reply.Response());
OLA_ASSERT_EQ(response, reply.MutableResponse());
OLA_ASSERT_EQ(static_cast<size_t>(1), reply.Frames().size());
OLA_ASSERT_TRUE(frame == reply.Frames()[0]);
}
/*
* Check that we got an unknown UID code
*/
void DmxterWidgetTest::ValidateStatus(
ola::rdm::RDMStatusCode expected_code,
RDMFrames expected_frames,
RDMReply *reply) {
OLA_ASSERT_EQ(expected_code, reply->StatusCode());
OLA_ASSERT_NULL(reply->Response());
const RDMFrames &frames = reply->Frames();
OLA_ASSERT_EQ(expected_frames.size(), frames.size());
for (unsigned int i = 0; i < frames.size(); i++) {
OLA_ASSERT_DATA_EQUALS(expected_frames[i].data.data(),
expected_frames[i].data.size(),
frames[i].data.data(),
frames[i].data.size());
OLA_ASSERT_TRUE(expected_frames[i] == frames[i]);
}
m_ss.Terminate();
}
RDMReply* RDMReply::DUBReply(const RDMFrame &frame) {
RDMFrames frames;
frames.push_back(frame);
return new RDMReply(ola::rdm::RDM_DUB_RESPONSE, NULL, frames);
}
/**
* Check that we send RDM discovery messages correctly.
*/
void DmxterWidgetTest::testSendRDMDUB() {
uint8_t RDM_DUB_LABEL = 0x83;
const UID source(0x4744, 0x12345678);
const UID destination = UID::AllDevices();
static const uint8_t REQUEST_DATA[] = {
0x7a, 0x70, 0, 0, 0, 0,
0x7a, 0x70, 0xff, 0xff, 0xff, 0xff
};
// request
RDMRequest *rdm_request = new ola::rdm::RDMDiscoveryRequest(
source,
destination,
0, // transaction #
1, // port id
0, // sub device
ola::rdm::PID_DISC_UNIQUE_BRANCH, // param id
REQUEST_DATA,
sizeof(REQUEST_DATA));
unsigned int request_size = RDMCommandSerializer::RequiredSize(*rdm_request);
uint8_t *expected_request_frame = new uint8_t[request_size + 1];
expected_request_frame[0] = 0xcc;
OLA_ASSERT(RDMCommandSerializer::Pack(*rdm_request,
expected_request_frame + 1,
&request_size));
// a 4 byte response means a timeout
static const uint8_t TIMEOUT_RESPONSE[] = {0, 17};
// add the expected response, send and verify
m_endpoint->AddExpectedUsbProDataAndReturn(
RDM_DUB_LABEL,
expected_request_frame,
request_size + 1,
RDM_DUB_LABEL,
TIMEOUT_RESPONSE,
sizeof(TIMEOUT_RESPONSE));
RDMFrames frames;
m_widget->SendRDMRequest(
rdm_request,
ola::NewSingleCallback(this,
&DmxterWidgetTest::ValidateStatus,
ola::rdm::RDM_TIMEOUT,
frames));
m_ss.Run();
m_endpoint->Verify();
delete[] expected_request_frame;
// now try a dub response that returns something
rdm_request = new ola::rdm::RDMDiscoveryRequest(
source,
destination,
1, // transaction #
1, // port id
0, // sub device
ola::rdm::PID_DISC_UNIQUE_BRANCH, // param id
REQUEST_DATA,
sizeof(REQUEST_DATA));
request_size = RDMCommandSerializer::RequiredSize(*rdm_request);
expected_request_frame = new uint8_t[request_size + 1];
expected_request_frame[0] = 0xcc;
OLA_ASSERT(RDMCommandSerializer::Pack(*rdm_request,
expected_request_frame + 1,
&request_size));
// something that looks like a DUB response
static const uint8_t FAKE_RESPONSE[] = {0x00, 19, 0xfe, 0xfe, 0xaa, 0xaa};
// add the expected response, send and verify
m_endpoint->AddExpectedUsbProDataAndReturn(
RDM_DUB_LABEL,
expected_request_frame,
request_size + 1,
RDM_DUB_LABEL,
FAKE_RESPONSE,
sizeof(FAKE_RESPONSE));
frames.push_back(RDMFrame(&FAKE_RESPONSE[2], arraysize(FAKE_RESPONSE) - 2));
m_widget->SendRDMRequest(
rdm_request,
ola::NewSingleCallback(this,
&DmxterWidgetTest::ValidateStatus,
ola::rdm::RDM_DUB_RESPONSE,
frames));
m_ss.Run();
m_endpoint->Verify();
delete[] expected_request_frame;
}
