Skip to content

Commit c2a84f4

Browse files
pcolbypcolby
committed
Add missing DeviceCommand unit tests
1 parent 94cc96e commit c2a84f4

File tree

3 files changed

+296
-5
lines changed

3 files changed

+296
-5
lines changed

‎src/cli/devicecommand.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -203,8 +203,8 @@ template<> PokitPro::VoltageRange DeviceCommand::minRange(const quint32 maxValue
203203
/// \endcond
204204

205205
/*!
206-
* Returns the \a product's lowest capacitance range that can measure at least up to \a maxValue, or AutoRange if no
207-
* such range is available.
206+
* Returns the \a product's lowest capacitance range that can measure at least up to \a maxValue (nF), or AutoRange if
207+
* no such range is available.
208208
*
209209
* \note Since Pokit Meters do not support capacitance measurement, \a product should not be PokitProduct::PokitMeter.
210210
*
@@ -224,7 +224,7 @@ quint8 DeviceCommand::minCapacitanceRange(const PokitProduct product, const quin
224224
}
225225

226226
/*!
227-
* Returns the \a product's lowest current range that can measure at least up to \a maxValue, or AutoRange if no
227+
* Returns the \a product's lowest current range that can measure at least up to \a maxValue (µA), or AutoRange if no
228228
* such range is available.
229229
*
230230
* \see DeviceCommand::minRange<PokitMeter::CurrentRange>(const quint32 maxValue)
@@ -243,7 +243,7 @@ quint8 DeviceCommand::minCurrentRange(const PokitProduct product, const quint32
243243
}
244244

245245
/*!
246-
* Returns the \a product's lowest resistance range that can measure at least up to \a maxValue, or AutoRange if no
246+
* Returns the \a product's lowest resistance range that can measure at least up to \a maxValue (Ω), or AutoRange if no
247247
* such range is available.
248248
*
249249
* \see DeviceCommand::minRange<PokitMeter::ResistanceRange>(const quint32 maxValue)
@@ -263,7 +263,7 @@ quint8 DeviceCommand::minResistanceRange(const PokitProduct product, const quint
263263

264264
/*!
265265
t
266-
* Returns the \a product's lowest voltage range that can measure at least up to \a maxValue, or AutoRange if no
266+
* Returns the \a product's lowest voltage range that can measure at least up to \a maxValue (mV), or AutoRange if no
267267
* such range is available.
268268
*
269269
* \see DeviceCommand::minRange<PokitMeter::VoltageRange>(const quint32 maxValue)

‎test/unit/cli/testdevicecommand.cpp

Lines changed: 262 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,16 @@
66
#include "devicecommand.h"
77

88
#include <qtpokit/statusservice.h>
9+
#include <qtpokit/pokitmeter.h>
10+
#include <qtpokit/pokitpro.h>
11+
12+
Q_DECLARE_METATYPE(PokitMeter::CurrentRange)
13+
Q_DECLARE_METATYPE(PokitMeter::ResistanceRange)
14+
Q_DECLARE_METATYPE(PokitMeter::VoltageRange)
15+
Q_DECLARE_METATYPE(PokitPro::CapacitanceRange)
16+
Q_DECLARE_METATYPE(PokitPro::CurrentRange)
17+
Q_DECLARE_METATYPE(PokitPro::ResistanceRange)
18+
Q_DECLARE_METATYPE(PokitPro::VoltageRange)
919

1020
class MockDeviceCommand : public DeviceCommand
1121
{
@@ -50,6 +60,258 @@ void TestDeviceCommand::disconnect()
5060
// Cannot test DeviceCommand::disconnect() without a valid device controller.
5161
}
5262

63+
void TestDeviceCommand::minRange_meter_current_data()
64+
{
65+
QTest::addColumn<quint32>("maxValue");
66+
QTest::addColumn<PokitMeter::CurrentRange>("expected");
67+
68+
QTest::addRow("0") << (quint32) 0 << PokitMeter::CurrentRange::AutoRange;
69+
QTest::addRow("1μA") << (quint32) 1 << PokitMeter::CurrentRange::_10mA;
70+
QTest::addRow("10mA") << (quint32) 10000 << PokitMeter::CurrentRange::_10mA;
71+
QTest::addRow("10mA++") << (quint32) 10001 << PokitMeter::CurrentRange::_30mA;
72+
QTest::addRow("30mA") << (quint32) 30000 << PokitMeter::CurrentRange::_30mA;
73+
QTest::addRow("30mA++") << (quint32) 30001 << PokitMeter::CurrentRange::_150mA;
74+
QTest::addRow("150mA") << (quint32) 150000 << PokitMeter::CurrentRange::_150mA;
75+
QTest::addRow("150mA++") << (quint32) 150001 << PokitMeter::CurrentRange::_300mA;
76+
QTest::addRow("300mA") << (quint32) 300000 << PokitMeter::CurrentRange::_300mA;
77+
QTest::addRow("300mA++") << (quint32) 300001 << PokitMeter::CurrentRange::_2A;
78+
QTest::addRow("2A") << (quint32)2000000 << PokitMeter::CurrentRange::_2A;
79+
QTest::addRow("2A++") << (quint32)2000001 << PokitMeter::CurrentRange::AutoRange;
80+
}
81+
82+
void TestDeviceCommand::minRange_meter_current()
83+
{
84+
QFETCH(quint32, maxValue);
85+
QFETCH(PokitMeter::CurrentRange, expected);
86+
const auto actual = DeviceCommand::minRange<PokitMeter::CurrentRange>(maxValue);
87+
QCOMPARE(PokitMeter::toString(actual), PokitMeter::toString(expected));
88+
QVERIFY(actual == expected);
89+
}
90+
91+
void TestDeviceCommand::minRange_meter_resistance_data()
92+
{
93+
QTest::addColumn<quint32>("maxValue");
94+
QTest::addColumn<PokitMeter::ResistanceRange>("expected");
95+
96+
QTest::addRow("0") << (quint32) 0 << PokitMeter::ResistanceRange::AutoRange;
97+
QTest::addRow("1Ω") << (quint32) 1 << PokitMeter::ResistanceRange::_160;
98+
QTest::addRow("160Ω") << (quint32) 160 << PokitMeter::ResistanceRange::_160;
99+
QTest::addRow("160Ω++") << (quint32) 161 << PokitMeter::ResistanceRange::_330;
100+
QTest::addRow("330Ω") << (quint32) 330 << PokitMeter::ResistanceRange::_330;
101+
QTest::addRow("330Ω++") << (quint32) 331 << PokitMeter::ResistanceRange::_890;
102+
QTest::addRow("890Ω") << (quint32) 890 << PokitMeter::ResistanceRange::_890;
103+
QTest::addRow("890Ω++") << (quint32) 891 << PokitMeter::ResistanceRange::_1K5;
104+
QTest::addRow("1K5Ω") << (quint32) 1500 << PokitMeter::ResistanceRange::_1K5;
105+
QTest::addRow("1K5++") << (quint32) 1501 << PokitMeter::ResistanceRange::_10K;
106+
QTest::addRow("10KΩ") << (quint32) 10000 << PokitMeter::ResistanceRange::_10K;
107+
QTest::addRow("10KΩ++") << (quint32) 10001 << PokitMeter::ResistanceRange::_100K;
108+
QTest::addRow("100KΩ") << (quint32) 100000 << PokitMeter::ResistanceRange::_100K;
109+
QTest::addRow("100KΩ++") << (quint32) 100001 << PokitMeter::ResistanceRange::_470K;
110+
QTest::addRow("470KΩ") << (quint32) 470000 << PokitMeter::ResistanceRange::_470K;
111+
QTest::addRow("470KΩ++") << (quint32) 470001 << PokitMeter::ResistanceRange::_1M;
112+
QTest::addRow("1MΩ") << (quint32)1000000 << PokitMeter::ResistanceRange::_1M;
113+
QTest::addRow("1MΩ++") << (quint32)1000001 << PokitMeter::ResistanceRange::AutoRange;
114+
}
115+
116+
void TestDeviceCommand::minRange_meter_resistance()
117+
{
118+
QFETCH(quint32, maxValue);
119+
QFETCH(PokitMeter::ResistanceRange, expected);
120+
const auto actual = DeviceCommand::minRange<PokitMeter::ResistanceRange>(maxValue);
121+
QCOMPARE(PokitMeter::toString(actual), PokitMeter::toString(expected));
122+
QVERIFY(actual == expected);
123+
}
124+
125+
void TestDeviceCommand::minRange_meter_voltage_data()
126+
{
127+
QTest::addColumn<quint32>("maxValue");
128+
QTest::addColumn<PokitMeter::VoltageRange>("expected");
129+
130+
QTest::addRow("0") << (quint32) 0 << PokitMeter::VoltageRange::AutoRange;
131+
QTest::addRow("1mV") << (quint32) 1 << PokitMeter::VoltageRange::_300mV;
132+
QTest::addRow("300mV") << (quint32) 300 << PokitMeter::VoltageRange::_300mV;
133+
QTest::addRow("300mV++") << (quint32) 301 << PokitMeter::VoltageRange::_2V;
134+
QTest::addRow("2V") << (quint32) 2000 << PokitMeter::VoltageRange::_2V;
135+
QTest::addRow("2V++") << (quint32) 2001 << PokitMeter::VoltageRange::_6V;
136+
QTest::addRow("6V") << (quint32) 6000 << PokitMeter::VoltageRange::_6V;
137+
QTest::addRow("6V++") << (quint32) 6001 << PokitMeter::VoltageRange::_12V;
138+
QTest::addRow("12V") << (quint32)12000 << PokitMeter::VoltageRange::_12V;
139+
QTest::addRow("12V++") << (quint32)12001 << PokitMeter::VoltageRange::_30V;
140+
QTest::addRow("30V") << (quint32)30000 << PokitMeter::VoltageRange::_30V;
141+
QTest::addRow("30V++") << (quint32)30001 << PokitMeter::VoltageRange::_60V;
142+
QTest::addRow("60V") << (quint32)60000 << PokitMeter::VoltageRange::_60V;
143+
QTest::addRow("60V++") << (quint32)60001 << PokitMeter::VoltageRange::AutoRange;
144+
}
145+
146+
void TestDeviceCommand::minRange_meter_voltage()
147+
{
148+
QFETCH(quint32, maxValue);
149+
QFETCH(PokitMeter::VoltageRange, expected);
150+
const auto actual = DeviceCommand::minRange<PokitMeter::VoltageRange>(maxValue);
151+
QCOMPARE(PokitMeter::toString(actual), PokitMeter::toString(expected));
152+
QVERIFY(actual == expected);
153+
}
154+
155+
void TestDeviceCommand::minRange_pro_capacitance_data()
156+
{
157+
QTest::addColumn<quint32>("maxValue");
158+
QTest::addColumn<PokitPro::CapacitanceRange>("expected");
159+
160+
QTest::addRow("0") << (quint32) 0 << PokitPro::CapacitanceRange::AutoRange;
161+
QTest::addRow("1nF") << (quint32) 1 << PokitPro::CapacitanceRange::_100nF;
162+
QTest::addRow("100nF") << (quint32) 100 << PokitPro::CapacitanceRange::_100nF;
163+
QTest::addRow("100nF++") << (quint32) 101 << PokitPro::CapacitanceRange::_10uF;
164+
QTest::addRow("10μF") << (quint32) 10000 << PokitPro::CapacitanceRange::_10uF;
165+
QTest::addRow("10μF++") << (quint32) 10001 << PokitPro::CapacitanceRange::_1mF;
166+
QTest::addRow("1mF") << (quint32)1000000 << PokitPro::CapacitanceRange::_1mF;
167+
QTest::addRow("1mF++") << (quint32)1000001 << PokitPro::CapacitanceRange::AutoRange;
168+
}
169+
170+
void TestDeviceCommand::minRange_pro_capacitance()
171+
{
172+
QFETCH(quint32, maxValue);
173+
QFETCH(PokitPro::CapacitanceRange, expected);
174+
const auto actual = DeviceCommand::minRange<PokitPro::CapacitanceRange>(maxValue);
175+
QCOMPARE(PokitPro::toString(actual), PokitPro::toString(expected));
176+
QVERIFY(actual == expected);
177+
}
178+
179+
void TestDeviceCommand::minRange_pro_current_data()
180+
{
181+
QTest::addColumn<quint32>("maxValue");
182+
QTest::addColumn<PokitPro::CurrentRange>("expected");
183+
184+
QTest::addRow("0") << (quint32) 0 << PokitPro::CurrentRange::AutoRange;
185+
QTest::addRow("1μA") << (quint32) 1 << PokitPro::CurrentRange::_500uA;
186+
QTest::addRow("500μA") << (quint32) 500 << PokitPro::CurrentRange::_500uA;
187+
QTest::addRow("500μA++") << (quint32) 501 << PokitPro::CurrentRange::_2mA;
188+
QTest::addRow("2mA") << (quint32) 2000 << PokitPro::CurrentRange::_2mA;
189+
QTest::addRow("2mA++") << (quint32) 2001 << PokitPro::CurrentRange::_10mA;
190+
QTest::addRow("10mA") << (quint32) 10000 << PokitPro::CurrentRange::_10mA;
191+
QTest::addRow("10mA++") << (quint32) 10001 << PokitPro::CurrentRange::_125mA;
192+
QTest::addRow("125mA") << (quint32) 125000 << PokitPro::CurrentRange::_125mA;
193+
QTest::addRow("125mA++") << (quint32) 125001 << PokitPro::CurrentRange::_300mA;
194+
QTest::addRow("300mA") << (quint32) 300000 << PokitPro::CurrentRange::_300mA;
195+
QTest::addRow("300mA++") << (quint32) 300001 << PokitPro::CurrentRange::_3A;
196+
QTest::addRow("3A") << (quint32) 3000000 << PokitPro::CurrentRange::_3A;
197+
QTest::addRow("3A++") << (quint32) 3000001 << PokitPro::CurrentRange::_10A;
198+
QTest::addRow("10A") << (quint32)10000000 << PokitPro::CurrentRange::_10A;
199+
QTest::addRow("10A++") << (quint32)10000001 << PokitPro::CurrentRange::AutoRange;
200+
}
201+
202+
void TestDeviceCommand::minRange_pro_current()
203+
{
204+
QFETCH(quint32, maxValue);
205+
QFETCH(PokitPro::CurrentRange, expected);
206+
const auto actual = DeviceCommand::minRange<PokitPro::CurrentRange>(maxValue);
207+
QCOMPARE(PokitPro::toString(actual), PokitPro::toString(expected));
208+
QVERIFY(actual == expected);
209+
}
210+
211+
void TestDeviceCommand::minRange_pro_resistance_data()
212+
{
213+
QTest::addColumn<quint32>("maxValue");
214+
QTest::addColumn<PokitPro::ResistanceRange>("expected");
215+
216+
QTest::addRow("0") << (quint32) 0 << PokitPro::ResistanceRange::AutoRange;
217+
QTest::addRow("1Ω") << (quint32) 1 << PokitPro::ResistanceRange::_30;
218+
QTest::addRow("30Ω") << (quint32) 30 << PokitPro::ResistanceRange::_30;
219+
QTest::addRow("30Ω++") << (quint32) 31 << PokitPro::ResistanceRange::_75;
220+
QTest::addRow("75Ω") << (quint32) 75 << PokitPro::ResistanceRange::_75;
221+
QTest::addRow("75Ω++") << (quint32) 76 << PokitPro::ResistanceRange::_400;
222+
QTest::addRow("400Ω") << (quint32) 400 << PokitPro::ResistanceRange::_400;
223+
QTest::addRow("400Ω++") << (quint32) 401 << PokitPro::ResistanceRange::_5K;
224+
QTest::addRow("5KΩ") << (quint32) 5000 << PokitPro::ResistanceRange::_5K;
225+
QTest::addRow("5KΩ++") << (quint32) 5001 << PokitPro::ResistanceRange::_10K;
226+
QTest::addRow("10KΩ") << (quint32) 10000 << PokitPro::ResistanceRange::_10K;
227+
QTest::addRow("10KΩ++") << (quint32) 10001 << PokitPro::ResistanceRange::_15K;
228+
QTest::addRow("15KΩ") << (quint32) 15000 << PokitPro::ResistanceRange::_15K;
229+
QTest::addRow("15KΩ++") << (quint32) 15001 << PokitPro::ResistanceRange::_40K;
230+
QTest::addRow("40KΩ") << (quint32) 40000 << PokitPro::ResistanceRange::_40K;
231+
QTest::addRow("40KΩ++") << (quint32) 40001 << PokitPro::ResistanceRange::_500K;
232+
QTest::addRow("500KΩ") << (quint32) 500000 << PokitPro::ResistanceRange::_500K;
233+
QTest::addRow("500KΩ++") << (quint32) 500001 << PokitPro::ResistanceRange::_700K;
234+
QTest::addRow("700KΩ") << (quint32) 700000 << PokitPro::ResistanceRange::_700K;
235+
QTest::addRow("700KΩ++") << (quint32) 700001 << PokitPro::ResistanceRange::_1M;
236+
QTest::addRow("1MΩ") << (quint32)1000000 << PokitPro::ResistanceRange::_1M;
237+
QTest::addRow("1MΩ++") << (quint32)1000001 << PokitPro::ResistanceRange::_3M;
238+
QTest::addRow("3MΩ") << (quint32)3000000 << PokitPro::ResistanceRange::_3M;
239+
QTest::addRow("3MΩ++") << (quint32)3000001 << PokitPro::ResistanceRange::AutoRange;
240+
}
241+
242+
void TestDeviceCommand::minRange_pro_resistance()
243+
{
244+
QFETCH(quint32, maxValue);
245+
QFETCH(PokitPro::ResistanceRange, expected);
246+
const auto actual = DeviceCommand::minRange<PokitPro::ResistanceRange>(maxValue);
247+
QCOMPARE(PokitPro::toString(actual), PokitPro::toString(expected));
248+
QVERIFY(actual == expected);
249+
}
250+
251+
void TestDeviceCommand::minRange_pro_voltage_data()
252+
{
253+
QTest::addColumn<quint32>("maxValue");
254+
QTest::addColumn<PokitPro::VoltageRange>("expected");
255+
256+
QTest::addRow("0") << (quint32) 0 << PokitPro::VoltageRange::AutoRange;
257+
QTest::addRow("1mV") << (quint32) 1 << PokitPro::VoltageRange::_250mV;
258+
QTest::addRow("250mV") << (quint32) 250 << PokitPro::VoltageRange::_250mV;
259+
QTest::addRow("250mV++") << (quint32) 251 << PokitPro::VoltageRange::_2V;
260+
QTest::addRow("2V") << (quint32) 2000 << PokitPro::VoltageRange::_2V;
261+
QTest::addRow("2V++") << (quint32) 2001 << PokitPro::VoltageRange::_10V;
262+
QTest::addRow("10V") << (quint32) 10000 << PokitPro::VoltageRange::_10V;
263+
QTest::addRow("10V++") << (quint32) 10001 << PokitPro::VoltageRange::_30V;
264+
QTest::addRow("30V") << (quint32) 30000 << PokitPro::VoltageRange::_30V;
265+
QTest::addRow("30V++") << (quint32) 30001 << PokitPro::VoltageRange::_60V;
266+
QTest::addRow("60V") << (quint32) 60000 << PokitPro::VoltageRange::_60V;
267+
QTest::addRow("60V++") << (quint32) 60001 << PokitPro::VoltageRange::_125V;
268+
QTest::addRow("125V") << (quint32)125000 << PokitPro::VoltageRange::_125V;
269+
QTest::addRow("125V++") << (quint32)125001 << PokitPro::VoltageRange::_400V;
270+
QTest::addRow("400V") << (quint32)400000 << PokitPro::VoltageRange::_400V;
271+
QTest::addRow("400V++") << (quint32)400001 << PokitPro::VoltageRange::_600V;
272+
QTest::addRow("600V") << (quint32)600000 << PokitPro::VoltageRange::_600V;
273+
QTest::addRow("600V++") << (quint32)600001 << PokitPro::VoltageRange::AutoRange;
274+
}
275+
276+
void TestDeviceCommand::minRange_pro_voltage()
277+
{
278+
QFETCH(quint32, maxValue);
279+
QFETCH(PokitPro::VoltageRange, expected);
280+
const auto actual = DeviceCommand::minRange<PokitPro::VoltageRange>(maxValue);
281+
QCOMPARE(PokitPro::toString(actual), PokitPro::toString(expected));
282+
QVERIFY(actual == expected);
283+
}
284+
285+
void TestDeviceCommand::minCapacitanceRange()
286+
{
287+
const quint8 actual = DeviceCommand::minCapacitanceRange(PokitProduct::PokitPro, 123456);
288+
QCOMPARE(actual, (quint8)PokitPro::CapacitanceRange::_1mF);
289+
}
290+
291+
void TestDeviceCommand::minCurrentRange()
292+
{
293+
quint8 actual = DeviceCommand::minCurrentRange(PokitProduct::PokitMeter, 123456);
294+
QCOMPARE(actual, (quint8)PokitMeter::CurrentRange::_150mA);
295+
actual = DeviceCommand::minCurrentRange(PokitProduct::PokitPro, 123456);
296+
QCOMPARE(actual, (quint8)PokitPro::CurrentRange::_125mA);
297+
}
298+
299+
void TestDeviceCommand::minResistanceRange()
300+
{
301+
quint8 actual = DeviceCommand::minResistanceRange(PokitProduct::PokitMeter, 123456);
302+
QCOMPARE(actual, (quint8)PokitMeter::ResistanceRange::_470K);
303+
actual = DeviceCommand::minResistanceRange(PokitProduct::PokitPro, 123456);
304+
QCOMPARE(actual, (quint8)PokitPro::ResistanceRange::_500K);
305+
}
306+
307+
void TestDeviceCommand::minVoltageRange()
308+
{
309+
quint8 actual = DeviceCommand::minVoltageRange(PokitProduct::PokitMeter, 12345);
310+
QCOMPARE(actual, (quint8)PokitMeter::VoltageRange::_30V);
311+
actual = DeviceCommand::minVoltageRange(PokitProduct::PokitPro, 123456);
312+
QCOMPARE(actual, (quint8)PokitPro::VoltageRange::_125V);
313+
}
314+
53315
void TestDeviceCommand::controllerError()
54316
{
55317
MockDeviceCommand command;

‎test/unit/cli/testdevicecommand.h

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,35 @@ private slots:
1212

1313
void disconnect();
1414

15+
void minRange_meter_current_data();
16+
void minRange_meter_current();
17+
18+
void minRange_meter_resistance_data();
19+
void minRange_meter_resistance();
20+
21+
void minRange_meter_voltage_data();
22+
void minRange_meter_voltage();
23+
24+
void minRange_pro_capacitance_data();
25+
void minRange_pro_capacitance();
26+
27+
void minRange_pro_current_data();
28+
void minRange_pro_current();
29+
30+
void minRange_pro_resistance_data();
31+
void minRange_pro_resistance();
32+
33+
void minRange_pro_voltage_data();
34+
void minRange_pro_voltage();
35+
36+
void minCapacitanceRange();
37+
38+
void minCurrentRange();
39+
40+
void minResistanceRange();
41+
42+
void minVoltageRange();
43+
1544
void controllerError();
1645

1746
void deviceDisconnected();

0 commit comments

Comments
 (0)