Ticket #17861: test_serial.py

"""
Test serial port baudrates on multiple platforms.

Requires:

 - PySerial (`pip3 install {--user} pyserial`, or use `pkgman install pyserial`)
 - A loopback wire (Rx<->Tx) on the serial port.

For Haiku versions older than hrev56354:

Due to bug https://dev.haiku-os.org/ticket/17861, you need to comment out
line 344: "self._reset_input_buffer()" on PySerial's serialposix.py file.

Normal test duration: < 20 seconds.

For each tested baudrate:
 - Write a string to the loopback port. Ensure all bytes get written.
 - Split the reading back of that string on 3 parts, making sure that on each step:
   - the read data is correct.
   - the input buffer has the correct number of bytes left.

Supossedly supported baudrates on each platform:

Win32: 50 to  115200 bps - Confirmed working
Linux: 50 to 4000000 bps - Confirmed working
Haiku: 50 to  230400 bps - only 50 - 115200 seems to work.

For Haiku versions older than hrev56354:
   Make sure you don't call any function that call:
 - termios.tcflush()        - like serial.reset_input_buffer() and serial.reset_output_buffer()
 - termios.tcdrain()        - like serial.flush()
 - termios.tcsendbreak()    - like serial.send_break()
"""

import os
import serial
import sys
import time

#
# Default port names. Used if not given on the command line
#
if sys.platform == 'win32':
    PORT = 'COM1'
elif sys.platform == 'linux':
    PORT = '/dev/ttyS0'
elif sys.platform == 'haiku1':
    PORT = '/dev/ports/pc_serial0'
else:
    exit('unsupported platform')


USAGE_TEXT = """Test serial ports read/write via a loopback cable.

Usage:

> test_serial.py [-h] [port] [baudrate]

    -h            Show this text and exit.
    [port]        Name of the port to test. Default: '%s'.
    [baudrate]    Baudrate to test. Tests all the supported ones if not given.
""" % PORT


TEST_STRING = b'Hello World!'
TS_FIRST_HALF = TEST_STRING.split()[0]
TS_SECOND_HALF = TEST_STRING.split()[-1]

# print('Test strings:\n\t%s\n\t%s\n\t%s\n' % (TEST_STRING, TS_FIRST_HALF, TS_SECOND_HALF))

def test(port, baudrates=None):
    print('Testing port: %s.' % port)

    with serial.Serial(port) as s:
        if not s.isOpen():
            exit('Could not open the serial port.')

        if baudrates is None:
            baudrates = s.BAUDRATES

        for b in baudrates[::-1]:
            # 230400 hangs on Haiku, and it doesn't supports setting custom baudrates on pc_serial.
            if sys.platform == 'haiku1' and int(b) >= 230400:
                 continue

            if (int(b) == 0):
                print('Skipping tests for baudrate = 0 bps.')
                continue

            s.baudrate = b
            s.bytesize = serial.SEVENBITS
            s.timeout = 200000
            assert s.baudrate == b, b
            in_wating = s.in_waiting
            assert in_wating == 0, in_wating

            bytes_written = s.write(TEST_STRING)
            # Give it time to send the data:
            if sys.platform == 'linux':
                # PySerial flush() calls tcdrain(). This is enough on Linux, as it blocks until all the
                # bytes are written.
                s.flush()
                print('Testing baudrate: %d bps.' % b)
            else:
                # On Win32 flush() returns right away, so we need to wait an BPS appropiate time here
                # (same on Haiku, at least for now):
                s.flush()
                print('Testing baudrate: %d bps.' % b, end='')
                sleep_time = (1 / (b / 8) * bytes_written) * 2 # we need to write AND read, thus: time x 2.
                if sys.version_info < (3, 11) and sleep_time < 0.001:
                    sleep_time = 0.001 # time.sleep() is not THAT precise on earlier Python versions.
                print(' - Sleeping for %s seconds.' % sleep_time)
                time.sleep(sleep_time)

            assert bytes_written == len(TEST_STRING), bytes_written
            in_waiting = s.in_waiting
            assert in_waiting == bytes_written, '%d != %d' % (in_waiting, bytes_written)

            data = s.read(len(TS_FIRST_HALF))
            assert data == TS_FIRST_HALF, data
            in_waiting = s.in_waiting
            assert in_waiting == (len(TEST_STRING) - len(TS_FIRST_HALF)), in_waiting

            # Eat away the expected ' ' separator.
            data = s.read(1)
            assert data == b' ', data

            data = s.read(len(TS_SECOND_HALF))
            assert data == TS_SECOND_HALF, data
            in_waiting = s.in_waiting
            assert in_waiting == 0, in_waiting


if __name__ == '__main__':
    port = PORT
    baudrates = None

    if len(sys.argv) > 1:
        if '-h' in sys.argv:
            print(USAGE_TEXT)
            exit(0)

        if os.path.exists(sys.argv[1]):
            port = sys.argv[1]
        elif sys.argv[1].isnumeric():
            baudrates = [int(sys.argv[1])]
        else:
            exit('Couldn\'t find port "%s"' % sys.argv[1])

    if len(sys.argv) > 2 and sys.argv[2].isnumeric():
        baudrates = [int(sys.argv[2])]

    test(port, baudrates)