Skip to content

Fix __ name mangling issue #2226

Fix __ name mangling issue

Fix __ name mangling issue #2226

GitHub Actions / Unit Test Results failed Dec 6, 2023 in 0s

16 fail, 1 147 skipped, 236 pass in 9m 9s

1 399 tests  +1 399      236 ✔️ +   236   9m 9s ⏱️ + 9m 9s
       1 suites +       1   1 147 💤 +1 147 
       1 files   +       1        16 +     16 

Results for commit 255e74a. ± Comparison against earlier commit 2eeb678.

Annotations

Check warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers[param_set0-0-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers[param_set0-1-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers[param_set0-2-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers[param_set0-3-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers_exception[param_set0-0-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers_exception[param_set0-1-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers_exception[param_set0-2-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9081

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9081_cyclic_buffers_exception[param_set0-3-adi.ad9081] (test.test_ad9081) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers[param_set0-0-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers[param_set0-1-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers[param_set0-2-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers[param_set0-3-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer = <function cyclic_buffer at 0x7fba0e181940>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers_exception[param_set0-0-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers_exception[param_set0-1-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers_exception[param_set0-2-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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 warning on line 0 in test.test_ad9084

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

test_ad9084_cyclic_buffers_exception[param_set0-3-adi.ad9084] (test.test_ad9084) failed

results.xml
Raw output
test_cyclic_buffer_exception = <function cyclic_buffer_exception at 0x7fba0e1819d0>
iio_uri = 'ip:10.1.0.68', 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.68', 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