wirenboard / wb-mqtt-serial / 1

Committed 08 Jul 2025 01:20PM UTC coverage: 73.854% (+1.0%) from 72.836%

Build # 1

Build Type

Pull #963

github

Specific Base 39d9bc

Committed by

KraPete

Commit Message

Bump version

Pull Request Pull Request #963: Bump version

Run Details

6444 of 9057 branches covered (71.15%)

12341 of 16710 relevant lines covered (73.85%)

305.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.89

/test/mercury200_test.cpp

#include "devices/mercury200_device.h"
#include "fake_serial_port.h"
#include "mercury200_expectations.h"
#include <string>

class TMercury200Test: public TSerialDeviceTest, public TMercury200Expectations
{
protected:
    void SetUp();
    void VerifyEnergyQuery();
    void VerifyParamQuery();

    virtual PDeviceConfig GetDeviceConfig() const;

    PMercury200Device Mercury200Dev;

    PRegister Mercury200RET1Reg;
    PRegister Mercury200RET2Reg;
    PRegister Mercury200RET3Reg;
    PRegister Mercury200RET4Reg;
    PRegister Mercury200UReg;
    PRegister Mercury200IReg;
    PRegister Mercury200PReg;
    PRegister Mercury200BatReg;
};

PDeviceConfig TMercury200Test::GetDeviceConfig() const
{
    return std::make_shared<TDeviceConfig>("mercury200", "0xFE123456", "mercury200");
}

void TMercury200Test::SetUp()
{
    TSerialDeviceTest::SetUp();
    Mercury200Dev = std::make_shared<TMercury200Device>(GetDeviceConfig(), DeviceFactory.GetProtocol("mercury200"));

    Mercury200RET1Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x27, BCD32));
    TRegisterDesc regAddress;
    regAddress.Address = std::make_shared<TUint32RegisterAddress>(0x27);
    regAddress.DataOffset = 4;
    Mercury200RET2Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));
    regAddress.DataOffset = 8;
    Mercury200RET3Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));
    regAddress.DataOffset = 12;
    Mercury200RET4Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));
    Mercury200UReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x63, BCD16));
    regAddress.Address = std::make_shared<TUint32RegisterAddress>(0x63);
    regAddress.DataOffset = 2;
    Mercury200IReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD16));
    regAddress.DataOffset = 4;
    Mercury200PReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD24));
    Mercury200BatReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x29, BCD16));

    SerialPort->Open();
}

void TMercury200Test::VerifyEnergyQuery()
{
    EnqueueMercury200EnergyResponse();
    ASSERT_EQ(TRegisterValue{0x62142}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200RET1Reg->GetConfig()));
    ASSERT_EQ(TRegisterValue{0x20834}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200RET2Reg->GetConfig()));
    ASSERT_EQ(TRegisterValue{0x11111}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200RET3Reg->GetConfig()));
    ASSERT_EQ(TRegisterValue{0x22222}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200RET4Reg->GetConfig()));
    Mercury200Dev->InvalidateReadCache();
}

void TMercury200Test::VerifyParamQuery()
{
    EnqueueMercury200ParamResponse();
    ASSERT_EQ(TRegisterValue{0x1234}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200UReg->GetConfig()));
    ASSERT_EQ(TRegisterValue{0x5678}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200IReg->GetConfig()));
    ASSERT_EQ(TRegisterValue{0x765432}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200PReg->GetConfig()));
    Mercury200Dev->InvalidateReadCache();
}

TEST_F(TMercury200Test, EnergyQuery)
{
    try {
        VerifyEnergyQuery();
    } catch (const std::exception& e) {
        SerialPort->Close();
        throw e;
    }
    SerialPort->Close();
}

TEST_F(TMercury200Test, ParamsQuery)
{
    try {
        VerifyParamQuery();
    } catch (const std::exception& e) {
        SerialPort->Close();
        throw e;
    }
    SerialPort->Close();
}

TEST_F(TMercury200Test, BatteryVoltageQuery)
{
    EnqueueMercury200BatteryVoltageResponse();
    ASSERT_EQ(TRegisterValue{0x0391}, Mercury200Dev->ReadRegisterImpl(*SerialPort, *Mercury200BatReg->GetConfig()));
    SerialPort->Close();
}

class TMercury200IntegrationTest: public TSerialDeviceIntegrationTest, public TMercury200Expectations
{
protected:
    void SetUp() override;
    void TearDown() override;
    const char* ConfigPath() const override
    {
        return "configs/config-mercury200-test.json";
    }
    std::string GetTemplatePath() const override
    {
        return "../templates";
    }
};

void TMercury200IntegrationTest::SetUp()
{
    TSerialDeviceIntegrationTest::SetUp();
    SerialPort->SetExpectedFrameTimeout(std::chrono::milliseconds(7));
    ASSERT_TRUE(!!SerialPort);
}

void TMercury200IntegrationTest::TearDown()
{
    SerialPort->Close();
    TSerialDeviceIntegrationTest::TearDown();
}

TEST_F(TMercury200IntegrationTest, Poll)
{
    EnqueueMercury200EnergyResponse();
    EnqueueMercury200BatteryVoltageResponse();
    EnqueueMercury200ParamResponse();
    Note() << "LoopOnce()";
    for (auto i = 0; i < 3; ++i) {
        SerialDriver->LoopOnce();
    }
}

