Geoffrey Merck
4 years ago
commit
16b798a767
@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
#include "APRSFormater.h"
|
||||
#include "Log.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
bool CAPRSFormater::frameToString(std::string& output, CAPRSFrame& frame)
|
||||
{
|
||||
// make sur we have the minimal stuff to build a correct aprs string
|
||||
if(frame.getSource().empty()
|
||||
|| frame.getDestination().empty()
|
||||
|| frame.getBody().empty()) {
|
||||
CLog::logWarning("Invalid APRS frame, missing source, destination or body");
|
||||
return false;
|
||||
}
|
||||
|
||||
auto path = boost::join_if(frame.getPath(), ",", [](std::string s) { return !string_is_blank_or_empty(s); });
|
||||
|
||||
CStringUtils::string_format_in_place(output, "%s>%s%s%s:%s",
|
||||
frame.getSource().c_str(),
|
||||
frame.getDestination().c_str(),
|
||||
path.empty() ? "" : ",",
|
||||
path.c_str(),
|
||||
frame.getBody().c_str());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -0,0 +1,120 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
#include "APRSUnit.h"
|
||||
#include "APRSFormater.h"
|
||||
#include "StringUtils.h"
|
||||
#include "APRStoDPRS.h"
|
||||
|
||||
CAPRSUnit::CAPRSUnit(IRepeaterCallback * repeaterHandler) :
|
||||
m_frameBuffer(20U),
|
||||
m_status(APS_IDLE),
|
||||
m_repeaterHandler(repeaterHandler),
|
||||
m_headerData(nullptr),
|
||||
m_slowData(nullptr),
|
||||
m_out(0U),
|
||||
m_seq(0U),
|
||||
m_totalNeeded(0U),
|
||||
m_timer(1000U, 2U),
|
||||
m_start()
|
||||
{
|
||||
m_timer.start();
|
||||
}
|
||||
|
||||
void CAPRSUnit::writeFrame(CAPRSFrame& frame)
|
||||
{
|
||||
auto frameCopy = new CAPRSFrame(frame);
|
||||
frameCopy->getPath().clear();//path is of no use for us, just clear it
|
||||
|
||||
m_frameBuffer.push_back(frameCopy);
|
||||
m_timer.start();
|
||||
}
|
||||
|
||||
void CAPRSUnit::clock(unsigned int ms)
|
||||
{
|
||||
m_timer.clock(ms);
|
||||
if(m_status == APS_IDLE && !m_frameBuffer.empty() && m_timer.hasExpired()) {
|
||||
|
||||
auto frame = m_frameBuffer.front();
|
||||
m_frameBuffer.pop_front();
|
||||
|
||||
m_headerData = new CHeaderData();
|
||||
std::string dprs, text;
|
||||
if(!CAPRSToDPRS::aprsToDPRS(dprs, text, *m_headerData, *frame)) {
|
||||
delete m_headerData;
|
||||
m_headerData = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
m_slowData = new CSlowDataEncoder();
|
||||
|
||||
m_slowData->setHeaderData(*m_headerData);
|
||||
m_slowData->setGPSData(dprs);
|
||||
m_slowData->setTextData(text);
|
||||
|
||||
m_totalNeeded = (m_slowData->getInterleavedDataLength() / (DATA_FRAME_LENGTH_BYTES)) * 2U;
|
||||
|
||||
m_repeaterHandler->process(*m_headerData, DIR_INCOMING, AS_INFO);
|
||||
|
||||
m_out = 0U;
|
||||
m_seq = 0U;
|
||||
|
||||
m_start = std::chrono::high_resolution_clock::now();
|
||||
m_status = APS_TRANSMIT;
|
||||
return;
|
||||
}
|
||||
|
||||
if(m_status == APS_TRANSMIT) {
|
||||
unsigned int needed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - m_start).count();
|
||||
needed /= DSTAR_FRAME_TIME_MS;
|
||||
|
||||
unsigned char buffer[DV_FRAME_LENGTH_BYTES];
|
||||
|
||||
while (m_out < needed && m_out < m_totalNeeded) {
|
||||
CAMBEData data;
|
||||
data.setId(m_headerData->getId());
|
||||
data.setSeq(m_seq);
|
||||
if(m_out == m_totalNeeded - 1U)
|
||||
data.setEnd(true);
|
||||
|
||||
::memcpy(buffer + 0U, NULL_AMBE_DATA_BYTES, VOICE_FRAME_LENGTH_BYTES);
|
||||
|
||||
// Insert sync bytes when the sequence number is zero, slow data otherwise
|
||||
if (m_seq == 0U) {
|
||||
::memcpy(buffer + VOICE_FRAME_LENGTH_BYTES, DATA_SYNC_BYTES, DATA_FRAME_LENGTH_BYTES);
|
||||
} else {
|
||||
m_slowData->getInterleavedData(buffer + VOICE_FRAME_LENGTH_BYTES);
|
||||
m_out++;
|
||||
}
|
||||
|
||||
data.setData(buffer, DV_FRAME_LENGTH_BYTES);
|
||||
m_repeaterHandler->process(data, DIR_INCOMING, AS_INFO);
|
||||
|
||||
m_seq++;
|
||||
if (m_seq == 21U) m_seq = 0U;
|
||||
}
|
||||
|
||||
if(m_out >= m_totalNeeded) {
|
||||
m_status = APS_IDLE;
|
||||
delete m_headerData;
|
||||
delete m_slowData;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,57 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <boost/circular_buffer.hpp>
|
||||
#include <chrono>
|
||||
|
||||
#include "APRSFrame.h"
|
||||
#include "RepeaterCallback.h"
|
||||
#include "Timer.h"
|
||||
#include "SlowDataEncoder.h"
|
||||
|
||||
enum APRSUNIT_STATUS {
|
||||
APS_IDLE,
|
||||
APS_WAIT,
|
||||
APS_TRANSMIT
|
||||
};
|
||||
|
||||
class CAPRSUnit
|
||||
{
|
||||
public:
|
||||
CAPRSUnit(IRepeaterCallback * repeaterHandler);
|
||||
void writeFrame(CAPRSFrame& aprsFrame);
|
||||
void clock(unsigned ms);
|
||||
|
||||
private:
|
||||
// CRingBuffer<CAPRSFrame *> m_frameBuffer;
|
||||
boost::circular_buffer<CAPRSFrame *> m_frameBuffer;
|
||||
APRSUNIT_STATUS m_status;
|
||||
IRepeaterCallback * m_repeaterHandler;
|
||||
CHeaderData * m_headerData;
|
||||
CSlowDataEncoder * m_slowData;
|
||||
unsigned int m_out;
|
||||
unsigned int m_seq;
|
||||
unsigned int m_totalNeeded;
|
||||
CTimer m_timer;
|
||||
std::chrono::high_resolution_clock::time_point m_start;
|
||||
};
|
||||
|
||||
|
||||
@ -0,0 +1,73 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
#include "APRStoDPRS.h"
|
||||
#include "Log.h"
|
||||
#include "RSMS1AMessageBuilder.h"
|
||||
|
||||
|
||||
|
||||
bool CAPRSToDPRS::aprsToDPRS(std::string& dprs, std::string& text, CHeaderData& header, CAPRSFrame& frame)
|
||||
{
|
||||
dprs.clear();
|
||||
text.clear();
|
||||
switch (frame.getType())
|
||||
{
|
||||
case APFT_MESSAGE :
|
||||
return messageToDPRS(dprs, text, header, frame);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CAPRSToDPRS::messageToDPRS(std::string& dprs, std::string& text, CHeaderData& header, CAPRSFrame& frame)
|
||||
{
|
||||
auto frameBody = frame.getBody();
|
||||
if(frameBody.length() < 11 || frameBody[0] != ':' || frameBody[10] != ':') {
|
||||
CLog::logDebug("Invalid APRS message body : %s", frameBody.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
// extract recipient
|
||||
auto recipient = boost::trim_copy(frameBody.substr(1, 9));
|
||||
if(recipient.empty()) {
|
||||
CLog::logDebug("APRS message has no recipient");
|
||||
return false;
|
||||
}
|
||||
auto dashPos = recipient.find_first_of('-');
|
||||
if(dashPos != std::string::npos)
|
||||
recipient = recipient.substr(0, dashPos);
|
||||
|
||||
//extract message body
|
||||
auto messageBody = boost::trim_copy(frameBody.substr(11));
|
||||
|
||||
header.setId(header.createId());
|
||||
header.setMyCall1(frame.getSource());
|
||||
header.setMyCall2("MSG");
|
||||
header.setYourCall(recipient);
|
||||
|
||||
CRSMS1AMessageBuilder::buildMessage(dprs, frame.getSource(), recipient, messageBody);
|
||||
|
||||
text = messageBody;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -0,0 +1,157 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
#include "RSMS1AMessageBuilder.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
std::vector<signed char> CRSMS1AMessageBuilder::m_charsToEscape = {-17, 0, 17, 19, -2, -25, 26, -3, -1, 36, 13, 44};
|
||||
|
||||
void CRSMS1AMessageBuilder::buildMessage(std::string& message, const std::string& sender, const std::string& recipient, const std::string body)
|
||||
{
|
||||
auto bodyCrc = calculateBodyCRC(body);
|
||||
std::string bodyTmp;
|
||||
escapeBody(bodyTmp, body + (char)bodyCrc);
|
||||
|
||||
std::string header = CStringUtils::string_format("%s,%s,0011", sender.c_str(), recipient.c_str());
|
||||
signed char c1, c2;
|
||||
calcMsgIcomCRC(header, c1, c2);
|
||||
header.push_back(c1);
|
||||
header.push_back(c2);
|
||||
message = "$$Msg," + header + bodyTmp + '\r';
|
||||
}
|
||||
|
||||
signed char CRSMS1AMessageBuilder::calculateBodyCRC(const std::string& body)
|
||||
{
|
||||
if(body.length() == 1)
|
||||
return body[0];
|
||||
|
||||
signed int num = 0;
|
||||
for(signed char c : body) {
|
||||
num += c;
|
||||
}
|
||||
|
||||
signed int res = (num & 255);
|
||||
if(res >= 128)
|
||||
res -= 128;
|
||||
|
||||
return (signed char)res;
|
||||
}
|
||||
|
||||
void CRSMS1AMessageBuilder::escapeBody(std::string& output, const std::string& body)
|
||||
{
|
||||
output.clear();
|
||||
for(char c : body) {
|
||||
if(std::find(m_charsToEscape.begin(), m_charsToEscape.end(), c) != m_charsToEscape.end()) {
|
||||
output.push_back('o');
|
||||
}
|
||||
output.push_back(c);
|
||||
}
|
||||
}
|
||||
|
||||
void CRSMS1AMessageBuilder::calcMsgIcomCRC(const std::string& msg, signed char& c1, signed char& c2)
|
||||
{
|
||||
int num = 0;
|
||||
for(unsigned int i = 0U; i < msg.length(); i++) {
|
||||
num += msg[i];
|
||||
}
|
||||
|
||||
c1 = doWhatever((signed char)((num >> 4) & 15));
|
||||
c2 = doWhatever((signed char)(num & 15));
|
||||
}
|
||||
|
||||
signed char CRSMS1AMessageBuilder::doWhatever(signed char b2) {
|
||||
int i;
|
||||
int i2 = b2 & 255;
|
||||
if (i2 >= 0 && i2 <= 9) {
|
||||
i = b2 + 48;
|
||||
} else if (10 > i2 || i2 > 15) {
|
||||
return 0;
|
||||
} else {
|
||||
i = b2 + 55;
|
||||
}
|
||||
return (signed char) i;
|
||||
}
|
||||
|
||||
RSMS1A_PARSE_STATUS CRSMS1AMessageBuilder::parseMessage(std::string& sender, std::string& recipient, std::string& body, const std::string& message)
|
||||
{
|
||||
sender.clear();
|
||||
recipient.clear();
|
||||
body.clear();
|
||||
|
||||
if(!boost::starts_with(message, "$$Msg,"))
|
||||
return RSMS_FAIL;
|
||||
|
||||
auto firstCommaPos = message.find_first_of(',');
|
||||
if(firstCommaPos == std::string::npos || (firstCommaPos + 1) >= message.length())
|
||||
return RSMS_FAIL;
|
||||
|
||||
auto secondCommaPos = message.find_first_of(',', firstCommaPos + 1);
|
||||
if(secondCommaPos == std::string::npos || (secondCommaPos + 1) >= message.length())
|
||||
return RSMS_FAIL;
|
||||
|
||||
auto thirdCommaPos = message.find_first_of(',', secondCommaPos + 1);
|
||||
if(thirdCommaPos == std::string::npos || (thirdCommaPos + 1 + 6) >= message.length())
|
||||
return RSMS_FAIL;
|
||||
|
||||
sender.assign(message.substr(firstCommaPos + 1, secondCommaPos - firstCommaPos - 1));
|
||||
recipient.assign(message.substr(secondCommaPos + 1, thirdCommaPos - secondCommaPos - 1));
|
||||
body.assign(message.substr(thirdCommaPos + 1 + 6));
|
||||
unescapeBody(body, std::string(body));
|
||||
if(body.length() >= 2U) body.resize(body.length() - 2U);
|
||||
|
||||
// build a message out of what we received in order to check if all checksums matches
|
||||
// use only header of message to match checksum
|
||||
std::string messagecheck;
|
||||
buildMessage(messagecheck, sender, recipient, " ");
|
||||
messagecheck.resize(messagecheck.length() - 3U);// get rid of body, body check byte and trailing \r
|
||||
|
||||
if(messagecheck != message.substr(0, messagecheck.length())) {
|
||||
sender.clear();
|
||||
recipient.clear();
|
||||
body.clear();
|
||||
return RSMS_FAIL; // we do not allow any errors in message header
|
||||
}
|
||||
|
||||
//rebuild complete messsage with body
|
||||
buildMessage(messagecheck, sender, recipient, body);
|
||||
if(messagecheck != message)
|
||||
return RSMS_ERRONEOUS_MSG; // we allow erros to occur in the message body
|
||||
|
||||
return RSMS_OK;
|
||||
}
|
||||
|
||||
void CRSMS1AMessageBuilder::unescapeBody(std::string& output, const std::string& body)
|
||||
{
|
||||
output.clear();
|
||||
if(body.empty())
|
||||
return;
|
||||
|
||||
for(unsigned int i = 0U; i < body.length(); i++) {
|
||||
auto c = body[i];
|
||||
auto next = body[i + 1U];
|
||||
if(c == 'o' && std::find(m_charsToEscape.begin(), m_charsToEscape.end(), next) != m_charsToEscape.end()) {
|
||||
output.push_back(next);
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
|
||||
output.push_back(c);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,45 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
enum RSMS1A_PARSE_STATUS {
|
||||
RSMS_FAIL,
|
||||
RSMS_ERRONEOUS_MSG,
|
||||
RSMS_OK
|
||||
};
|
||||
|
||||
class CRSMS1AMessageBuilder
|
||||
{
|
||||
public:
|
||||
static void buildMessage(std::string& message, const std::string& sender, const std::string& recipient, const std::string body);
|
||||
static RSMS1A_PARSE_STATUS parseMessage(std::string& sender, std::string& recipient, std::string& body, const std::string& message);
|
||||
|
||||
private:
|
||||
static void calcMsgIcomCRC(const std::string& msg, signed char& c1, signed char& c2);
|
||||
static void escapeBody(std::string& output, const std::string& body);
|
||||
static void unescapeBody(std::string& output, const std::string& body);
|
||||
static void escapeBytes(std::vector<char> output, const std::vector<char> input);
|
||||
static signed char calculateBodyCRC(const std::string& body);
|
||||
static signed char doWhatever(signed char b2);
|
||||
|
||||
static std::vector<signed char> m_charsToEscape;
|
||||
};
|
||||
@ -0,0 +1,98 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "SlowDataCollectorThrottle.h"
|
||||
|
||||
CSlowDataCollectorThrottle::CSlowDataCollectorThrottle(ISlowDataCollector* collector, unsigned int timeout) :
|
||||
m_collector(collector),
|
||||
m_timer(1000U, timeout),
|
||||
m_isFirst(true)
|
||||
{
|
||||
assert(collector != nullptr);
|
||||
}
|
||||
|
||||
CSlowDataCollectorThrottle::~CSlowDataCollectorThrottle()
|
||||
{
|
||||
delete m_collector;
|
||||
}
|
||||
|
||||
std::string CSlowDataCollectorThrottle::getMyCall() const
|
||||
{
|
||||
return m_collector->getMyCall();
|
||||
}
|
||||
|
||||
void CSlowDataCollectorThrottle::setMyCall(const std::string& mycall)
|
||||
{
|
||||
m_isFirst = true;
|
||||
m_collector->setMyCall(mycall);
|
||||
}
|
||||
bool CSlowDataCollectorThrottle::writeData(const unsigned char* data)
|
||||
{
|
||||
m_isComplete = false;
|
||||
bool complete = m_collector->writeData(data);
|
||||
if(complete){
|
||||
if(m_isFirst) {
|
||||
m_isFirst = false;
|
||||
m_isComplete = true;
|
||||
m_timer.start();
|
||||
return true;
|
||||
}
|
||||
|
||||
if(m_timer.hasExpired()) {
|
||||
m_isComplete = true;
|
||||
m_timer.start();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
void CSlowDataCollectorThrottle::sync()
|
||||
{
|
||||
m_collector->sync();
|
||||
}
|
||||
unsigned int CSlowDataCollectorThrottle::getData(unsigned char* data, unsigned int length)
|
||||
{
|
||||
if(m_isComplete)
|
||||
return m_collector->getData(data, length);
|
||||
|
||||
return 0U;
|
||||
}
|
||||
bool CSlowDataCollectorThrottle::getData(std::string& data)
|
||||
{
|
||||
if(m_isComplete)
|
||||
return m_collector->getData(data);
|
||||
|
||||
return false;
|
||||
}
|
||||
void CSlowDataCollectorThrottle::reset()
|
||||
{
|
||||
m_timer.start();
|
||||
m_collector->reset();
|
||||
}
|
||||
unsigned char CSlowDataCollectorThrottle::getDataType()
|
||||
{
|
||||
return m_collector->getDataType();
|
||||
}
|
||||
|
||||
void CSlowDataCollectorThrottle::clock(unsigned int ms)
|
||||
{
|
||||
m_timer.clock(ms);
|
||||
}
|
||||
@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "SlowDataCollector.h"
|
||||
#include "Timer.h"
|
||||
|
||||
class CSlowDataCollectorThrottle : public ISlowDataCollector
|
||||
{
|
||||
public:
|
||||
CSlowDataCollectorThrottle(ISlowDataCollector* collector, unsigned int timeout);
|
||||
~CSlowDataCollectorThrottle();
|
||||
std::string getMyCall() const;
|
||||
void setMyCall(const std::string& mycall);
|
||||
bool writeData(const unsigned char* data);
|
||||
void sync();
|
||||
unsigned int getData(unsigned char* data, unsigned int length);
|
||||
bool getData(std::string& data);
|
||||
void reset();
|
||||
unsigned char getDataType();
|
||||
void clock(unsigned int ms);
|
||||
|
||||
private:
|
||||
ISlowDataCollector* m_collector;
|
||||
CTimer m_timer;
|
||||
bool m_isFirst;
|
||||
bool m_isComplete;
|
||||
};
|
||||
@ -0,0 +1,115 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../APRSFormater.h"
|
||||
|
||||
class APRSFormater_frameToString : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(APRSFormater_frameToString, EmptyFrame) {
|
||||
|
||||
CAPRSFrame aprsFrame("", "", { }, "", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_FALSE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "This should be left untouched if the test succeeds");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, SourceOnly) {
|
||||
|
||||
CAPRSFrame aprsFrame("N0CALL", "", { }, "", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_FALSE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "This should be left untouched if the test succeeds");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, DestinationOnly) {
|
||||
|
||||
CAPRSFrame aprsFrame("", "APRS", { }, "", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_FALSE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "This should be left untouched if the test succeeds");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, PathOnly) {
|
||||
|
||||
CAPRSFrame aprsFrame("", "", { "WIDE1-1, WIDE2-1" }, "", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_FALSE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "This should be left untouched if the test succeeds");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, BodyOnly) {
|
||||
|
||||
CAPRSFrame aprsFrame("", "", { }, "Lorem Ipsum", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_FALSE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "This should be left untouched if the test succeeds");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, CorrectWithoutPath) {
|
||||
|
||||
CAPRSFrame aprsFrame("N0CALL", "APRS", { }, "Lorem Ipsum", APFT_UNKNOWN);
|
||||
std::string output("This should NOT be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_TRUE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "N0CALL>APRS:Lorem Ipsum");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, CorrectWithPath) {
|
||||
|
||||
CAPRSFrame aprsFrame("N0CALL", "APRS", { "WIDE1-1", "WIDE2-2" }, "Lorem Ipsum", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_TRUE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "N0CALL>APRS,WIDE1-1,WIDE2-2:Lorem Ipsum");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, WithSomeEmptyPath) {
|
||||
|
||||
CAPRSFrame aprsFrame("N0CALL", "APRS", { "WIDE1-1", "", "WIDE2-2" }, "Lorem Ipsum", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_TRUE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "N0CALL>APRS,WIDE1-1,WIDE2-2:Lorem Ipsum");
|
||||
}
|
||||
|
||||
TEST_F(APRSFormater_frameToString, WithSomeBlankPath) {
|
||||
|
||||
CAPRSFrame aprsFrame("N0CALL", "APRS", { "WIDE1-1", "", "WIDE2-2" }, "Lorem Ipsum", APFT_UNKNOWN);
|
||||
std::string output("This should be left untouched if the test succeeds");
|
||||
bool retVal = CAPRSFormater::frameToString(output, aprsFrame);
|
||||
|
||||
EXPECT_TRUE(retVal);
|
||||
EXPECT_STREQ(output.c_str(), "N0CALL>APRS,WIDE1-1,WIDE2-2:Lorem Ipsum");
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright (c) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../APRStoDPRS.h"
|
||||
|
||||
namespace APRStoDPRSTests
|
||||
{
|
||||
class APRStoDPRS_aprsToDPRS : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(APRStoDPRS_aprsToDPRS, validMessage)
|
||||
{
|
||||
CAPRSFrame frame("KC3FRA", "APRS", {"WIDE1-1", "WIDE2-2"}, ":F4FXL :Salut, comment vas tu?", APFT_MESSAGE);
|
||||
|
||||
std::string dprs, text;
|
||||
CHeaderData header;
|
||||
bool ret = CAPRSToDPRS::aprsToDPRS(dprs, text, header, frame);
|
||||
|
||||
EXPECT_TRUE(ret);
|
||||
EXPECT_STREQ(dprs.c_str(), "$$Msg,KC3FRA,F4FXL,001118Saluto, comment vas tu?z\r");
|
||||
EXPECT_STREQ(text.c_str(), "Salut, comment vas tu?");
|
||||
EXPECT_STREQ(header.getMyCall1().c_str(), "KC3FRA ");
|
||||
EXPECT_STREQ(header.getMyCall2().c_str(), "MSG ");
|
||||
EXPECT_STREQ(header.getYourCall().c_str(), "F4FXL ");
|
||||
}
|
||||
|
||||
TEST_F(APRStoDPRS_aprsToDPRS, validMessageRecipientWithSSID)
|
||||
{
|
||||
CAPRSFrame frame("KC3FRA", "APRS", {"WIDE1-1", "WIDE2-2"}, ":F4FXL-7 :Salut, comment vas tu?", APFT_MESSAGE);
|
||||
|
||||
std::string dprs, text;
|
||||
CHeaderData header;
|
||||
bool ret = CAPRSToDPRS::aprsToDPRS(dprs, text, header, frame);
|
||||
|
||||
EXPECT_TRUE(ret);
|
||||
EXPECT_STREQ(dprs.c_str(), "$$Msg,KC3FRA,F4FXL,001118Saluto, comment vas tu?z\r");
|
||||
EXPECT_STREQ(text.c_str(), "Salut, comment vas tu?");
|
||||
EXPECT_STREQ(header.getMyCall1().c_str(), "KC3FRA ");
|
||||
EXPECT_STREQ(header.getMyCall2().c_str(), "MSG ");
|
||||
EXPECT_STREQ(header.getYourCall().c_str(), "F4FXL ");
|
||||
}
|
||||
|
||||
TEST_F(APRStoDPRS_aprsToDPRS, emptyRecipient)
|
||||
{
|
||||
CAPRSFrame frame("KC3FRA", "APRS", {"WIDE1-1", "WIDE2-2"}, ": :Salut, comment vas tu?", APFT_MESSAGE);
|
||||
|
||||
std::string dprs, text;
|
||||
CHeaderData header;
|
||||
bool ret = CAPRSToDPRS::aprsToDPRS(dprs, text, header, frame);
|
||||
|
||||
EXPECT_FALSE(ret);
|
||||
EXPECT_STREQ(dprs.c_str(), "");
|
||||
EXPECT_STREQ(text.c_str(), "");
|
||||
EXPECT_STREQ(header.getMyCall1().c_str(), " ");
|
||||
EXPECT_STREQ(header.getMyCall2().c_str(), " ");
|
||||
EXPECT_STREQ(header.getYourCall().c_str(), " ");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,86 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../RSMS1AMessageBuilder.h"
|
||||
|
||||
namespace RSMS1AMessageBuilderTests
|
||||
{
|
||||
|
||||
class RSMS1AMessageBuilder_buildMessage : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, ABC)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", "ABC");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118ABCF\r");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, A)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", "A");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118AA\r");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, AA)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", "AA");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118AA\02\r");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, SalutCommentVasTu)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", "Salut, comment vas tu?");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118Saluto, comment vas tu?z\r");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, escapeComma)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", ",");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118o,o,\r");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, INeedMoreDollars)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL", "I need more $$$$");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL,001118I need more o$o$o$o$\x08\r");
|
||||
}
|
||||
|
||||
//"$$Msg,KC3FRA,F4FXL 7,00116Fhello\024\r"
|
||||
TEST_F(RSMS1AMessageBuilder_buildMessage, hello)
|
||||
{
|
||||
std::string message;
|
||||
CRSMS1AMessageBuilder::buildMessage(message, "KC3FRA", "F4FXL 7", "hello");
|
||||
|
||||
EXPECT_STREQ(message.c_str(), "$$Msg,KC3FRA,F4FXL 7,00116Fhello\024\r");
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../RSMS1AMessageBuilder.h"
|
||||
|
||||
namespace RSMS1AMessageBuilderTests
|
||||
{
|
||||
class RSMS1AMessageBuilder_parseMessage : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_parseMessage, NoError)
|
||||
{
|
||||
std::string message = "$$Msg,KC3FRA,F4FXL,001118Saluto, comment vas tu?z\r";
|
||||
std::string sender, recipient, body;
|
||||
|
||||
auto ret = CRSMS1AMessageBuilder::parseMessage(sender, recipient, body, message);
|
||||
|
||||
EXPECT_EQ(ret, RSMS_OK);
|
||||
EXPECT_STREQ(sender.c_str(), "KC3FRA");
|
||||
EXPECT_STREQ(recipient.c_str(), "F4FXL");
|
||||
EXPECT_STREQ(body.c_str(), "Salut, comment vas tu?");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_parseMessage, ErrorInMessage)
|
||||
{
|
||||
std::string message = "$$Msg,KC3FRA,F4FXL,001118Saluto, comlent vas tu?z\r";
|
||||
std::string sender, recipient, body;
|
||||
|
||||
auto ret = CRSMS1AMessageBuilder::parseMessage(sender, recipient, body, message);
|
||||
|
||||
EXPECT_EQ(ret, RSMS_ERRONEOUS_MSG);
|
||||
EXPECT_STREQ(sender.c_str(), "KC3FRA");
|
||||
EXPECT_STREQ(recipient.c_str(), "F4FXL");
|
||||
EXPECT_STREQ(body.c_str(), "Salut, comlent vas tu?");
|
||||
}
|
||||
|
||||
TEST_F(RSMS1AMessageBuilder_parseMessage, ErrorInHeader)
|
||||
{
|
||||
std::string message = "$$Msg,KC3FRB,F4FXL,001118Saluto, comment vas tu?z\r";
|
||||
std::string sender, recipient, body;
|
||||
|
||||
auto ret = CRSMS1AMessageBuilder::parseMessage(sender, recipient, body, message);
|
||||
|
||||
EXPECT_EQ(ret, RSMS_FAIL);
|
||||
EXPECT_STREQ(sender.c_str(), "");
|
||||
EXPECT_STREQ(recipient.c_str(), "");
|
||||
EXPECT_STREQ(body.c_str(), "");
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,78 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../SlowDataEncoder.h"
|
||||
#include "../../DStarDefines.h"
|
||||
|
||||
namespace SlowDataEncoderTests
|
||||
{
|
||||
class SlowDataEncoder_gpsData : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(SlowDataEncoder_gpsData, gpsDataCorrectlySet)
|
||||
{
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setGPSData("ABCDEFGHIJKLMN");
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getGPSData(buffer);
|
||||
encoder.getGPSData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'A');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'B');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'C');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'D');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getGPSData(buffer);
|
||||
encoder.getGPSData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'I');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'J');
|
||||
|
||||
encoder.getGPSData(buffer);
|
||||
encoder.getGPSData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x4U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'K');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'L');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'M');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'N');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
// all the remaining data shall be filled with 'f'
|
||||
for(unsigned int i = 18; i < 60U; i+= 6U) {
|
||||
encoder.getGPSData(buffer);
|
||||
encoder.getGPSData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,139 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../SlowDataEncoder.h"
|
||||
#include "../../DStarDefines.h"
|
||||
|
||||
namespace SlowDataEncoderTests
|
||||
{
|
||||
class SlowDataEncoder_headerData : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(SlowDataEncoder_headerData, headerDataCorrectlySet)
|
||||
{
|
||||
CHeaderData header;
|
||||
header.setFlags('1', '2', '3');
|
||||
header.setMyCall1("F4FXL");
|
||||
header.setMyCall2("5100");
|
||||
header.setYourCall("CQCQCQ");
|
||||
header.setRptCall1("F5ZEE B");
|
||||
header.setRptCall2("F5ZEE G");
|
||||
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setHeaderData(header);
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, '1');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, '2');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '3');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, '5');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'Z');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'E');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'E');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'F');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '5');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'Z');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'E');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'B');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'C');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'Q');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'C');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'Q');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'C');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'Q');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'F');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, '4');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'F');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'X');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'L');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, '5');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, '1');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '0');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, '0');
|
||||
EXPECT_NE(buffer[5] ^ SCRAMBLER_BYTE3, 'f'); // we do not check the actual result of the CRC, we just make sure is inot 'f'
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x1U);
|
||||
EXPECT_NE(buffer[1] ^ SCRAMBLER_BYTE2, 'f'); // done with crc check, remaining shall be filled with 'f'
|
||||
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
encoder.getHeaderData(buffer);
|
||||
encoder.getHeaderData(buffer + 3);
|
||||
// all the remaining data shall be filled with 'f'
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,865 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <cstring>
|
||||
|
||||
#include "../../SlowDataEncoder.h"
|
||||
#include "../../DStarDefines.h"
|
||||
|
||||
namespace SlowDataEncoderTests
|
||||
{
|
||||
class SlowDataEncoder_interleavedData : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, gpsAndHeaderData)
|
||||
{
|
||||
// Header is never interleaved, text and header are sent as two blocks
|
||||
CHeaderData header;
|
||||
unsigned char headerData[RADIO_HEADER_LENGTH_BYTES];
|
||||
::memset(headerData, 'H', RADIO_HEADER_LENGTH_BYTES);
|
||||
header.setData(headerData, RADIO_HEADER_LENGTH_BYTES, false);
|
||||
|
||||
//here we only test for correct interleaving
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setGPSData("GGGGGGGG"); // 8 times G
|
||||
encoder.setHeaderData(header);
|
||||
|
||||
for(unsigned int i = 0U; i < 2U; i++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
// all the remaining data shall be filled with 'f' until next block
|
||||
for(unsigned int j = 12; j < 60U; j+= 6U) {
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_NE(buffer[5] ^ SCRAMBLER_BYTE3, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x1U);
|
||||
EXPECT_NE(buffer[1] ^ SCRAMBLER_BYTE2, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
//remaining data is only 'f'
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, textAndHeaderData)
|
||||
{
|
||||
// Header is never interleaved, text and header are sent as two blocks
|
||||
CHeaderData header;
|
||||
unsigned char headerData[RADIO_HEADER_LENGTH_BYTES];
|
||||
::memset(headerData, 'H', RADIO_HEADER_LENGTH_BYTES);
|
||||
header.setData(headerData, RADIO_HEADER_LENGTH_BYTES, false);
|
||||
|
||||
//here we only test for correct interleaving
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setTextData("TTTTTT"); // 6 times T
|
||||
encoder.setHeaderData(header);
|
||||
|
||||
auto dataLen = encoder.getInterleavedDataLength();
|
||||
EXPECT_EQ(dataLen, 120); //2* 60
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x0U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'T');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'T');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'T');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x1U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
// all the remaining data shall be filled with 'f' until next block
|
||||
for(unsigned int j = 24; j < 60U; j+= 6U) {
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_NE(buffer[5] ^ SCRAMBLER_BYTE3, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x1U);
|
||||
EXPECT_NE(buffer[1] ^ SCRAMBLER_BYTE2, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
//remaining data is only 'f'
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, gpsTextAndHeaderData)
|
||||
{
|
||||
CHeaderData header;
|
||||
unsigned char headerData[RADIO_HEADER_LENGTH_BYTES];
|
||||
::memset(headerData, 'H', RADIO_HEADER_LENGTH_BYTES);
|
||||
header.setData(headerData, RADIO_HEADER_LENGTH_BYTES, false);
|
||||
|
||||
//here we only test for correct interleaving
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setTextData("TTTTTT"); // 6 times T
|
||||
encoder.setGPSData("GGGGGGGGGGGGGGGGGGGGGG"); // 22 times G
|
||||
encoder.setHeaderData(header);
|
||||
|
||||
auto dataLen = encoder.getInterleavedDataLength();
|
||||
|
||||
EXPECT_EQ(dataLen, 120);// including data type bytes we need 54 (20 + 5 + 22 + 6) bytes, this shall be rounded up to next block size multiple, in this case 60
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x0U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'T');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'T');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'T');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x1U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
// header is not interleaved, attached as one contiguous block, but it only starts at the nex block
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'H');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'H');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'H');
|
||||
EXPECT_NE(buffer[5] ^ SCRAMBLER_BYTE3, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x1U);
|
||||
EXPECT_NE(buffer[1] ^ SCRAMBLER_BYTE2, 'f');// this is checksum byte, just make sure is is not 'f'
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
//remaining data is only 'f'
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, gpsAndTextData)
|
||||
{
|
||||
//here we only test for correct interleaving
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setTextData("TTTTTT"); // 6 times T
|
||||
encoder.setGPSData("GGGGGGGGGGGGGGGGGGGGGG"); // 22 times G
|
||||
|
||||
auto dataLen = encoder.getInterleavedDataLength();
|
||||
|
||||
EXPECT_EQ(dataLen, 60);// including data type bytes we need 54 (20 + 5 + 22 + 6) bytes, this shall be rounded up to next block size multiple, in this case 60
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x0U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'T');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'T');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'T');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x1U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'T');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'G');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'G');
|
||||
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
//remaining shall only be 'f"
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, onlyGPSData)
|
||||
{
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setGPSData("ABCDEFGHIJKLMN");
|
||||
|
||||
auto dataLen = encoder.getInterleavedDataLength();
|
||||
EXPECT_EQ(dataLen, 60);
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'A');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'B');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'C');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'D');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'H');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'I');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'J');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_GPS | 0x4U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'K');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'L');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'M');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'N');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
// all the remaining data shall be filled with 'f'
|
||||
for(unsigned int i = 18; i < 60U; i+= 6U) {
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, onlyTextData)
|
||||
{
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setTextData("ABCDEFG");
|
||||
|
||||
auto dataLen = encoder.getInterleavedDataLength();
|
||||
EXPECT_EQ(dataLen, 60);
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x0U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'A');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'B');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'C');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'D');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x1U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
// all the remaining data shall be filled with 'f'
|
||||
for(unsigned int i = 24; i < 60U; i+= 6U) {
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SlowDataEncoder_interleavedData, onlyHeaderData)
|
||||
{
|
||||
CHeaderData header;
|
||||
header.setFlags('1', '2', '3');
|
||||
header.setMyCall1("F4FXL");
|
||||
header.setMyCall2("5100");
|
||||
header.setYourCall("CQCQCQ");
|
||||
header.setRptCall1("F5ZEE B");
|
||||
header.setRptCall2("F5ZEE G");
|
||||
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setHeaderData(header);
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, '1');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, '2');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '3');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, '5');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'Z');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'E');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'E');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'G');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'F');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '5');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'Z');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'E');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'B');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'C');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'Q');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'C');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'Q');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'C');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'Q');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'F');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, '4');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'F');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'X');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'L');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x5U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, '5');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, '1');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, '0');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, '0');
|
||||
EXPECT_NE(buffer[5] ^ SCRAMBLER_BYTE3, 'f'); // we do not check the actual result of the CRC, we just make sure is inot 'f'
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_HEADER | 0x1U);
|
||||
EXPECT_NE(buffer[1] ^ SCRAMBLER_BYTE2, 'f'); // done with crc check, remaining shall be filled with 'f'
|
||||
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
|
||||
encoder.getInterleavedData(buffer);
|
||||
encoder.getInterleavedData(buffer + 3);
|
||||
// all the remaining data shall be filled with 'f'
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright (C) 2021-2022 by Geoffrey Merck F4FXL / KC3FRA
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "../../SlowDataEncoder.h"
|
||||
#include "../../DStarDefines.h"
|
||||
|
||||
namespace SlowDataEncoderTests
|
||||
{
|
||||
class SlowDataEncoder_textData : public ::testing::Test {
|
||||
|
||||
};
|
||||
|
||||
TEST_F(SlowDataEncoder_textData, textDataCorrectlySet)
|
||||
{
|
||||
CSlowDataEncoder encoder;
|
||||
encoder.setTextData("ABCDEFG");
|
||||
|
||||
for(unsigned int testCount = 0U; testCount < 2U; testCount++) {
|
||||
unsigned char buffer[6U];
|
||||
|
||||
encoder.getTextData(buffer);
|
||||
encoder.getTextData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x0U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'A');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'B');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'C');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'D');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'E');
|
||||
|
||||
encoder.getTextData(buffer);
|
||||
encoder.getTextData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x1U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'F');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'G');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getTextData(buffer);
|
||||
encoder.getTextData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x2U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
encoder.getTextData(buffer);
|
||||
encoder.getTextData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, SLOW_DATA_TYPE_TEXT | 0x3U);
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, ' ');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, ' ');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, ' ');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, ' ');
|
||||
|
||||
// all the remaining data shall be filled with 'f'
|
||||
for(unsigned int i = 24; i < 60U; i+= 6U) {
|
||||
encoder.getTextData(buffer);
|
||||
encoder.getTextData(buffer + 3);
|
||||
EXPECT_EQ(buffer[0] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[1] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[2] ^ SCRAMBLER_BYTE3, 'f');
|
||||
EXPECT_EQ(buffer[3] ^ SCRAMBLER_BYTE1, 'f');
|
||||
EXPECT_EQ(buffer[4] ^ SCRAMBLER_BYTE2, 'f');
|
||||
EXPECT_EQ(buffer[5] ^ SCRAMBLER_BYTE3, 'f');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue