Tasmota/lib/IRremoteESP8266-2.7.8.10/test/ir_Teco_test.cpp

473 lines
14 KiB
C++

// Copyright 2019 David Conran
#include "ir_Teco.h"
#include "IRac.h"
#include "IRrecv.h"
#include "IRrecv_test.h"
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// General housekeeping
TEST(TestTeco, Housekeeping) {
ASSERT_EQ("TECO", typeToString(TECO));
ASSERT_FALSE(hasACState(TECO)); // Uses uint64_t, not uint8_t*.
}
// Tests for sendTeco()
// Test sending typical data only.
TEST(TestSendTeco, SendDataOnly) {
IRsendTest irsend(0);
irsend.begin();
irsend.reset();
irsend.sendTeco(0x250002BC9);
EXPECT_EQ(
"f38000d50"
"m9000s4440"
"m620s1650m620s580m620s580m620s1650m620s580m620s580m620s1650m620s1650"
"m620s1650m620s1650m620s580m620s1650m620s580m620s1650m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s580m620s580m620s580m620s580"
"m620s580m620s580m620s580m620s580m620s1650m620s580m620s1650m620s580"
"m620s580m620s1650m620s580"
"m620s100000",
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());
}
// Tests for IRTeco class.
TEST(TestTecoACClass, Power) {
IRTecoAc ac(0);
ac.begin();
ac.setPower(true);
EXPECT_TRUE(ac.getPower());
ac.setPower(false);
EXPECT_EQ(false, ac.getPower());
ac.setPower(true);
EXPECT_TRUE(ac.getPower());
ac.off();
EXPECT_EQ(false, ac.getPower());
ac.on();
EXPECT_TRUE(ac.getPower());
}
TEST(TestTecoACClass, OperatingMode) {
IRTecoAc ac(0);
ac.begin();
ac.setMode(kTecoAuto);
EXPECT_EQ(kTecoAuto, ac.getMode());
ac.setMode(kTecoCool);
EXPECT_EQ(kTecoCool, ac.getMode());
ac.setMode(kTecoHeat);
EXPECT_EQ(kTecoHeat, ac.getMode());
ac.setMode(kTecoFan);
EXPECT_EQ(kTecoFan, ac.getMode());
ac.setMode(kTecoDry);
EXPECT_EQ(kTecoDry, ac.getMode());
ac.setMode(kTecoAuto - 1);
EXPECT_EQ(kTecoAuto, ac.getMode());
ac.setMode(kTecoCool);
EXPECT_EQ(kTecoCool, ac.getMode());
ac.setMode(kTecoHeat + 1);
EXPECT_EQ(kTecoAuto, ac.getMode());
ac.setMode(255);
EXPECT_EQ(kTecoAuto, ac.getMode());
}
TEST(TestTecoACClass, Temperature) {
IRTecoAc ac(0);
ac.begin();
ac.setTemp(kTecoMinTemp);
EXPECT_EQ(kTecoMinTemp, ac.getTemp());
ac.setTemp(kTecoMinTemp + 1);
EXPECT_EQ(kTecoMinTemp + 1, ac.getTemp());
ac.setTemp(kTecoMaxTemp);
EXPECT_EQ(kTecoMaxTemp, ac.getTemp());
ac.setTemp(kTecoMinTemp - 1);
EXPECT_EQ(kTecoMinTemp, ac.getTemp());
ac.setTemp(kTecoMaxTemp + 1);
EXPECT_EQ(kTecoMaxTemp, ac.getTemp());
ac.setTemp(23);
EXPECT_EQ(23, ac.getTemp());
ac.setTemp(0);
EXPECT_EQ(kTecoMinTemp, ac.getTemp());
ac.setTemp(255);
EXPECT_EQ(kTecoMaxTemp, ac.getTemp());
}
TEST(TestTecoACClass, FanSpeed) {
IRTecoAc ac(0);
ac.begin();
ac.setFan(kTecoFanLow);
ac.setFan(kTecoFanAuto);
EXPECT_EQ(kTecoFanAuto, ac.getFan());
ac.setFan(kTecoFanLow);
EXPECT_EQ(kTecoFanLow, ac.getFan());
ac.setFan(kTecoFanMed);
EXPECT_EQ(kTecoFanMed, ac.getFan());
ac.setFan(kTecoFanHigh);
EXPECT_EQ(kTecoFanHigh, ac.getFan());
ac.setFan(kTecoFanHigh);
EXPECT_EQ(kTecoFanHigh, ac.getFan());
}
TEST(TestTecoACClass, Swing) {
IRTecoAc ac(0);
ac.begin();
ac.setSwing(true);
EXPECT_TRUE(ac.getSwing());
ac.setSwing(false);
EXPECT_EQ(false, ac.getSwing());
ac.setSwing(true);
EXPECT_TRUE(ac.getSwing());
}
TEST(TestTecoACClass, Sleep) {
IRTecoAc ac(0);
ac.begin();
ac.setSleep(true);
EXPECT_TRUE(ac.getSleep());
ac.setSleep(false);
EXPECT_EQ(false, ac.getSleep());
ac.setSleep(true);
EXPECT_TRUE(ac.getSleep());
}
TEST(TestTecoACClass, Light) {
IRTecoAc ac(0);
ac.begin();
ac.setLight(true);
EXPECT_TRUE(ac.getLight());
ac.setLight(false);
EXPECT_EQ(false, ac.getLight());
ac.setLight(true);
EXPECT_TRUE(ac.getLight());
// Ref: https://github.com/crankyoldgit/IRremoteESP8266/issues/870#issue-484797174
ac.setRaw(0x250200A09);
EXPECT_TRUE(ac.getLight());
}
TEST(TestTecoACClass, Humid) {
IRTecoAc ac(0);
ac.begin();
ac.setHumid(true);
EXPECT_TRUE(ac.getHumid());
ac.setHumid(false);
EXPECT_EQ(false, ac.getHumid());
ac.setHumid(true);
EXPECT_TRUE(ac.getHumid());
// Ref: https://github.com/crankyoldgit/IRremoteESP8266/issues/870#issuecomment-524536810
ac.setRaw(0x250100A09);
EXPECT_TRUE(ac.getHumid());
}
TEST(TestTecoACClass, Save) {
IRTecoAc ac(0);
ac.begin();
ac.setSave(true);
EXPECT_TRUE(ac.getSave());
ac.setSave(false);
EXPECT_EQ(false, ac.getSave());
ac.setSave(true);
EXPECT_TRUE(ac.getSave());
// Ref: https://github.com/crankyoldgit/IRremoteESP8266/issues/870#issuecomment-524536810
ac.setRaw(0x250800A09);
EXPECT_TRUE(ac.getSave());
}
// Ref: https://github.com/crankyoldgit/IRremoteESP8266/issues/882
TEST(TestTecoACClass, Timer) {
IRTecoAc ac(0);
ac.begin();
ac.setTimer(60);
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(60, ac.getTimer());
ac.setTimer(0);
EXPECT_EQ(false, ac.getTimerEnabled());
EXPECT_EQ(0, ac.getTimer());
ac.setTimer(17 * 60 + 59);
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(17 * 60 + 30, ac.getTimer());
ac.setTimer(24 * 60 + 31);
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(24 * 60, ac.getTimer());
// Data from: https://github.com/crankyoldgit/IRremoteESP8266/issues/882#issuecomment-527079339
ac.setRaw(0x250218A49); // Timer On 1hr
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(60, ac.getTimer());
ac.setRaw(0x250219A49); // Timer On 1.5hr
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(60 + 30, ac.getTimer());
ac.setRaw(0x250200A49); // Timer Off
EXPECT_FALSE(ac.getTimerEnabled());
EXPECT_EQ(0, ac.getTimer());
ac.setRaw(0x25023DA41); // Timer On 23.5hrs
EXPECT_TRUE(ac.getTimerEnabled());
EXPECT_EQ(23 * 60 + 30, ac.getTimer());
}
TEST(TestTecoACClass, MessageConstuction) {
IRTecoAc ac(0);
EXPECT_EQ(
"Power: Off, Mode: 0 (Auto), Temp: 16C, Fan: 0 (Auto), Sleep: Off, "
"Swing: Off, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
ac.setPower(true);
ac.setMode(kTecoCool);
ac.setTemp(21);
ac.setFan(kTecoFanHigh);
ac.setSwing(false);
ac.setLight(false);
EXPECT_EQ(
"Power: On, Mode: 1 (Cool), Temp: 21C, Fan: 3 (High), Sleep: Off, "
"Swing: Off, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
ac.setSwing(true);
EXPECT_EQ(
"Power: On, Mode: 1 (Cool), Temp: 21C, Fan: 3 (High), Sleep: Off, "
"Swing: On, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
ac.setSwing(false);
ac.setFan(kTecoFanLow);
ac.setSleep(true);
ac.setMode(kTecoHeat);
EXPECT_EQ(
"Power: On, Mode: 4 (Heat), Temp: 21C, Fan: 1 (Low), Sleep: On, "
"Swing: Off, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
ac.setSleep(false);
EXPECT_EQ(
"Power: On, Mode: 4 (Heat), Temp: 21C, Fan: 1 (Low), Sleep: Off, "
"Swing: Off, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
ac.setTemp(25);
ac.setLight(true);
ac.setSave(true);
ac.setHumid(true);
ac.setTimer(18 * 60 + 37);
EXPECT_EQ(
"Power: On, Mode: 4 (Heat), Temp: 25C, Fan: 1 (Low), Sleep: Off, "
"Swing: Off, Light: On, Humid: On, Save: On, Timer: 18:30",
ac.toString());
}
TEST(TestTecoACClass, ReconstructKnownMessage) {
IRTecoAc ac(0);
const uint64_t expected = 0x250002BC9;
ASSERT_FALSE(ac.getRaw() == expected);
ac.setPower(true);
ac.setMode(kTecoCool);
ac.setTemp(27);
ac.setFan(kTecoFanAuto);
ac.setSleep(true);
ac.setSwing(true);
EXPECT_EQ(expected, ac.getRaw());
EXPECT_EQ(
"Power: On, Mode: 1 (Cool), Temp: 27C, Fan: 0 (Auto), Sleep: On, "
"Swing: On, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
}
// Tests for decodeTeco().
// Decode normal "synthetic" messages.
TEST(TestDecodeTeco, NormalDecodeWithStrict) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
// With the specific decoder.
uint64_t expectedState = kTecoReset;
irsend.reset();
irsend.sendTeco(expectedState);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decodeTeco(&irsend.capture, kStartOffset, kTecoBits,
true));
EXPECT_EQ(TECO, irsend.capture.decode_type);
EXPECT_EQ(kTecoBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(expectedState, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
// With the all the decoders.
irsend.reset();
irsend.sendTeco(expectedState);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(TECO, irsend.capture.decode_type);
EXPECT_EQ(kTecoBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(expectedState, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
IRTecoAc ac(0);
ac.begin();
ac.setRaw(irsend.capture.value);
EXPECT_EQ(
"Power: Off, Mode: 0 (Auto), Temp: 16C, Fan: 0 (Auto), Sleep: Off, "
"Swing: Off, Light: Off, Humid: Off, Save: Off, Timer: Off",
ac.toString());
}
// Decode a real message from Raw Data.
TEST(TestDecodeTeco, RealNormalExample) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
uint16_t rawData1[73] = {
9076, 4442, 670, 1620, 670, 516, 670, 516, 666, 1626, 670, 516,
664, 520, 666, 1626, 666, 1626, 664, 1626, 666, 1626, 666, 520,
666, 1626, 666, 520, 666, 1626, 666, 520, 666, 516, 670, 514,
670, 516, 666, 520, 670, 516, 666, 520, 666, 516, 672, 514, 670,
516, 666, 520, 666, 516, 672, 514, 670, 516, 666, 1624, 666, 520,
666, 1626, 666, 520, 666, 516, 672, 1620, 670, 516, 670};
uint64_t expected1 = 0b01001010000000000000010101111001001; // 0x250002BC9
irsend.reset();
irsend.sendRaw(rawData1, 73, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(TECO, irsend.capture.decode_type);
EXPECT_EQ(kTecoBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(expected1, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
EXPECT_EQ(
"Power: On, Mode: 1 (Cool), Temp: 27C, Fan: 0 (Auto), Sleep: On, "
"Swing: On, Light: Off, Humid: Off, Save: Off, Timer: Off",
IRAcUtils::resultAcToString(&irsend.capture));
stdAc::state_t r, p;
ASSERT_TRUE(IRAcUtils::decodeToState(&irsend.capture, &r, &p));
uint16_t rawData2[73] = {
9048, 4472, 636, 548, 636, 1654, 638, 546, 642, 1650, 642, 546, 638,
1654, 638, 1654, 638, 546, 638, 1654, 636, 546, 642, 1650, 640, 548,
636, 548, 638, 546, 636, 546, 642, 542, 642, 546, 638, 546, 638, 546,
636, 548, 642, 542, 642, 546, 636, 548, 636, 546, 642, 542, 642, 546,
638, 546, 638, 546, 636, 1654, 642, 542, 642, 1650, 642, 546, 638, 546,
638, 1654, 638, 546, 642}; // TECO 25000056A
uint64_t expected2 = 0b01001010000000000000000010101101010; // 0x25000056A
irsend.reset();
irsend.sendRaw(rawData2, 73, 38);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(TECO, irsend.capture.decode_type);
EXPECT_EQ(kTecoBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(expected2, irsend.capture.value);
EXPECT_EQ(0, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
EXPECT_EQ(
"Power: On, Mode: 2 (Dry), Temp: 21C, Fan: 2 (Medium), Sleep: Off, "
"Swing: On, Light: Off, Humid: Off, Save: Off, Timer: Off",
IRAcUtils::resultAcToString(&irsend.capture));
ASSERT_TRUE(IRAcUtils::decodeToState(&irsend.capture, &r, &p));
}
TEST(TestTecoACClass, toCommon) {
IRTecoAc ac(0);
ac.setPower(true);
ac.setMode(kTecoCool);
ac.setTemp(20);
ac.setFan(kTecoFanHigh);
ac.setSwing(true);
ac.setSleep(true);
// Now test it.
ASSERT_EQ(decode_type_t::TECO, ac.toCommon().protocol);
ASSERT_TRUE(ac.toCommon().power);
ASSERT_TRUE(ac.toCommon().celsius);
ASSERT_EQ(20, ac.toCommon().degrees);
ASSERT_EQ(stdAc::opmode_t::kCool, ac.toCommon().mode);
ASSERT_EQ(stdAc::fanspeed_t::kMax, ac.toCommon().fanspeed);
ASSERT_EQ(stdAc::swingv_t::kAuto, ac.toCommon().swingv);
ASSERT_EQ(0, ac.toCommon().sleep);
// Unsupported.
ASSERT_EQ(-1, ac.toCommon().model);
ASSERT_EQ(stdAc::swingh_t::kOff, ac.toCommon().swingh);
ASSERT_FALSE(ac.toCommon().turbo);
ASSERT_FALSE(ac.toCommon().econo);
ASSERT_FALSE(ac.toCommon().light);
ASSERT_FALSE(ac.toCommon().filter);
ASSERT_FALSE(ac.toCommon().clean);
ASSERT_FALSE(ac.toCommon().beep);
ASSERT_FALSE(ac.toCommon().quiet);
ASSERT_EQ(-1, ac.toCommon().clock);
}