Skip to content
Linux Tests

Fix __ name mangling issue #2226

Sign in to view logs

Fix __ name mangling issue

Fix __ name mangling issue #2226

GitHub Actions / JUnit Test Report failed Dec 6, 2023 in 0s

1399 tests run, 236 passed, 1147 skipped, 16 failed.

Annotations

Check failure on line 139 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers[param_set0-0-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 0
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9081.py:139: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 0
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 139 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers[param_set0-1-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 1
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9081.py:139: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 1
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 139 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers[param_set0-2-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 2
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9081.py:139: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 2
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 139 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers[param_set0-3-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 3
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9081.py:139: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 3
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 168 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers_exception[param_set0-0-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 0
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9081.py:168: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 0
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 168 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers_exception[param_set0-1-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 1
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9081.py:168: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 1
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 168 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers_exception[param_set0-2-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 2
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9081.py:168: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 2
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 168 in test/test_ad9081.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9081.test_ad9081_cyclic_buffers_exception[param_set0-3-adi.ad9081] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 3
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                loopback_mode=0,
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9081_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9081.py:168: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9081', channel = 3
param_set = {'loopback_mode': 0, 'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 131 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers[param_set0-0-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 0
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9084.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 0
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 131 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers[param_set0-1-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 1
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9084.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 1
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 131 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers[param_set0-2-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 2
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9084.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 2
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 131 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers[param_set0-3-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer = <function cyclic_buffer at 0x7fddd66fd320>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 3
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_nyquist_zone=["odd", "odd", "odd", "odd"],
                tx_channel_nco_gain_scales=[0.5, 0.5, 0.5, 0.5],
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers(
        test_cyclic_buffer, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer(iio_uri, classname, channel, param_set)

test/test_ad9084.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 3
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer(uri, classname, channel, param_set):
        """cyclic_buffer: Construct Cyclic TX buffers and verify
        no errors occur when pushed. This is performed twice
        without closing the context
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:943: TypeError

Check failure on line 159 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers_exception[param_set0-0-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 0
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9084.py:159: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 0
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 159 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers_exception[param_set0-1-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 1
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9084.py:159: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 1
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 159 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers_exception[param_set0-2-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 2
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9084.py:159: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 2
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError

Check failure on line 159 in test/test_ad9084.py

See this annotation in the file changed.

@github-actions github-actions / JUnit Test Report

test_ad9084.test_ad9084_cyclic_buffers_exception[param_set0-3-adi.ad9084] 

TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
Raw output 
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fddd66fd3b0>
iio_uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 3
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    @pytest.mark.iio_hardware(hardware)
    @pytest.mark.parametrize("classname", [(classname)])
    @pytest.mark.parametrize("channel", [0, 1, 2, 3])
    @pytest.mark.parametrize(
        "param_set",
        [
            dict(
                rx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                tx_main_nco_frequencies=[1000000000, 1000000000, 1000000000, 1000000000],
                rx_channel_nco_frequencies=[0, 0, 0, 0],
                tx_channel_nco_frequencies=[0, 0, 0, 0],
                rx_main_nco_phases=[0, 0, 0, 0],
                tx_main_nco_phases=[0, 0, 0, 0],
                rx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_phases=[0, 0, 0, 0],
                tx_channel_nco_test_tone_en=[0, 0, 0, 0],
                tx_main_nco_test_tone_en=[0, 0, 0, 0],
            )
        ],
    )
    def test_ad9084_cyclic_buffers_exception(
        test_cyclic_buffer_exception, iio_uri, classname, channel, param_set
    ):
        param_set = scale_field(param_set, iio_uri)
>       test_cyclic_buffer_exception(iio_uri, classname, channel, param_set)

test/test_ad9084.py:159: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

uri = 'ip:10.1.0.114', classname = 'adi.ad9084', channel = 3
param_set = {'rx_channel_nco_frequencies': [0, 0, 0, 0], 'rx_channel_nco_phases': [0, 0, 0, 0], 'rx_main_nco_frequencies': [1000000000, 1000000000, 1000000000, 1000000000], 'rx_main_nco_phases': [0, 0, 0, 0], ...}

    def cyclic_buffer_exception(uri, classname, channel, param_set):
        """cyclic_buffer_exception: Construct Cyclic TX buffers and verify
        errors occur when pushed. This is performed twice
        without closing the context and with resetting the TX buffers
        which should cause an exception
    
        parameters:
            uri: type=string
                URI of IIO context of target board/system
            classname: type=string
                Name of pyadi interface class which contain attribute
            channel: type=list
                List of integers or list of list of integers of channels to
                enable through tx_enabled_channels
            param_set: type=dict
                Dictionary of attribute and values to be set before tone is
                generated
        """
        # See if we can tone using DMAs
        sdr = eval(classname + "(uri='" + uri + "')")
        # Set custom device parameters
        for p in param_set.keys():
            setattr(sdr, p, param_set[p])
    
        if hasattr(sdr, "sample_rate"):
>           fs = int(sdr.sample_rate)
E           TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'

test/dma_tests.py:1001: TypeError
View more details on GitHub Actions