1	#include "devices/mercury200_device.h"
2	#include "fake_serial_port.h"
3	#include "mercury200_expectations.h"
4	#include <string>
5
6	class TMercury200Test: public TSerialDeviceTest, public TMercury200Expectations
7	{
8	protected:
9	void SetUp();
10	void VerifyEnergyQuery();
11	void VerifyParamQuery();
12
13	virtual PDeviceConfig GetDeviceConfig() const;
14
15	PMercury200Device Mercury200Dev;
16
17	PRegister Mercury200RET1Reg;
18	PRegister Mercury200RET2Reg;
19	PRegister Mercury200RET3Reg;
20	PRegister Mercury200RET4Reg;
21	PRegister Mercury200UReg;
22	PRegister Mercury200IReg;
23	PRegister Mercury200PReg;
24	PRegister Mercury200BatReg;
25	};
26
27	PDeviceConfig TMercury200Test::GetDeviceConfig() const	3✔
28	{
29	return std::make_shared<TDeviceConfig>("mercury200", "0xFE123456", "mercury200");	3✔
30	}
31
32	void TMercury200Test::SetUp()	3✔
33	{
34	TSerialDeviceTest::SetUp();	3✔
35	Mercury200Dev = std::make_shared<TMercury200Device>(GetDeviceConfig(), DeviceFactory.GetProtocol("mercury200"));	3✔
36
37	Mercury200RET1Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x27, BCD32));	3✔
38	TRegisterDesc regAddress;	3✔
39	regAddress.Address = std::make_shared<TUint32RegisterAddress>(0x27);	3✔
40	regAddress.DataOffset = 4;	3✔
41	Mercury200RET2Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));	3✔
42	regAddress.DataOffset = 8;	3✔
43	Mercury200RET3Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));	3✔
44	regAddress.DataOffset = 12;	3✔
45	Mercury200RET4Reg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD32));	3✔
46	Mercury200UReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x63, BCD16));	3✔
47	regAddress.Address = std::make_shared<TUint32RegisterAddress>(0x63);	3✔
48	regAddress.DataOffset = 2;	3✔
49	Mercury200IReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD16));	3✔
50	regAddress.DataOffset = 4;	3✔
51	Mercury200PReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, regAddress, BCD24));	3✔
52	Mercury200BatReg = Mercury200Dev->AddRegister(TRegisterConfig::Create(0, 0x29, BCD16));	3✔
53
54	SerialPort->Open();	3✔
55	}	3✔
56
57	void TMercury200Test::VerifyEnergyQuery()	1✔
58	{
59	EnqueueMercury200EnergyResponse();	1✔
60	ASSERT_EQ(TRegisterValue{0x62142}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200RET1Reg->GetConfig()));	2✔
61	ASSERT_EQ(TRegisterValue{0x20834}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200RET2Reg->GetConfig()));	2✔
62	ASSERT_EQ(TRegisterValue{0x11111}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200RET3Reg->GetConfig()));	2✔
63	ASSERT_EQ(TRegisterValue{0x22222}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200RET4Reg->GetConfig()));	2✔
64	Mercury200Dev->InvalidateReadCache();	1✔
65	}
66
67	void TMercury200Test::VerifyParamQuery()	1✔
68	{
69	EnqueueMercury200ParamResponse();	1✔
70	ASSERT_EQ(TRegisterValue{0x1234}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200UReg->GetConfig()));	2✔
71	ASSERT_EQ(TRegisterValue{0x5678}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200IReg->GetConfig()));	2✔
72	ASSERT_EQ(TRegisterValue{0x765432}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200PReg->GetConfig()));	2✔
73	Mercury200Dev->InvalidateReadCache();	1✔
74	}
75
76	TEST_F(TMercury200Test, EnergyQuery)	8✔
77	{
78	try {
79	VerifyEnergyQuery();	2✔
80	} catch (const std::exception& e) {	×
81	SerialPort->Close();	×
82	throw e;	×
83	}
84	SerialPort->Close();	2✔
85	}	2✔
86
87	TEST_F(TMercury200Test, ParamsQuery)	8✔
88	{
89	try {
90	VerifyParamQuery();	2✔
91	} catch (const std::exception& e) {	×
92	SerialPort->Close();	×
93	throw e;	×
94	}
95	SerialPort->Close();	2✔
96	}	2✔
97
98	TEST_F(TMercury200Test, BatteryVoltageQuery)	8✔
99	{
100	EnqueueMercury200BatteryVoltageResponse();	2✔
101	ASSERT_EQ(TRegisterValue{0x0391}, Mercury200Dev->ReadRegisterImpl(SerialPort, Mercury200BatReg->GetConfig()));	4✔
102	SerialPort->Close();	2✔
103	}
104
105	class TMercury200IntegrationTest: public TSerialDeviceIntegrationTest, public TMercury200Expectations
106	{
107	protected:
108	void SetUp() override;
109	void TearDown() override;
110	const char* ConfigPath() const override	1✔
111	{
112	return "configs/config-mercury200-test.json";	1✔
113	}
114	std::string GetTemplatePath() const override	1✔
115	{
116	return "../templates";	2✔
117	}
118	};
119
120	void TMercury200IntegrationTest::SetUp()	1✔
121	{
122	TSerialDeviceIntegrationTest::SetUp();	1✔
123	SerialPort->SetExpectedFrameTimeout(std::chrono::milliseconds(7));	1✔
124	ASSERT_TRUE(!!SerialPort);	1✔
125	}
126
127	void TMercury200IntegrationTest::TearDown()	1✔
128	{
129	SerialPort->Close();	1✔
130	TSerialDeviceIntegrationTest::TearDown();	1✔
131	}	1✔
132
133	TEST_F(TMercury200IntegrationTest, Poll)	8✔
134	{
135	EnqueueMercury200EnergyResponse();	2✔
136	EnqueueMercury200BatteryVoltageResponse();	2✔
137	EnqueueMercury200ParamResponse();	2✔
138	Note() << "LoopOnce()";	2✔
139	for (auto i = 0; i < 3; ++i) {	8✔
140	SerialDriver->LoopOnce();	6✔
141	}
142	}	2✔

wirenboard / wb-mqtt-serial / 1

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous