Replace print() with assert

So changes in behavior can be detected.

bindings/python/test_startup.py

@@ -5,7 +5,7 @@ Running this script directly will use the installed bindings.
 For an in-tree run use "make check", or set PYTHONPATH to point to
 the directories containing Hamlib.py and _Hamlib.so.
 """
-import sys
+from pytest import approx
 
 import Hamlib
 
@@ -15,113 +15,117 @@ class TestClass:
     def test_startup(self):
         """Simple script to test the Hamlib.py module with Python3."""
 
-        print("%s: Python %s; %s\n" \
+        assert isinstance(Hamlib.cvar.hamlib_version, str)
-            % (sys.argv[0], sys.version.split()[0], Hamlib.cvar.hamlib_version))
 
         Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
 
-        # Init RIG_MODEL_DUMMY
+        model = Hamlib.RIG_MODEL_DUMMY
-        my_rig = Hamlib.Rig(Hamlib.RIG_MODEL_DUMMY)
+        my_rig = Hamlib.Rig(model)
-        my_rig.set_conf("rig_pathname", "/dev/Rig")
+        assert my_rig is not None
-        my_rig.set_conf("retry", "5")
+        assert my_rig.set_conf("rig_pathname", "/dev/Rig") is None
+        assert my_rig.set_conf("retry", "5") is None
 
-        my_rig.open ()
+        assert my_rig.open() is None
 
-        rpath = my_rig.get_conf("rig_pathname")
+        assert my_rig.get_conf("rig_pathname") == "/dev/Rig"
-        retry = my_rig.get_conf("retry")
+        assert my_rig.get_conf("retry") == '5'
 
-        print("status(str):\t\t%s" % Hamlib.rigerror(my_rig.error_status))
+        assert my_rig.error_status == Hamlib.RIG_OK
-        print("get_conf:\t\tpath = %s, retry = %s" \
+        # assert Hamlib.rigerror(my_rig.error_status) == "Command completed successfully\n"  # FIXME: the string returned contains debug messages, fix in PR #1727
-            % (rpath, retry))
 
-        my_rig.set_freq(Hamlib.RIG_VFO_B, 5700000000)
+        assert my_rig.set_freq(Hamlib.RIG_VFO_B, 5700000000) is None
-        my_rig.set_vfo(Hamlib.RIG_VFO_B)
+        assert my_rig.set_vfo(Hamlib.RIG_VFO_B) is None
+        assert my_rig.get_freq() == 5700000000
 
-        print("freq:\t\t\t%s" % my_rig.get_freq())
+        assert my_rig.set_freq(Hamlib.RIG_VFO_A, 145550000) is None
 
-        my_rig.set_freq(Hamlib.RIG_VFO_A, 145550000)
         (mode, width) = my_rig.get_mode(Hamlib.RIG_VFO_A)
+        assert Hamlib.rig_strrmode(mode) == 'FM'
+        assert width == 15000
 
-        print("mode:\t\t\t%s\nbandwidth:\t\t%s" % (Hamlib.rig_strrmode(mode), width))
+        assert my_rig.set_mode(Hamlib.RIG_MODE_CW) is None
-
-        my_rig.set_mode(Hamlib.RIG_MODE_CW)
         (mode, width) = my_rig.get_mode()
+        assert Hamlib.rig_strrmode(mode) == 'CW'
+        assert width == 0
 
-        print("mode:\t\t\t%s\nbandwidth:\t\t%s" % (Hamlib.rig_strrmode(mode), width))
+        assert isinstance(my_rig.caps.copyright, str)
+        assert isinstance(my_rig.caps.model_name, str)
+        assert isinstance(my_rig.caps.mfg_name, str)
+        assert isinstance(my_rig.caps.version, str)
+        assert isinstance(Hamlib.rig_strstatus(my_rig.caps.status), str)
+        assert isinstance(my_rig.get_info(), str)
 
-        print("Backend copyright:\t%s" % my_rig.caps.copyright)
+        assert my_rig.set_level("VOXDELAY", 1) is None
-        print("Model:\t\t\t%s" % my_rig.caps.model_name)
+        assert my_rig.get_level_i("VOXDELAY") == 1
-        print("Manufacturer:\t\t%s" % my_rig.caps.mfg_name)
-        print("Backend version:\t%s" % my_rig.caps.version)
-        print("Backend status:\t\t%s" % Hamlib.rig_strstatus(my_rig.caps.status))
-        print("Rig info:\t\t%s" % my_rig.get_info())
 
-        my_rig.set_level("VOXDELAY",  1)
+        assert my_rig.set_level(Hamlib.RIG_LEVEL_VOXDELAY, 5) is None
-
+        assert my_rig.get_level_i(Hamlib.RIG_LEVEL_VOXDELAY) == 5
-        print("VOX delay:\t\t%s" % my_rig.get_level_i("VOXDELAY"))
-
-        my_rig.set_level(Hamlib.RIG_LEVEL_VOXDELAY, 5)
-
-        print("VOX delay:\t\t%s" % my_rig.get_level_i(Hamlib.RIG_LEVEL_VOXDELAY))
 
         af = 12.34
+        assert my_rig.set_level("AF", af) is None
+        assert my_rig.error_status == Hamlib.RIG_OK
+        assert my_rig.get_level_f(Hamlib.RIG_LEVEL_AF) == approx(12.34)
+        assert my_rig.error_status == Hamlib.RIG_OK
 
-        print("Setting AF to %0.2f...." % (af))
+        assert my_rig.get_level_f(Hamlib.RIG_LEVEL_RFPOWER_METER)
-
+        assert my_rig.get_level_f(Hamlib.RIG_LEVEL_RFPOWER_METER_WATTS)
-        my_rig.set_level("AF", af)
+        assert my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH)
-
-        print("status:\t\t\t%s - %s" % (my_rig.error_status,
-                                        Hamlib.rigerror(my_rig.error_status)))
-
-        print("AF level:\t\t%0.2f" % my_rig.get_level_f(Hamlib.RIG_LEVEL_AF))
-        print("Power level:\t\t%0.2f" % my_rig.get_level_f(Hamlib.RIG_LEVEL_RFPOWER_METER))
-        print("Power level Watts:\t\t%0.2f" % my_rig.get_level_f(Hamlib.RIG_LEVEL_RFPOWER_METER_WATTS))
-        print("strength:\t\t%s" % my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH))
-        print("status:\t\t\t%s" % my_rig.error_status)
-        print("status(str):\t\t%s" % Hamlib.rigerror(my_rig.error_status))
 
         chan = Hamlib.channel(Hamlib.RIG_VFO_B)
-        my_rig.get_channel(chan,1)
+        assert chan.vfo == Hamlib.RIG_VFO_B
+        assert my_rig.get_channel(chan, 1) is None
+        assert my_rig.error_status == Hamlib.RIG_OK
 
-        print("get_channel status:\t%s" % my_rig.error_status)
+        assert Hamlib.rig_strvfo(chan.vfo) == 'MainB'
-        print("VFO:\t\t\t%s, %s" % (Hamlib.rig_strvfo(chan.vfo), chan.freq))
+        assert chan.freq == 5700000000
-        print("Attenuators:\t\t%s" % my_rig.caps.attenuator)
+        assert my_rig.caps.attenuator == [10, 20, 30, 0, 0, 0, 0, 0]
         # Can't seem to get get_vfo_info to work
         #(freq, width, mode, split) = my_rig.get_vfo_info(Hamlib.RIG_VFO_A,freq,width,mode,split)
         #print("Rig vfo_info:\t\tfreq=%s, mode=%s, width=%s, split=%s" % (freq, mode, width, split))
-        print("\nSending Morse, '73'")
 
-        my_rig.send_morse(Hamlib.RIG_VFO_A, "73")
+        assert my_rig.send_morse(Hamlib.RIG_VFO_A, "73") is None
-        my_rig.close()
+        assert my_rig.close() is None
 
-        print("\nSome static functions:")
+        # Some static functions
 
         err, lon1, lat1 = Hamlib.locator2longlat("IN98XC")
-        err, lon2, lat2 = Hamlib.locator2longlat("DM33DX")
+        assert err == Hamlib.RIG_OK
-        err, loc1 = Hamlib.longlat2locator(lon1, lat1, 3)
+        assert lon1 == approx(-0.0417, abs=1.0e-04)  # FIXME why need to override tolerance?
-        err, loc2 = Hamlib.longlat2locator(lon2, lat2, 3)
+        assert lat1 == approx(48.1042)
+        assert Hamlib.longlat2locator(lon1, lat1, 3) == [Hamlib.RIG_OK, 'IN98XC']
 
-        print("Loc1:\t\tIN98XC -> %9.4f, %9.4f -> %s" % (lon1, lat1, loc1))
+        err, lon2, lat2 = Hamlib.locator2longlat("DM33DX")
-        print("Loc2:\t\tDM33DX -> %9.4f, %9.4f -> %s" % (lon2, lat2, loc2))
+        assert err == Hamlib.RIG_OK
+        assert lon2 == approx(-113.7083)
+        assert lat2 == approx(33.9792)
+        assert Hamlib.longlat2locator(lon2, lat2, 3) == [Hamlib.RIG_OK, 'DM33DX']
 
         err, dist, az = Hamlib.qrb(lon1, lat1, lon2, lat2)
+        assert err == Hamlib.RIG_OK
+        assert dist == approx(8765.814)
+        assert az == approx(309.0)
         longpath = Hamlib.distance_long_path(dist)
-
+        assert longpath == approx(31266.186)
-        print("Distance:\t%.3f km, azimuth %.2f, long path:\t%.3f km" \
-            % (dist, az, longpath))
 
         # dec2dms expects values from 180 to -180
         # sw is 1 when deg is negative (west or south) as 0 cannot be signed
         err, deg1, mins1, sec1, sw1 = Hamlib.dec2dms(lon1)
+        assert err == Hamlib.RIG_OK
+        assert deg1 == 0
+        assert mins1 == 2
+        assert sec1 == 29
+        assert sw1 == 1
+
         err, deg2, mins2, sec2, sw2 = Hamlib.dec2dms(lat1)
+        assert err == Hamlib.RIG_OK
+        assert deg2 == 48
+        assert mins2 == 6
+        assert sec2 == 15
+        assert sw2 == 0
 
         lon3 = Hamlib.dms2dec(deg1, mins1, sec1, sw1)
         lat3 = Hamlib.dms2dec(deg2, mins2, sec2, sw2)
+        assert lon3 == approx(-0.0414, abs=1.0e-04)  # FIXME why need to override tolerance?
+        assert lat3 == approx(48.1042)
 
-        print('Longitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
+        assert my_rig.set_vfo_opt(0) is None
-            % (lon1, deg1, mins1, sec1, ('W' if sw1 else 'E'), lon3))
-
-        print('Latitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
-            % (lat1, deg2, mins2, sec2, ('S' if sw2 else 'N'), lat3))
-
-        my_rig.set_vfo_opt(0);