// 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);
}
// 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));
}
// Decode a real message from Raw Data.
TEST(TestDecodeVestelAc, RealNormalExample) {
IRsendTest irsend(0);
IRrecv irrecv(0);
IRVestelAc ac(0);
irsend.begin();
uint16_t rawData[115] = {
3098, 9080, 548, 1538, 526, 492, 526, 468, 524, 468, 526, 468,
550, 466, 526, 466, 526, 504, 540, 466, 526, 1538, 526, 466,
526, 466, 552, 1540, 522, 466, 526, 492, 526, 544, 526, 1536,
526, 1536, 552, 1536, 526, 1536, 552, 1536, 552, 1536, 526, 1536,
526, 1574, 542, 1536, 526, 492, 526, 466, 526, 494, 524, 468,
524, 468, 526, 492, 526, 502, 540, 468, 524, 494, 524, 468,
526, 468, 524, 468, 526, 492, 526, 468, 524, 520, 524, 1538,
524, 468, 524, 468, 524, 468, 524, 468, 524, 468, 524, 1538,
524, 506, 538, 468, 524, 468, 524, 1538, 524, 468, 550, 1538,
550, 1538, 524, 1538, 534, 1528, 544}; // VESTEL_AC
irsend.reset();
irsend.sendRaw(rawData, 115, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(VESTEL_AC, irsend.capture.decode_type);
EXPECT_EQ(kVestelAcBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(0xF4410001FF1201ULL, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
ac.begin();
ac.setRaw(irsend.capture.value);
EXPECT_EQ(
"Power: On, Mode: 4 (HEAT), Temp: 16C, Fan: 1 (AUTO), Sleep: Off, "
"Turbo: Off, Ion: On, Swing: Off",
ac.toString());
}
// Test sending different bit lengths.
TEST(TestSendNEC, SendSmallData) {
IRsendTest irsend(4);
irsend.begin();
irsend.sendNEC(0xA, 4); // Send only 4 data bits.
EXPECT_EQ("f38000d33m8960s4480m560s1680m560s560m560s1680m560s560m560s87360",
irsend.outputStr());
irsend.sendNEC(0, 8); // Send only 8 data bits.
EXPECT_EQ(
"f38000d33"
"m8960s4480m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s85120",
irsend.outputStr());
irsend.sendNEC(0x1234567890ABCDEF, 64); // Send 64 data bits.
EXPECT_EQ(
"f38000d33"
"m8960s4480m560s560m560s560m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s560m560s560m560s1680m560s1680m560s560"
"m560s1680m560s560m560s560m560s560m560s1680m560s560m560s1680"
"m560s560m560s1680m560s1680m560s560m560s560m560s1680m560s1680"
"m560s1680m560s1680m560s560m560s560m560s560m560s1680m560s560"
"m560s560m560s1680m560s560m560s560m560s560m560s560m560s1680m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s1680"
"m560s1680m560s560m560s560m560s1680m560s1680m560s560m560s1680"
"m560s1680m560s1680m560s1680m560s560m560s1680m560s1680m560s1680"
"m560s1680m560s22400",
irsend.outputStr());
}
// Test sending typical data with repeats.
TEST(TestSendTeco, SendWithRepeats) {
IRsendTest irsend(0);
irsend.begin();
irsend.reset();
irsend.sendTeco(0x250002BC9, kTecoBits, 2); // two repeats.
EXPECT_EQ(
"f38000d50"
"m9000s4440"
"m620s1650m620s580m620s580m620s1650m620s580m620s580m620s1650m620s1650"
"m620s1650m620s1650m620s580m620s1650m620s580m620s1650m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s580m620s580m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s1650m620s580m620s1650m620s580"
"m620s580m620s1650m620s580"
"m620s100000"
"m9000s4440"
"m620s1650m620s580m620s580m620s1650m620s580m620s580m620s1650m620s1650"
"m620s1650m620s1650m620s580m620s1650m620s580m620s1650m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s580m620s580m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s1650m620s580m620s1650m620s580"
"m620s580m620s1650m620s580"
"m620s100000"
"m9000s4440"
"m620s1650m620s580m620s580m620s1650m620s580m620s580m620s1650m620s1650"
"m620s1650m620s1650m620s580m620s1650m620s580m620s1650m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s580m620s580m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s1650m620s580m620s1650m620s580"
"m620s580m620s1650m620s580"
"m620s100000",
irsend.outputStr());
}
// Decode normal repeated Midea messages.
TEST(TestDecodeMidea, NormalDecodeWithRepeatAndStrict) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
// Normal Midea 48-bit message with 2 repeats.
irsend.reset();
irsend.sendMidea(0xA18263FFFF6E, MIDEA_BITS, 2);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeMidea(&irsend.capture, MIDEA_BITS, true));
EXPECT_EQ(MIDEA, irsend.capture.decode_type);
EXPECT_EQ(MIDEA_BITS, irsend.capture.bits);
EXPECT_EQ(0xA18263FFFF6E, irsend.capture.value);
EXPECT_FALSE(irsend.capture.repeat);
irsend.makeDecodeResult(2 * (2 * MIDEA_BITS + 4));
ASSERT_TRUE(irrecv.decodeMidea(&irsend.capture, MIDEA_BITS, true));
EXPECT_EQ(MIDEA, irsend.capture.decode_type);
EXPECT_EQ(MIDEA_BITS, irsend.capture.bits);
EXPECT_EQ(0xA18263FFFF6E, irsend.capture.value);
irsend.makeDecodeResult(4 * (2 * MIDEA_BITS + 4));
ASSERT_TRUE(irrecv.decodeMidea(&irsend.capture, MIDEA_BITS, true));
EXPECT_EQ(MIDEA, irsend.capture.decode_type);
EXPECT_EQ(MIDEA_BITS, irsend.capture.bits);
EXPECT_EQ(0xA18263FFFF6E, irsend.capture.value);
}
// 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"
"m432s74736", irsend.outputStr());
}
// Decode synthetic Panasonic AC message.
TEST(TestDecodePanasonicAC, SyntheticExample) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
// Data from Issue #525
uint8_t expectedState[kPanasonicAcStateLength] = {
0x02, 0x20, 0xE0, 0x04, 0x00, 0x00, 0x00, 0x06, 0x02,
0x20, 0xE0, 0x04, 0x00, 0x30, 0x32, 0x80, 0xAF, 0x00,
0x00, 0x06, 0x60, 0x00, 0x00, 0x80, 0x00, 0x06, 0x83};
irsend.sendPanasonicAC(expectedState);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
ASSERT_EQ(PANASONIC_AC, irsend.capture.decode_type);
EXPECT_EQ(kPanasonicAcBits, irsend.capture.bits);
EXPECT_STATE_EQ(expectedState, irsend.capture.state, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
IRPanasonicAc pana(0);
pana.setRaw(irsend.capture.state);
EXPECT_EQ(
"Model: 4 (JKE), Power: Off, Mode: 3 (COOL), Temp: 25C, "
"Fan: 7 (AUTO), Swing (Vertical): 15 (AUTO), Quiet: Off, "
"Powerful: Off, Clock: 0:00, On Timer: Off, Off Timer: Off",
pana.toString());
}
// Test sending an atypical data size.
TEST(TestSendPanasonic64, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendPanasonic64(0x0, 8);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s432m432s432m432s432m432s432m432s432"
"m432s130000", irsend.outputStr());
irsend.reset();
irsend.sendPanasonic64(0x1234567890ABCDEF, 64);
EXPECT_EQ(
"m3456s1728"
"m432s432m432s432m432s432m432s1296m432s432m432s432m432s1296m432s432"
"m432s432m432s432m432s1296m432s1296m432s432m432s1296m432s432m432s432"
"m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296m432s432"
"m432s432m432s1296m432s1296m432s1296m432s1296m432s432m432s432m432s432"
"m432s1296m432s432m432s432m432s1296m432s432m432s432m432s432m432s432"
"m432s1296m432s432m432s1296m432s432m432s1296m432s432m432s1296m432s1296"
"m432s1296m432s1296m432s432m432s432m432s1296m432s1296m432s432m432s1296"
"m432s1296m432s1296m432s1296m432s432m432s1296m432s1296m432s1296m432s1296"
"m432s130000", irsend.outputStr());
}
// 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, kSharpBits, 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, kSharpBits, false));
}
// Test sending an atypical data size.
TEST(TestSendSharp, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendSharp(0x0, 0x0, 8);
EXPECT_EQ(
"f38000d33"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602",
irsend.outputStr());
irsend.reset();
irsend.sendSharp(0x0, 0x0, 16);
EXPECT_EQ(
"f38000d33"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s780m260s780"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s780"
"m260s43602"
"m260s780m260s780m260s780m260s780m260s780m260s780m260s1820m260s1820"
"m260s1820m260s1820m260s1820m260s1820m260s1820m260s1820m260s780m260s1820"
"m260s43602",
irsend.outputStr());
}
// 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, kSharpBits, 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, kSharpBits, 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);
}
// Test sending an atypical data size.
TEST(TestSendLG, SendUnusualSize) {
IRsendTest irsend(4);
irsend.begin();
irsend.reset();
irsend.sendLG(0x0, 31);
EXPECT_EQ(
"m8000s4000"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s550m550s550m550s550m550s550m550s550m550s550m550s550"
"m550s61400", irsend.outputStr());
irsend.reset();
irsend.sendLG(0x0, 64);
EXPECT_EQ(
"m4480s4480"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s26880"
"m8950s2250m550s96300", 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"
"m550s51050"
"m8000s2250m550s97250", irsend.outputStr());
irsend.reset();
irsend.sendLG(0xB4B4AE51, LG32_BITS, 1);
EXPECT_EQ(
"m4480s4480"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s1680m560s560m560s1680m560s560m560s560"
"m560s1680m560s560m560s1680m560s560m560s1680m560s1680m560s1680m560s560"
"m560s560m560s1680m560s560m560s1680m560s560m560s560m560s560m560s1680"
"m560s44800"
"m8950s2250m550s96300"
"m8950s2250m550s96300", irsend.outputStr());
}
// 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);
}
// 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 normal "synthetic" messages.
TEST(TestDecodeHaierAC, NormalDecodeWithStrict) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
uint8_t expectedState[HAIER_AC_STATE_LENGTH] = {
0xA5, 0x01, 0x20, 0x01, 0x00, 0xC0, 0x20, 0x00, 0xA7};
// With the specific decoder.
irsend.reset();
irsend.sendHaierAC(expectedState);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeHaierAC(&irsend.capture, HAIER_AC_BITS, true));
EXPECT_EQ(HAIER_AC, irsend.capture.decode_type);
EXPECT_EQ(HAIER_AC_BITS, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_STATE_EQ(expectedState, irsend.capture.state, irsend.capture.bits);
// With the all the decoders.
irsend.reset();
irsend.sendHaierAC(expectedState);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(HAIER_AC, irsend.capture.decode_type);
EXPECT_EQ(HAIER_AC_BITS, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_STATE_EQ(expectedState, irsend.capture.state, irsend.capture.bits);
}
// 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 against a real capture reported by a user. See issue #354
TEST(TestDecodeMidea, DecodeRealExample) {
IRsendTest irsend(4);
IRrecv irrecv(4);
irsend.begin();
irsend.reset();
uint16_t rawData[199] = {
4366, 4470, 498, 1658, 522, 554, 498, 1658, 496, 580, 498, 580, 498, 578,
498, 580, 498, 1658, 498, 1658, 498, 578, 498, 578, 498, 580, 496, 582,
496, 578, 498, 1658, 498, 580, 498, 580, 498, 1656, 498, 1656, 500, 580,
498, 578, 502, 576, 500, 1656, 498, 1656, 500, 1654, 500, 1656, 500, 1656,
498, 1658, 498, 1656, 500, 1658, 498, 1656, 498, 1656, 500, 1656, 500,
1654, 500, 1578, 578, 1658, 498, 1656, 500, 1658, 498, 1656, 498, 1656,
500, 578, 498, 1638, 516, 1656, 500, 578, 500, 1656, 500, 1656, 498, 1658,
522, 554, 500, 5258, 4366, 4472, 498, 580, 498, 1658, 498, 580, 498, 1656,
500, 1600, 556, 1658, 500, 1656, 500, 578, 498, 578, 522, 1634, 498, 1588,
568, 1658, 498, 1656, 500, 1654, 498, 580, 498, 1658, 498, 1658, 498, 580,
496, 578, 500, 1654, 500, 1636, 518, 1656, 500, 578, 520, 558, 498, 578,
498, 580, 498, 576, 500, 578, 498, 580, 498, 578, 498, 578, 498, 580, 498,
578, 498, 580, 498, 580, 520, 556, 498, 580, 496, 580, 498, 578, 500, 578,
498, 1658, 498, 580, 498, 578, 498, 1656, 500, 578, 498, 580, 498, 580,
498, 1656, 522};
irsend.sendRaw(rawData, 199, 38000);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(MIDEA, irsend.capture.decode_type);
EXPECT_EQ(MIDEA_BITS, irsend.capture.bits);
EXPECT_EQ(0xA18263FFFF6E, irsend.capture.value);
}
// 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);
}
// 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"
"m432s98928", irsend.outputStr());
}
// 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));
}
// 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(
"f38000d33"
"m8960s4480m560s560m560s560m560s560m560s560m560s560m560s560m560s560"
"m560s560m560s85120",
irsend.outputStr());
irsend.sendNEC(0xAA, 8, 1); // Send a command with 1 repeat.
EXPECT_EQ(
"f38000d33"
"m8960s4480m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s80640"
"m8960s2240m560s96320",
irsend.outputStr());
irsend.sendNEC(0xAA, 8, 3); // Send a command with 3 repeats.
EXPECT_EQ(
"f38000d33"
"m8960s4480m560s1680m560s560m560s1680m560s560m560s1680m560s560"
"m560s1680m560s560m560s80640"
"m8960s2240m560s96320"
"m8960s2240m560s96320"
"m8960s2240m560s96320",
irsend.outputStr());
}
// Decode a documented example
TEST(TestDecodeLutron, DocumentedExampleFullOff) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
// Full Off code.
// Ref: https://github.com/markszabo/IRremoteESP8266/issues/515
uint16_t rawData[14] = {20518, 6839, 2280, 6839, 2280, 2280, 9119,
2280, 2280, 6839, 2280, 4560, 2280, 11399};
irsend.reset();
irsend.sendRaw(rawData, 14, 40);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LUTRON, irsend.capture.decode_type);
EXPECT_EQ(kLutronBits, irsend.capture.bits);
EXPECT_EQ(0x7F88BD120, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, irsend.capture.command);
uint16_t pronto[18] = {0x0000, 0x0069, 0x0007, 0x0000, 0x032a, 0x010e,
0x005a, 0x010e, 0x005a, 0x005a, 0x0168, 0x005a,
0x005a, 0x010e, 0x005a, 0x00b4, 0x005a, 0x01c2};
irsend.reset();
irsend.sendPronto(pronto, 18);
irsend.makeDecodeResult();
EXPECT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LUTRON, irsend.capture.decode_type);
EXPECT_EQ(kLutronBits, irsend.capture.bits);
EXPECT_EQ(0x7F88BD120, irsend.capture.value);
EXPECT_EQ(0x0, irsend.capture.address);
EXPECT_EQ(0x0, 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);
}
// Test sending with repeats.
TEST(TestSendLutron, SendWithRepeats) {
IRsendTest irsend(0);
irsend.begin();
// Send a command with 0 repeats.
irsend.sendLutron(0x7F88BD120, kLutronBits, 0);
EXPECT_EQ(
"f40000d40"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440",
irsend.outputStr());
// Send a command with 1 repeat.
irsend.sendLutron(0x7F88BD120, kLutronBits, 1);
EXPECT_EQ(
"f40000d40"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440",
irsend.outputStr());
// Send a command with 3 repeats.
irsend.sendLutron(0x7F88BD120, kLutronBits, 3);
EXPECT_EQ(
"f40000d40"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440"
"m20592s6864m2288s6864m2288s2288m9152s2288m2288s6864m2288s4576m2288"
"s161440",
irsend.outputStr());
}
// 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 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);
}
TEST(TestDecodeVestelAc, RealTimerExample) {
IRsendTest irsend(0);
IRrecv irrecv(0);
IRVestelAc ac(0);
irsend.begin();
uint16_t rawData[115] = {
3022, 9080, 546, 1536, 526, 466, 526, 492, 526, 468, 526, 492,
524, 468, 524, 494, 524, 504, 540, 492, 524, 1538, 526, 468,
524, 492, 526, 466, 552, 1536, 526, 1536, 526, 1570, 542, 492,
524, 1538, 550, 1538, 524, 1536, 526, 494, 524, 466, 526, 468,
524, 1574, 540, 1536, 550, 1536, 526, 468, 550, 1536, 526, 492,
526, 468, 524, 492, 526, 518, 526, 1536, 552, 1536, 550, 1536,
526, 494, 550, 1538, 526, 492, 524, 1538, 526, 504, 540, 466,
526, 1536, 526, 1536, 526, 468, 550, 1538, 524, 468, 524, 1538,
550, 1574, 540, 468, 550, 1538, 526, 492, 524, 468, 526, 466,
526, 468, 524, 494, 524, 468, 546}; // VESTEL_AC 2D6570B8EE201
irsend.reset();
irsend.sendRaw(rawData, 115, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(VESTEL_AC, irsend.capture.decode_type);
EXPECT_EQ(kVestelAcBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(0x2D6570B8EE201ULL, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
ac.begin();
ac.setRaw(irsend.capture.value);
EXPECT_EQ(
"Time: 5:45, Timer: Off, On Timer: 14:00, Off Timer: 23:00",
ac.toString());
}
// 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));
}
