publish libraries to avoid users to have to download them one by one

This commit is contained in:
1technophile committed 2018-03-04 13:47:37 +01:00
1 parent 93c075e880
commit f0546fab8c
396 files changed
+536928

No files matched your search

+448
View File
@@ -0,0 +1,448 @@
// Copyright 2017 David Conran
#include "IRremoteESP8266.h"
#include "IRrecv.h"
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for the IRrecv object.
TEST(TestIRrecv, DefaultBufferSize) {
IRrecv irrecv_default(1);
EXPECT_EQ(RAWBUF, irrecv_default.getBufSize());
}
TEST(TestIRrecv, LargeBufferSize) {
IRrecv irrecv_large(3, 1024);
EXPECT_EQ(1024, irrecv_large.getBufSize());
}
TEST(TestIRrecv, SmallBufferSize) {
IRrecv irrecv_small(4, 80);
EXPECT_EQ(80, irrecv_small.getBufSize());
}
TEST(TestIRrecv, MediumBufferSize) {
IRrecv irrecv_medium(4, 512);
EXPECT_EQ(512, irrecv_medium.getBufSize());
}
TEST(TestIRrecv, IRrecvDestructor) {
IRrecv *irrecv_ptr = new IRrecv(1);
EXPECT_EQ(RAWBUF, irrecv_ptr->getBufSize());
delete irrecv_ptr;
irrecv_ptr = new IRrecv(1, 1234);
EXPECT_EQ(1234, irrecv_ptr->getBufSize());
delete irrecv_ptr;
irrecv_ptr = new IRrecv(1, 123);
EXPECT_EQ(123, irrecv_ptr->getBufSize());
delete irrecv_ptr;
}
// Tests for copyIrParams()
TEST(TestCopyIrParams, CopyEmpty) {
irparams_t src;
irparams_t dst;
uint16_t test_size = 1234;
src.bufsize = test_size;
src.rawlen = 0;
src.rawbuf = new uint16_t[test_size];
src.overflow = false;
dst.bufsize = 4567;
dst.rawlen = 123;
dst.rawbuf = new uint16_t[test_size];
dst.overflow = true;
// Confirm we are looking at different memory for the buffers.
ASSERT_NE(src.rawbuf, dst.rawbuf);
IRrecv irrecv(4);
irrecv.copyIrParams(&src, &dst);
ASSERT_EQ(src.bufsize, dst.bufsize);
ASSERT_EQ(src.rawlen, dst.rawlen);
ASSERT_NE(src.rawbuf, dst.rawbuf); // Pointers, not content.
ASSERT_EQ(src.overflow, dst.overflow);
// Contents of the buffers needs to match.
EXPECT_EQ(0, memcmp(src.rawbuf, dst.rawbuf, src.bufsize * sizeof(uint16_t)));
}
TEST(TestCopyIrParams, CopyNonEmpty) {
irparams_t src;
irparams_t dst;
uint16_t test_size = 1234;
src.bufsize = test_size;
src.rawlen = 67;
src.rawbuf = new uint16_t[test_size];
src.rawbuf[0] = 0xF00D;
src.rawbuf[1] = 0xBEEF;
src.rawbuf[test_size - 1] = 0xDEAD;
src.overflow = true;
dst.bufsize = 0;
dst.rawlen = 0;
dst.rawbuf = new uint16_t[test_size];
dst.overflow = false;
// Confirm we are looking at different memory for the buffers.
ASSERT_NE(src.rawbuf, dst.rawbuf);
// and that they differ before we test.
EXPECT_NE(0, memcmp(src.rawbuf, dst.rawbuf, src.bufsize * sizeof(uint16_t)));
IRrecv irrecv(4);
irrecv.copyIrParams(&src, &dst);
ASSERT_EQ(src.bufsize, dst.bufsize);
EXPECT_EQ(test_size, dst.bufsize);
ASSERT_EQ(src.rawlen, dst.rawlen);
EXPECT_EQ(67, dst.rawlen);
ASSERT_EQ(src.overflow, dst.overflow);
EXPECT_TRUE(dst.overflow);
ASSERT_NE(src.rawbuf, dst.rawbuf); // Pointers, not content.
// Contents of the buffers needs to match.
EXPECT_EQ(0, memcmp(src.rawbuf, dst.rawbuf, src.bufsize * sizeof(uint16_t)));
// Check the canary values.
EXPECT_EQ(0xF00D, dst.rawbuf[0]);
EXPECT_EQ(0xBEEF, dst.rawbuf[1]);
EXPECT_EQ(0xDEAD, dst.rawbuf[test_size - 1]);
}
// Tests for decode().
// Test decode of a NEC message.
TEST(TestDecode, DecodeNEC) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendNEC(0x807F40BF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x807F40BF, irsend.capture.value);
}
// Test decode of a JVC message.
TEST(TestDecode, DecodeJVC) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendJVC(0xC2B8);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
}
// Test decode of a LG message.
TEST(TestDecode, DecodeLG) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendLG(0x4B4AE51);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG_BITS, irsend.capture.bits);
EXPECT_EQ(0x4B4AE51, irsend.capture.value);
irsend.reset();
irsend.sendLG(0xB4B4AE51, LG32_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0xB4B4AE51, irsend.capture.value);
}
// Test decode of a Panasonic message.
TEST(TestDecode, DecodePanasonic) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
}
// Test decode of a Samsun message.
TEST(TestDecode, DecodeSamsung) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendSAMSUNG(0xE0E09966);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0xE0E09966, irsend.capture.value);
}
// Test decode of a Sherwood message.
TEST(TestDecode, DecodeSherwood) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendSherwood(0x807F40BF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
// Sherwood codes are really NEC codes.
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x807F40BF, irsend.capture.value);
}
// Test decode of a Whynter message.
TEST(TestDecode, DecodeWhynter) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendWhynter(0x87654321);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(WHYNTER_BITS, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
}
// Test decode of Sony messages.
TEST(TestDecode, DecodeSony) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
// Synthesised Normal Sony 20-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_20_BITS, 0x1, 0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_20_BITS, irsend.capture.bits);
EXPECT_EQ(0x81080, irsend.capture.value);
// Synthesised Normal Sony 15-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_15_BITS, 21, 1), SONY_15_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_15_BITS, irsend.capture.bits);
EXPECT_EQ(0x5480, irsend.capture.value);
// Synthesised Normal Sony 12-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_12_BITS, 21, 1), SONY_12_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_12_BITS, irsend.capture.bits);
EXPECT_EQ(0xA90, irsend.capture.value);
}
// Test decode of Sharp messages.
TEST(TestDecode, DecodeSharp) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendSharpRaw(0x454A);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x454A, irsend.capture.value);
}
// Test decode of Sanyo messages.
TEST(TestDecode, DecodeSanyo) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendSanyoLC7461(0x2468DCB56A9);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x2468DCB56A9, irsend.capture.value);
}
// Test decode of RC-MM messages.
TEST(TestDecode, DecodeRCMM) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
// Normal RCMM 24-bit message.
irsend.reset();
irsend.sendRCMM(0xe0a600);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(RCMM_BITS, irsend.capture.bits);
EXPECT_EQ(0xe0a600, irsend.capture.value);
// Normal RCMM 12-bit message.
irsend.reset();
irsend.sendRCMM(0x600, 12);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(12, irsend.capture.bits);
EXPECT_EQ(0x600, irsend.capture.value);
// Normal RCMM 32-bit message.
irsend.reset();
irsend.sendRCMM(0x28e0a600, 32);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x28e0a600, irsend.capture.value);
}
// Test decode of Mitsubishi messages.
TEST(TestDecode, DecodeMitsubishi) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendMitsubishi(0xC2B8);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
}
// Test decode of RC-5/RC-5X messages.
TEST(TestDecode, DecodeRC5) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
// Normal RC-5 12-bit message.
irsend.reset();
irsend.sendRC5(0x175);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
// Synthesised Normal RC-5X 13-bit message.
irsend.reset();
irsend.sendRC5(irsend.encodeRC5X(0x02, 0x41, true), RC5X_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RC5X, irsend.capture.decode_type);
EXPECT_EQ(RC5X_BITS, irsend.capture.bits);
EXPECT_EQ(0x1881, irsend.capture.value);
}
// Test decode of RC-6 messages.
TEST(TestDecode, DecodeRC6) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
// Normal RC-6 Mode 0 (20-bit) message.
irsend.reset();
irsend.sendRC6(0x175);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
// Normal RC-6 36-bit message.
irsend.reset();
irsend.sendRC6(0xC800F742A, RC6_36_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0xC800F742A, irsend.capture.value);
}
// Test decode of Dish messages.
TEST(TestDecode, DecodeDish) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendDISH(0x9C00);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x9C00, irsend.capture.value);
}
// Test decode of Denon messages.
TEST(TestDecode, DecodeDenon) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
// Normal Denon 15-bit message. (Sharp)
irsend.reset();
irsend.sendDenon(0x2278);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_BITS, irsend.capture.bits);
EXPECT_EQ(0x2278, irsend.capture.value);
// Legacy Denon 14-bit message.
irsend.reset();
irsend.sendDenon(0x1278, DENON_LEGACY_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_BITS, irsend.capture.bits);
EXPECT_EQ(0x1278, irsend.capture.value);
// Normal Denon 48-bit message. (Panasonic/Kaseikyo)
irsend.reset();
irsend.sendDenon(0x2A4C028D6CE3, DENON_48_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_48_BITS, irsend.capture.bits);
EXPECT_EQ(0x2A4C028D6CE3, irsend.capture.value);
}
// Test decode of Coolix messages.
TEST(TestDecode, DecodeCoolix) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendCOOLIX(0x123456);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456, irsend.capture.value);
}
// Test decode of Aiwa messages.
TEST(TestDecode, DecodeAiwa) {
IRsendTest irsend(0);
IRrecv irrecv(1);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x7F);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x7F, irsend.capture.value);
}
+139
View File
@@ -0,0 +1,139 @@
// Copyright 2017 David Conran
#include "IRsend_test.h"
#include "IRsend.h"
#include "gtest/gtest.h"
// Tests sendData().
// Test sending zero bits.
TEST(TestSendData, SendZeroBits) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0b1, 0, true);
EXPECT_EQ("", irsend.outputStr());
}
// Test sending zero and one.
TEST(TestSendData, SendSingleBit) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0b1, 1, true);
EXPECT_EQ("m1s2", irsend.outputStr());
irsend.sendData(1, 2, 3, 4, 0b0, 1, true);
EXPECT_EQ("m3s4", irsend.outputStr());
}
// Test sending bit order.
TEST(TestSendData, TestingBitSendOrder) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0b10, 2, true);
EXPECT_EQ("m1s2m3s4", irsend.outputStr());
irsend.sendData(1, 2, 3, 4, 0b10, 2, false);
EXPECT_EQ("m3s4m1s2", irsend.outputStr());
irsend.sendData(1, 2, 3, 4, 0b0001, 4, false);
EXPECT_EQ("m1s2m3s4m3s4m3s4", irsend.outputStr());
}
// Test sending typical data.
TEST(TestSendData, SendTypicalData) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0b1010110011110000, 16, true);
EXPECT_EQ("m1s2m3s4m1s2m3s4m1s2m1s2m3s4m3s4m1s2m1s2m1s2m1s2m3s4m3s4m3s4m3s4",
irsend.outputStr());
irsend.sendData(1, 2, 3, 4, 0x1234567890ABCDEF, 64, true);
EXPECT_EQ("m3s4m3s4m3s4m1s2m3s4m3s4m1s2m3s4m3s4m3s4m1s2m1s2m3s4m1s2m3s4m3s4"
"m3s4m1s2m3s4m1s2m3s4m1s2m1s2m3s4m3s4m1s2m1s2m1s2m1s2m3s4m3s4m3s4"
"m1s2m3s4m3s4m1s2m3s4m3s4m3s4m3s4m1s2m3s4m1s2m3s4m1s2m3s4m1s2m1s2"
"m1s2m1s2m3s4m3s4m1s2m1s2m3s4m1s2m1s2m1s2m1s2m3s4m1s2m1s2m1s2m1s2",
irsend.outputStr());
}
// Test sending more than expected bits.
TEST(TestSendData, SendOverLargeData) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0xFFFFFFFFFFFFFFFF, 70, true);
EXPECT_EQ("m3s4m3s4m3s4m3s4m3s4m3s4"
"m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2"
"m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2"
"m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2"
"m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2m1s2",
irsend.outputStr());
}
// Test inverting the output.
TEST(TestIRSend, InvertedOutput) {
IRsendTest irsend(4, true);
irsend.begin();
irsend.sendData(1, 2, 3, 4, 0b1, 1, true);
EXPECT_EQ("s1m2", irsend.outputStr());
irsend.sendData(1, 2, 3, 4, 0b0, 1, true);
EXPECT_EQ("s3m4", irsend.outputStr());
}
// Test typical use of sendRaw().
TEST(TestSendRaw, GeneralUse) {
IRsendTest irsend(4);
IRrecv irrecv(0);
irsend.begin();
// NEC C3E0E0E8 as measured in #204
uint16_t rawData[67] = {8950, 4500, 550, 1650, 600, 1650, 550, 550, 600, 500,
600, 550, 550, 550, 600, 1650, 550, 1650, 600, 1650,
600, 1650, 550, 1700, 550, 550, 600, 550, 550, 550,
600, 500, 600, 550, 550, 1650, 600, 1650, 600, 1650,
550, 550, 600, 500, 600, 500, 600, 550, 550, 550,
600, 1650, 550, 1650, 600, 1650, 600, 500, 650, 1600,
600, 500, 600, 550, 550, 550, 600};
irsend.sendRaw(rawData, 67, 38);
EXPECT_EQ(
"m8950s4500"
"m550s1650m600s1650m550s550m600s500m600s550m550s550m600s1650m550s1650"
"m600s1650m600s1650m550s1700m550s550m600s550m550s550m600s500m600s550"
"m550s1650m600s1650m600s1650m550s550m600s500m600s500m600s550m550s550"
"m600s1650m550s1650m600s1650m600s500m650s1600m600s500m600s550m550s550"
"m600", irsend.outputStr());
irsend.reset();
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
EXPECT_EQ(
"m8950s4500"
"m550s1650m600s1650m550s550m600s500m600s550m550s550m600s1650m550s1650"
"m600s1650m600s1650m550s1700m550s550m600s550m550s550m600s500m600s550"
"m550s1650m600s1650m600s1650m550s550m600s500m600s500m600s550m550s550"
"m600s1650m550s1650m600s1650m600s500m650s1600m600s500m600s550m550s550"
"m600", irsend.outputStr());
ASSERT_TRUE(irrecv.decodeNEC(&irsend.capture, NEC_BITS, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0xC3E0E0E8, irsend.capture.value);
}
// Incorrect handling of decodes from Raw. i.e. There is no gap recorded at
// the end of a command when using the interrupt code. sendRaw() best emulates
// this for unit testing purposes. sendGC() and sendXXX() will add the trailing
// gap. Users won't see this in normal use.
TEST(TestSendRaw, NoTrailingGap) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t rawData[67] = {9000, 4500, 650, 550, 650, 1650, 600, 550, 650, 550,
600, 1650, 650, 550, 600, 1650, 650, 1650, 650, 1650,
600, 550, 650, 1650, 650, 1650, 650, 550, 600, 1650,
650, 1650, 650, 550, 650, 550, 650, 1650, 650, 550,
650, 550, 650, 550, 600, 550, 650, 550, 650, 550,
650, 1650, 600, 550, 650, 1650, 650, 1650, 650, 1650,
650, 1650, 650, 1650, 650, 1650, 600};
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
}
+104
View File
@@ -0,0 +1,104 @@
// Copyright 2017 David Conran
#ifndef TEST_IRSEND_TEST_H_
#define TEST_IRSEND_TEST_H_
#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <iostream>
#include <sstream>
#include <string>
#include "IRrecv.h"
#include "IRsend.h"
#define OUTPUT_BUF 1000U
#define RAW_BUF 1000U
class IRsendTest: public IRsend {
public:
uint32_t output[OUTPUT_BUF];
uint16_t last;
uint16_t rawbuf[RAW_BUF];
decode_results capture;
explicit IRsendTest(uint16_t x, bool i = false) : IRsend(x, i) {
reset();
}
void reset() {
last = 0;
output[last] = 0;
}
std::string outputStr() {
std::stringstream result;
if (last == 0 && output[0] == 0)
return "";
for (uint16_t i = 0; i <= last; i++) {
if ((i & 1) != outputOff ) // Odd XOR outputOff
result << "s";
else
result << "m";
result << output[i];
}
reset();
return result.str();
}
void makeDecodeResult(uint16_t offset = 0) {
capture.decode_type = UNKNOWN;
capture.bits = 0;
capture.rawlen = last + 1 - offset;
capture.overflow = (last - offset >= (int16_t) RAW_BUF);
capture.repeat = false;
capture.address = 0;
capture.command = 0;
capture.value = 0;
capture.rawbuf = rawbuf;
for (uint16_t i = 0;
(i < RAW_BUF - 1) && (offset < OUTPUT_BUF);
i++, offset++)
if (output[offset] / RAWTICK > UINT16_MAX)
rawbuf[i + 1] = UINT16_MAX;
else
rawbuf[i + 1] = output[offset] / RAWTICK;
}
void dumpRawResult() {
std::cout << "uint16_t rawbuf["<< capture.rawlen << "] =\n";
for (uint16_t i = 0; i < capture.rawlen; i++) {
std::cout << (capture.rawbuf[i] * RAWTICK);
std::cout << "(";
std::cout << capture.rawbuf[i];
std::cout << "), ";
if (i % 8 == 7)
std::cout << "\n";
}
std::cout << "\n";
}
void addGap(uint32_t usecs) {
space(usecs);
}
protected:
uint16_t mark(uint16_t usec) {
if (last >= OUTPUT_BUF)
return 0;
if (last & 1) // Is odd? (i.e. last call was a space())
output[++last] = usec;
else
output[last] += usec;
return 0;
}
void space(uint32_t time) {
if (last >= OUTPUT_BUF)
return;
if (last & 1) { // Is odd? (i.e. last call was a space())
output[last] += time;
} else {
output[++last] = time;
}
}
};
#endif // TEST_IRSEND_TEST_H_
+35
View File
@@ -0,0 +1,35 @@
// Copyright 2017 David Conran
#include "IRutils.h"
#include "gtest/gtest.h"
// Tests reverseBits().
// Tests reverseBits for typical use.
TEST(ReverseBitsTest, TypicalUse) {
EXPECT_EQ(0xF, reverseBits(0xF0, 8));
EXPECT_EQ(0xFFFF, reverseBits(0xFFFF0000, 32));
EXPECT_EQ(0x555500005555FFFF, reverseBits(0xFFFFAAAA0000AAAA, 64));
EXPECT_EQ(0, reverseBits(0, 64));
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, reverseBits(0xFFFFFFFFFFFFFFFF, 64));
}
// Tests reverseBits for bit size values <= 1
TEST(ReverseBitsTest, LessThanTwoBitsReversed) {
EXPECT_EQ(0x12345678, reverseBits(0x12345678, 1));
EXPECT_EQ(1234, reverseBits(1234, 0));
}
// Tests reverseBits for bit size larger than a uint64_t.
TEST(ReverseBitsTest, LargerThan64BitsReversed) {
EXPECT_EQ(0, reverseBits(0, 65));
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, reverseBits(0xFFFFFFFFFFFFFFFF, 100));
EXPECT_EQ(0x555500005555FFFF, reverseBits(0xFFFFAAAA0000AAAA, 3000));
}
// Tests reverseBits for bit sizes less than all the data stored.
TEST(ReverseBitsTest, LessBitsReversedThanInputHasSet) {
EXPECT_EQ(0xF8, reverseBits(0xF1, 4));
EXPECT_EQ(0xF5, reverseBits(0xFA, 4));
EXPECT_EQ(0x12345678FFFF0000, reverseBits(0x123456780000FFFF, 32));
}
+339
View File
@@ -0,0 +1,339 @@
# SYNOPSIS:
#
# make [all] - makes everything.
# make TARGET - makes the given target.
# make clean - removes all files generated by make.
# Please tweak the following variable definitions as needed by your
# project, except GTEST_HEADERS, which you can use in your own targets
# but shouldn't modify.
# Points to the root of Google Test, relative to where this file is.
# Remember to tweak this if you move this file.
GTEST_DIR = ../lib/googletest/googletest
# Where to find user code.
USER_DIR = ../src
# Flags passed to the preprocessor.
# Set Google Test's header directory as a system directory, such that
# the compiler doesn't generate warnings in Google Test headers.
CPPFLAGS += -isystem $(GTEST_DIR)/include -DUNIT_TEST
# Flags passed to the C++ compiler.
CXXFLAGS += -g -Wall -Wextra -pthread
# All tests produced by this Makefile. Remember to add new tests you
# created to the list.
TESTS = IRutils_test IRsend_test ir_NEC_test ir_GlobalCache_test \
ir_Sherwood_test ir_Sony_test ir_Samsung_test ir_Kelvinator_test \
ir_JVC_test ir_RCMM_test ir_LG_test ir_Mitsubishi_test ir_Sharp_test \
ir_RC5_RC6_test ir_Panasonic_test ir_Dish_test ir_Whynter_test \
ir_Aiwa_test ir_Denon_test ir_Sanyo_test ir_Daikin_test ir_Coolix_test \
ir_Gree_test IRrecv_test ir_Pronto_test ir_Fujitsu_test
# All Google Test headers. Usually you shouldn't change this
# definition.
GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
$(GTEST_DIR)/include/gtest/internal/*.h
# House-keeping build targets.
all : $(TESTS)
clean :
rm -f $(TESTS) gtest.a gtest_main.a *.o
# Build and run all the tests.
run : all
failed=""; \
for unittest in $(TESTS); do \
./$${unittest} || failed="$${failed} $${unittest}"; \
done; \
if [ -n "$${failed}" ]; then \
echo "FAIL: :-( :-( Unit test(s)$${failed} failed! :-( :-("; exit 1; \
else \
echo "PASS: \o/ \o/ All unit tests passed. \o/ \o/"; \
fi
install-googletest :
git clone https://github.com/google/googletest.git ../lib/googletest
# Builds gtest.a and gtest_main.a.
# Usually you shouldn't tweak such internal variables, indicated by a
# trailing _.
GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
# All the IR protocol object files.
PROTOCOLS = ir_NEC.o ir_Sony.o ir_Samsung.o ir_JVC.o ir_RCMM.o ir_RC5_RC6.o \
ir_LG.o ir_Mitsubishi.o ir_Fujitsu.o ir_Sharp.o ir_Sanyo.o ir_Denon.o ir_Dish.o \
ir_Panasonic.o ir_Whynter.o ir_Coolix.o ir_Aiwa.o ir_Sherwood.o \
ir_Kelvinator.o ir_Daikin.o ir_Gree.o ir_Pronto.o
# Common object files
COMMON_OBJ = IRutils.o IRtimer.o IRsend.o IRrecv.o ir_GlobalCache.o \
$(PROTOCOLS) gtest_main.a
# Common dependencies
COMMON_DEPS = $(USER_DIR)/IRrecv.h $(USER_DIR)/IRsend.h $(USER_DIR)/IRtimer.h \
$(USER_DIR)/IRutils.h $(USER_DIR)/IRremoteESP8266.h
# Common test dependencies
COMMON_TEST_DEPS = $(COMMON_DEPS) IRsend_test.h
# For simplicity and to avoid depending on Google Test's
# implementation details, the dependencies specified below are
# conservative and not optimized. This is fine as Google Test
# compiles fast and for ordinary users its source rarely changes.
gtest-all.o : $(GTEST_SRCS_)
$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
$(GTEST_DIR)/src/gtest-all.cc
gtest_main.o : $(GTEST_SRCS_)
$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
$(GTEST_DIR)/src/gtest_main.cc
gtest.a : gtest-all.o
$(AR) $(ARFLAGS) $@ $^
gtest_main.a : gtest-all.o gtest_main.o
$(AR) $(ARFLAGS) $@ $^
# Builds a our test. A test should link with either gtest.a or
# gtest_main.a, depending on whether it defines its own main()
# function.
IRutils.o : $(USER_DIR)/IRutils.cpp $(USER_DIR)/IRutils.h
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/IRutils.cpp
IRutils_test.o : IRutils_test.cpp $(USER_DIR)/IRutils.h $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c IRutils_test.cpp
IRutils_test : IRutils.o IRutils_test.o gtest_main.a
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
IRtimer.o : $(USER_DIR)/IRtimer.cpp $(USER_DIR)/IRtimer.h
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/IRtimer.cpp
IRsend.o : $(USER_DIR)/IRsend.cpp $(USER_DIR)/IRsend.h $(USER_DIR)/IRremoteESP8266.h
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/IRsend.cpp
IRsend_test.o : IRsend_test.cpp $(USER_DIR)/IRsend.h $(USER_DIR)/IRrecv.h IRsend_test.h $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c IRsend_test.cpp
IRsend_test : IRsend_test.o $(COMMON_OBJ)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
IRrecv.o : $(USER_DIR)/IRrecv.cpp $(USER_DIR)/IRrecv.h $(USER_DIR)/IRremoteESP8266.h $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/IRrecv.cpp
IRrecv_test.o : IRrecv_test.cpp $(USER_DIR)/IRsend.h $(USER_DIR)/IRrecv.h IRsend_test.h $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c IRrecv_test.cpp
IRrecv_test : IRrecv_test.o $(COMMON_OBJ)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_NEC.o : $(USER_DIR)/ir_NEC.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_NEC.cpp
ir_NEC_test.o : ir_NEC_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_NEC_test.cpp
ir_NEC_test : $(COMMON_OBJ) ir_NEC_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_GlobalCache.o : $(USER_DIR)/ir_GlobalCache.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_GlobalCache.cpp
ir_GlobalCache_test.o : ir_GlobalCache_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_GlobalCache_test.cpp
ir_GlobalCache_test : $(COMMON_OBJ) ir_GlobalCache_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Sherwood.o : $(USER_DIR)/ir_Sherwood.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Sherwood.cpp
ir_Sherwood_test.o : ir_Sherwood_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Sherwood_test.cpp
ir_Sherwood_test : $(COMMON_OBJ) ir_Sherwood_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Sony.o : $(USER_DIR)/ir_Sony.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Sony.cpp
ir_Sony_test.o : ir_Sony_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Sony_test.cpp
ir_Sony_test : $(COMMON_OBJ) ir_Sony_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Samsung.o : $(USER_DIR)/ir_Samsung.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Samsung.cpp
ir_Samsung_test.o : ir_Samsung_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Samsung_test.cpp
ir_Samsung_test : $(COMMON_OBJ) ir_Samsung_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Kelvinator.o : $(USER_DIR)/ir_Kelvinator.cpp $(USER_DIR)/ir_Kelvinator.h $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Kelvinator.cpp
ir_Kelvinator_test.o : ir_Kelvinator_test.cpp $(USER_DIR)/ir_Kelvinator.h $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Kelvinator_test.cpp
ir_Kelvinator_test : $(COMMON_OBJ) ir_Kelvinator_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_JVC.o : $(USER_DIR)/ir_JVC.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_JVC.cpp
ir_JVC_test.o : ir_JVC_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_JVC_test.cpp
ir_JVC_test : $(COMMON_OBJ) ir_JVC_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_RCMM.o : $(USER_DIR)/ir_RCMM.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_RCMM.cpp
ir_RCMM_test.o : ir_RCMM_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_RCMM_test.cpp
ir_RCMM_test : $(COMMON_OBJ) ir_RCMM_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_LG.o : $(USER_DIR)/ir_LG.h $(USER_DIR)/ir_LG.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_LG.cpp
ir_LG_test.o : ir_LG_test.cpp $(USER_DIR)/ir_LG.h $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_LG_test.cpp
ir_LG_test : $(COMMON_OBJ) ir_LG_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Mitsubishi.o : $(USER_DIR)/ir_Mitsubishi.h $(USER_DIR)/ir_Mitsubishi.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Mitsubishi.cpp
ir_Mitsubishi_test.o : ir_Mitsubishi_test.cpp $(USER_DIR)/ir_Mitsubishi.h $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Mitsubishi_test.cpp
ir_Mitsubishi_test : $(COMMON_OBJ) ir_Mitsubishi_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Fujitsu.o : $(USER_DIR)/ir_Fujitsu.h $(USER_DIR)/ir_Fujitsu.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Fujitsu.cpp
ir_Fujitsu_test.o : ir_Fujitsu_test.cpp $(USER_DIR)/ir_Fujitsu.h $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Fujitsu_test.cpp
ir_Fujitsu_test : $(COMMON_OBJ) ir_Fujitsu_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Sharp.o : $(USER_DIR)/ir_Sharp.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Sharp.cpp
ir_Sharp_test.o : ir_Sharp_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Sharp_test.cpp
ir_Sharp_test : $(COMMON_OBJ) ir_Sharp_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_RC5_RC6.o : $(USER_DIR)/ir_RC5_RC6.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_RC5_RC6.cpp
ir_RC5_RC6_test.o : ir_RC5_RC6_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_RC5_RC6_test.cpp
ir_RC5_RC6_test : $(COMMON_OBJ) ir_RC5_RC6_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Panasonic.o : $(USER_DIR)/ir_Panasonic.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Panasonic.cpp
ir_Panasonic_test.o : ir_Panasonic_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Panasonic_test.cpp
ir_Panasonic_test : $(COMMON_OBJ) ir_Panasonic_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Dish.o : $(USER_DIR)/ir_Dish.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Dish.cpp
ir_Dish_test.o : ir_Dish_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Dish_test.cpp
ir_Dish_test : $(COMMON_OBJ) ir_Dish_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Whynter.o : $(USER_DIR)/ir_Whynter.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Whynter.cpp
ir_Whynter_test.o : ir_Whynter_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Whynter_test.cpp
ir_Whynter_test : $(COMMON_OBJ) ir_Whynter_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Coolix.o : $(USER_DIR)/ir_Coolix.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Coolix.cpp
ir_Coolix_test.o : ir_Coolix_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Coolix_test.cpp
ir_Coolix_test : $(COMMON_OBJ) ir_Coolix_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Aiwa.o : $(USER_DIR)/ir_Aiwa.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Aiwa.cpp
ir_Aiwa_test.o : ir_Aiwa_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Aiwa_test.cpp
ir_Aiwa_test : $(COMMON_OBJ) ir_Aiwa_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Denon.o : $(USER_DIR)/ir_Denon.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Denon.cpp
ir_Denon_test.o : ir_Denon_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Denon_test.cpp
ir_Denon_test : $(COMMON_OBJ) ir_Denon_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Sanyo.o : $(USER_DIR)/ir_Sanyo.cpp $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Sanyo.cpp
ir_Sanyo_test.o : ir_Sanyo_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Sanyo_test.cpp
ir_Sanyo_test : $(COMMON_OBJ) ir_Sanyo_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Daikin.o : $(USER_DIR)/ir_Daikin.cpp $(USER_DIR)/ir_Daikin.h $(COMMON_DEPS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Daikin.cpp
ir_Daikin_test.o : ir_Daikin_test.cpp $(USER_DIR)/ir_Daikin.h $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Daikin_test.cpp
ir_Daikin_test : $(COMMON_OBJ) ir_Daikin_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Gree.o : $(USER_DIR)/ir_Gree.cpp $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Gree.cpp
ir_Gree_test.o : ir_Gree_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Gree_test.cpp
ir_Gree_test : $(COMMON_OBJ) ir_Gree_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
ir_Pronto.o : $(USER_DIR)/ir_Pronto.cpp $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/ir_Pronto.cpp
ir_Pronto_test.o : ir_Pronto_test.cpp $(COMMON_TEST_DEPS) $(GTEST_HEADERS)
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -I$(USER_DIR) -c ir_Pronto_test.cpp
ir_Pronto_test : $(COMMON_OBJ) ir_Pronto_test.o
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
+338
View File
@@ -0,0 +1,338 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendAiwaRCT501().
// Test sending typical data only.
TEST(TestSendAiwa, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x7F); // Aiwa Power Toggle.
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Test sending oversized data.
TEST(TestSendAiwa, SendOversizedData) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x7F, 38); // 38 bits is over the maximum. Should fail.
EXPECT_EQ("", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendAiwa, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x7F, AIWA_RC_T501_BITS, 0); // No repeats.
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080", irsend.outputStr());
irsend.reset();
irsend.sendAiwaRCT501(0x7F, AIWA_RC_T501_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
irsend.reset();
irsend.sendAiwaRCT501(0x7F, AIWA_RC_T501_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080"
"m8960s2240m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendAiwa, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x12, 8);
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
irsend.reset();
irsend.sendAiwaRCT501(0x1234567890, 37);
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s1680m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s1680"
"m560s560m560s560m560s1680m560s560m560s560m560s560m560s560m560s1680"
"m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Tests for decodeAiwaRCT501().
// Decode normal Aiwa messages.
TEST(TestDecodeAiwa, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Aiwa 15-bit(42bit) message.
irsend.reset();
irsend.sendAiwaRCT501(0x7F);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x7F, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Aiwa 15-bit(42bit) message.
irsend.reset();
irsend.sendAiwaRCT501(0x0);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Aiwa 15-bit(42bit) message.
irsend.reset();
irsend.sendAiwaRCT501(0x7FFF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x7FFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Aiwa messages.
TEST(TestDecodeAiwa, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Aiwa 15-bit(42bit) message with 2 repeats.
irsend.reset();
irsend.sendAiwaRCT501(0x7F, AIWA_RC_T501_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x7F, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode unsupported Aiwa messages.
TEST(TestDecodeAiwa, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Confirm using sendNEC(data, 42, 1) can make a legal Aiwa message.
irsend.sendNEC(0x1D8113F00FF, 42, AIWA_RC_T501_MIN_REPEAT);
irsend.makeDecodeResult();
// MUST pass with strict on.
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
ASSERT_EQ(0x7F, irsend.capture.value);
irsend.reset();
// Use sendNEC(data, 42) to make/send an illegal value Aiwa message.
// Value is illegal due to bad pre & post data.
irsend.sendNEC(0x1234567890A, 42, AIWA_RC_T501_MIN_REPEAT);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
// Should fail if strict off too.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
false));
irsend.reset();
// Use sendNEC(data, 42) to make/send an illegal value Aiwa message.
// Value is illegal due to bad post data only.
irsend.sendNEC(0x1D8113F00FE, 42, AIWA_RC_T501_MIN_REPEAT);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
// Should fail if strict off too.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
false));
irsend.reset();
// Use sendNEC(data, 42) to make/send an illegal value Aiwa message.
// Value is illegal due to bad pre data only.
irsend.sendNEC(0x0D8113F00FF, 42, AIWA_RC_T501_MIN_REPEAT);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
// Should fail if strict off too.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
false));
}
// Decode unsupported Aiwa messages.
TEST(TestDecodeAiwa, DecodeWithNonStrictSizes) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendAiwaRCT501(0x0, 8); // Illegal size Aiwa 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, 8, false));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
irsend.reset();
irsend.sendAiwaRCT501(0x12345678, 32); // Illegal size Aiwa 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
true));
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, 32, false));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeAiwa, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Aiwa 37(64)-bit message.
irsend.sendAiwaRCT501(0x1FFFFFFFFF, 37);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, 37, false));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(37, irsend.capture.bits);
EXPECT_EQ(0x1FFFFFFFFF, irsend.capture.value);
// Reconfirm it by sending a true 64bit NEC message with the Aiwa prefix.
irsend.reset();
irsend.sendNEC(0x76044FFFFFFFFFFF, 64, AIWA_RC_T501_MIN_REPEAT);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture, 37, false));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(37, irsend.capture.bits);
EXPECT_EQ(0x1FFFFFFFFF, irsend.capture.value);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeAiwa, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Aiwa Power Toggle from Global Cache.
uint16_t gc_test[95] = {38000, 1, 89, 342, 171, 21, 21, 21, 64, 21, 64,
21, 64, 21, 21, 21, 64, 21, 64, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 64, 21, 21,
21, 21, 21, 21, 21, 64, 21, 21, 21, 21, 21, 64,
21, 64, 21, 64, 21, 64, 21, 64, 21, 64, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 64, 21, 64, 21, 64, 21, 64, 21, 64,
21, 64, 21, 64, 21, 64, 21, 875, 342, 171, 21, 3565};
irsend.sendGC(gc_test, 95);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeAiwaRCT501(&irsend.capture));
EXPECT_EQ(AIWA_RC_T501, irsend.capture.decode_type);
EXPECT_EQ(AIWA_RC_T501_BITS, irsend.capture.bits);
EXPECT_EQ(0x7F, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Confirm what the 42-bit NEC decode is.
ASSERT_TRUE(irrecv.decodeNEC(&irsend.capture, 42, false));
EXPECT_EQ(0x1D8113F00FF, irsend.capture.value);
}
// Fail to decode a non-Aiwa example via GlobalCache
TEST(TestDecodeAiwa, FailToDecodeNonAiwaExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture));
ASSERT_FALSE(irrecv.decodeAiwaRCT501(&irsend.capture, AIWA_RC_T501_BITS,
false));
}
+290
View File
@@ -0,0 +1,290 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendCOOLIX().
// Test sending typical data only.
TEST(TestSendCoolix, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendCOOLIX(0x0);
EXPECT_EQ(
"m4480s4480"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s5040", irsend.outputStr());
irsend.reset();
irsend.sendCOOLIX(0xAA55AA);
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040", irsend.outputStr());
irsend.reset();
irsend.sendCOOLIX(0xFFFFFF);
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s5040", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendCoolix, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendCOOLIX(0xAA55AA, COOLIX_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040"
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040", irsend.outputStr());
irsend.sendCOOLIX(0xAA55AA, COOLIX_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040"
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040"
"m4480s4480"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680"
"m560s5040", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendCoolix, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendCOOLIX(0x0, 8);
EXPECT_EQ(
"m4480s4480"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s5040", irsend.outputStr());
irsend.reset();
irsend.sendCOOLIX(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m4480s4480"
"m560s560m560s560m560s560m560s1680m560s560m560s560m560s1680m560s560"
"m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560m560s1680"
"m560s560m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s1680m560s560m560s560m560s1680m560s560m560s1680m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s560m560s1680"
"m560s560m560s1680m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s560m560s1680m560s1680m560s1680"
"m560s1680m560s560m560s560m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s1680"
"m560s560m560s1680m560s560m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s1680m560s560m560s560m560s1680m560s1680m560s560m560s1680"
"m560s560m560s560m560s1680m560s1680m560s560m560s560m560s1680m560s560"
"m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s560m560s560m560s560m560s1680m560s560m560s560m560s560m560s560"
"m560s5040", irsend.outputStr());
// Bit sizes must be a multiple of 8.
irsend.reset();
irsend.sendCOOLIX(0x0, 17);
EXPECT_EQ("" , irsend.outputStr());
}
// Tests for decodeCOOLIX().
// Decode normal Coolix messages.
TEST(TestDecodeCoolix, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Coolix 24-bit message.
irsend.reset();
irsend.sendCOOLIX(0x123456);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Coolix 24-bit message.
irsend.reset();
irsend.sendCOOLIX(0x0);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Coolix 24-bit message.
irsend.reset();
irsend.sendCOOLIX(0xFFFFFF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0xFFFFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Coolix messages.
TEST(TestDecodeCoolix, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Coolix 16-bit message with 2 repeats.
irsend.reset();
irsend.sendCOOLIX(0x123456, COOLIX_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456, irsend.capture.value);
EXPECT_FALSE(irsend.capture.repeat);
irsend.makeDecodeResult(4 * COOLIX_BITS + 4);
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456, irsend.capture.value);
irsend.makeDecodeResult(2 * (4 * COOLIX_BITS + 4));
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(COOLIX_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456, irsend.capture.value);
}
// Decode unsupported Coolix messages.
TEST(TestDecodeCoolix, DecodeWithNonStrictSizes) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendCOOLIX(0x12, 8); // Illegal value Coolix 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, 8, false));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x12, irsend.capture.value);
irsend.reset();
irsend.sendCOOLIX(0x12345678, 32); // Illegal value Coolix 32-bit message.
irsend.makeDecodeResult();
// Shouldn't pass with strict when we ask for less bits than we got.
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, 32, false));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
// Decode should fail if asked to decode non-multiples of 8 bits.
irsend.reset();
irsend.sendCOOLIX(0x123456, COOLIX_BITS, 2);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture, 9, false));
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeCoolix, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal size Coolix 64-bit message.
irsend.sendCOOLIX(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeCOOLIX(&irsend.capture, 64, false));
EXPECT_EQ(COOLIX, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
}
// Fail to decode a non-Coolix example via GlobalCache
TEST(TestDecodeCoolix, FailToDecodeNonCoolixExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture));
ASSERT_FALSE(irrecv.decodeCOOLIX(&irsend.capture, COOLIX_BITS, false));
}
+419
View File
@@ -0,0 +1,419 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "ir_Daikin.h"
#include "gtest/gtest.h"
// Tests for sendDaikin().
// Test sending typical data only.
TEST(TestSendDaikin, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
uint8_t daikin_code[DAIKIN_COMMAND_LENGTH] = {
0x11, 0xDA, 0x27, 0xF0, 0x00, 0x00, 0x00, 0x20,
0x11, 0xDA, 0x27, 0x00, 0x00, 0x41, 0x1E, 0x00,
0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xE3};
irsend.reset();
irsend.sendDaikin(daikin_code);
EXPECT_EQ(
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s1280m428s428m428s428"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s428m428s428m428s428m428s428m428s428m428s1280m428s428"
"m428s428m428s1280m428s1280m428s1280m428s1280m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s428m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s1280m428s428m428s428m428s428m428s1280m428s1280m428s1280"
"m428s29428", irsend.outputStr());
}
// Test sending with repeats.
TEST(TestSendDaikin, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
uint8_t daikin_code[DAIKIN_COMMAND_LENGTH] = {
0x11, 0xDA, 0x27, 0xF0, 0x00, 0x00, 0x00, 0x20,
0x11, 0xDA, 0x27, 0x00, 0x00, 0x41, 0x1E, 0x00,
0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xE3};
irsend.reset();
irsend.sendDaikin(daikin_code, DAIKIN_COMMAND_LENGTH, 1);
EXPECT_EQ(
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s1280m428s428m428s428"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s428m428s428m428s428m428s428m428s428m428s1280m428s428"
"m428s428m428s1280m428s1280m428s1280m428s1280m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s428m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s1280m428s428m428s428m428s428m428s1280m428s1280m428s1280"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s1280m428s428m428s428"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s428m428s428m428s428m428s428m428s428m428s1280m428s428"
"m428s428m428s1280m428s1280m428s1280m428s1280m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s428m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s1280m428s428m428s428m428s428m428s1280m428s1280m428s1280"
"m428s29428", irsend.outputStr());
}
// Test sending atypical sizes.
TEST(TestSendDaikin, SendUnexpectedSizes) {
IRsendTest irsend(4);
irsend.begin();
uint8_t daikin_short_code[DAIKIN_COMMAND_LENGTH - 1] = {
0x11, 0xDA, 0x27, 0xF0, 0x00, 0x00, 0x00, 0x20,
0x11, 0xDA, 0x27, 0x00, 0x00, 0x41, 0x1E, 0x00,
0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00};
irsend.reset();
irsend.sendDaikin(daikin_short_code, DAIKIN_COMMAND_LENGTH - 1);
ASSERT_EQ("", irsend.outputStr());
uint8_t daikin_long_code[DAIKIN_COMMAND_LENGTH + 1] = {
0x11, 0xDA, 0x27, 0xF0, 0x00, 0x00, 0x00, 0x20,
0x11, 0xDA, 0x27, 0x00, 0x00, 0x41, 0x1E, 0x00,
0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xE3, 0x11};
irsend.reset();
irsend.sendDaikin(daikin_long_code, DAIKIN_COMMAND_LENGTH + 1);
ASSERT_EQ(
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s1280m428s428m428s428"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s428m428s428m428s428m428s428m428s428m428s1280m428s428"
"m428s428m428s1280m428s1280m428s1280m428s1280m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s428m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s1280m428s428m428s428m428s428m428s1280m428s1280m428s1280"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s29428", irsend.outputStr());
}
// Tests for IRDaikinESP class.
TEST(TestDaikinClass, Power) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.on();
EXPECT_TRUE(irdaikin.getPower());
irdaikin.off();
EXPECT_FALSE(irdaikin.getPower());
irdaikin.setPower(true);
EXPECT_TRUE(irdaikin.getPower());
irdaikin.setPower(false);
EXPECT_FALSE(irdaikin.getPower());
}
TEST(TestDaikinClass, Temperature) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setTemp(0);
EXPECT_EQ(DAIKIN_MIN_TEMP, irdaikin.getTemp());
irdaikin.setTemp(255);
EXPECT_EQ(DAIKIN_MAX_TEMP, irdaikin.getTemp());
irdaikin.setTemp(DAIKIN_MIN_TEMP);
EXPECT_EQ(DAIKIN_MIN_TEMP, irdaikin.getTemp());
irdaikin.setTemp(DAIKIN_MAX_TEMP);
EXPECT_EQ(DAIKIN_MAX_TEMP, irdaikin.getTemp());
irdaikin.setTemp(DAIKIN_MIN_TEMP - 1);
EXPECT_EQ(DAIKIN_MIN_TEMP, irdaikin.getTemp());
irdaikin.setTemp(DAIKIN_MAX_TEMP + 1);
EXPECT_EQ(DAIKIN_MAX_TEMP, irdaikin.getTemp());
irdaikin.setTemp(DAIKIN_MIN_TEMP + 1);
EXPECT_EQ(DAIKIN_MIN_TEMP + 1, irdaikin.getTemp());
irdaikin.setTemp(21);
EXPECT_EQ(21, irdaikin.getTemp());
irdaikin.setTemp(25);
EXPECT_EQ(25, irdaikin.getTemp());
irdaikin.setTemp(29);
EXPECT_EQ(29, irdaikin.getTemp());
}
TEST(TestDaikinClass, OperatingMode) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setMode(DAIKIN_AUTO);
EXPECT_EQ(DAIKIN_AUTO, irdaikin.getMode());
irdaikin.setMode(DAIKIN_COOL);
EXPECT_EQ(DAIKIN_COOL, irdaikin.getMode());
irdaikin.setMode(DAIKIN_HEAT);
EXPECT_EQ(DAIKIN_HEAT, irdaikin.getMode());
irdaikin.setMode(DAIKIN_DRY);
EXPECT_EQ(DAIKIN_DRY, irdaikin.getMode());
irdaikin.setMode(DAIKIN_FAN);
EXPECT_EQ(DAIKIN_FAN, irdaikin.getMode());
irdaikin.setMode(DAIKIN_FAN + 1);
EXPECT_EQ(DAIKIN_AUTO, irdaikin.getMode());
irdaikin.setMode(DAIKIN_AUTO + 1);
EXPECT_EQ(DAIKIN_AUTO, irdaikin.getMode());
irdaikin.setMode(255);
EXPECT_EQ(DAIKIN_AUTO, irdaikin.getMode());
}
TEST(TestDaikinClass, VaneSwing) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setSwingHorizontal(true);
irdaikin.setSwingVertical(false);
irdaikin.setSwingHorizontal(true);
EXPECT_TRUE(irdaikin.getSwingHorizontal());
EXPECT_FALSE(irdaikin.getSwingVertical());
irdaikin.setSwingVertical(true);
EXPECT_TRUE(irdaikin.getSwingHorizontal());
EXPECT_TRUE(irdaikin.getSwingVertical());
irdaikin.setSwingHorizontal(false);
EXPECT_FALSE(irdaikin.getSwingHorizontal());
EXPECT_TRUE(irdaikin.getSwingVertical());
irdaikin.setSwingVertical(false);
EXPECT_FALSE(irdaikin.getSwingHorizontal());
EXPECT_FALSE(irdaikin.getSwingVertical());
}
TEST(TestDaikinClass, QuietMode) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setQuiet(true);
EXPECT_TRUE(irdaikin.getQuiet());
irdaikin.setQuiet(false);
EXPECT_FALSE(irdaikin.getQuiet());
irdaikin.setQuiet(true);
EXPECT_TRUE(irdaikin.getQuiet());
irdaikin.setPowerful(true);
EXPECT_FALSE(irdaikin.getQuiet());
}
TEST(TestDaikinClass, PowerfulMode) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setPowerful(true);
EXPECT_TRUE(irdaikin.getPowerful());
irdaikin.setPowerful(false);
EXPECT_FALSE(irdaikin.getPowerful());
irdaikin.setPowerful(true);
EXPECT_TRUE(irdaikin.getPowerful());
irdaikin.setQuiet(true);
EXPECT_FALSE(irdaikin.getPowerful());
}
TEST(TestDaikinClass, FanSpeed) {
IRDaikinESP irdaikin(0);
irdaikin.begin();
irdaikin.setFan(0);
EXPECT_EQ(0, irdaikin.getFan());
irdaikin.setFan(255);
EXPECT_EQ(DAIKIN_FAN_MAX, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_MAX);
EXPECT_EQ(DAIKIN_FAN_MAX, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_MAX + 1);
EXPECT_EQ(DAIKIN_FAN_MAX, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_MAX - 1);
EXPECT_EQ(DAIKIN_FAN_MAX - 1, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_MIN);
EXPECT_EQ(DAIKIN_FAN_MIN, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_MIN + 1);
EXPECT_EQ(DAIKIN_FAN_MIN + 1, irdaikin.getFan());
irdaikin.setFan(3);
EXPECT_EQ(3, irdaikin.getFan());
irdaikin.setFan(DAIKIN_FAN_AUTO);
EXPECT_EQ(DAIKIN_FAN_AUTO, irdaikin.getFan());
}
TEST(TestDaikinClass, MessageConstuction) {
IRDaikinESP irdaikin(0);
IRsendTest irsend(4);
irdaikin.begin();
irsend.begin();
irdaikin.setFan(DAIKIN_FAN_MIN);
irdaikin.setMode(DAIKIN_COOL);
irdaikin.setTemp(27);
irdaikin.setSwingVertical(false);
irdaikin.setSwingHorizontal(true);
irdaikin.setQuiet(false);
irdaikin.setPower(true);
// Check everything for kicks.
EXPECT_EQ(DAIKIN_FAN_MIN, irdaikin.getFan());
EXPECT_EQ(DAIKIN_COOL, irdaikin.getMode());
EXPECT_EQ(27, irdaikin.getTemp());
EXPECT_FALSE(irdaikin.getSwingVertical());
EXPECT_TRUE(irdaikin.getSwingHorizontal());
EXPECT_FALSE(irdaikin.getQuiet());
EXPECT_TRUE(irdaikin.getPower());
irsend.reset();
irsend.sendDaikin(irdaikin.getRaw());
EXPECT_EQ(
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s29428"
"m3650s1623"
"m428s1280m428s428m428s428m428s428m428s1280m428s428m428s428m428s428"
"m428s428m428s1280m428s428m428s1280m428s1280m428s428m428s1280m428s1280"
"m428s1280m428s1280m428s1280m428s428m428s428m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s1280m428s428m428s428m428s428m428s1280m428s1280m428s428m428s428"
"m428s428m428s1280m428s1280m428s428m428s1280m428s1280m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s1280m428s1280m428s428m428s428"
"m428s1280m428s1280m428s1280m428s1280m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s1280m428s1280"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s428m428s428m428s428m428s428m428s428"
"m428s428m428s428m428s428m428s1280m428s1280m428s1280m428s1280m428s428"
"m428s29428", irsend.outputStr());
}
+272
View File
@@ -0,0 +1,272 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendDenon().
// Test sending typical data only.
TEST(TestSendDenon, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDenon(0x2278); // Denon AVR Power On. (Sharp)
EXPECT_EQ(
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602", irsend.outputStr());
irsend.reset();
// Denon Eco Mode On. (Panasonic/Kaseikyo)
irsend.sendDenon(0x2A4C028D6CE3, DENON_48_BITS);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendDenon, SendNormalWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDenon(0x2278, DENON_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602", irsend.outputStr());
irsend.sendDenon(0x2278, DENON_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s1820m260s780m260s780"
"m260s1820m260s1820m260s1820m260s1820m260s780m260s780m260s780"
"m260s43602"
"m260s780m260s1820m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s780m260s780m260s780m260s780m260s1820m260s1820m260s1820"
"m260s43602", irsend.outputStr());
}
TEST(TestSendDenon, Send48BitWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDenon(0x2A4C028D6CE3, DENON_48_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600"
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600", irsend.outputStr());
irsend.sendDenon(0x2A4C028D6CE3, DENON_48_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600"
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600"
"m3456s1728"
"m432s432m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s432"
"m432s432m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s1296m432s432"
"m432s1296m432s432m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s432m432s432m432s1296m432s1296"
"m432s129600", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendDenon, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDenon(0x12, 8);
EXPECT_EQ(
"m260s780m260s780m260s780m260s1820m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s1820m260s1820m260s780m260s1820m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
irsend.reset();
irsend.sendDenon(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s1296m432s432m432s432m432s1296m432s432"
"m432s432m432s432m432s1296m432s1296m432s432m432s1296m432s432m432s432"
"m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296m432s432"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s432m432s432m432s432"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296"
"m432s1296m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s1296m432s1296"
"m432s129600", irsend.outputStr());
}
// Tests for decodeDenon().
// Decode normal Denon messages.
TEST(TestDecodeDenon, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Denon 15-bit message. (Sharp)
irsend.reset();
irsend.sendDenon(0x2278);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDenon(&irsend.capture, DENON_BITS, true));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_BITS, irsend.capture.bits);
EXPECT_EQ(0x2278, irsend.capture.value);
EXPECT_EQ(0x2, irsend.capture.address);
EXPECT_EQ(0x79, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Legacy Denon 14-bit message.
irsend.reset();
irsend.sendDenon(0x1278, DENON_LEGACY_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDenon(&irsend.capture, DENON_LEGACY_BITS, true));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_LEGACY_BITS, irsend.capture.bits);
EXPECT_EQ(0x1278, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Denon 48-bit message. (Panasonic/Kaseikyo)
irsend.reset();
irsend.sendDenon(0x2A4C028D6CE3, DENON_48_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDenon(&irsend.capture, DENON_48_BITS, true));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_48_BITS, irsend.capture.bits);
EXPECT_EQ(0x2A4C028D6CE3, irsend.capture.value);
EXPECT_EQ(0x2A4C, irsend.capture.address);
EXPECT_EQ(0x028D6CE3, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeDenon, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Denon AVR series Power On code from Global Cache. (Sharp style)
uint16_t gc_test_power[67] = {38000, 1, 1,
10, 30, 10, 70, 10, 30, 10, 30, 10, 30, 10, 70,
10, 30, 10, 30, 10, 70, 10, 70, 10, 70, 10, 70,
10, 30, 10, 30, 10, 30, 10, 1657,
10, 30, 10, 70, 10, 30, 10, 30, 10, 30, 10, 30,
10, 70, 10, 70, 10, 30, 10, 30, 10, 30, 10, 30,
10, 70, 10, 70, 10, 70, 10, 1657};
irsend.sendGC(gc_test_power, 67);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDenon(&irsend.capture, DENON_BITS, true));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_BITS, irsend.capture.bits);
EXPECT_EQ(0x2278, irsend.capture.value);
EXPECT_EQ(0x2, irsend.capture.address);
EXPECT_EQ(0x79, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Denon "Eco Mode Auto" code from Global Cache. (Panasonic style)
uint16_t gc_test_eco[103] = {37000, 1, 1, 128, 64, 16, 16, 16, 16, 16, 48,
16, 16, 16, 48, 16, 16, 16, 48, 16, 16, 16, 16,
16, 48, 16, 16, 16, 16, 16, 48, 16, 48, 16, 16,
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
16, 16, 16, 48, 16, 16, 16, 48, 16, 16, 16, 16,
16, 16, 16, 48, 16, 48, 16, 16, 16, 48, 16, 16,
16, 48, 16, 48, 16, 16, 16, 48, 16, 48, 16, 16,
16, 16, 16, 48, 16, 48, 16, 48, 16, 16, 16, 16,
16, 16, 16, 48, 16, 48, 16, 2766};
irsend.reset();
irsend.sendGC(gc_test_eco, 103);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDenon(&irsend.capture, DENON_48_BITS, true));
EXPECT_EQ(DENON, irsend.capture.decode_type);
EXPECT_EQ(DENON_48_BITS, irsend.capture.bits);
EXPECT_EQ(0x2A4C028D6CE3, irsend.capture.value);
EXPECT_EQ(0x2A4C, irsend.capture.address);
EXPECT_EQ(0x028D6CE3, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-Denon example via GlobalCache
TEST(TestDecodeDenon, FailToDecodeNonDenonExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeDenon(&irsend.capture));
ASSERT_FALSE(irrecv.decodeDenon(&irsend.capture, DENON_LEGACY_BITS, false));
ASSERT_FALSE(irrecv.decodeDenon(&irsend.capture, DENON_BITS, false));
ASSERT_FALSE(irrecv.decodeDenon(&irsend.capture, DENON_48_BITS, false));
}
+321
View File
@@ -0,0 +1,321 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendDISH().
// Test sending typical data only.
TEST(TestSendDish, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDISH(0x0);
EXPECT_EQ(
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
irsend.reset();
irsend.sendDISH(0x9C00); // Power on.
EXPECT_EQ(
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
irsend.reset();
irsend.sendDISH(0xFFFF);
EXPECT_EQ(
"m400s6100"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700m400s1700"
"m400s6100", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendDish, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDISH(0x9C00, DISH_BITS, 0); // 0 repeats.
EXPECT_EQ(
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
irsend.reset();
irsend.sendDISH(0x9C00, DISH_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
irsend.sendDISH(0x9C00, DISH_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s1700m400s2800m400s2800m400s1700m400s1700m400s1700m400s2800m400s2800"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendDish, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendDISH(0x0, 8);
EXPECT_EQ(
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100"
"m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800m400s2800"
"m400s6100", irsend.outputStr());
irsend.reset();
irsend.sendDISH(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m400s6100"
"m400s2800m400s2800m400s2800m400s1700m400s2800m400s2800m400s1700m400s2800"
"m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700m400s2800m400s2800"
"m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700m400s2800"
"m400s2800m400s1700m400s1700m400s1700m400s1700m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s2800m400s1700m400s2800m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700"
"m400s1700m400s1700m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700"
"m400s1700m400s1700m400s1700m400s2800m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s2800m400s2800m400s2800m400s1700m400s2800m400s2800m400s1700m400s2800"
"m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700m400s2800m400s2800"
"m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700m400s2800"
"m400s2800m400s1700m400s1700m400s1700m400s1700m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s2800m400s1700m400s2800m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700"
"m400s1700m400s1700m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700"
"m400s1700m400s1700m400s1700m400s2800m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s2800m400s2800m400s2800m400s1700m400s2800m400s2800m400s1700m400s2800"
"m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700m400s2800m400s2800"
"m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700m400s2800"
"m400s2800m400s1700m400s1700m400s1700m400s1700m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s2800m400s1700m400s2800m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700"
"m400s1700m400s1700m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700"
"m400s1700m400s1700m400s1700m400s2800m400s1700m400s1700m400s1700m400s1700"
"m400s6100"
"m400s2800m400s2800m400s2800m400s1700m400s2800m400s2800m400s1700m400s2800"
"m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700m400s2800m400s2800"
"m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700m400s2800"
"m400s2800m400s1700m400s1700m400s1700m400s1700m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s2800m400s1700m400s2800m400s2800m400s2800m400s2800"
"m400s1700m400s2800m400s1700m400s2800m400s1700m400s2800m400s1700m400s1700"
"m400s1700m400s1700m400s2800m400s2800m400s1700m400s1700m400s2800m400s1700"
"m400s1700m400s1700m400s1700m400s2800m400s1700m400s1700m400s1700m400s1700"
"m400s6100", irsend.outputStr());
}
// Tests for decodeDISH().
// Decode normal Dish messages.
TEST(TestDecodeDish, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Dish 16-bit message.
irsend.reset();
irsend.sendDISH(0x9C00);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, true));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x9C00, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode Dish messages with unsupported size/lengths.
TEST(TestDecodeDish, DecodeWithNonStrictSize) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendDISH(0x12, 8); // Illegal size Dish message. (smaller)
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, 8, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, 8, false));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x12, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendDISH(0x12345678, 32); // Illegal size Dish message. (larger)
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, 32, false));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeDish, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Dish 64-bit message.
irsend.sendDISH(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, 64, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, 64, false));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeDish, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
/*
irsend.reset();
// Dish DTV Pal code from Global Cache.
uint16_t gc_test_dtv[27] = {58000, 1, 3, 22, 538, 22, 252, 22, 156, 22, 156,
22, 156, 22, 156, 22, 252, 22, 252, 22, 252, 22,
252, 22, 252, 22, 538};
irsend.sendGC(gc_test_dtv, 27);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, true));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
*/
// Dish Hopper 3 code from Global Cache.
uint16_t gc_test_hopper[73] = {58000, 1, 37, 23, 351, 23, 94, 23, 164,
23, 164, 23, 94, 23, 94, 23, 94, 23, 164,
23, 164, 23, 164, 23, 164, 23, 164, 23, 164,
23, 164, 23, 164, 23, 164, 23, 164, 23, 351,
23, 94, 23, 164, 23, 164, 23, 94, 23, 94,
23, 94, 23, 164, 23, 164, 23, 164, 23, 164,
23, 164, 23, 164, 23, 164, 23, 164, 23, 164,
23, 164, 23, 351};
irsend.reset();
irsend.sendGC(gc_test_hopper, 73);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, true));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x9C00, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
ASSERT_TRUE(irrecv.decodeDISH(&irsend.capture));
EXPECT_EQ(DISH, irsend.capture.decode_type);
EXPECT_EQ(DISH_BITS, irsend.capture.bits);
EXPECT_EQ(0x9C00, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-Dish example via GlobalCache
TEST(TestDecodeDish, FailToDecodeNonDishExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture));
ASSERT_FALSE(irrecv.decodeDISH(&irsend.capture, DISH_BITS, false));
}
@@ -0,0 +1,207 @@
// Copyright 2017 Jonny Graham
#include "IRsend.h"
#include "IRsend_test.h"
#include "ir_Fujitsu.h"
#include "gtest/gtest.h"
template<typename T, size_t size>
::testing::AssertionResult ArraysMatch(const T (&expected)[size],
const T* actual) {
for (size_t i(0); i < size; ++i) {
if (expected[i] != actual[i]) {
int e = expected[i];
int a = actual[i];
return ::testing::AssertionFailure() << "array[" << i
<< "] (" << std::hex << a << std::dec << ") != expected[" << i
<< "] (" << std::hex << e << std::dec << ")";
}
}
return ::testing::AssertionSuccess();
}
// Tests for Mitsubishi A/C methods.
// Test sending typical data only.
TEST(TestSendFujitsuAC, GetRawDefault) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.setCmd(FUJITSU_AC_CMD_TURN_ON);
fujitsuACSender.setSwing(FUJITSU_AC_SWING_BOTH);
fujitsuACSender.setMode(FUJITSU_AC_MODE_COOL);
fujitsuACSender.setFanSpeed(FUJITSU_AC_FAN_HIGH);
fujitsuACSender.setTemp(24);
uint8_t expected[16] = {0x14, 0x63, 0x0, 0x10, 0x10, 0xFE, 0x9, 0x30,
0x81, 0x1, 0x31, 0x0, 0x0, 0x0, 0x20, 0xFD};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GetRawTurnOff) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.off();
uint8_t expected[7] = {0x14, 0x63, 0x0, 0x10, 0x10, 0x02, 0xFD};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GetRawStepHoriz) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.stepHoriz();
uint8_t expected[7] = {0x14, 0x63, 0x0, 0x10, 0x10, 0x79, 0x86};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GetRawStepVert) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.stepVert();
uint8_t expected[7] = {0x14, 0x63, 0x0, 0x10, 0x10, 0x6C, 0x93};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GetRawWithSwingHoriz) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.setCmd(FUJITSU_AC_CMD_STAY_ON);
fujitsuACSender.setSwing(FUJITSU_AC_SWING_HORIZ);
fujitsuACSender.setMode(FUJITSU_AC_MODE_COOL);
fujitsuACSender.setFanSpeed(FUJITSU_AC_FAN_QUIET);
fujitsuACSender.setTemp(25);
uint8_t expected[16] = {0x14, 0x63, 0x0, 0x10, 0x10, 0xFE, 0x9, 0x30,
0x90, 0x1, 0x24, 0x0, 0x0, 0x0, 0x20, 0xFB};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GetRawWithFan) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
fujitsuACSender.setCmd(FUJITSU_AC_CMD_STAY_ON);
fujitsuACSender.setSwing(FUJITSU_AC_SWING_HORIZ);
fujitsuACSender.setMode(FUJITSU_AC_MODE_FAN);
fujitsuACSender.setFanSpeed(FUJITSU_AC_FAN_MED);
fujitsuACSender.setTemp(20); // temp doesn't matter for fan
// but it is sent by the RC anyway
uint8_t expected[16] = {0x14, 0x63, 0x0, 0x10, 0x10, 0xFE, 0x9, 0x30,
0x40, 0x3, 0x22, 0x0, 0x0, 0x0, 0x20, 0x4B};
EXPECT_TRUE(ArraysMatch(expected, fujitsuACSender.getRaw()));
}
TEST(TestSendFujitsuAC, GenerateMessage) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
IRsendTest irsend(4);
fujitsuACSender.begin();
irsend.begin();
fujitsuACSender.setCmd(FUJITSU_AC_CMD_STAY_ON);
fujitsuACSender.setSwing(FUJITSU_AC_SWING_BOTH);
fujitsuACSender.setMode(FUJITSU_AC_MODE_COOL);
fujitsuACSender.setFanSpeed(FUJITSU_AC_FAN_HIGH);
fujitsuACSender.setTemp(24);
EXPECT_EQ(FUJITSU_AC_FAN_HIGH, fujitsuACSender.getFanSpeed());
EXPECT_EQ(FUJITSU_AC_MODE_COOL, fujitsuACSender.getMode());
EXPECT_EQ(24, fujitsuACSender.getTemp());
EXPECT_EQ(FUJITSU_AC_SWING_BOTH, fujitsuACSender.getSwing());
EXPECT_EQ(FUJITSU_AC_CMD_STAY_ON, fujitsuACSender.getCmd());
irsend.reset();
irsend.sendFujitsuAC(fujitsuACSender.getRaw(), FUJITSU_AC_STATE_LENGTH);
EXPECT_EQ(
"m3224s1574m448s367m448s367m448s1182m448s367m448s1182m448s367m448s367m448"
"s367m448s1182m448s1182m448s367m448s367m448s367m448s1182m448s1182m448s367"
"m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s367m448s1182m448s367m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s1182m448s367m448s367m448s367m448s367m448s1182"
"m448s1182m448s1182m448s1182m448s1182m448s1182m448s1182m448s1182m448s367"
"m448s367m448s1182m448s367m448s367m448s367m448s367m448s367m448s367m448s367"
"m448s367m448s1182m448s1182m448s367m448s367m448s367m448s367m448s367m448s367"
"m448s367m448s367m448s367m448s1182m448s1182m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s367m448s1182m448s367m448s367m448s367m448s1182m448"
"s1182m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448"
"s367m448s367m448s367m448s367m448s367m448s1182m448s367m448s367m448s367m448"
"s1182m448s1182m448s1182m448s1182m448s1182m448s1182m448s1182m448s8100",
irsend.outputStr());
}
TEST(TestSendFujitsuAC, GenerateShortMessage) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
IRsendTest irsend(4);
fujitsuACSender.begin();
irsend.begin();
fujitsuACSender.off();
EXPECT_EQ(FUJITSU_AC_CMD_TURN_OFF, fujitsuACSender.getCmd());
irsend.reset();
irsend.sendFujitsuAC(fujitsuACSender.getRaw(), FUJITSU_AC_STATE_LENGTH_SHORT);
EXPECT_EQ(
"m3224s1574m448s367m448s367m448s1182m448s367m448s1182m448s367m448s367m448"
"s367m448s1182m448s1182m448s367m448s367m448s367m448s1182m448s1182m448s367"
"m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367"
"m448s367m448s367m448s367m448s1182m448s367m448s367m448s367m448s367m448s367"
"m448s367m448s367m448s1182m448s367m448s367m448s367m448s367m448s1182m448s367"
"m448s367m448s367m448s367m448s367m448s367m448s1182m448s367m448s1182m448"
"s1182m448s1182m448s1182m448s1182m448s1182m448s8100",
irsend.outputStr());
}
// Issue #275
TEST(TestSendFujitsuAC, Issue275) {
IRFujitsuAC fujitsuACSender = IRFujitsuAC(4);
IRsendTest irsend(4);
fujitsuACSender.begin();
irsend.begin();
irsend.reset();
fujitsuACSender.setCmd(FUJITSU_AC_CMD_TURN_OFF);
irsend.sendFujitsuAC(fujitsuACSender.getRaw(), FUJITSU_AC_STATE_LENGTH_SHORT);
EXPECT_EQ(
// Header
"m3224s1574"
// 0 0 1 0 1 0 0 0 (0x28)
"m448s367m448s367m448s1182m448s367m448s1182m448s367m448s367m448s367"
// 1 1 0 0 0 1 1 0 (0xC6)
"m448s1182m448s1182m448s367m448s367m448s367m448s1182m448s1182m448s367"
// 0 0 0 0 0 0 0 0 (0x00)
"m448s367m448s367m448s367m448s367m448s367m448s367m448s367m448s367"
// 0 0 0 0 1 0 0 0 (0x08)
"m448s367m448s367m448s367m448s367m448s1182m448s367m448s367m448s367"
// 0 0 0 0 1 0 0 0 (0x08)
"m448s367m448s367m448s367m448s367m448s1182m448s367m448s367m448s367"
// 0 1 0 0 0 0 0 0 (0x40)
"m448s367m448s1182m448s367m448s367m448s367m448s367m448s367m448s367"
// 1 0 1 1 1 1 1 1 (0xBF)
"m448s1182m448s367m448s1182m448s1182m448s1182m448s1182m448s1182m448s1182"
// Footer
"m448s8100", irsend.outputStr());
irsend.reset();
// Per report in Issue #275
uint16_t off[115] = {
3350, 1650,
450, 400, 450, 450, 450, 1250, 450, 400, 450, 1250, 450, 400, 450, 400,
450, 400, 450, 1250, 450, 1250, 450, 400, 450, 400, 450, 400, 450, 1250,
450, 1250, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400,
450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400,
450, 1250, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400,
450, 400, 450, 1250, 450, 400, 450, 400, 450, 400, 450, 400, 450, 1250,
450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 400, 450, 1250,
450, 400, 450, 1250, 450, 1250, 450, 1250, 450, 1250, 450, 1250,
450, 1250, 450};
irsend.sendRaw(off, 115, 38);
EXPECT_EQ(
// Header
"m3350s1650"
// 0 0 1 0 1 0 0 0 (0x28)
"m450s400m450s450m450s1250m450s400m450s1250m450s400m450s400m450s400"
// 1 1 0 0 0 1 1 0 (0xC6)
"m450s1250m450s1250m450s400m450s400m450s400m450s1250m450s1250m450s400"
// 0 0 0 0 0 0 0 0 (0x00)
"m450s400m450s400m450s400m450s400m450s400m450s400m450s400m450s400"
// 0 0 0 0 1 0 0 0 (0x08)
"m450s400m450s400m450s400m450s400m450s1250m450s400m450s400m450s400"
// 0 0 0 0 1 0 0 0 (0x08)
"m450s400m450s400m450s400m450s400m450s1250m450s400m450s400m450s400"
// 0 1 0 0 0 0 0 0 (0x40)
"m450s400m450s1250m450s400m450s400m450s400m450s400m450s400m450s400"
// 1 0 1 1 1 1 1 1 (0xBF)
"m450s1250m450s400m450s1250m450s1250m450s1250m450s1250m450s1250m450s1250"
// Footer
"m450",
irsend.outputStr());
}
@@ -0,0 +1,68 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendGlobalCache().
// Test sending a typical command wihtout a repeat.
TEST(TestSendGlobalCache, NonRepeatingCode) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified NEC TV "Power On" from Global Cache with no repeats
uint16_t gc_test[71] = {38000, 1, 1, 342, 172, 21, 22, 21, 21, 21, 65, 21, 21,
21, 22, 21, 22, 21, 21, 21, 22, 21, 65, 21, 65, 21,
22, 21, 65, 21, 65, 21, 65, 21, 65, 21, 65, 21, 65,
21, 22, 21, 22, 21, 21, 21, 22, 21, 22, 21, 65, 21,
22, 21, 21, 21, 65, 21, 65, 21, 65, 21, 64, 22, 65,
21, 22, 21, 65, 21, 1519};
irsend.sendGC(gc_test, 71);
irsend.makeDecodeResult();
EXPECT_EQ("m8892s4472m546s572m546s546m546s1690m546s546m546s572m546s572"
"m546s546m546s572m546s1690m546s1690m546s572m546s1690m546s1690"
"m546s1690m546s1690m546s1690m546s1690m546s572m546s572m546s546"
"m546s572m546s572m546s1690m546s572m546s546m546s1690m546s1690"
"m546s1690m546s1664m572s1690m546s572m546s1690m546s39494",
irsend.outputStr());
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x20DF827D, irsend.capture.value);
EXPECT_EQ(0x4, irsend.capture.address);
EXPECT_EQ(0x41, irsend.capture.command);
}
// Test sending typical command with repeats.
TEST(TestSendGlobalCache, RepeatCode) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Sherwood (NEC-like) "Power On" from Global Cache with 2 repeats
uint16_t gc_test[75] = {38000, 2, 69, 341, 171, 21, 64, 21, 64, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 64, 21, 64, 21, 21,
21, 64, 21, 21, 21, 21, 21, 21, 21, 64, 21, 21, 21,
64, 21, 21, 21, 21, 21, 21, 21, 64, 21, 21, 21, 21,
21, 21, 21, 21, 21, 64, 21, 64, 21, 64, 21, 21, 21,
64, 21, 64, 21, 64, 21, 1600, 341, 85, 21, 3647};
irsend.sendGC(gc_test, 75);
irsend.makeDecodeResult();
EXPECT_EQ("m8866s4446m546s1664m546s1664m546s546m546s546m546s546m546s546"
"m546s546m546s1664m546s1664m546s546m546s1664m546s546m546s546"
"m546s546m546s1664m546s546m546s1664m546s546m546s546m546s546"
"m546s1664m546s546m546s546m546s546m546s546m546s1664m546s1664"
"m546s1664m546s546m546s1664m546s1664m546s1664m546s41600"
"m8866s2210m546s94822"
"m8866s2210m546s94822", irsend.outputStr());
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC1A28877, irsend.capture.value);
EXPECT_EQ(0x4583, irsend.capture.address);
EXPECT_EQ(0x11, irsend.capture.command);
}
+192
View File
@@ -0,0 +1,192 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendGree().
// Test sending typical data only.
TEST(TestSendGreeChars, SendData) {
IRsendTest irsend(4);
irsend.begin();
uint8_t gree_code[GREE_STATE_LENGTH] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
irsend.reset();
irsend.sendGree(gree_code);
EXPECT_EQ(
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000", irsend.outputStr());
}
TEST(TestSendGreeUint64, SendData) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendGree(0x1234567890ABCDEF);
EXPECT_EQ(
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000", irsend.outputStr());
}
// Test sending with repeats.
TEST(TestSendGreeChars, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
uint8_t gree_code[GREE_STATE_LENGTH] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
irsend.reset();
irsend.sendGree(gree_code, GREE_STATE_LENGTH, 1);
EXPECT_EQ(
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000"
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000", irsend.outputStr());
}
TEST(TestSendGreeUint64, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendGree(0x1234567890ABCDEF, GREE_BITS, 1);
EXPECT_EQ(
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000"
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s19000", irsend.outputStr());
}
// Test sending atypical sizes.
TEST(TestSendGreeChars, SendUnexpectedSizes) {
IRsendTest irsend(4);
irsend.begin();
uint8_t gree_short_code[GREE_STATE_LENGTH - 1] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD};
uint8_t gree_long_code[GREE_STATE_LENGTH + 1] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x12};
irsend.reset();
irsend.sendGree(gree_short_code, GREE_STATE_LENGTH - 1);
ASSERT_EQ("", irsend.outputStr());
irsend.reset();
irsend.sendGree(gree_long_code, GREE_STATE_LENGTH + 1);
ASSERT_EQ(
"m9000s4000"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s540m620s540m620s1600m620s540m620s1600m620s1600m620s540m620s540"
"m620s540m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540"
"m620s540m620s540m620s540m620s1600m620s1600m620s1600m620s1600m620s540"
"m620s540m620s1600m620s540"
"m620s19000"
"m620s540m620s540m620s540m620s540m620s1600m620s540m620s540m620s1600"
"m620s1600m620s1600m620s540m620s1600m620s540m620s1600m620s540m620s1600"
"m620s1600m620s540m620s1600m620s1600m620s540m620s540m620s1600m620s1600"
"m620s1600m620s1600m620s1600m620s1600m620s540m620s1600m620s1600m620s1600"
"m620s540m620s1600m620s540m620s540m620s1600m620s540m620s540m620s540"
"m620s19000", irsend.outputStr());
}
TEST(TestSendGreeUint64, SendUnexpectedSizes) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendGree(0x1234567890ABCDEF, GREE_BITS - 1);
ASSERT_EQ("", irsend.outputStr());
irsend.reset();
irsend.sendGree(0x1234567890ABCDEF, GREE_BITS + 1);
ASSERT_EQ("", irsend.outputStr());
}
TEST(TestSendGree, CompareUint64ToCharResults) {
IRsendTest irsend_chars(4);
IRsendTest irsend_uint64(0);
uint8_t gree_code[GREE_STATE_LENGTH] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
irsend_chars.begin();
irsend_uint64.begin();
irsend_chars.reset();
irsend_uint64.reset();
irsend_chars.sendGree(gree_code);
irsend_uint64.sendGree(0x1234567890ABCDEF);
ASSERT_EQ(irsend_chars.outputStr(), irsend_uint64.outputStr());
uint8_t gree_zero_code[GREE_STATE_LENGTH] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
irsend_chars.reset();
irsend_uint64.reset();
irsend_chars.sendGree(gree_zero_code);
irsend_uint64.sendGree((uint64_t) 0x0);
ASSERT_EQ(irsend_chars.outputStr(), irsend_uint64.outputStr());
}
+299
View File
@@ -0,0 +1,299 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendJVC().
// Test sending typical data only.
TEST(TestSendJVC, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendJVC(0xC2B8); // JVC VCR Power On.
EXPECT_EQ(
"m8400s4200"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendJVC, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendJVC(0xC2B8, JVC_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m8400s4200"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000", irsend.outputStr());
irsend.sendJVC(0xC2B8, JVC_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m8400s4200"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000"
"m525s1725m525s1725m525s525m525s525m525s525m525s525m525s1725m525s525"
"m525s1725m525s525m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s60000", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendJVC, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendJVC(0x0, 8);
EXPECT_EQ(
"m8400s4200"
"m525s525m525s525m525s525m525s525m525s525m525s525m525s525m525s525"
"m525s60000", irsend.outputStr());
irsend.reset();
irsend.sendJVC(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m8400s4200"
"m525s525m525s525m525s525m525s1725m525s525m525s525m525s1725m525s525"
"m525s525m525s525m525s1725m525s1725m525s525m525s1725m525s525m525s525"
"m525s525m525s1725m525s525m525s1725m525s525m525s1725m525s1725m525s525"
"m525s525m525s1725m525s1725m525s1725m525s1725m525s525m525s525m525s525"
"m525s1725m525s525m525s525m525s1725m525s525m525s525m525s525m525s525"
"m525s1725m525s525m525s1725m525s525m525s1725m525s525m525s1725m525s1725"
"m525s1725m525s1725m525s525m525s525m525s1725m525s1725m525s525m525s1725"
"m525s1725m525s1725m525s1725m525s525m525s1725m525s1725m525s1725m525s1725"
"m525s60000", irsend.outputStr());
}
// Tests for encodeJVC().
TEST(TestEncodeJVC, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeJVC(0, 0));
EXPECT_EQ(0x8080, irsend.encodeJVC(1, 1));
EXPECT_EQ(0x8040, irsend.encodeJVC(1, 2));
EXPECT_EQ(0xC2B8, irsend.encodeJVC(0x43, 0x1D));
EXPECT_EQ(0x55AA, irsend.encodeJVC(0xAA, 0x55));
EXPECT_EQ(0xFFFF, irsend.encodeJVC(0xFF, 0xFF));
}
// Tests for decodeJVC().
// Decode normal JVC messages.
TEST(TestDecodeJVC, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal JVC 16-bit message.
irsend.reset();
irsend.sendJVC(0xC2B8);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x43, irsend.capture.address);
EXPECT_EQ(0x1D, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal JVC 16-bit message.
irsend.reset();
irsend.sendJVC(irsend.encodeJVC(0x07, 0x99));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xE099, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal JVC 16-bit message.
irsend.reset();
irsend.sendJVC(irsend.encodeJVC(0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0x8080, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x1, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated JVC messages.
TEST(TestDecodeJVC, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal JVC 16-bit message with 2 repeats.
irsend.reset();
irsend.sendJVC(0xC2B8, JVC_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x43, irsend.capture.address);
EXPECT_EQ(0x1D, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.makeDecodeResult(2 * JVC_BITS + 4);
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_TRUE(irsend.capture.repeat);
irsend.makeDecodeResult(2 * JVC_BITS + 4 + 2 * JVC_BITS + 2);
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_TRUE(irsend.capture.repeat);
// Simulate 'just' a JVC repeat command.
// JVC VCR Power On from Global Cache, but modified to be a repeat message.
uint16_t gc_test[37] = {38000, 1, 1, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 20, 20, 61, 20, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.reset();
irsend.sendGC(gc_test, 37);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x43, irsend.capture.address);
EXPECT_EQ(0x1D, irsend.capture.command);
EXPECT_TRUE(irsend.capture.repeat);
}
// Decode unsupported JVC messages.
TEST(TestDecodeJVC, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendJVC(0x0, 8); // Illegal value JVC 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, 8, false));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendJVC(0x12345678, 32); // Illegal value JVC 32-bit message.
irsend.makeDecodeResult();
// Should not pass with strict when we ask for less bits than we got.
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, 32, false));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x12346A, irsend.capture.address);
EXPECT_EQ(0x1E, irsend.capture.command);
// Illegal over length (36-bit) message.
irsend.reset();
irsend.sendJVC(irsend.encodeJVC(2, 3), 36);
irsend.makeDecodeResult();
// Shouldn't pass if strict off and the wrong expected bits.
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, false));
// Re-decode with correct bit size.
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, 36, true));
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, 36, false));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0x40C0, irsend.capture.value);
EXPECT_EQ(0x2, irsend.capture.address);
EXPECT_EQ(0x3, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeJVC, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size JVC 64-bit message.
irsend.sendJVC(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture, 64, false));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0xFFFFFFFF, irsend.capture.address);
EXPECT_EQ(0xFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeJVC, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// JVC VCR Power On from Global Cache.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 20, 20, 61, 20, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
// 38000,1,37,320,161,21,59,21,59,21,19,21,19,21,19,21,19,21,59,21,19,21,59,21,59,21,19,21,59,21,19,21,19,21,19,21,19,21,838,21,59,21,59,21,19,21,19,21,19,21,19,21,59,21,19,21,59,21,19,21,59,21,59,21,59,21,19,21,19,21,19,21,850};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeJVC(&irsend.capture));
EXPECT_EQ(JVC, irsend.capture.decode_type);
EXPECT_EQ(JVC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x43, irsend.capture.address);
EXPECT_EQ(0x1D, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-JVC example via GlobalCache
TEST(TestDecodeJVC, FailToDecodeNonJVCExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture));
ASSERT_FALSE(irrecv.decodeJVC(&irsend.capture, JVC_BITS, false));
}
@@ -0,0 +1,432 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "ir_Kelvinator.h"
#include "gtest/gtest.h"
// Tests for sendKelvinator().
// Test sending typical data only.
TEST(TestSendKelvinator, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
uint8_t kelv_code[KELVINATOR_STATE_LENGTH] = {
0x19, 0x0B, 0x80, 0x50, 0x00, 0x00, 0x00, 0xE0,
0x19, 0x0B, 0x80, 0x70, 0x00, 0x00, 0x10, 0xf0};
irsend.reset();
irsend.sendKelvinator(kelv_code);
EXPECT_EQ(
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900", irsend.outputStr());
}
// Test sending with repeats.
TEST(TestSendKelvinator, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
uint8_t kelv_code[KELVINATOR_STATE_LENGTH] = {
0x19, 0x0B, 0x80, 0x50, 0x00, 0x00, 0x00, 0xE0,
0x19, 0x0B, 0x80, 0x70, 0x00, 0x00, 0x10, 0xf0};
irsend.reset();
irsend.sendKelvinator(kelv_code, KELVINATOR_STATE_LENGTH, 1);
EXPECT_EQ(
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900", irsend.outputStr());
}
// Test sending atypical sizes.
TEST(TestSendKelvinator, SendUnexpectedSizes) {
IRsendTest irsend(4);
irsend.begin();
uint8_t kelv_short_code[15] = {0x19, 0x0B, 0x80, 0x50, 0x00, 0x00, 0x00, 0xE0,
0x19, 0x0B, 0x80, 0x70, 0x00, 0x00, 0x10};
uint8_t kelv_long_code[17] = {0x19, 0x0B, 0x80, 0x50, 0x00, 0x00, 0x00, 0xE0,
0x19, 0x0B, 0x80, 0x70, 0x00, 0x00, 0x10, 0xf0,
0x00};
irsend.reset();
irsend.sendKelvinator(kelv_short_code, 15);
ASSERT_EQ("", irsend.outputStr());
irsend.reset();
// Shouldn't be different from the SendDataOnly. We just don't send the
// extra data.
irsend.sendKelvinator(kelv_long_code, 17);
ASSERT_EQ(
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s520m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900", irsend.outputStr());
}
// Tests for IRKelvinatorAC class.
TEST(TestKelvinatorClass, Power) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.on();
EXPECT_TRUE(irkelv.getPower());
irkelv.off();
EXPECT_FALSE(irkelv.getPower());
irkelv.setPower(true);
EXPECT_TRUE(irkelv.getPower());
irkelv.setPower(false);
EXPECT_FALSE(irkelv.getPower());
}
TEST(TestKelvinatorClass, Temperature) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setTemp(0);
EXPECT_EQ(KELVINATOR_MIN_TEMP, irkelv.getTemp());
irkelv.setTemp(255);
EXPECT_EQ(KELVINATOR_MAX_TEMP, irkelv.getTemp());
irkelv.setTemp(KELVINATOR_MIN_TEMP);
EXPECT_EQ(KELVINATOR_MIN_TEMP, irkelv.getTemp());
irkelv.setTemp(KELVINATOR_MAX_TEMP);
EXPECT_EQ(KELVINATOR_MAX_TEMP, irkelv.getTemp());
irkelv.setTemp(KELVINATOR_MIN_TEMP - 1);
EXPECT_EQ(KELVINATOR_MIN_TEMP, irkelv.getTemp());
irkelv.setTemp(KELVINATOR_MAX_TEMP + 1);
EXPECT_EQ(KELVINATOR_MAX_TEMP, irkelv.getTemp());
irkelv.setTemp(17);
EXPECT_EQ(17, irkelv.getTemp());
irkelv.setTemp(21);
EXPECT_EQ(21, irkelv.getTemp());
irkelv.setTemp(25);
EXPECT_EQ(25, irkelv.getTemp());
irkelv.setTemp(29);
EXPECT_EQ(29, irkelv.getTemp());
}
TEST(TestKelvinatorClass, OperatingMode) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setTemp(24);
irkelv.setMode(KELVINATOR_AUTO);
EXPECT_EQ(KELVINATOR_AUTO, irkelv.getMode());
EXPECT_EQ(KELVINATOR_AUTO_TEMP, irkelv.getTemp());
irkelv.setMode(KELVINATOR_COOL);
EXPECT_EQ(KELVINATOR_COOL, irkelv.getMode());
irkelv.setMode(KELVINATOR_HEAT);
EXPECT_EQ(KELVINATOR_HEAT, irkelv.getMode());
irkelv.setTemp(24);
irkelv.setMode(KELVINATOR_DRY);
EXPECT_EQ(KELVINATOR_DRY, irkelv.getMode());
EXPECT_EQ(KELVINATOR_AUTO_TEMP, irkelv.getTemp());
irkelv.setMode(KELVINATOR_FAN);
EXPECT_EQ(KELVINATOR_FAN, irkelv.getMode());
irkelv.setMode(KELVINATOR_HEAT + 1);
EXPECT_EQ(KELVINATOR_AUTO, irkelv.getMode());
irkelv.setMode(255);
EXPECT_EQ(KELVINATOR_AUTO, irkelv.getMode());
}
TEST(TestKelvinatorClass, VaneSwing) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setSwingHorizontal(true);
irkelv.setSwingVertical(false);
irkelv.setSwingHorizontal(true);
EXPECT_TRUE(irkelv.getSwingHorizontal());
EXPECT_FALSE(irkelv.getSwingVertical());
irkelv.setSwingVertical(true);
EXPECT_TRUE(irkelv.getSwingHorizontal());
EXPECT_TRUE(irkelv.getSwingVertical());
irkelv.setSwingHorizontal(false);
EXPECT_FALSE(irkelv.getSwingHorizontal());
EXPECT_TRUE(irkelv.getSwingVertical());
irkelv.setSwingVertical(false);
EXPECT_FALSE(irkelv.getSwingHorizontal());
EXPECT_FALSE(irkelv.getSwingVertical());
}
TEST(TestKelvinatorClass, QuietMode) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setQuiet(true);
EXPECT_TRUE(irkelv.getQuiet());
irkelv.setQuiet(false);
EXPECT_FALSE(irkelv.getQuiet());
irkelv.setQuiet(true);
EXPECT_TRUE(irkelv.getQuiet());
}
TEST(TestKelvinatorClass, IonFilter) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setIonFilter(true);
EXPECT_TRUE(irkelv.getIonFilter());
irkelv.setIonFilter(false);
EXPECT_FALSE(irkelv.getIonFilter());
irkelv.setIonFilter(true);
EXPECT_TRUE(irkelv.getIonFilter());
}
TEST(TestKelvinatorClass, Light) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setLight(true);
EXPECT_TRUE(irkelv.getLight());
irkelv.setLight(false);
EXPECT_FALSE(irkelv.getLight());
irkelv.setLight(true);
EXPECT_TRUE(irkelv.getLight());
}
TEST(TestKelvinatorClass, XFan) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setXFan(true);
EXPECT_TRUE(irkelv.getXFan());
irkelv.setXFan(false);
EXPECT_FALSE(irkelv.getXFan());
irkelv.setXFan(true);
EXPECT_TRUE(irkelv.getXFan());
}
TEST(TestKelvinatorClass, TurboFan) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setTurbo(true);
EXPECT_TRUE(irkelv.getTurbo());
irkelv.setTurbo(false);
EXPECT_FALSE(irkelv.getTurbo());
irkelv.setFan(2);
irkelv.setTurbo(true);
EXPECT_TRUE(irkelv.getTurbo());
// Turbo mode is turned off if the temperature is changed.
irkelv.setFan(3);
EXPECT_FALSE(irkelv.getTurbo());
// But only when it is changed, not set to the same value again.
irkelv.setTurbo(true);
irkelv.setFan(3);
EXPECT_TRUE(irkelv.getTurbo());
}
TEST(TestKelvinatorClass, FanSpeed) {
IRKelvinatorAC irkelv(0);
irkelv.begin();
irkelv.setFan(0);
EXPECT_EQ(0, irkelv.getFan());
irkelv.setFan(255);
EXPECT_EQ(KELVINATOR_FAN_MAX, irkelv.getFan());
irkelv.setFan(KELVINATOR_FAN_MAX);
EXPECT_EQ(KELVINATOR_FAN_MAX, irkelv.getFan());
irkelv.setFan(KELVINATOR_FAN_MAX + 1);
EXPECT_EQ(KELVINATOR_FAN_MAX, irkelv.getFan());
irkelv.setFan(KELVINATOR_FAN_MAX - 1);
EXPECT_EQ(KELVINATOR_FAN_MAX - 1, irkelv.getFan());
irkelv.setFan(1);
EXPECT_EQ(1, irkelv.getFan());
irkelv.setFan(1);
EXPECT_EQ(1, irkelv.getFan());
irkelv.setFan(3);
EXPECT_EQ(3, irkelv.getFan());
}
TEST(TestKelvinatorClass, MessageConstuction) {
IRKelvinatorAC irkelv(0);
IRsendTest irsend(4);
irkelv.begin();
irsend.begin();
irkelv.setFan(1);
irkelv.setMode(KELVINATOR_COOL);
irkelv.setTemp(27);
irkelv.setSwingVertical(false);
irkelv.setSwingHorizontal(true);
irkelv.setIonFilter(true);
irkelv.setQuiet(false);
irkelv.setLight(false);
irkelv.setPower(true);
irkelv.setTurbo(false);
irkelv.setXFan(true);
// Check everything for kicks.
EXPECT_EQ(1, irkelv.getFan());
EXPECT_EQ(KELVINATOR_COOL, irkelv.getMode());
EXPECT_EQ(27, irkelv.getTemp());
EXPECT_FALSE(irkelv.getSwingVertical());
EXPECT_TRUE(irkelv.getSwingHorizontal());
EXPECT_TRUE(irkelv.getIonFilter());
EXPECT_FALSE(irkelv.getQuiet());
EXPECT_FALSE(irkelv.getLight());
EXPECT_TRUE(irkelv.getPower());
EXPECT_FALSE(irkelv.getTurbo());
EXPECT_TRUE(irkelv.getXFan());
irsend.reset();
irsend.sendKelvinator(irkelv.getRaw());
EXPECT_EQ(
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s1560m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900"
"m8990s4490"
"m675s1560m675s520m675s520m675s1560m675s1560m675s520m675s1560m675s520"
"m675s1560m675s1560m675s520m675s1560m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s1560m675s1560"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s520"
"m675s520m675s1560m675s520"
"m675s19950"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s520m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s520m675s520m675s520"
"m675s520m675s520m675s520m675s520m675s1560m675s1560m675s1560m675s1560"
"m675s39900", irsend.outputStr());
}
+358
View File
@@ -0,0 +1,358 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "ir_LG.h"
#include "gtest/gtest.h"
// Tests for calcLGChecksum()
TEST(TestCalcLGChecksum, General) {
EXPECT_EQ(0x0, calcLGChecksum(0x0));
EXPECT_EQ(0x1, calcLGChecksum(0x1));
EXPECT_EQ(0xF, calcLGChecksum(0xF));
EXPECT_EQ(0x4, calcLGChecksum(0x1111));
EXPECT_EQ(0x8, calcLGChecksum(0x2222));
EXPECT_EQ(0x0, calcLGChecksum(0x4444));
EXPECT_EQ(0xA, calcLGChecksum(0x1234));
EXPECT_EQ(0xA, calcLGChecksum(0x4321));
EXPECT_EQ(0xE, calcLGChecksum(0xABCD));
EXPECT_EQ(0x1, calcLGChecksum(0x4AE5));
EXPECT_EQ(0xC, calcLGChecksum(0xFFFF));
}
// Tests for sendLG().
// Test sending typical data only.
TEST(TestSendLG, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendLG(0x4B4AE51);
EXPECT_EQ(
"m8000s4000"
"m550s550m550s1600m550s550m550s550"
"m550s1600m550s550m550s1600m550s1600m550s550m550s1600m550s550m550s550"
"m550s1600m550s550m550s1600m550s550m550s1600m550s1600m550s1600m550s550"
"m550s550m550s1600m550s550m550s1600m550s550m550s550m550s550m550s1600"
"m550s108050", irsend.outputStr());
irsend.reset();
irsend.sendLG(0xB4B4AE51, LG32_BITS);
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560m560s1680"
"m560s108080"
"m8950s2250m550s108050", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendLG, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendLG(0x4B4AE51, LG_BITS, 1);
EXPECT_EQ(
"m8000s4000"
"m550s550m550s1600m550s550m550s550"
"m550s1600m550s550m550s1600m550s1600m550s550m550s1600m550s550m550s550"
"m550s1600m550s550m550s1600m550s550m550s1600m550s1600m550s1600m550s550"
"m550s550m550s1600m550s550m550s1600m550s550m550s550m550s550m550s1600"
"m550s108050"
"m8000s2250m550s108050", irsend.outputStr());
irsend.reset();
irsend.sendLG(0xB4B4AE51, LG32_BITS, 1);
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560m560s1680"
"m560s108080"
"m8950s2250m550s108050"
"m8950s2250m550s108050", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendLG, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendLG(0x0, 31);
EXPECT_EQ(
"m8000s4000"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s108050", irsend.outputStr());
irsend.reset();
irsend.sendLG(0x0, 64);
EXPECT_EQ(
"m4480s4480"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s108080"
"m8950s2250m550s108050", irsend.outputStr());
}
// Tests for encodeLG().
TEST(TestEncodeLG, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeLG(0, 0));
EXPECT_EQ(0x100011, irsend.encodeLG(1, 1));
EXPECT_EQ(0x100022, irsend.encodeLG(1, 2));
EXPECT_EQ(0x43001DE, irsend.encodeLG(0x43, 0x1D));
EXPECT_EQ(0xB4B4AE51, irsend.encodeLG(0xB4B, 0x4AE5));
EXPECT_EQ(0xAA0055A, irsend.encodeLG(0xAA, 0x55));
EXPECT_EQ(0xFFFFFFFC, irsend.encodeLG(0xFFFF, 0xFFFF));
}
// Tests for decodeLG().
// Decode normal LG messages.
TEST(TestDecodeLG, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal LG 28-bit message.
irsend.reset();
irsend.sendLG(0x4B4AE51, LG_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG_BITS, irsend.capture.bits);
EXPECT_EQ(0x4B4AE51, irsend.capture.value);
EXPECT_EQ(0x4B, irsend.capture.address);
EXPECT_EQ(0x4AE5, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal LG 32-bit message.
irsend.reset();
irsend.sendLG(0xB4B4AE51, LG32_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG32_BITS, false));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0xB4B4AE51, irsend.capture.value);
EXPECT_EQ(0xB4B, irsend.capture.address);
EXPECT_EQ(0x4AE5, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal LG 28-bit message.
irsend.reset();
irsend.sendLG(irsend.encodeLG(0x07, 0x99));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG_BITS, irsend.capture.bits);
EXPECT_EQ(0x700992, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal LG 32-bit message.
irsend.reset();
irsend.sendLG(irsend.encodeLG(0x800, 0x8000), LG32_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0x80080008, irsend.capture.value);
EXPECT_EQ(0x800, irsend.capture.address);
EXPECT_EQ(0x8000, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated LG messages.
TEST(TestDecodeLG, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal LG 28-bit message with 2 repeats.
irsend.reset();
irsend.sendLG(irsend.encodeLG(0x07, 0x99), LG_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG_BITS, irsend.capture.bits);
EXPECT_EQ(0x700992, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal LG 32-bit message with 2 repeats.
irsend.reset();
irsend.sendLG(irsend.encodeLG(0x07, 0x99), LG32_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0x700992, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode unsupported LG message values.
TEST(TestDecodeLG, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Illegal values should be rejected when strict is on.
// Illegal LG 28-bit message value.
irsend.reset();
irsend.sendLG(0x1);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, false));
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG_BITS, false));
// Illegal LG 32-bit message value.
irsend.reset();
irsend.sendLG(0x1111111, LG32_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG32_BITS, false));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0x1111111, irsend.capture.value);
EXPECT_EQ(0x11, irsend.capture.address);
EXPECT_EQ(0x1111, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.reset();
irsend.sendLG(0x1111111, LG32_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, false));
}
// Decode unsupported LG message sizes.
TEST(TestDecodeLG, DecodeWithNonStrictSizes) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Illegal sizes should be rejected when strict is on.
// Illegal LG 16-bit message size.
irsend.reset();
irsend.sendLG(irsend.encodeLG(0x07, 0x99), 16);
irsend.makeDecodeResult();
// Should fail when unexpected against different bit sizes.
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, false));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, false));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, 16, false));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(16, irsend.capture.bits);
EXPECT_EQ(0x992, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
// Illegal LG 36-bit message size.
irsend.reset();
irsend.sendLG(0x123456789, 36); // Illegal value LG 36-bit message.
irsend.makeDecodeResult();
// Should fail when unexpected against different bit sizes.
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, false));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG32_BITS, false));
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, 36, false));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x1234, irsend.capture.address);
EXPECT_EQ(0x5678, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeLG, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size LG 64-bit message.
irsend.sendLG(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, 64, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, 64, false));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0xFFFFFFFF, irsend.capture.address);
EXPECT_EQ(0xFFFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeLG, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// TODO(anyone): Find a Global Cache example of the LG 28-bit message.
irsend.reset();
// LG (32-bit) code from Global Cache.
uint16_t gc_test[75] = {38000, 1, 69, 341, 170, 21, 64, 21, 21, 21, 64,
21, 64, 21, 21, 21, 64, 21, 21, 21, 21, 21, 64,
21, 21, 21, 64, 21, 64, 21, 21, 21, 64, 21, 21,
21, 21, 21, 64, 21, 21, 21, 64, 21, 21, 21, 64,
21, 64, 21, 64, 21, 21, 21, 21, 21, 64, 21, 21,
21, 64, 21, 21, 21, 21, 21, 21, 21, 64, 21, 1517,
341, 85, 21, 3655};
irsend.sendGC(gc_test, 75);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeLG(&irsend.capture, LG32_BITS, true));
EXPECT_EQ(LG, irsend.capture.decode_type);
EXPECT_EQ(LG32_BITS, irsend.capture.bits);
EXPECT_EQ(0xB4B4AE51, irsend.capture.value);
EXPECT_EQ(0xB4B, irsend.capture.address);
EXPECT_EQ(0x4AE5, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-LG example via GlobalCache
TEST(TestDecodeLG, FailToDecodeNonLGExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture));
ASSERT_FALSE(irrecv.decodeLG(&irsend.capture, LG_BITS, false));
}
@@ -0,0 +1,694 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "ir_Mitsubishi.h"
#include "gtest/gtest.h"
// Tests for sendMitsubishi().
// Test sending typical data only.
TEST(TestSendMitsubishi, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendMitsubishi(0xE242);
EXPECT_EQ(
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580"
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishi(0x0);
EXPECT_EQ(
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s53580"
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s53580", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishi(0x4321);
EXPECT_EQ(
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s2100"
"m300s900m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100"
"m300s53580"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s2100"
"m300s900m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100"
"m300s53580", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendMitsubishi, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendMitsubishi(0xE242, MITSUBISHI_BITS, 0); // 0 repeat.
EXPECT_EQ(
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishi(0xE242, MITSUBISHI_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580"
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580", irsend.outputStr());
irsend.sendMitsubishi(0xE242, MITSUBISHI_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580"
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580"
"m300s2100m300s2100m300s2100m300s900m300s900m300s900m300s2100m300s900"
"m300s900m300s2100m300s900m300s900m300s900m300s900m300s2100m300s900"
"m300s53580", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendMitsubishi, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendMitsubishi(0x0, 8);
EXPECT_EQ(
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s53580"
"m300s900m300s900m300s900m300s900m300s900m300s900m300s900m300s900"
"m300s53580", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishi(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m300s900m300s900m300s900m300s2100m300s900m300s900m300s2100m300s900"
"m300s900m300s900m300s2100m300s2100m300s900m300s2100m300s900m300s900"
"m300s900m300s2100m300s900m300s2100m300s900m300s2100m300s2100m300s900"
"m300s900m300s2100m300s2100m300s2100m300s2100m300s900m300s900m300s900"
"m300s2100m300s900m300s900m300s2100m300s900m300s900m300s900m300s900"
"m300s2100m300s900m300s2100m300s900m300s2100m300s900m300s2100m300s2100"
"m300s2100m300s2100m300s900m300s900m300s2100m300s2100m300s900m300s2100"
"m300s2100m300s2100m300s2100m300s900m300s2100m300s2100m300s2100m300s2100"
"m300s53580"
"m300s900m300s900m300s900m300s2100m300s900m300s900m300s2100m300s900"
"m300s900m300s900m300s2100m300s2100m300s900m300s2100m300s900m300s900"
"m300s900m300s2100m300s900m300s2100m300s900m300s2100m300s2100m300s900"
"m300s900m300s2100m300s2100m300s2100m300s2100m300s900m300s900m300s900"
"m300s2100m300s900m300s900m300s2100m300s900m300s900m300s900m300s900"
"m300s2100m300s900m300s2100m300s900m300s2100m300s900m300s2100m300s2100"
"m300s2100m300s2100m300s900m300s900m300s2100m300s2100m300s900m300s2100"
"m300s2100m300s2100m300s2100m300s900m300s2100m300s2100m300s2100m300s2100"
"m300s53580", irsend.outputStr());
}
// Decode normal Mitsubishi messages.
TEST(TestDecodeMitsubishi, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Mitsubishi 16-bit message.
irsend.reset();
irsend.sendMitsubishi(0xC2B8);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.reset();
irsend.sendMitsubishi(0x0);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.reset();
irsend.sendMitsubishi(0xFFFF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xFFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Non-standard Mitsubishi sizes should fail with strict.
irsend.reset();
// 12 bits.
irsend.sendMitsubishi(0xFFF, 12);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 12, true));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 64, true));
// 32 bits.
irsend.sendMitsubishi(0xFFF, 32);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 12, true));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 32, true));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 64, true));
}
// Decode normal repeated Mitsubishi messages.
TEST(TestDecodeMitsubishi, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Mitsubishi 16-bit message with 2 repeats.
irsend.reset();
irsend.sendMitsubishi(0xC2B8, MITSUBISHI_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Mitsubishi 16-bit message with 0 repeats.
irsend.reset();
irsend.sendMitsubishi(0xC2B8, MITSUBISHI_BITS, 0);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xC2B8, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode unsupported Mitsubishi messages.
TEST(TestDecodeMitsubishi, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendMitsubishi(0x0, 8); // Illegal sized Mitsubishi 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, 8, false));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 64, false));
irsend.reset();
// Illegal sized Mitsubishi 64-bit message.
irsend.sendMitsubishi(0xFEDCBA9876543210, 64);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture, 64, false));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFEDCBA9876543210, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
// Should fail when we are after a shorter message than we got.
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, 8, false));
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeMitsubishi, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Mitsubishi "Power On" (16-bit) code from Global Cache.
uint16_t gc_test[37] = {33000, 1, 1, 10, 70, 10, 70, 10, 70, 10, 30, 10, 30,
10, 30, 10, 70, 10, 30, 10, 30, 10, 70, 10, 30,
10, 30, 10, 30, 10, 30, 10, 70, 10, 30, 10, 936};
irsend.sendGC(gc_test, 37);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMitsubishi(&irsend.capture));
EXPECT_EQ(MITSUBISHI, irsend.capture.decode_type);
EXPECT_EQ(MITSUBISHI_BITS, irsend.capture.bits);
EXPECT_EQ(0xE242, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-Mitsubishi example via GlobalCache
TEST(TestDecodeMitsubishi, FailToDecodeNonMitsubishiExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture));
ASSERT_FALSE(irrecv.decodeMitsubishi(&irsend.capture, MITSUBISHI_BITS,
false));
}
// Tests for Mitsubishi A/C methods.
// Test sending typical data only.
TEST(TestSendMitsubishiAC, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
uint8_t mitsub_code[MITSUBISHI_AC_STATE_LENGTH] = {
0x23, 0xCB, 0x26, 0x01, 0x00, 0x20, 0x08, 0x06, 0x30,
0x45, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F};
irsend.reset();
irsend.sendMitsubishiAC(mitsub_code);
EXPECT_EQ(
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100"
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100", irsend.outputStr());
}
// Test sending with repeats.
TEST(TestSendMitsubishiAC, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
uint8_t mitsub_code[MITSUBISHI_AC_STATE_LENGTH] = {
0x23, 0xCB, 0x26, 0x01, 0x00, 0x20, 0x08, 0x06, 0x30,
0x45, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F};
irsend.sendMitsubishiAC(mitsub_code, MITSUBISHI_AC_STATE_LENGTH, 0);
EXPECT_EQ(
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishiAC(mitsub_code, MITSUBISHI_AC_STATE_LENGTH, 2);
EXPECT_EQ(
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100"
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100"
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m440s17100", irsend.outputStr());
}
// Test sending atypical sizes.
TEST(TestSendMitsubishiAC, SendUnexpectedSizes) {
IRsendTest irsend(4);
irsend.begin();
uint8_t mitsub_short_code[17] = {0x23, 0xCB, 0x26, 0x01, 0x00, 0x20,
0x08, 0x06, 0x30, 0x45, 0x67, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t mitsub_long_code[19] = {0x23, 0xCB, 0x26, 0x01, 0x00, 0x20,
0x08, 0x06, 0x30, 0x45, 0x67, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
0x00};
irsend.reset();
irsend.sendMitsubishiAC(mitsub_short_code, 17);
ASSERT_EQ("", irsend.outputStr());
irsend.reset();
irsend.sendMitsubishiAC(mitsub_long_code, 19);
ASSERT_EQ(
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m440s17100"
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s1300m450s1300m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s1300m450s420m450s420m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s1300m450s1300m450s1300m450s1300m450s1300m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m440s17100", irsend.outputStr());
}
// Tests for IRMitsubishiAC class.
TEST(TestMitsubishiACClass, Power) {
IRMitsubishiAC mitsub(0);
mitsub.begin();
mitsub.on();
EXPECT_TRUE(mitsub.getPower());
mitsub.off();
EXPECT_FALSE(mitsub.getPower());
mitsub.setPower(true);
EXPECT_TRUE(mitsub.getPower());
mitsub.setPower(false);
EXPECT_FALSE(mitsub.getPower());
}
TEST(TestMitsubishiACClass, Temperature) {
IRMitsubishiAC mitsub(0);
mitsub.begin();
mitsub.setTemp(0);
EXPECT_EQ(MITSUBISHI_AC_MIN_TEMP, mitsub.getTemp());
mitsub.setTemp(255);
EXPECT_EQ(MITSUBISHI_AC_MAX_TEMP, mitsub.getTemp());
mitsub.setTemp(MITSUBISHI_AC_MIN_TEMP);
EXPECT_EQ(MITSUBISHI_AC_MIN_TEMP, mitsub.getTemp());
mitsub.setTemp(MITSUBISHI_AC_MAX_TEMP);
EXPECT_EQ(MITSUBISHI_AC_MAX_TEMP, mitsub.getTemp());
mitsub.setTemp(MITSUBISHI_AC_MIN_TEMP - 1);
EXPECT_EQ(MITSUBISHI_AC_MIN_TEMP, mitsub.getTemp());
mitsub.setTemp(MITSUBISHI_AC_MAX_TEMP + 1);
EXPECT_EQ(MITSUBISHI_AC_MAX_TEMP, mitsub.getTemp());
mitsub.setTemp(17);
EXPECT_EQ(17, mitsub.getTemp());
mitsub.setTemp(21);
EXPECT_EQ(21, mitsub.getTemp());
mitsub.setTemp(25);
EXPECT_EQ(25, mitsub.getTemp());
mitsub.setTemp(30);
EXPECT_EQ(30, mitsub.getTemp());
}
TEST(TestMitsubishiACClass, OperatingMode) {
IRMitsubishiAC mitsub(0);
mitsub.begin();
mitsub.setMode(MITSUBISHI_AC_AUTO);
EXPECT_EQ(MITSUBISHI_AC_AUTO, mitsub.getMode());
mitsub.setMode(MITSUBISHI_AC_COOL);
EXPECT_EQ(MITSUBISHI_AC_COOL, mitsub.getMode());
mitsub.setMode(MITSUBISHI_AC_HEAT);
EXPECT_EQ(MITSUBISHI_AC_HEAT, mitsub.getMode());
mitsub.setMode(MITSUBISHI_AC_DRY);
EXPECT_EQ(MITSUBISHI_AC_DRY, mitsub.getMode());
mitsub.setMode(MITSUBISHI_AC_AUTO + 1);
EXPECT_EQ(MITSUBISHI_AC_AUTO, mitsub.getMode());
mitsub.setMode(255);
EXPECT_EQ(MITSUBISHI_AC_AUTO, mitsub.getMode());
}
TEST(TestMitsubishiACClass, VaneMode) {
IRMitsubishiAC mitsub(0);
mitsub.begin();
mitsub.setVane(MITSUBISHI_AC_VANE_AUTO);
EXPECT_EQ(MITSUBISHI_AC_VANE_AUTO, mitsub.getVane());
mitsub.setVane(MITSUBISHI_AC_VANE_AUTO + 1);
EXPECT_EQ(MITSUBISHI_AC_VANE_AUTO + 1, mitsub.getVane());
mitsub.setVane(MITSUBISHI_AC_VANE_AUTO_MOVE);
EXPECT_EQ(MITSUBISHI_AC_VANE_AUTO_MOVE, mitsub.getVane());
mitsub.setVane(MITSUBISHI_AC_VANE_AUTO_MOVE + 1);
EXPECT_EQ(MITSUBISHI_AC_VANE_AUTO_MOVE, mitsub.getVane());
mitsub.setVane(MITSUBISHI_AC_VANE_AUTO_MOVE - 1);
EXPECT_EQ(MITSUBISHI_AC_VANE_AUTO_MOVE - 1, mitsub.getVane());
}
TEST(TestMitsubishiACClass, FanSpeed) {
IRMitsubishiAC mitsub(0);
mitsub.begin();
mitsub.setFan(MITSUBISHI_AC_FAN_AUTO);
EXPECT_EQ(MITSUBISHI_AC_FAN_AUTO, mitsub.getFan());
mitsub.setFan(255);
EXPECT_EQ(MITSUBISHI_AC_FAN_REAL_MAX, mitsub.getFan());
mitsub.setFan(MITSUBISHI_AC_FAN_MAX);
EXPECT_EQ(MITSUBISHI_AC_FAN_REAL_MAX, mitsub.getFan());
mitsub.setFan(MITSUBISHI_AC_FAN_MAX - 1);
EXPECT_EQ(MITSUBISHI_AC_FAN_MAX - 1, mitsub.getFan());
mitsub.setFan(1);
EXPECT_EQ(1, mitsub.getFan());
mitsub.setFan(2);
EXPECT_EQ(2, mitsub.getFan());
mitsub.setFan(3);
EXPECT_EQ(3, mitsub.getFan());
mitsub.setFan(4);
EXPECT_EQ(4, mitsub.getFan());
mitsub.setFan(MITSUBISHI_AC_FAN_SILENT);
EXPECT_EQ(MITSUBISHI_AC_FAN_SILENT, mitsub.getFan());
mitsub.setFan(MITSUBISHI_AC_FAN_SILENT + 1);
EXPECT_EQ(MITSUBISHI_AC_FAN_REAL_MAX, mitsub.getFan());
}
TEST(TestMitsubishiACClass, MessageConstuction) {
IRMitsubishiAC mitsub(0);
IRsendTest irsend(4);
mitsub.begin();
irsend.begin();
mitsub.setFan(1);
mitsub.setMode(MITSUBISHI_AC_COOL);
mitsub.setTemp(27);
mitsub.setVane(3);
mitsub.on();
// Check everything for kicks.
EXPECT_EQ(1, mitsub.getFan());
EXPECT_EQ(MITSUBISHI_AC_COOL, mitsub.getMode());
EXPECT_EQ(27, mitsub.getTemp());
EXPECT_EQ(3, mitsub.getVane());
EXPECT_TRUE(mitsub.getPower());
irsend.reset();
irsend.sendMitsubishiAC(mitsub.getRaw());
EXPECT_EQ(
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s1300m450s1300m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s1300m450s420"
"m440s17100"
"m3400s1750"
"m450s1300m450s1300m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s1300m450s1300"
"m450s420m450s1300m450s1300m450s420m450s420m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s1300m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420m450s420"
"m450s1300m450s1300m450s420m450s1300m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s1300m450s1300m450s420m450s420"
"m450s1300m450s420m450s420m450s1300m450s1300m450s420m450s1300m450s420"
"m450s1300m450s1300m450s1300m450s420m450s420m450s1300m450s1300m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s420m450s420m450s420m450s420m450s420"
"m450s420m450s420m450s420m450s1300m450s420m450s420m450s1300m450s420"
"m440s17100", irsend.outputStr());
}
+320
View File
@@ -0,0 +1,320 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendNEC().
// Test sending typical data only.
TEST(TestSendNEC, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendNEC(0);
EXPECT_EQ("m8960s4480m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s108080", irsend.outputStr());
irsend.sendNEC(0xAA00FF55);
EXPECT_EQ("m8960s4480m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s1680m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s560m560s1680m560s108080",
irsend.outputStr());
}
// Test sending different bit lengths.
TEST(TestSendNEC, SendSmallData) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendNEC(0xA, 4); // Send only 4 data bits.
EXPECT_EQ("m8960s4480m560s1680m560s560m560s1680m560s560m560s108080",
irsend.outputStr());
irsend.sendNEC(0, 8); // Send only 8 data bits.
EXPECT_EQ("m8960s4480m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s108080", irsend.outputStr());
irsend.sendNEC(0x1234567890ABCDEF, 64); // Send 64 data bits.
EXPECT_EQ("m8960s4480m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s1680m560s1680m560s560"
"m560s1680m560s560m560s560m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s1680m560s560m560s560m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s560m560s560m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s1680"
"m560s1680m560s560m560s560m560s1680m560s1680m560s560m560s1680"
"m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s1680"
"m560s1680m560s108080", irsend.outputStr());
}
// Test sending with repeats.
TEST(TestSendNEC, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendNEC(0, 8, 0); // Send a command with 0 repeats.
EXPECT_EQ("m8960s4480m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s108080", irsend.outputStr());
irsend.sendNEC(0xAA, 8, 1); // Send a command with 1 repeat.
EXPECT_EQ("m8960s4480m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s108080"
"m8960s2240m560s108080",
irsend.outputStr());
irsend.sendNEC(0xAA, 8, 3); // Send a command with 3 repeats.
EXPECT_EQ("m8960s4480m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s108080"
"m8960s2240m560s108080"
"m8960s2240m560s108080"
"m8960s2240m560s108080",
irsend.outputStr());
}
// Tests for encodeNEC().
TEST(TestEncodeNEC, NormalNECEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x807F40BF, irsend.encodeNEC(1, 2));
EXPECT_EQ(0x9A656897, irsend.encodeNEC(0x59, 0x16));
}
TEST(TestEncodeNEC, ExtendedNECEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x9A806897, irsend.encodeNEC(0x159, 0x16));
}
TEST(TestEncodeNEC, CommandTrimmedTo8Bits) {
IRsendTest irsend(4);
EXPECT_EQ(irsend.encodeNEC(0x1, 0x2), irsend.encodeNEC(0x1, 0xF02));
EXPECT_EQ(irsend.encodeNEC(0xFFF0, 0x2), irsend.encodeNEC(0xFFF0, 0xF02));
}
// Tests for decodeNEC().
// Decode normal NEC messages.
TEST(TestDecodeNEC, NormalNECDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Synthesised Normal NEC message.
irsend.reset();
irsend.sendNEC(irsend.encodeNEC(0x1, 0x2));
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x807F40BF, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x2, irsend.capture.command);
// Real-life Extended NEC code from an actual capture/decode.
irsend.reset();
irsend.sendNEC(0xC1A28877);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC1A28877, irsend.capture.value);
EXPECT_EQ(0x4583, irsend.capture.address);
EXPECT_EQ(0x11, irsend.capture.command);
// Test strict decoding rejects a NEC-like message.
irsend.reset();
irsend.sendNEC(0x0);
irsend.makeDecodeResult();
EXPECT_FALSE(irrecv.decodeNEC(&irsend.capture));
// Synthesised Normal NEC message with a repeat.
irsend.reset();
irsend.sendNEC(irsend.encodeNEC(0x1, 0x2), 32, 1);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x807F40BF, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x2, irsend.capture.command);
}
// NEC-like messages without strict mode.
TEST(TestDecodeNEC, NormalNECDecodeWithoutStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendNEC(0x0);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, 32, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
irsend.reset();
irsend.sendNEC(0x12345678);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, 32, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x2C48, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
}
// Short NEC-like messages (without strict naturally)
TEST(TestDecodeNEC, ShortNECDecodeWithoutStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendNEC(0x0, 16);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, 16, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(16, irsend.capture.bits);
EXPECT_EQ(0, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
// Expecting less than what was sent is not valid.
irsend.reset();
irsend.sendNEC(0x0, 32);
irsend.makeDecodeResult();
EXPECT_FALSE(irrecv.decodeNEC(&irsend.capture, 16, false));
// Send 16 bits of data, but fail because we are expecting 17.
irsend.reset();
irsend.sendNEC(0x0, 16);
irsend.makeDecodeResult();
EXPECT_FALSE(irrecv.decodeNEC(&irsend.capture, 17, false));
}
// Longer NEC-like messages (without strict naturally)
TEST(TestDecodeNEC, LongerNECDecodeWithoutStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendNEC(0x1234567890ABCDEF, 64);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, 64, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0x1234567890ABCDEF, irsend.capture.value);
EXPECT_EQ(0xD509, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
// Send 63 bits of data, but fail because we are expecting 64.
irsend.reset();
irsend.sendNEC(0x0, 63);
irsend.makeDecodeResult();
EXPECT_FALSE(irrecv.decodeNEC(&irsend.capture, 64, false));
}
// Incorrect decoding reported in Issue #243
// Incorrect handling of decodes when there is no gap recorded at
// the end of a command when using the interrupt code. sendRaw() best emulates
// this for unit testing purposes. sendGC() and sendXXX() will add the trailing
// gap. Users won't see this in normal use.
TEST(TestDecodeNEC, NoTrailingGap_Issue243) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t rawData[67] = {9000, 4500, 650, 550, 650, 1650, 600, 550, 650, 550,
600, 1650, 650, 550, 600, 1650, 650, 1650, 650, 1650,
600, 550, 650, 1650, 650, 1650, 650, 550, 600, 1650,
650, 1650, 650, 550, 650, 550, 650, 1650, 650, 550,
650, 550, 650, 550, 600, 550, 650, 550, 650, 550,
650, 1650, 600, 550, 650, 1650, 650, 1650, 650, 1650,
650, 1650, 650, 1650, 650, 1650, 600};
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x4BB640BF, irsend.capture.value);
EXPECT_EQ(0x6DD2, irsend.capture.address);
EXPECT_EQ(0x2, irsend.capture.command);
irsend.reset();
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x4BB640BF, irsend.capture.value);
// Add a zero length space to the message to test how it handles that as
// a end of command gap.
irsend.addGap(0);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x4BB640BF, irsend.capture.value);
}
// Inconsistent decoding for unknown in Issue #264
// Reported issues decoding an Apple Remote. Apple doesn't appear to respect
// or use the command structure/checks in the NEC protocol.
TEST(TestDecodeNEC, NonStrictNECDecode_Issue264) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Slightly modified example than reported due to poor timings that are too
// far out of spec.
uint16_t rawData[67] = {9150, 4650, 550, 600, 550, 1800, 600, 1750, 600, 1800,
550, 600, 550, 1800, 550, 1750, 600, 1750, 600, 1750,
600, 1750, 600, 1700, 600, 600, 600, 600, 550, 600,
600, 600, 600, 1750, 600, 1750, 600, 600, 550, 1800,
600, 600, 600, 600, 600, 600, 500, 600, 600, 600,
600, 600, 600, 1750, 600, 600, 600, 550, 600, 600,
600, 600, 600, 600, 600, 550, 600};
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
EXPECT_FALSE(irrecv.decodeNEC(&irsend.capture)); // Not strictly NEC
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, NEC_BITS, false));
EXPECT_EQ(0x77E1A040, irsend.capture.value);
// Do it all again, but with a normal decode.
irsend.reset();
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC_LIKE, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x77E1A040, irsend.capture.value);
}
TEST(TestDecodeNEC, AutoReceiveCalibration) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Data from Issue #264, for a remote that is slightly off spec.
// Should be matched as a NEC-like message however without self-calibrating
// the timings of the short spaces is out.
uint16_t rawData[67] = {9150, 4600, 650, 600, 650, 1650, 650, 1700, 650, 1750,
650, 600, 650, 1700, 650, 1750, 650, 1750, 650, 1700,
650, 1700, 650, 1700, 650, 600, 650, 600, 650, 600,
600, 600, 650, 1750, 650, 1750, 650, 600, 650, 1700,
600, 600, 700, 550, 650, 550, 650, 600, 650, 600,
650, 600, 650, 1750, 600, 600, 650, 600, 650, 550,
650, 600, 650, 600, 650, 600, 600};
irsend.sendRaw(rawData, 67, 38);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture, NEC_BITS, false));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x77E1A040, irsend.capture.value);
}
@@ -0,0 +1,457 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for encodePanasonic().
TEST(TestEncodePanasonic, General) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodePanasonic(0, 0, 0, 0));
EXPECT_EQ(0x101010101, irsend.encodePanasonic(1, 1, 1, 1));
EXPECT_EQ(0xFFFF, irsend.encodePanasonic(0, 0, 0, 0xFF));
EXPECT_EQ(0xFF00FF, irsend.encodePanasonic(0, 0, 0xFF, 0));
EXPECT_EQ(0xFF0000FF, irsend.encodePanasonic(0, 0xFF, 0, 0));
EXPECT_EQ(0xFFFF00000000, irsend.encodePanasonic(0xFFFF, 0, 0, 0));
EXPECT_EQ(0xFFFFFFFFFFFF, irsend.encodePanasonic(0xFFFF, 0xFF, 0xFF, 0xFF));
EXPECT_EQ(0x40040190ED7C, irsend.encodePanasonic(0x4004, 0x01, 0x90, 0xED));
}
// Tests for sendPanasonic64().
// Test sending typical data only.
TEST(TestSendPanasonic64, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x0);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s129600", irsend.outputStr());
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600", irsend.outputStr());
irsend.reset();
irsend.sendPanasonic64(0xFFFFFFFFFFFF);
EXPECT_EQ(
"m3456s1728"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296m432s1296"
"m432s129600", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendPanasonic64, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C, PANASONIC_BITS, 0); // 0 repeats.
EXPECT_EQ(
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600", irsend.outputStr());
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C, PANASONIC_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600"
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600", irsend.outputStr());
irsend.sendPanasonic64(0x40040190ED7C, PANASONIC_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600"
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600"
"m3456s1728"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s432m432s1296"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s129600", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendPanasonic64, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x0, 8);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s129600", irsend.outputStr());
irsend.reset();
irsend.sendPanasonic64(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s1296m432s432m432s432m432s1296m432s432"
"m432s432m432s432m432s1296m432s1296m432s432m432s1296m432s432m432s432"
"m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296m432s432"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s432m432s432m432s432"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296"
"m432s1296m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s1296m432s1296"
"m432s129600", irsend.outputStr());
}
// Tests for sendPanasonic().
TEST(TestSendPanasonic, CompareToSendPanasonic64) {
IRsendTest panasonic(4);
IRsendTest panasonic64(0);
panasonic.begin();
panasonic64.begin();
panasonic.reset();
panasonic64.reset();
panasonic.sendPanasonic(0x4004, 0x0190ED7C);
panasonic64.sendPanasonic64(0x40040190ED7C);
EXPECT_EQ(panasonic64.outputStr(), panasonic.outputStr());
panasonic.sendPanasonic(0x0, 0x0);
panasonic64.sendPanasonic64(0x0);
EXPECT_EQ(panasonic64.outputStr(), panasonic.outputStr());
panasonic.sendPanasonic(0x0, 0x0, 8);
panasonic64.sendPanasonic64(0x0, 8);
EXPECT_EQ(panasonic64.outputStr(), panasonic.outputStr());
panasonic.sendPanasonic(0x1234, 0x567890AB, 64);
panasonic64.sendPanasonic64(0x1234567890AB, 64);
EXPECT_EQ(panasonic64.outputStr(), panasonic.outputStr());
panasonic.sendPanasonic(0x1234, 0x567890AB, PANASONIC_BITS, 2);
panasonic64.sendPanasonic64(0x1234567890AB, PANASONIC_BITS, 2);
EXPECT_EQ(panasonic64.outputStr(), panasonic.outputStr());
}
// Tests for decodePanasonic().
// Decode normal Panasonic messages.
TEST(TestDecodePanasonic, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Panasonic 48-bit message.
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x0190ED7C, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Panasonic 48-bit message.
irsend.reset();
irsend.sendPanasonic64(irsend.encodePanasonic(0x4004, 0x12, 0x34, 0x56));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x400412345670, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x12345670, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Panasonic 48-bit message.
irsend.reset();
irsend.sendPanasonic64(irsend.encodePanasonic(0x4004, 0x1, 0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x400401010101, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x1010101, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Panasonic messages.
TEST(TestDecodePanasonic, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Panasonic 48-bit message with 2 repeats.
irsend.reset();
irsend.sendPanasonic64(0x40040190ED7C, PANASONIC_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x190ED7C, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.makeDecodeResult(2 * PANASONIC_BITS + 4);
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
irsend.makeDecodeResult(2 * (2 * PANASONIC_BITS + 4));
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
}
// Decode Panasonic messages with unsupported values.
TEST(TestDecodePanasonic, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x0); // Illegal value Panasonic 48-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, false));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
// Illegal address/Manufacturer code. The rest is legal.
irsend.sendPanasonic64(irsend.encodePanasonic(0, 1, 2, 3));
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, false));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x1020300, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x1020300, irsend.capture.command);
}
// Decode Panasonic messages with unsupported size/lengths.
TEST(TestDecodePanasonic, DecodeWithNonStrictSize) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x12345678, 32); // Illegal size Panasonic message.
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, 32, false));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x12345678, irsend.capture.command);
// Illegal over length (56-bit) message.
irsend.reset();
irsend.sendPanasonic64(irsend.encodePanasonic(0x4004, 1, 2, 3), 56);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
// Shouldn't pass if strict off and wrong bit size.
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, false));
// Re-decode with correct bit size.
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, 56, true));
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, 56, false));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(56, irsend.capture.bits);
EXPECT_EQ(0x400401020300, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x01020300, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodePanasonic, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Panasonic 64-bit message.
irsend.sendPanasonic64(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, 64, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, 64, false));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0xFFFFFFFF, irsend.capture.address);
EXPECT_EQ(0xFFFFFFFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodePanasonic, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Panasonic code from Global Cache.
uint16_t gc_test[103] = {37000, 1, 1, 126, 64, 16, 17, 16, 49, 15, 16, 16, 16,
16, 16, 16, 17, 15, 17, 15, 17, 15, 17, 15, 16, 16,
16, 16, 16, 16, 17, 15, 49, 16, 16, 16, 16, 16, 17,
15, 17, 15, 17, 15, 17, 15, 16, 16, 16, 16, 16, 16,
49, 15, 49, 16, 17, 15, 17, 15, 49, 16, 16, 16, 17,
16, 17, 15, 17, 15, 49, 16, 49, 15, 49, 16, 17, 16,
49, 15, 49, 16, 17, 15, 48, 16, 16, 16, 49, 15, 48,
16, 49, 15, 49, 16, 49, 15, 17, 15, 16, 16, 2721};
irsend.sendGC(gc_test, 103);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, true));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x0190ED7C, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040190ED7C, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x0190ED7C, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-Panasonic example via GlobalCache
TEST(TestDecodePanasonic, FailToDecodeNonPanasonicExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture));
ASSERT_FALSE(irrecv.decodePanasonic(&irsend.capture, PANASONIC_BITS, false));
}
// Failing to decode Panasonic in Issue #245
TEST(TestDecodePanasonic, DecodeIssue245) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t rawData[100] = {3550, 1750, 500, 450, 500, 1300, 500, 450, 500, 450,
500, 450, 500, 450, 500, 450, 500, 450, 500, 450,
500, 450, 500, 450, 500, 450, 500, 450, 500, 1300,
500, 450, 500, 450, 500, 450, 500, 450, 500, 450,
500, 450, 500, 450, 500, 450, 500, 450, 500, 1300,
500, 450, 500, 450, 500, 450, 500, 450, 500, 450,
500, 450, 500, 450, 500, 450, 500, 1300, 500, 450,
500, 1300, 500, 1300, 500, 1300, 500, 1300, 500, 450,
500, 450, 500, 1300, 500, 450, 500, 1300, 500, 1300,
500, 1300, 500, 1300, 500, 450, 500, 1300, 500, 5000};
irsend.sendRaw(rawData, 100, 37);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodePanasonic(&irsend.capture));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040100BCBD, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x100BCBD, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
irsend.reset();
irsend.sendRaw(rawData, 99, 37);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x40040100BCBD, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x100BCBD, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
+358
View File
@@ -0,0 +1,358 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendPronto().
TEST(TestSendPronto, CodeTooShort) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// Less entries than the smallest possible (practical) Pronto code.
uint16_t pronto_test[5] = {0x0000, 0x0067, 0x0034, 0x0000, 0x0000};
irsend.sendPronto(pronto_test, 5);
EXPECT_EQ("", irsend.outputStr()); // Should do nothing.
}
TEST(TestSendPronto, NormalSequenceTooLong) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// The First 'Normal' sequence is declared to be longer than the data we have.
uint16_t pronto_test[6] = {0x0000, 0x0067, 0x0010, 0x0000, 0x0000, 0x0000};
irsend.sendPronto(pronto_test, 6);
EXPECT_EQ("", irsend.outputStr()); // Should do nothing.
}
TEST(TestSendPronto, RepeatSequenceTooLong) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// The 2nd 'Repeat' sequence is declared to be longer than the data we have.
uint16_t pronto_test[6] = {0x0000, 0x0067, 0x0000, 0x0010, 0x0000, 0x0000};
irsend.sendPronto(pronto_test, 6);
EXPECT_EQ("", irsend.outputStr()); // Should do nothing.
}
TEST(TestSendPronto, BothSequencesTooLong) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// All sequences are declared to be longer than the data we have.
uint16_t pronto_test[6] = {0x0000, 0x0067, 0x0010, 0x0010, 0x0000, 0x0000};
irsend.sendPronto(pronto_test, 6);
EXPECT_EQ("", irsend.outputStr()); // Should do nothing.
}
TEST(TestSendPronto, MoreDataThanNeededInNormal) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// We should handle when we are given more data than needed. (normal seq.)
uint16_t pronto_test[8] = {0x0000, 0x0067, 0x0001, 0x0000,
0x0001, 0x0002, 0x0003, 0x0004};
irsend.sendPronto(pronto_test, 8);
EXPECT_EQ("m25s50", irsend.outputStr()); // Only send the data required.
}
TEST(TestSendPronto, MoreDataThanNeededInRepeat) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// We should handle when we are given more data than needed. (repeat seq.)
uint16_t pronto_test[8] = {0x0000, 0x0067, 0x0000, 0x0001,
0x0001, 0x0002, 0x0003, 0x0004};
irsend.sendPronto(pronto_test, 8);
EXPECT_EQ("m25s50", irsend.outputStr()); // Only send the data required.
}
TEST(TestSendPronto, MoreDataThanNeededInBoth) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
// We should handle when we are given more data than needed. (repeat seq.)
uint16_t pronto_test[10] = {0x0000, 0x0067, 0x0001, 0x0001,
0x0001, 0x0002, 0x0003, 0x0004, 0x5, 0x6};
irsend.sendPronto(pronto_test, 10);
EXPECT_EQ("m25s50", irsend.outputStr()); // Only send the data required.
irsend.sendPronto(pronto_test, 10, 1);
EXPECT_EQ("m25s50m75s100", irsend.outputStr()); // Only the data required.
}
TEST(TestSendPronto, ShortestValidCodeThatSendsNothing) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
uint16_t pronto_test[6] = {0x0000, 0x0067, 0x0000, 0x0000, 0x0001, 0x0002};
irsend.sendPronto(pronto_test, 6);
EXPECT_EQ("", irsend.outputStr()); // Nothing Happens.
irsend.sendPronto(pronto_test, 6, 1);
EXPECT_EQ("", irsend.outputStr()); // Twice as much Nothing Happens. ;-)
}
// Test sending a Pronto code that only has a normal (first) sequence.
// i.e. No Pronto repeat sequence.
TEST(TestSendPronto, NonRepeatingCode) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// A random Pronto code I found on the Internet that has no repeat sequence.
// It was an example of a poor Pronto code.
// It turned out to be a 4 copies of a Sony 12-bit code. Who knew!?!
uint16_t pronto_test[108] = {
0x0000, 0x0067, 0x0034, 0x0000,
0x0060, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0030, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0452, 0x0060, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0030, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0452, 0x0060, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0452, 0x0060, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018,
0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018};
// Send the Pronto code without any repeats set.
irsend.reset();
irsend.sendPronto(pronto_test, 108);
irsend.makeDecodeResult();
EXPECT_EQ(
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s600", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_12_BITS, irsend.capture.bits);
EXPECT_EQ(0x10, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
// Now try repeating it.
// As it has no repeat sequence, we shouldn't repeat it. (I think)
irsend.reset();
irsend.sendPronto(pronto_test, 108, 3);
irsend.makeDecodeResult();
EXPECT_EQ(
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s27650"
"m2400s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m600s600m600s600", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_12_BITS, irsend.capture.bits);
EXPECT_EQ(0x10, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Test sending a Pronto code that only has a repeat sequence (Sony).
TEST(TestSendPronto, RepeatSequenceOnlyForSony) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Sony 20-bit command.
uint16_t pronto_test[46] = {
0x0000, 0x0067, 0x0000, 0x0015,
0x0060, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018, 0x0030, 0x0018,
0x0030, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018, 0x0018, 0x0018,
0x0018, 0x0018, 0x0030, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018,
0x0030, 0x0018, 0x0030, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018,
0x0030, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018,
0x0018, 0x03f6};
// Send the Pronto code without any repeats set.
irsend.reset();
irsend.sendPronto(pronto_test, 46);
irsend.makeDecodeResult();
EXPECT_EQ(
"m2400s600"
"m600s600m1200s600m1200s600m1200s600m600s600m1200s600m600s600m600s600"
"m1200s600m600s600m1200s600m1200s600m1200s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s25350", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_20_BITS, irsend.capture.bits);
EXPECT_EQ(0x74B92, irsend.capture.value);
EXPECT_EQ(0x1A, irsend.capture.address);
EXPECT_EQ(0x24AE, irsend.capture.command);
// Send the Pronto code with 2 repeats.
irsend.reset();
irsend.sendPronto(pronto_test, 46, SONY_MIN_REPEAT);
irsend.makeDecodeResult();
EXPECT_EQ(
"m2400s600"
"m600s600m1200s600m1200s600m1200s600m600s600m1200s600m600s600m600s600"
"m1200s600m600s600m1200s600m1200s600m1200s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s25350"
"m2400s600"
"m600s600m1200s600m1200s600m1200s600m600s600m1200s600m600s600m600s600"
"m1200s600m600s600m1200s600m1200s600m1200s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s25350"
"m2400s600"
"m600s600m1200s600m1200s600m1200s600m600s600m1200s600m600s600m600s600"
"m1200s600m600s600m1200s600m1200s600m1200s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s25350", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_20_BITS, irsend.capture.bits);
EXPECT_EQ(0x74B92, irsend.capture.value);
EXPECT_EQ(0x1A, irsend.capture.address);
EXPECT_EQ(0x24AE, irsend.capture.command);
}
// Test sending a Pronto code that only has a repeat sequence (Panasonic).
TEST(TestSendPronto, RepeatSequenceOnlyForPanasonic) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Panasonic Plasma TV Descrete code (Power On).
uint16_t pronto_test[104] = {
0x0000, 0x0071, 0x0000, 0x0032,
0x0080, 0x003F, 0x0010, 0x0010, 0x0010, 0x0030, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0030, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0030, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0030, 0x0010, 0x0030,
0x0010, 0x0030, 0x0010, 0x0030, 0x0010, 0x0030, 0x0010, 0x0010,
0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0030, 0x0010, 0x0030,
0x0010, 0x0030, 0x0010, 0x0030, 0x0010, 0x0030, 0x0010, 0x0010,
0x0010, 0x0030, 0x0010, 0x0A98};
// Send the Pronto code without any repeats set.
irsend.reset();
irsend.sendPronto(pronto_test, 104);
irsend.makeDecodeResult();
EXPECT_EQ(
"m3456s1701"
"m432s432m432s1296m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s1296m432s432m432s432"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s1296"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s432"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s1296m432s432m432s1296"
"m432s73224", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(PANASONIC, irsend.capture.decode_type);
EXPECT_EQ(PANASONIC_BITS, irsend.capture.bits);
EXPECT_EQ(0x400401007C7D, irsend.capture.value);
EXPECT_EQ(0x4004, irsend.capture.address);
EXPECT_EQ(0x1007C7D, irsend.capture.command);
}
// Test sending a Pronto code that has a normal & arepeat sequence (NEC).
TEST(TestSendPronto, NormalPlusRepeatSequence) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// NEC 32 bit power on command.
uint16_t pronto_test[76] = {
0x0000, 0x006D, 0x0022, 0x0002,
0x0156, 0x00AB, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015,
0x0015, 0x0040, 0x0015, 0x0040, 0x0015, 0x0015, 0x0015, 0x0015,
0x0015, 0x0015, 0x0015, 0x0040, 0x0015, 0x0040, 0x0015, 0x0040,
0x0015, 0x0015, 0x0015, 0x0015, 0x0015, 0x0040, 0x0015, 0x0040,
0x0015, 0x0040, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015,
0x0015, 0x0040, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015, 0x0015,
0x0015, 0x0015, 0x0015, 0x0040, 0x0015, 0x0040, 0x0015, 0x0040,
0x0015, 0x0015, 0x0015, 0x0040, 0x0015, 0x0040, 0x0015, 0x0040,
0x0015, 0x0040, 0x0015, 0x05FD,
0x0156, 0x0055, 0x0015, 0x0E4E};
// Send the Pronto code without any repeats set.
irsend.reset();
irsend.sendPronto(pronto_test, 76);
irsend.makeDecodeResult();
EXPECT_EQ(
"m8892s4446"
"m546s546m546s546m546s546m546s1664m546s1664m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s546m546s1664m546s1664m546s1664"
"m546s546m546s546m546s546m546s1664m546s546m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s1664m546s1664m546s1664m546s1664"
"m546s39858", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x18E710EF, irsend.capture.value);
EXPECT_EQ(0x18, irsend.capture.address);
EXPECT_EQ(0x8, irsend.capture.command);
// Send it again with a single repeat.
irsend.reset();
irsend.sendPronto(pronto_test, 76, 1);
irsend.makeDecodeResult();
EXPECT_EQ(
"m8892s4446"
"m546s546m546s546m546s546m546s1664m546s1664m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s546m546s1664m546s1664m546s1664"
"m546s546m546s546m546s546m546s1664m546s546m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s1664m546s1664m546s1664m546s1664"
"m546s39858"
"m8892s2210m546s95212", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x18E710EF, irsend.capture.value);
EXPECT_EQ(0x18, irsend.capture.address);
EXPECT_EQ(0x8, irsend.capture.command);
// Send it again with a two repeats.
irsend.reset();
irsend.sendPronto(pronto_test, 76, 2);
irsend.makeDecodeResult();
EXPECT_EQ(
"m8892s4446"
"m546s546m546s546m546s546m546s1664m546s1664m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s546m546s1664m546s1664m546s1664"
"m546s546m546s546m546s546m546s1664m546s546m546s546m546s546m546s546"
"m546s1664m546s1664m546s1664m546s546m546s1664m546s1664m546s1664m546s1664"
"m546s39858"
"m8892s2210m546s95212"
"m8892s2210m546s95212", irsend.outputStr());
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0x18E710EF, irsend.capture.value);
EXPECT_EQ(0x18, irsend.capture.address);
EXPECT_EQ(0x8, irsend.capture.command);
}
@@ -0,0 +1,873 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// RRRRRR CCCCC 555555 RRRRRR CCCCC 555555 XX XX
// RR RR CC C 55 RR RR CC C 55 XX XX
// RRRRRR CC _____ 555555 RRRRRR CC _____ 555555 XXXX
// RR RR CC C 5555 RR RR CC C 5555 XX XX
// RR RR CCCCC 555555 RR RR CCCCC 555555 XX XX
// Tests for encodeRC5().
TEST(TestEncodeRC5, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeRC5(0, 0));
EXPECT_EQ(0x800, irsend.encodeRC5(0, 0, true));
EXPECT_EQ(0x41, irsend.encodeRC5(1, 1));
EXPECT_EQ(0x42, irsend.encodeRC5(1, 2));
EXPECT_EQ(0x7FF, irsend.encodeRC5(0x1F, 0x3F));
EXPECT_EQ(0xFFF, irsend.encodeRC5(0x1F, 0x3F, true));
EXPECT_EQ(0x7FF, irsend.encodeRC5(0xFF, 0xFF));
EXPECT_EQ(0xFFF, irsend.encodeRC5(0xFF, 0xFF, true));
EXPECT_EQ(0x175, irsend.encodeRC5(0x05, 0x35));
}
// Tests for encodeRC5X().
TEST(TestEncodeRC5X, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeRC5X(0, 0));
EXPECT_EQ(0x800, irsend.encodeRC5X(0, 0, true));
EXPECT_EQ(0x41, irsend.encodeRC5X(1, 1));
EXPECT_EQ(0x42, irsend.encodeRC5X(1, 2));
EXPECT_EQ(0x3FF, irsend.encodeRC5X(0x0F, 0x3F));
EXPECT_EQ(0x3FF, irsend.encodeRC5X(0x0F, 0x3F, false));
EXPECT_EQ(0xBFF, irsend.encodeRC5X(0x0F, 0x3F, true));
EXPECT_EQ(0x17FF, irsend.encodeRC5X(0x1F, 0x7F));
EXPECT_EQ(0x1FFF, irsend.encodeRC5X(0x1F, 0x7F, true));
EXPECT_EQ(0x17FF, irsend.encodeRC5X(0xFF, 0xFF));
EXPECT_EQ(0x1FFF, irsend.encodeRC5X(0xFF, 0xFF, true));
EXPECT_EQ(0x175, irsend.encodeRC5X(0x05, 0x35));
// Values of command <= 6-bits. i.e (<= 63 (0x3F)) should be the same
// as encodeRC5.
EXPECT_EQ(irsend.encodeRC5X(0, 0), irsend.encodeRC5(0, 0));
EXPECT_EQ(irsend.encodeRC5X(0, 0, true), irsend.encodeRC5(0, 0, true));
EXPECT_EQ(irsend.encodeRC5X(0x5, 0x35, false),
irsend.encodeRC5(0x5, 0x35, false));
EXPECT_EQ(irsend.encodeRC5X(0x5, 0x35, true),
irsend.encodeRC5(0x5, 0x35, true));
EXPECT_EQ(irsend.encodeRC5X(0x1F, 0x3F, true),
irsend.encodeRC5(0x1F, 0x3F, true));
EXPECT_NE(irsend.encodeRC5X(0x1F, 0x7F, true),
irsend.encodeRC5(0x1F, 0x7F, true));
}
// Tests for toggleRC5().
TEST(TestToggleRC5, GeneralUse) {
IRsendTest irsend(4);
EXPECT_EQ(0x800, irsend.toggleRC5(0x0));
EXPECT_EQ(0x0, irsend.toggleRC5(0x800));
EXPECT_EQ(0x0, irsend.toggleRC5(irsend.toggleRC5(0x0)));
EXPECT_EQ(irsend.encodeRC5(0x5, 0x35, false),
irsend.toggleRC5(irsend.encodeRC5(0x5, 0x35, true)));
}
// Tests for sendRC5().
// Test sending typical RC-5 & RC-5X data only.
TEST(TestSendRC5, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC5(0x0, RC5_BITS);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s889m889s889m889s889m889"
"s889m889s889m889s889m889s889m889s889m889s889m889s114667",
irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x1AAA, RC5_BITS);
EXPECT_EQ(
"m889s889m889s889m1778s1778m1778s1778m1778s1778"
"m1778s1778m1778s1778m1778s114667", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x175, RC5_BITS);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x3FFF, RC5_BITS);
EXPECT_EQ(
"m889s889m889s889m889s889m889s889m889s889m889s889m889s889"
"m889s889m889s889m889s889m889s889m889s889m889s889m889s113778",
irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x0, RC5X_BITS);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s889m889s889m889s889m889"
"s889m889s889m889s889m889s889m889s889m889s889m889s114667",
irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x1AAA, RC5X_BITS);
EXPECT_EQ(
"m1778s1778m1778s1778m1778s1778m1778"
"s1778m1778s1778m1778s1778m1778s114667", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x175, RC5X_BITS);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x3FFF, RC5X_BITS);
EXPECT_EQ(
"m1778s1778m889s889m889s889m889s889m889s889m889s889m889"
"s889m889s889m889s889m889s889m889s889m889s889m889s113778",
irsend.outputStr());
}
// Test sending RC-5 & RC-5X with different repeats.
TEST(TestSendRC5, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC5(0x175, RC5_BITS, 1);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x175, RC5_BITS, 2);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x175, RC5X_BITS, 1);
EXPECT_EQ(
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m889s889m1778s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
irsend.reset();
irsend.sendRC5(0x1175, RC5X_BITS, 2);
EXPECT_EQ(
"m1778s889m889s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m1778s889m889s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s114667"
"m1778s889m889s889m889s889m889s1778m1778s1778"
"m889s889m889s889m1778s1778m1778s1778m889s113778", irsend.outputStr());
}
// Tests for decodeRC5().
// Decode normal RC-5/RC5X messages.
TEST(TestDecodeRC5, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-5 12-bit message.
irsend.reset();
irsend.sendRC5(0x175);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x05, irsend.capture.address);
EXPECT_EQ(0x35, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal RC-5 12-bit message decoded as RC5-X.
irsend.reset();
irsend.sendRC5(0x175);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x05, irsend.capture.address);
EXPECT_EQ(0x35, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// A RC-5X 13-bit message but with a value that is valid for RC-5 decoded
// as RC5-X.
irsend.reset();
irsend.sendRC5(0x175, RC5X_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x05, irsend.capture.address);
EXPECT_EQ(0x35, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal RC-5 12-bit message.
irsend.reset();
irsend.sendRC5(irsend.encodeRC5(0x00, 0x0B, true));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x80B, irsend.capture.value);
EXPECT_EQ(0x00, irsend.capture.address);
EXPECT_EQ(0x0B, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal RC-5X 13-bit message.
irsend.reset();
irsend.sendRC5(irsend.encodeRC5X(0x02, 0x41, true), RC5X_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
EXPECT_EQ(RC5X, irsend.capture.decode_type);
EXPECT_EQ(RC5X_BITS, irsend.capture.bits);
EXPECT_EQ(0x1881, irsend.capture.value);
EXPECT_EQ(0x02, irsend.capture.address);
EXPECT_EQ(0x41, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal RC-5X 13-bit message should fail at being decoded
// as a normal RC-5 (12 bit) message.
irsend.reset();
irsend.sendRC5(irsend.encodeRC5X(0x02, 0x41, true), RC5X_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
}
// Decode normal repeated RC5 messages.
TEST(TestDecodeRC5, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-5 12-bit (even) message with one repeat.
irsend.reset();
irsend.sendRC5(0x174, RC5_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x174, irsend.capture.value);
EXPECT_EQ(0x05, irsend.capture.address);
EXPECT_EQ(0x34, irsend.capture.command);
// Normal RC-5 12-bit (odd) message with one repeat.
irsend.reset();
irsend.sendRC5(0x175, RC5_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(RC5_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x05, irsend.capture.address);
EXPECT_EQ(0x35, irsend.capture.command);
// Synthesised Normal RC-5X 13-bit message with 2 repeats.
irsend.reset();
irsend.sendRC5(irsend.encodeRC5X(0x02, 0x41, true), RC5X_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
EXPECT_EQ(RC5X, irsend.capture.decode_type);
EXPECT_EQ(RC5X_BITS, irsend.capture.bits);
EXPECT_EQ(0x1881, irsend.capture.value);
EXPECT_EQ(0x02, irsend.capture.address);
EXPECT_EQ(0x41, irsend.capture.command);
}
// Decode unsupported RC5 messages.
TEST(TestDecodeRC5, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendRC5(0xFA, 8); // Illegal value RC5 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, 8, false));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0xFA, irsend.capture.value);
EXPECT_EQ(0x3, irsend.capture.address);
EXPECT_EQ(0x3A, irsend.capture.command);
irsend.reset();
irsend.sendRC5(0x12345678, 32); // Illegal size RC5 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, 32, false));
EXPECT_EQ(RC5, irsend.capture.decode_type);
EXPECT_EQ(31, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
irsend.reset();
irsend.sendRC5(0x87654321, 32); // Illegal size RC5 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, true));
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5X_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, 32, false));
EXPECT_EQ(RC5X, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeRC5, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal size RC-5 64-bit message.
irsend.sendRC5(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeRC5(&irsend.capture, 64, false));
EXPECT_EQ(RC5X, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
}
// Fail to decode a non-RC-5 example via GlobalCache
TEST(TestDecodeRC5, FailToDecodeNonRC5Example) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture));
ASSERT_FALSE(irrecv.decodeRC5(&irsend.capture, RC5_BITS, false));
}
// RRRRRR CCCCC 666
// RR RR CC C 66
// RRRRRR CC _____ 666666
// RR RR CC C 66 66
// RR RR CCCCC 66666
// Tests for encodeRC6().
TEST(TestEncodeRC6, Mode0Encoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeRC6(0, 0, RC6_MODE0_BITS));
EXPECT_EQ(0x1234, irsend.encodeRC6(0x12, 0x34, RC6_MODE0_BITS));
EXPECT_EQ(0x12345, irsend.encodeRC6(0x123, 0x45, RC6_MODE0_BITS));
EXPECT_EQ(0xFFFFF, irsend.encodeRC6(0xFFF, 0xFF, RC6_MODE0_BITS));
EXPECT_EQ(0xFFF00, irsend.encodeRC6(0xFFFF, 0x00, RC6_MODE0_BITS));
EXPECT_EQ(0xFF, irsend.encodeRC6(0x00, 0xFF, RC6_MODE0_BITS));
}
TEST(TestEncodeRC6, 36BitEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeRC6(0, 0, RC6_36_BITS));
EXPECT_EQ(0x1234, irsend.encodeRC6(0x12, 0x34, RC6_36_BITS));
EXPECT_EQ(0x123456789, irsend.encodeRC6(0x1234567, 0x89, RC6_36_BITS));
EXPECT_EQ(0xFFFFFFFFF, irsend.encodeRC6(0xFFFFFFF, 0xFF, RC6_36_BITS));
EXPECT_EQ(0xFFFFFFFFF, irsend.encodeRC6(0xFFFFFFFF, 0xFF, RC6_36_BITS));
EXPECT_EQ(0xFFFFFFF00, irsend.encodeRC6(0xFFFFFFF, 0x00, RC6_36_BITS));
EXPECT_EQ(0xFF, irsend.encodeRC6(0x0, 0xFF, RC6_36_BITS));
EXPECT_EQ(0xFFFFFFFFF, irsend.encodeRC6(0xFFFFFFFF, 0xFF, RC6_36_BITS));
}
// Tests for toggleRC6().
// Normal use (RC-6 Mode 0)
TEST(TestToggleRC6, Mode0) {
IRsendTest irsend(4);
EXPECT_EQ(0x10000, irsend.toggleRC6(0x0));
EXPECT_EQ(irsend.toggleRC6(0x0), irsend.toggleRC6(0x0, RC6_MODE0_BITS));
EXPECT_EQ(0x0, irsend.toggleRC6(0x10000));
EXPECT_EQ(0x0, irsend.toggleRC6(irsend.toggleRC6(0x0)));
}
// RC-6 36-bit use (Xbox 360)
TEST(TestToggleRC6, 36BitUse) {
IRsendTest irsend(4);
EXPECT_EQ(0x8000, irsend.toggleRC6(0x0, RC6_36_BITS));
EXPECT_EQ(0x0, irsend.toggleRC6(0x8000, RC6_36_BITS));
EXPECT_EQ(0x0, irsend.toggleRC6(irsend.toggleRC6(0x0, RC6_36_BITS),
RC6_36_BITS));
}
// Tests for sendRC6().
// Test sending typical RC-6 Mode-0 data only.
TEST(TestSendRC6, SendMode0DataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC6(0x0);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444s888m888s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s83028", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x1FFFF);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m1332s888m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444"
"s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x15555);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m1332s1332m888s888m888s888"
"m888s888m888s888m888s888m888s888m888s888m888"
"s83472", irsend.outputStr());
}
// Test sending typical RC-6 36-bit data only.
TEST(TestSendRC6, Send36BitDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC6(0x0, RC6_36_BITS);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s83028", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0xFFFFFFFFF, RC6_36_BITS);
EXPECT_EQ(
"m2664s888"
"m444s444m444s444m444s444m444s444"
"m888s888"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444"
"m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0xAAAAAAAAAA, RC6_36_BITS);
EXPECT_EQ(
"m2664s888m444s444m444s888m888"
"s1332m1332"
"s888m888s888m888s888m888s888m888s888m888s888m888s888m888s888m888s888m888"
"s888m888s888m888s888m888s888m888s888m888s888m888s888m444s83028",
irsend.outputStr());
irsend.reset();
irsend.sendRC6(0xC800F740C, RC6_36_BITS); // Xbox 360 OnOff code
EXPECT_EQ(
"m2664s888"
"m444s444m444s444m444s888m444"
"s888m1332"
"s888m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m888s444m444s444m444s444m444s888m888s444m444"
"s444m444s888m888s888m444s444m444s444m444s444m444s444m444s444m888"
"s444m444s888m444s444m444s83028", irsend.outputStr());
irsend.reset();
irsend.sendRC6(irsend.toggleRC6(0xC800F740C, RC6_36_BITS),
RC6_36_BITS); // Xbox 360 OnOff code (toggled)
EXPECT_EQ(
"m2664s888"
"m444s444m444s444m444s888m444"
"s888m1332"
"s888m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m888s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s888m888s888m444s444m444s444m444s444m444s444m444"
"s444m888s444m444s888m444s444m444s83028", irsend.outputStr());
}
// Test sending RC-6 Mode 0 with different repeats.
TEST(TestSendRC6, SendMode0WithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC6(0x175, RC6_MODE0_BITS, 0);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x175, RC6_MODE0_BITS, 1);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x175, RC6_MODE0_BITS, 2);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
}
// Test sending RC-6 36-bit with different repeats.
TEST(TestSendRC6, Send36BitWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRC6(0x175, RC6_36_BITS, 0);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x175, RC6_36_BITS, 1);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
irsend.reset();
irsend.sendRC6(0x175, RC6_36_BITS, 2);
EXPECT_EQ(
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472"
"m2664s888"
"m444s888m444s444m444s444m444"
"s888m888"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m444s444m444"
"s444m444s444m444s444m444s444m444s444m444s444m444s444m888s888m888"
"s444m444s444m444s888m888s888m888s83472", irsend.outputStr());
}
// Tests for decodeRC6().
// Decode normal RC-6 Mode 0 messages.
TEST(TestDecodeRC6, NormalMode0DecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-6 Mode 0 (20-bit) message.
irsend.reset();
irsend.sendRC6(0x175);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x01, irsend.capture.address);
EXPECT_EQ(0x75, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Synthesised RC-6 Mode 0 (20-bit) message.
irsend.reset();
irsend.sendRC6(irsend.encodeRC6(0x1234567, 0x89, RC6_MODE0_BITS));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x56789, irsend.capture.value);
EXPECT_EQ(0x567, irsend.capture.address);
EXPECT_EQ(0x89, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Same again, but encoded manually.
irsend.reset();
irsend.sendRC6(0x123456789, RC6_MODE0_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x56789, irsend.capture.value);
EXPECT_EQ(0x567, irsend.capture.address);
EXPECT_EQ(0x89, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal RC-6 36-bit messages.
TEST(TestDecodeRC6, Normal36BitDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-6 36-bit message.
irsend.reset();
irsend.sendRC6(0x175, RC6_36_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x01, irsend.capture.address);
EXPECT_EQ(0x75, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Synthesised RC-6 36-bit message.
irsend.reset();
irsend.sendRC6(irsend.encodeRC6(0x1234567, 0x89, RC6_36_BITS), RC6_36_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x1234567, irsend.capture.address);
EXPECT_EQ(0x89, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated RC6 Mode 0 messages.
TEST(TestDecodeRC6, NormalMode0DecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-6 Mode 0 (20-bit) even message with one repeat.
irsend.reset();
irsend.sendRC6(0x174, RC6_MODE0_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x174, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x74, irsend.capture.command);
// Normal RC-6 Mode 0 (20-bit) odd message with one repeat.
irsend.reset();
irsend.sendRC6(0x175, RC6_MODE0_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x75, irsend.capture.command);
}
// Decode normal repeated RC6 36-bit messages.
TEST(TestDecodeRC6, Normal36BitDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-6 36-bit odd message with one repeat.
irsend.reset();
irsend.sendRC6(0x175, RC6_36_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x75, irsend.capture.command);
// Normal RC-6 36-bit even message with one repeat.
irsend.reset();
irsend.sendRC6(0x174, RC6_36_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x174, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x74, irsend.capture.command);
}
// Decode RC-6 messages without strict.
TEST(TestDecodeRC6, NormalDecodeWithoutStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RC-6 Mode 0 (20-bit) message.
irsend.reset();
irsend.sendRC6(0x175, RC6_MODE0_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x175, irsend.capture.value);
EXPECT_EQ(0x01, irsend.capture.address);
EXPECT_EQ(0x75, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal RC-6 Mode 0 (20-bit) message.
irsend.reset();
irsend.sendRC6(0x174, RC6_MODE0_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_MODE0_BITS, irsend.capture.bits);
EXPECT_EQ(0x174, irsend.capture.value);
EXPECT_EQ(0x01, irsend.capture.address);
EXPECT_EQ(0x74, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal RC-6 36-bit message.
irsend.reset();
irsend.sendRC6(0x174, RC6_36_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x174, irsend.capture.value);
EXPECT_EQ(0x01, irsend.capture.address);
EXPECT_EQ(0x74, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal Synthesised RC-6 36-bit message.
irsend.reset();
irsend.sendRC6(irsend.encodeRC6(0x1234567, 0x89, RC6_36_BITS), RC6_36_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x1234567, irsend.capture.address);
EXPECT_EQ(0x89, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeRC6, Decode36BitGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Xbox-360 Power On from Global Cache.
uint16_t gc_test[65] = {36000, 1, 1, 96, 32, 16, 16, 16, 16, 16, 32, 16, 32,
48, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 16, 16, 16,
16, 16, 16, 32, 32, 16, 16, 16, 16, 32, 32, 32, 16,
16, 16, 16, 16, 16, 32, 32, 32, 32, 32, 32, 16, 2476};
irsend.sendGC(gc_test, 65);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS));
EXPECT_EQ(RC6, irsend.capture.decode_type);
EXPECT_EQ(RC6_36_BITS, irsend.capture.bits);
EXPECT_EQ(0xC800F742A, irsend.capture.value);
EXPECT_EQ(0xC800F74, irsend.capture.address);
EXPECT_EQ(0x2A, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-RC-6 example via GlobalCache
TEST(TestDecodeRC5, FailToDecodeNonRC6Example) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, false));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, false));
irsend.reset();
irsend.sendRC5(0x0);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, true));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_MODE0_BITS, false));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, true));
ASSERT_FALSE(irrecv.decodeRC6(&irsend.capture, RC6_36_BITS, false));
}
+239
View File
@@ -0,0 +1,239 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendRCMM().
// Test sending typical data only.
TEST(TestSendRCMM, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRCMM(0xe0a600);
EXPECT_EQ("m416s277"
"m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s27778", irsend.outputStr());
irsend.reset();
irsend.sendRCMM(0x28e0a600UL, 32);
EXPECT_EQ("m416s277"
"m166s277m166s611m166s611m166s277m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s27778", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendRCMM, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRCMM(0x28e0a600, 32, 2); // 2 repeats.
EXPECT_EQ("m416s277"
"m166s277m166s611m166s611m166s277m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s27778"
"m416s277"
"m166s277m166s611m166s611m166s277m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s27778"
"m416s277"
"m166s277m166s611m166s611m166s277m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s27778", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendRCMM, SendUsualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendRCMM(0xE0, 8);
EXPECT_EQ("m416s277"
"m166s777m166s611m166s277m166s277"
"m166s27778", irsend.outputStr());
irsend.reset();
irsend.sendRCMM(0x28e0a60000UL, 40);
EXPECT_EQ("m416s277"
"m166s277m166s611m166s611m166s277m166s777m166s611m166s277m166s277"
"m166s611m166s611m166s444m166s611m166s277m166s277m166s277m166s277"
"m166s277m166s277m166s277m166s277m166s27778", irsend.outputStr());
}
// Tests for decodeRCMM().
// Decode normal RCMM messages.
TEST(TestDecodeRCMM, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal RCMM 24-bit message.
irsend.reset();
irsend.sendRCMM(0xe0a600);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, RCMM_BITS, true));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(RCMM_BITS, irsend.capture.bits);
EXPECT_EQ(0xe0a600, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal RCMM 12-bit message.
irsend.reset();
irsend.sendRCMM(0x600, 12);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 12, true));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(12, irsend.capture.bits);
EXPECT_EQ(0x600, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Normal RCMM 32-bit message.
irsend.reset();
irsend.sendRCMM(0x28e0a600, 32);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 32, true));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x28e0a600, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decodes should fail for illegal bit sizes when in strict mode.
TEST(TestDecodeRCMM, IllegalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Illegal RCMM 8-bit message.
irsend.reset();
irsend.sendRCMM(0x0, 8);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture, 8, true));
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture, 12, true));
// Illegal RCMM 36-bit message.
irsend.reset();
irsend.sendRCMM(0x0, 36);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture, 12, true));
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture, 36, true));
}
// Decodes without strict mode.
TEST(TestDecodeRCMM, DecodeWithoutStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Illegal RCMM 8-bit message.
irsend.reset();
irsend.sendRCMM(0x55, 8);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 8, false));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x55, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 12, false));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x55, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
// Illegal RCMM 36-bit message.
irsend.reset();
irsend.sendRCMM(0x123456789, 36);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 12, false));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 24, false));
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 36, false));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0x123456789, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeRCMM, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size RCMM 64-bit message.
irsend.sendRCMM(0xFEDCBA9876543210, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeRCMM(&irsend.capture, 64, false));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFEDCBA9876543210, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
}
// Fail to decode a non-RCMM example via GlobalCache
TEST(TestDecodeRCMM, FailToDecodeNonRCMMExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture));
ASSERT_FALSE(irrecv.decodeRCMM(&irsend.capture, RCMM_BITS, false));
}
// Issue 281 Debugging
TEST(TestDecodeRCMM, DebugIssue281) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Data from Issue #281 (shortened version)
uint16_t rawData[36] = {448, 276, 150, 285, 164, 613, 163, 447, 162, 613,
164, 445, 164, 776, 167, 278, 163, 280, 163, 280,
162, 611, 168, 444, 163, 612, 164, 277, 168, 447,
157, 282, 165, 276,
165, 65535}; // Last value modified from 89729
irsend.reset();
irsend.sendRaw(rawData, 36, 36);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(RCMM, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x26702610, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
@@ -0,0 +1,276 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendSAMSUNG().
// Test sending typical data only.
TEST(TestSendSamsung, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSAMSUNG(0xE0E09966); // Samsung TV Power On.
EXPECT_EQ("m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080",
irsend.outputStr());
irsend.reset();
}
// Test sending with different repeats.
TEST(TestSendSamsung, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSAMSUNG(0xE0E09966, SAMSUNG_BITS, 1); // 1 repeat.
EXPECT_EQ("m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080"
"m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080"
, irsend.outputStr());
irsend.sendSAMSUNG(0xE0E09966, SAMSUNG_BITS, 2); // 2 repeats.
EXPECT_EQ("m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080"
"m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080"
"m4480s4480"
"m560s1680m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s1680m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s560m560s560m560s1680m560s1680"
"m560s560m560s560m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s1680m560s1680m560s560m560s108080"
, irsend.outputStr());
}
// Tests for encodeSAMSUNG().
TEST(TestEncodeSamsung, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0xFF, irsend.encodeSAMSUNG(0, 0));
EXPECT_EQ(0x8080807F, irsend.encodeSAMSUNG(1, 1));
EXPECT_EQ(0xF8F805FA, irsend.encodeSAMSUNG(0x1F, 0xA0));
EXPECT_EQ(0xA0A0CC33, irsend.encodeSAMSUNG(0x05, 0x33));
EXPECT_EQ(0xFFFFFF00, irsend.encodeSAMSUNG(0xFF, 0xFF));
EXPECT_EQ(0xE0E09966, irsend.encodeSAMSUNG(0x07, 0x99));
}
// Tests for decodeSAMSUNG().
// Decode normal Samsung messages.
TEST(TestDecodeSamsung, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Samsung 32-bit message.
irsend.reset();
irsend.sendSAMSUNG(0xE0E09966);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0xE0E09966, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
// Synthesised Normal Samsung 32-bit message.
irsend.reset();
irsend.sendSAMSUNG(irsend.encodeSAMSUNG(0x07, 0x99));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0xE0E09966, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
// Synthesised Normal Samsung 32-bit message.
irsend.reset();
irsend.sendSAMSUNG(irsend.encodeSAMSUNG(0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0x8080807F, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x1, irsend.capture.command);
}
// Decode normal repeated Samsung messages.
TEST(TestDecodeSamsung, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Samsung 32-bit message.
irsend.reset();
irsend.sendSAMSUNG(0xE0E09966, SAMSUNG_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0xE0E09966, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
}
// Decode unsupported Samsung messages.
TEST(TestDecodeSamsung, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendSAMSUNG(0x0); // Illegal value Samsung 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, false));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendSAMSUNG(0x12345678); // Illegal value Samsung 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, false));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x48, irsend.capture.address);
EXPECT_EQ(0x6A, irsend.capture.command);
// Illegal over length (36-bit) message.
irsend.reset();
irsend.sendSAMSUNG(irsend.encodeSAMSUNG(0, 0), 36);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
// Shouldn't pass if strict off and wrong expected bit size.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, false));
// Re-decode with correct bit size.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, 36, true));
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, 36, false));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(36, irsend.capture.bits);
EXPECT_EQ(0xFF, irsend.capture.value); // We told it to expect 8 bits less.
EXPECT_EQ(0x00, irsend.capture.address);
EXPECT_EQ(0x00, irsend.capture.command);
// Illegal under length (16-bit) message
irsend.reset();
irsend.sendSAMSUNG(irsend.encodeSAMSUNG(0x0, 0x0), 16);
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
// And it should fail when we expect more bits.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, false));
// Should pass if strict off if we ask for correct nr. of bits sent.
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, 16, false));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(16, irsend.capture.bits);
EXPECT_EQ(0xFF, irsend.capture.value); // We told it to expect 4 bits less.
EXPECT_EQ(0x00, irsend.capture.address);
EXPECT_EQ(0x00, irsend.capture.command);
// Should fail as we are expecting less bits than there are.
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, 12, false));
}
// Decode (non-standard) 64-bit messages.
// Decode unsupported Samsung messages.
TEST(TestDecodeSamsung, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Samsung 64-bit message.
irsend.sendSAMSUNG(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture, 64, false));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0xFF, irsend.capture.address);
EXPECT_EQ(0xFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeSamsung, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Samsung TV Power On from Global Cache.
uint16_t gc_test[71] = {38000, 1, 1, 172, 172, 22, 64, 22, 64, 22, 64, 22, 21,
22, 21, 22, 21, 22, 21, 22, 21, 22, 64, 22, 64, 22,
64, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 64,
22, 21, 22, 21, 22, 64, 22, 64, 22, 21, 22, 21, 22,
64, 22, 21, 22, 64, 22, 64, 22, 21, 22, 21, 22, 64,
22, 64, 22, 21, 22, 1820};
irsend.sendGC(gc_test, 71);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSAMSUNG(&irsend.capture));
EXPECT_EQ(SAMSUNG, irsend.capture.decode_type);
EXPECT_EQ(SAMSUNG_BITS, irsend.capture.bits);
EXPECT_EQ(0xE0E09966, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
}
// Fail to decode a non-Samsung example via GlobalCache
TEST(TestDecodeSamsung, FailToDecodeNonSamsungExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[71] = {38000, 1, 1, 172, 172, 22, 64, 22, 64, 22, 64, 22, 21,
22, 21, 22, 21, 22, 11, 22, 21, 22, 128, 22, 64, 22,
64, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 64,
22, 21, 22, 21, 22, 64, 22, 64, 22, 21, 22, 21, 22,
64, 22, 21, 22, 64, 22, 64, 22, 21, 22, 21, 22, 64,
22, 64, 22, 21, 22, 1820};
irsend.sendGC(gc_test, 71);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture));
ASSERT_FALSE(irrecv.decodeSAMSUNG(&irsend.capture, SAMSUNG_BITS, false));
}
+242
View File
@@ -0,0 +1,242 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for encodeSanyoLC7461().
TEST(TestEncodeSanyoLC7461, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x1FFF00FF, irsend.encodeSanyoLC7461(0, 0));
EXPECT_EQ(0x3FFE01FE, irsend.encodeSanyoLC7461(1, 1));
EXPECT_EQ(0x3FFE02FD, irsend.encodeSanyoLC7461(1, 2));
EXPECT_EQ(0x3FFE000FF00, irsend.encodeSanyoLC7461(0x1FFF, 0xFF));
EXPECT_EQ(0x2AAAAAA55AA, irsend.encodeSanyoLC7461(0x1555, 0x55));
EXPECT_EQ(0x3FFE000FF00, irsend.encodeSanyoLC7461(0xFFFF, 0xFF));
EXPECT_EQ(0x1D8113F00FF, irsend.encodeSanyoLC7461(0xEC0, 0x0));
}
// Tests for sendSanyoLC7461().
// Test sending typical data only.
TEST(TestEncodeSanyoLC7461, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSanyoLC7461(0x1D8113F00FF);
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestEncodeSanyoLC7461, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSanyoLC7461(0x1D8113F00FF, SANYO_LC7461_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m8960s4480"
"m560s560m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s560m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s1680m560s1680m560s1680m560s1680m560s1680m560s1680"
"m560s1680m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Tests for decodeSanyoLC7461().
// Decode normal Sanyo LC7461 messages.
TEST(TestDecodeSanyoLC7461, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Sanyo LC7461 42-bit message.
irsend.reset();
irsend.sendSanyoLC7461(0x1D8113F00FF);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x1D8113F00FF, irsend.capture.value);
EXPECT_EQ(0xEC0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Sanyo LC7461 42-bit message.
irsend.reset();
irsend.sendSanyoLC7461(irsend.encodeSanyoLC7461(0x1234, 0x56));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x2468DCB56A9, irsend.capture.value);
EXPECT_EQ(0x1234, irsend.capture.address);
EXPECT_EQ(0x56, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Sanyo LC7461 42-bit message.
irsend.reset();
irsend.sendSanyoLC7461(irsend.encodeSanyoLC7461(0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x3FFE01FE, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x1, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Sanyo LC7461 messages.
TEST(TestDecodeSanyoLC7461, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Sanyo LC7461 16-bit message with 1 repeat.
irsend.reset();
irsend.sendSanyoLC7461(0x3FFE01FE, SANYO_LC7461_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x3FFE01FE, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x1, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode unsupported Sanyo LC7461 messages.
TEST(TestDecodeSanyoLC7461, DecodeWithNonStrictValues) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendSanyoLC7461(0x0); // Illegal value Sanyo LC7461 message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
false));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
// Illegal value Sanyo LC7461 42-bit message.
irsend.sendSanyoLC7461(0x1234567890A);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, 32,
true));
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, 64,
true));
// And should fail for a bad value.
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
false));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x1234567890A, irsend.capture.value);
EXPECT_EQ(0x91A, irsend.capture.address);
EXPECT_EQ(0x89, irsend.capture.command);
// Shouldn't pass if strict off and looking for a smaller size.
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, 34, false));
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeSanyoLC7461, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Sanyo LC7461 64-bit message.
irsend.sendSanyoLC7461(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, 64, false));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0xFFFF, irsend.capture.address);
EXPECT_EQ(0xFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeSanyoLC7461, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t gc_test[95] = {38000, 1, 89, 342, 171, 21, 21, 21, 64, 21, 64,
21, 64, 21, 21, 21, 64, 21, 64, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 64, 21, 21,
21, 21, 21, 21, 21, 64, 21, 21, 21, 21, 21, 64,
21, 64, 21, 64, 21, 64, 21, 64, 21, 64, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 64, 21, 64, 21, 64, 21, 64, 21, 64,
21, 64, 21, 64, 21, 64, 21, 875, 342, 171, 21, 3565};
irsend.sendGC(gc_test, 95);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS, true));
EXPECT_EQ(SANYO_LC7461, irsend.capture.decode_type);
EXPECT_EQ(SANYO_LC7461_BITS, irsend.capture.bits);
EXPECT_EQ(0x1D8113F00FF, irsend.capture.value);
EXPECT_EQ(0xEC0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Confirm what the 42-bit NEC decode is.
ASSERT_TRUE(irrecv.decodeNEC(&irsend.capture, 42, false));
EXPECT_EQ(0x1D8113F00FF, irsend.capture.value);
}
// Fail to decode a non-Sanyo LC7461 example via GlobalCache
TEST(TestDecodeSanyoLC7461, FailToDecodeNonSanyoLC7461Example) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture));
ASSERT_FALSE(irrecv.decodeSanyoLC7461(&irsend.capture, SANYO_LC7461_BITS,
false));
}
+357
View File
@@ -0,0 +1,357 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for encodeSharp().
TEST(TestEncodeSharp, NormalEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x2, irsend.encodeSharp(0, 0));
EXPECT_EQ(0x4202, irsend.encodeSharp(1, 1));
EXPECT_EQ(0x4102, irsend.encodeSharp(1, 2));
EXPECT_EQ(0x62E2, irsend.encodeSharp(0x43, 0x1D));
EXPECT_EQ(0x2AAA, irsend.encodeSharp(0xAA, 0x55));
EXPECT_EQ(0x7FFE, irsend.encodeSharp(0x1F, 0xFF));
EXPECT_EQ(0x454A, irsend.encodeSharp(0x11, 0x4A));
}
TEST(TestEncodeSharp, AdvancedEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeSharp(0, 0, 0, 0));
EXPECT_EQ(0x1, irsend.encodeSharp(0, 0, 0, 1));
EXPECT_EQ(0x2, irsend.encodeSharp(0, 0, 1, 0));
EXPECT_EQ(0x3, irsend.encodeSharp(0, 0, 1, 1));
EXPECT_EQ(0x4200, irsend.encodeSharp(1, 1, 0, 0));
EXPECT_EQ(0x4203, irsend.encodeSharp(1, 1, 1, 1));
EXPECT_EQ(0x4200, irsend.encodeSharp(1, 1, 0, 0, false));
EXPECT_EQ(0x4201, irsend.encodeSharp(1, 1, 0, 1, false));
EXPECT_EQ(0x4203, irsend.encodeSharp(1, 1, 1, 1, false));
EXPECT_EQ(0x0404, irsend.encodeSharp(1, 1, 0, 0, true));
EXPECT_EQ(0x0405, irsend.encodeSharp(1, 1, 0, 1, true));
EXPECT_EQ(0x0407, irsend.encodeSharp(1, 1, 1, 1, true));
EXPECT_EQ(0x454A, irsend.encodeSharp(0x11, 0x52, 1, 0, true));
}
// Tests for sendSharp().
// Test sending typical data only.
TEST(TestSendSharp, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharp(0x11, 0x52);
EXPECT_EQ(
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendSharp, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharp(0x11, 0x52, SHARP_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendSharp, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharp(0x0, 0x0, 8);
EXPECT_EQ(
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
irsend.reset();
irsend.sendSharp(0x0, 0x0, 16);
EXPECT_EQ(
"m260s780m260s780m260s780m260s780m260s780m260s780m260s780m260s780"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Tests for sendSharpRaw().
// Test sending typical data only.
TEST(TestSendSharpRaw, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharpRaw(0x454A);
EXPECT_EQ(
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendSharpRaw, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharpRaw(0x454A, SHARP_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s1820m260s780m260s780m260s1820m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s780m260s780m260s780m260s1820m260s1820m260s780m260s1820"
"m260s780m260s1820m260s1820m260s780m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendSharpRaw, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharpRaw(0x2, 8);
EXPECT_EQ(
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
irsend.reset();
irsend.sendSharpRaw(0x2, 16);
EXPECT_EQ(
"m260s780m260s780m260s780m260s780m260s780m260s780m260s780m260s780"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602", irsend.outputStr());
}
// Tests for decodeSharp().
// Decode normal Sharp messages.
TEST(TestDecodeSharp, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Sharp 15-bit message.
irsend.reset();
irsend.sendSharpRaw(0x454A);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x454A, irsend.capture.value);
EXPECT_EQ(0x11, irsend.capture.address);
EXPECT_EQ(0x4A, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Sharp 15-bit message.
irsend.reset();
irsend.sendSharpRaw(irsend.encodeSharp(0x07, 0x99));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x7266, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
// Synthesised Normal Sharp 15-bit message.
irsend.reset();
irsend.sendSharpRaw(irsend.encodeSharp(0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x4202, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x1, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Sharp messages.
TEST(TestDecodeSharp, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Sharp 15-bit message with 1 repeat.
irsend.reset();
irsend.sendSharpRaw(0x7266, SHARP_BITS, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x7266, irsend.capture.value);
EXPECT_EQ(0x07, irsend.capture.address);
EXPECT_EQ(0x99, irsend.capture.command);
irsend.makeDecodeResult(2 * (2 * SHARP_BITS + FOOTER));
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x7266, irsend.capture.value);
}
// Decode unsupported Sharp messages.
TEST(TestDecodeSharp, DecodeWithNonStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendSharpRaw(0x0, 8); // Illegal length Sharp 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, 8, false));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x0, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendSharpRaw(0x12345678, 32); // Illegal length Sharp 32-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, true));
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture, 32, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, 32, false));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(32, irsend.capture.bits);
EXPECT_EQ(0x12345678, irsend.capture.value);
EXPECT_EQ(0x8, irsend.capture.address);
EXPECT_EQ(0x79, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeSharp, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal value & size Sharp 64-bit message.
irsend.sendSharpRaw(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture, 64, false));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0x1F, irsend.capture.address);
EXPECT_EQ(0xFF, irsend.capture.command);
}
// Decode a 'real' example via GlobalCache
TEST(TestDecodeSharp, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Sharp Power On from Global Cache.
uint16_t gc_test[67] = {38000, 1, 1,
10, 70, 10, 30, 10, 30, 10, 30, 10, 70, 10, 30,
10, 70, 10, 30, 10, 70, 10, 30, 10, 30, 10, 70,
10, 30, 10, 70, 10, 30,
10, 1657,
10, 70, 10, 30, 10, 30, 10, 30, 10, 70, 10, 70,
10, 30, 10, 70, 10, 30, 10, 70, 10, 70, 10, 30,
10, 70, 10, 30, 10, 70,
10, 1657};
irsend.sendGC(gc_test, 67);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSharp(&irsend.capture));
EXPECT_EQ(SHARP, irsend.capture.decode_type);
EXPECT_EQ(SHARP_BITS, irsend.capture.bits);
EXPECT_EQ(0x454A, irsend.capture.value);
EXPECT_EQ(0x11, irsend.capture.address);
EXPECT_EQ(0x4A, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Fail to decode a non-Sharp example via GlobalCache
TEST(TestDecodeSharp, FailToDecodeNonSharpExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[67] = {38000, 1, 1,
10, 70, 30, 30, 10, 30, 10, 30, 10, 70, 10, 30,
10, 70, 10, 30, 10, 70, 10, 30, 10, 30, 10, 70,
10, 30, 10, 70, 10, 30,
10, 1657,
10, 70, 10, 30, 10, 30, 10, 30, 10, 70, 10, 70,
10, 30, 10, 60, 10, 30, 10, 70, 10, 70, 10, 30,
10, 10, 70, 30, 10, 70,
10, 1657};
irsend.sendGC(gc_test, 67);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture));
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, false));
// Test only half of a good message, as it is sent (sort of) twice.
uint16_t gc_half[35] = {38000, 1, 1,
10, 70, 10, 30, 10, 30, 10, 30, 10, 70, 10, 30,
10, 70, 10, 30, 10, 70, 10, 30, 10, 30, 10, 70,
10, 30, 10, 70, 10, 30,
10, 1657};
irsend.sendGC(gc_half, 35);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture));
ASSERT_FALSE(irrecv.decodeSharp(&irsend.capture, SHARP_BITS, false));
}
@@ -0,0 +1,72 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendSherwood().
// Test sending typical data only.
TEST(TestSendSherwood, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSherwood(0xC1A28877);
EXPECT_EQ("m8960s4480m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s560m560s1680m560s1680"
"m560s1680m560s560m560s1680m560s1680m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Test sending typical data with extra repeats.
TEST(TestSendSherwood, SendDataWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSherwood(0xC1A28877, 32, 2);
EXPECT_EQ("m8960s4480m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s560m560s1680m560s1680"
"m560s1680m560s560m560s1680m560s1680m560s1680m560s108080"
"m8960s2240m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Test sending typical data with explicit no repeats.
TEST(TestSendSherwood, SendDataWithZeroRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSherwood(0xC1A28877, 32, 0);
// Should have a single NEC repeat, as we always send one.
EXPECT_EQ("m8960s4480m560s1680m560s1680m560s560m560s560m560s560m560s560"
"m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s560m560s1680m560s1680"
"m560s1680m560s560m560s1680m560s1680m560s1680m560s108080"
"m8960s2240m560s108080", irsend.outputStr());
}
// Test that a typical Sherwood send decodes as the appropriate NEC value.
TEST(TestSendSherwood, DecodesAsNEC) {
IRsendTest irsend(4);
IRrecv irrecv(0);
irsend.begin();
irsend.reset();
irsend.sendSherwood(0xC1A28877);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decodeNEC(&irsend.capture));
EXPECT_EQ(NEC, irsend.capture.decode_type);
EXPECT_EQ(NEC_BITS, irsend.capture.bits);
EXPECT_EQ(0xC1A28877, irsend.capture.value);
EXPECT_EQ(0x4583, irsend.capture.address);
EXPECT_EQ(0x11, irsend.capture.command);
}
+323
View File
@@ -0,0 +1,323 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendSony().
// Test sending typical data only.
TEST(TestSendSony, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSony(0);
// We expect three 20-bit commands to be sent.
EXPECT_EQ("m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m600s600m600s600m600s600m600s45600", irsend.outputStr());
irsend.reset();
irsend.sendSony(0x240C, SONY_20_BITS);
// We expect three 20-bit commands to be sent.
EXPECT_EQ("m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600", irsend.outputStr());
irsend.reset();
irsend.sendSony(0x240C, SONY_15_BITS);
// We expect three 15-bit commands to be sent.
EXPECT_EQ("m2400s600m600s600m1200s600m600s600m600s600m1200s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m1200s600m1200s600m600s600"
"m600s45600"
"m2400s600m600s600m1200s600m600s600m600s600m1200s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m1200s600m1200s600m600s600"
"m600s45600"
"m2400s600m600s600m1200s600m600s600m600s600m1200s600m600s600"
"m600s600m600s600m600s600m600s600m600s600m1200s600m1200s600m600s600"
"m600s45600", irsend.outputStr());
irsend.reset();
irsend.sendSony(0xA90, SONY_12_BITS);
// We expect three 15-bit commands to be sent.
EXPECT_EQ("m2400s600m1200s600m600s600m1200s600m600s600m1200s600m600s600"
"m600s600m1200s600m600s600m600s600m600s600m600s45600"
"m2400s600m1200s600m600s600m1200s600m600s600m1200s600m600s600"
"m600s600m1200s600m600s600m600s600m600s600m600s45600"
"m2400s600m1200s600m600s600m1200s600m600s600m1200s600m600s600"
"m600s600m1200s600m600s600m600s600m600s600m600s45600",
irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendSony, SendWithDiffRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSony(0x240C, SONY_20_BITS, 0); // Send a command with 0 repeats.
EXPECT_EQ("m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600", irsend.outputStr());
irsend.sendSony(0x240C, SONY_20_BITS, 1); // Send a command with 1 repeat.
EXPECT_EQ("m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600", irsend.outputStr());
irsend.sendSony(0x240C, SONY_20_BITS, 3); // Send a command with 3 repeats.
EXPECT_EQ("m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600"
"m2400s600m600s600m600s600m600s600m600s600m600s600m600s600m1200s600"
"m600s600m600s600m1200s600m600s600m600s600m600s600m600s600m600s600"
"m600s600m1200s600m1200s600m600s600m600s45600", irsend.outputStr());
}
// Tests for encodeSony().
TEST(TestEncodeSony, NormalSonyEncoding) {
IRsendTest irsend(4);
EXPECT_EQ(0x0, irsend.encodeSony(SONY_12_BITS, 0, 0));
EXPECT_EQ(0xA90, irsend.encodeSony(SONY_12_BITS, 21, 1));
EXPECT_EQ(0xFFF, irsend.encodeSony(SONY_12_BITS, 0x7F, 0x1F));
EXPECT_EQ(0x0, irsend.encodeSony(SONY_15_BITS, 0, 0));
EXPECT_EQ(0x5480, irsend.encodeSony(SONY_15_BITS, 21, 1));
EXPECT_EQ(0x5455, irsend.encodeSony(SONY_15_BITS, 21, 0xAA));
EXPECT_EQ(0x7FFF, irsend.encodeSony(SONY_15_BITS, 0x7F, 0xFF));
EXPECT_EQ(0x0, irsend.encodeSony(SONY_20_BITS, 0, 0, 0));
EXPECT_EQ(0x81080, irsend.encodeSony(SONY_20_BITS, 1, 1, 1));
EXPECT_EQ(0xFFFFF, irsend.encodeSony(SONY_20_BITS, 0x7F, 0x1F, 0xFF));
}
TEST(TestEncodeSony, SonyEncodingWithOversizedValues) {
IRsendTest irsend(4);
EXPECT_EQ(0xFFF, irsend.encodeSony(SONY_12_BITS, 0xFFFF, 0xFFFF));
EXPECT_EQ(0x7FFF, irsend.encodeSony(SONY_15_BITS, 0xFFFF, 0xFFFF));
EXPECT_EQ(0xFFFFF, irsend.encodeSony(SONY_20_BITS, 0xFFFF, 0xFFFF, 0xFFFF));
}
// Tests for decodeSony().
// Decode normal Sony messages.
TEST(TestDecodeSony, NormalSonyDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Synthesised Normal Sony 20-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_20_BITS, 0x1, 0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_20_BITS, irsend.capture.bits);
EXPECT_EQ(0x81080, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x81, irsend.capture.command);
// Synthesised Normal Sony 15-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_15_BITS, 21, 1), SONY_15_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_15_BITS, irsend.capture.bits);
EXPECT_EQ(0x5480, irsend.capture.value);
EXPECT_EQ(1, irsend.capture.address);
EXPECT_EQ(21, irsend.capture.command);
// Synthesised Normal Sony 12-bit message.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_12_BITS, 21, 1), SONY_12_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_12_BITS, irsend.capture.bits);
EXPECT_EQ(0xA90, irsend.capture.value);
EXPECT_EQ(1, irsend.capture.address);
EXPECT_EQ(21, irsend.capture.command);
}
// Decode unexpected Sony messages. i.e longer than minimum etc.
TEST(TestDecodeSony, SonyDecodeWithUnexpectedLegalSize) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Synthesised Normal Sony 20-bit message decoded when looking for 12-bits
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_20_BITS, 0x1, 0x1, 0x1));
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_MIN_BITS));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_20_BITS, irsend.capture.bits);
EXPECT_EQ(0x81080, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x81, irsend.capture.command);
// Synthesised Normal Sony 12-bit message when expecting 20-bits.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_12_BITS, 21, 1), SONY_12_BITS);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(SONY_12_BITS, irsend.capture.bits);
EXPECT_EQ(0xA90, irsend.capture.value);
EXPECT_EQ(1, irsend.capture.address);
EXPECT_EQ(21, irsend.capture.command);
// 12-bit message should be regected when using strict and a different size.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_12_BITS, 21, 1), SONY_12_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
// 15-bit message should be regected when using strict and a different size.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_15_BITS, 21, 1), SONY_15_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
// 20-bit message should be regected when using strict and a different size.
irsend.reset();
irsend.sendSony(irsend.encodeSony(SONY_20_BITS, 1, 1, 1), SONY_20_BITS);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
ASSERT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
}
// Decode unsupported Sony messages. i.e non-standard sizes.
TEST(TestDecodeSony, SonyDecodeWithIllegalSize) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendSony(0xFF, 8); // Illegal 8-bit Sony-like message.
irsend.makeDecodeResult();
// Should fail with strict on.
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_MIN_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0xFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendSony(0x1FFF, 13); // Illegal 13-bit Sony-like message.
irsend.makeDecodeResult();
// Should fail with strict on.
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_MIN_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(13, irsend.capture.bits);
EXPECT_EQ(0x1FFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendSony(0x1FFFF, 17); // Illegal 17-bit Sony-like message.
irsend.makeDecodeResult();
// Should fail with strict on.
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_MIN_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(17, irsend.capture.bits);
EXPECT_EQ(0x1FFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendSony(0x1FFFFF, 21); // Illegal 21-bit Sony-like message.
irsend.makeDecodeResult();
// Should fail with strict on.
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_MIN_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_15_BITS, true));
EXPECT_FALSE(irrecv.decodeSony(&irsend.capture, SONY_20_BITS, true));
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(21, irsend.capture.bits);
EXPECT_EQ(0x1FFFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
// Illegal 64-bit (max) Sony-like message.
irsend.sendSony(0xFFFFFFFFFFFFFFFF, 64, 0);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Decode unsupported Sony messages. i.e non-standard sizes.
TEST(TestDecodeSony, DecodeGlobalCacheExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Sony "Power On" from Global Cache.
uint16_t gc_test[29] = {40000, 1, 1, 96, 24, 24, 24, 48, 24, 48, 24, 48, 24,
24, 24, 48, 24, 24, 24, 48, 24, 24, 24, 24, 24, 24,
24, 24, 1013};
irsend.sendGC(gc_test, 29);
irsend.makeDecodeResult();
// Without strict.
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture));
EXPECT_EQ(SONY, irsend.capture.decode_type);
EXPECT_EQ(12, irsend.capture.bits);
EXPECT_EQ(0x750, irsend.capture.value);
EXPECT_EQ(0x1, irsend.capture.address);
EXPECT_EQ(0x2E, irsend.capture.command);
// With strict and correct size.
ASSERT_TRUE(irrecv.decodeSony(&irsend.capture, SONY_12_BITS, true));
}
@@ -0,0 +1,247 @@
// Copyright 2017 David Conran
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// Tests for sendWhynter().
// Test sending typical data only.
TEST(TestSendWhynter, SendDataOnly) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendWhynter(0x0);
EXPECT_EQ(
"m750s750m2850s2850"
"m750s750m750s750m750s750m750s750m750s750m750s750m750s750m750s750"
"m750s750m750s750m750s750m750s750m750s750m750s750m750s750m750s750"
"m750s750m750s750m750s750m750s750m750s750m750s750m750s750m750s750"
"m750s750m750s750m750s750m750s750m750s750m750s750m750s750m750s750"
"m750s108000", irsend.outputStr());
irsend.reset();
irsend.sendWhynter(0xFFFFFFFF);
EXPECT_EQ(
"m750s750m2850s2850"
"m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150"
"m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150"
"m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150"
"m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150m750s2150"
"m750s108000", irsend.outputStr());
irsend.reset();
irsend.sendWhynter(0x87654321);
EXPECT_EQ(
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000", irsend.outputStr());
}
// Test sending with different repeats.
TEST(TestSendWhynter, SendWithRepeats) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendWhynter(0x87654321, WHYNTER_BITS, 0); // 0 repeats.
EXPECT_EQ(
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000", irsend.outputStr());
irsend.reset();
irsend.sendWhynter(0x87654321, WHYNTER_BITS, 1); // 1 repeat.
EXPECT_EQ(
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000"
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000", irsend.outputStr());
irsend.sendWhynter(0x87654321, WHYNTER_BITS, 2); // 2 repeats.
EXPECT_EQ(
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000"
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000"
"m750s750m2850s2850"
"m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150m750s2150"
"m750s750m750s2150m750s2150m750s750m750s750m750s2150m750s750m750s2150"
"m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150m750s2150"
"m750s750m750s750m750s2150m750s750m750s750m750s750m750s750m750s2150"
"m750s108000", irsend.outputStr());
}
// Test sending an atypical data size.
TEST(TestSendWhynter, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendWhynter(0x0, 8);
EXPECT_EQ(
"m750s750m2850s2850"
"m750s750m750s750m750s750m750s750m750s750m750s750m750s750m750s750"
"m750s108000", irsend.outputStr());
irsend.reset();
irsend.sendWhynter(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m750s750m2850s2850"
"m750s750m750s750m750s750m750s2150m750s750m750s750m750s2150m750s750"
"m750s750m750s750m750s2150m750s2150m750s750m750s2150m750s750m750s750"
"m750s750m750s2150m750s750m750s2150m750s750m750s2150m750s2150m750s750"
"m750s750m750s2150m750s2150m750s2150m750s2150m750s750m750s750m750s750"
"m750s2150m750s750m750s750m750s2150m750s750m750s750m750s750m750s750"
"m750s2150m750s750m750s2150m750s750m750s2150m750s750m750s2150m750s2150"
"m750s2150m750s2150m750s750m750s750m750s2150m750s2150m750s750m750s2150"
"m750s2150m750s2150m750s2150m750s750m750s2150m750s2150m750s2150m750s2150"
"m750s108000", irsend.outputStr());
}
// Tests for decodeWhynter().
// Decode normal Whynter messages.
TEST(TestDecodeWhynter, NormalDecodeWithStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Whynter 32-bit message.
irsend.reset();
irsend.sendWhynter(0x87654321);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(WHYNTER_BITS, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
EXPECT_FALSE(irsend.capture.repeat);
}
// Decode normal repeated Whynter messages.
TEST(TestDecodeWhynter, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Whynter 32-bit message with 2 repeats.
irsend.reset();
irsend.sendWhynter(0x87654321, WHYNTER_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(WHYNTER_BITS, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
EXPECT_FALSE(irsend.capture.repeat);
irsend.makeDecodeResult(2 * WHYNTER_BITS + 6);
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(WHYNTER_BITS, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
irsend.makeDecodeResult(2 * (2 * WHYNTER_BITS + 6));
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(WHYNTER_BITS, irsend.capture.bits);
EXPECT_EQ(0x87654321, irsend.capture.value);
}
// Decode unsupported Whynter messages.
TEST(TestDecodeWhynter, DecodeWithNonStrictSizes) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
irsend.sendWhynter(0x12, 8); // Illegal sized Whynter 8-bit message.
irsend.makeDecodeResult();
// Should fail with strict on.
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture, 8, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, 8, false));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(8, irsend.capture.bits);
EXPECT_EQ(0x12, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
irsend.reset();
irsend.sendWhynter(0x1234567890, 40); // Illegal size Whynter 40-bit message.
irsend.makeDecodeResult();
// Shouldn't pass with strict when we ask for less bits than we got.
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, true));
irsend.makeDecodeResult();
// Should fail with strict when we ask for the wrong bit size.
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture, 40, true));
// Should pass if strict off.
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, 40, false));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(40, irsend.capture.bits);
EXPECT_EQ(0x1234567890, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Decode (non-standard) 64-bit messages.
TEST(TestDecodeWhynter, Decode64BitMessages) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Illegal size Whynter 64-bit message.
irsend.sendWhynter(0xFFFFFFFFFFFFFFFF, 64);
irsend.makeDecodeResult();
// Should work with a 'normal' match (not strict)
ASSERT_TRUE(irrecv.decodeWhynter(&irsend.capture, 64, false));
EXPECT_EQ(WHYNTER, irsend.capture.decode_type);
EXPECT_EQ(64, irsend.capture.bits);
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
}
// Fail to decode a non-Whynter example via GlobalCache
TEST(TestDecodeWhynter, FailToDecodeNonWhynterExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
// Modified a few entries to unexpected values, based on previous test case.
uint16_t gc_test[39] = {38000, 1, 1, 322, 162, 20, 61, 20, 61, 20, 20, 20, 20,
20, 20, 20, 127, 20, 61, 9, 20, 20, 61, 20, 20, 20,
61, 20, 61, 20, 61, 20, 20, 20, 20, 20, 20, 20, 884};
irsend.sendGC(gc_test, 39);
irsend.makeDecodeResult();
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture));
ASSERT_FALSE(irrecv.decodeWhynter(&irsend.capture, WHYNTER_BITS, false));
}