Re: [dts] [PATCH] add unit_test_cmdline , unit_test_dump and unit_test_eal test suite and testplan

["Xu, HuilongX" <huilongx.xu@intel.com>]

Hi haifeng,
Would you send patch again, and used a patch file for add a new code file and rst file?
When I read the code it too pain.
Thanks  a lot

> -----Original Message-----
> From: dts [mailto:dts-bounces@dpdk.org] On Behalf Of haifeng
> Sent: Monday, May 25, 2015 3:55 PM
> To: dts@dpdk.org
> Subject: [dts] [PATCH] add unit_test_cmdline ,unit_test_dump and
> unit_test_eal test suite and testplan
> 
> From: TangHaifeng <haifengx.tang@intel.com>
> 
> ---
>  test_plans/unit_tests_cmdline_test_plan.rst |   38 +++
>  test_plans/unit_tests_dump_test_plan.rst    |  169 +++++++++++
>  test_plans/unit_tests_eal_test_plan.rst     |  315 +++++++++++++++++++++
>  tests/TestSuite_unit_tests_cmdline.py       |   60 ++++
>  tests/TestSuite_unit_tests_dump.py          |  181 ++++++++++++
>  tests/TestSuite_unit_tests_eal.py           |  409
> +++++++++++++++++++++++++++
>  6 files changed, 1172 insertions(+), 0 deletions(-)
>  create mode 100644 test_plans/unit_tests_cmdline_test_plan.rst
>  create mode 100644 test_plans/unit_tests_dump_test_plan.rst
>  create mode 100644 test_plans/unit_tests_eal_test_plan.rst
>  create mode 100644 tests/TestSuite_unit_tests_cmdline.py
>  create mode 100644 tests/TestSuite_unit_tests_dump.py
>  create mode 100644 tests/TestSuite_unit_tests_eal.py
> 
> diff --git a/test_plans/unit_tests_cmdline_test_plan.rst
> b/test_plans/unit_tests_cmdline_test_plan.rst
> new file mode 100644
> index 0000000..95702e0
> --- /dev/null
> +++ b/test_plans/unit_tests_cmdline_test_plan.rst
> @@ -0,0 +1,38 @@
> +.. Copyright (c) <2010>, Intel Corporation
> +   All rights reserved.
> +
> +   Redistribution and use in source and binary forms, with or without
> +   modification, are permitted provided that the following conditions
> +   are met:
> +
> +   - Redistributions of source code must retain the above copyright
> +     notice, this list of conditions and the following disclaimer.
> +
> +   - Redistributions in binary form must reproduce the above copyright
> +     notice, this list of conditions and the following disclaimer in
> +     the documentation and/or other materials provided with the
> +     distribution.
> +
> +   - Neither the name of Intel Corporation nor the names of its
> +     contributors may be used to endorse or promote products derived
> +     from this software without specific prior written permission.
> +
> +   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
> +   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
> +   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
> +   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
> +   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
> +   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> +   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
> +   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> +   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
> +   OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +==================
> +Cmdline  Autotests
> +==================
> +
> +
> +TODO.
> diff --git a/test_plans/unit_tests_dump_test_plan.rst
> b/test_plans/unit_tests_dump_test_plan.rst
> new file mode 100644
> index 0000000..23dd993
> --- /dev/null
> +++ b/test_plans/unit_tests_dump_test_plan.rst
> @@ -0,0 +1,169 @@
> +.. Copyright (c) <2014>, Intel Corporation
> +   All rights reserved.
> +
> +   Redistribution and use in source and binary forms, with or without
> +   modification, are permitted provided that the following conditions
> +   are met:
> +
> +   - Redistributions of source code must retain the above copyright
> +     notice, this list of conditions and the following disclaimer.
> +
> +   - Redistributions in binary form must reproduce the above copyright
> +     notice, this list of conditions and the following disclaimer in
> +     the documentation and/or other materials provided with the
> +     distribution.
> +
> +   - Neither the name of Intel Corporation nor the names of its
> +     contributors may be used to endorse or promote products derived
> +     from this software without specific prior written permission.
> +
> +   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
> +   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
> +   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
> +   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
> +   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
> +   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> +   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
> +   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> +   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
> +   OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +=========================
> +Dump log history Autotest
> +=========================
> +
> +This is the test plan for dump history log of Intel® DPDK .
> +
> +This section explains how to run the unit tests for dump history log. The
> test
> +can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_log_history
> +
> +The final output of the test will be the initial log of DPDK.
> +
> +==================
> +Dump ring Autotest
> +==================
> +
> +This is the test plan for dump the elements of Intel® DPDK ring.
> +
> +This section explains how to run the unit tests for dump elements of ring.
> +The test can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_ring
> +
> +The final output of the test will be detail elements of DPDK ring.
> +
> +=====================
> +Dump mempool Autotest
> +=====================
> +
> +This is the test plan for dump the elements of Intel® DPDK mempool.
> +
> +This section explains how to run the unit tests for dump elements of
> mempool.
> +The test can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_mempool
> +
> +The final output of the test will be detail elements of DPDK mempool.
> +
> +=============================
> +Dump Physical memory Autotest
> +=============================
> +
> +This is the test plan for dump the elements of Intel® DPDK physical
> memory.
> +
> +This section explains how to run the unit tests for dump elements of
> memory.
> +The test can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_physmem
> +
> +The final output of the test will be detail elements of DPDK physical
> memory.
> +
> +=====================
> +Dump Memzone Autotest
> +=====================
> +
> +This is the test plan for dump the elements of Intel® DPDK memzone.
> +
> +This section explains how to run the unit tests for dump elements of
> memzone.
> +The test can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_memzone
> +
> +The final output of the test will be detail elements of DPDK memzone.
> +
> +================
> +Dump Struct size
> +================
> +
> +This is the test plan for dump the size of Intel® DPDK structure.
> +
> +This section explains how to run the unit tests for dump structure size.
> +The test can be launched independently using the command line interface.
> +This test is implemented as a linuxapp environment application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +The steps to run the unit test manually are as follow::
> +
> +  # make -C ./app/test/
> +  # ./app/test/test -n 1 -c ffff
> +  RTE>> dump_struct_sizes
> +
> +The final output of the test will be the size of DPDK structure.
> diff --git a/test_plans/unit_tests_eal_test_plan.rst
> b/test_plans/unit_tests_eal_test_plan.rst
> new file mode 100644
> index 0000000..c1f8950
> --- /dev/null
> +++ b/test_plans/unit_tests_eal_test_plan.rst
> @@ -0,0 +1,315 @@
> +.. Copyright (c) <2010>, Intel Corporation
> +   All rights reserved.
> +
> +   Redistribution and use in source and binary forms, with or without
> +   modification, are permitted provided that the following conditions
> +   are met:
> +
> +   - Redistributions of source code must retain the above copyright
> +     notice, this list of conditions and the following disclaimer.
> +
> +   - Redistributions in binary form must reproduce the above copyright
> +     notice, this list of conditions and the following disclaimer in
> +     the documentation and/or other materials provided with the
> +     distribution.
> +
> +   - Neither the name of Intel Corporation nor the names of its
> +     contributors may be used to endorse or promote products derived
> +     from this software without specific prior written permission.
> +
> +   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
> +   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
> +   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
> +   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
> +   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
> +   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> +   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
> +   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> +   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
> +   OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +=============
> +EAL Autotests
> +=============
> +
> +This section describes the tests that are done to validate the EAL. Each
> +test can be launched independently using the command line
> +interface. These tests are implemented as a linuxapp environment
> +application.
> +
> +The complete test suite is launched automatically using a python-expect
> +script (launched using ``make test``) that sends commands to
> +the application and checks the results. A test report is displayed on
> +stdout.
> +
> +Version
> +=======
> +
> +To Be Filled
> +
> +
> +Common
> +=======
> +
> +To Be Filled
> +
> +Eal_fs
> +======
> +
> +To Be Filled
> +
> +Memory
> +======
> +
> +- Dump the mapped memory. The python-expect script checks that at
> +  least one line is dumped.
> +
> +- Check that memory size is different than 0.
> +
> +- Try to read all memory; it should not segfault.
> +
> +PCI
> +===
> +
> +- Register a driver with a ``devinit()`` function.
> +
> +- Dump all PCI devices.
> +
> +- Check that the ``devinit()`` function is called at least once.
> +
> +Per-lcore Variables and lcore Launch
> +====================================
> +
> +- Use ``rte_eal_mp_remote_launch()`` to call ``assign_vars()`` on
> +  every available lcore. In this function, a per-lcore variable is
> +  assigned to the lcore_id.
> +
> +- Use ``rte_eal_mp_remote_launch()`` to call ``display_vars()`` on
> +  every available lcore. The function checks that the variable is
> +  correctly set, or returns -1.
> +
> +- If at least one per-core variable was not correct, the test function
> +  returns -1.
> +
> +Spinlock
> +========
> +
> +- There is a global spinlock and a table of spinlocks (one per lcore).
> +
> +- The test function takes all of these locks and launches the
> +  ``test_spinlock_per_core()`` function on each core (except the master).
> +
> +  - The function takes the global lock, displays something, then releases
> +    the global lock.
> +  - The function takes the per-lcore lock, displays something, then
> releases
> +    the per-core lock.
> +
> +- The main function unlocks the per-lcore locks sequentially and
> +  waits between each lock. This triggers the display of a message
> +  for each core, in the correct order. The autotest script checks that
> +  this order is correct.
> +
> +Rwlock
> +======
> +
> +- There is a global rwlock and a table of rwlocks (one per lcore).
> +
> +- The test function takes all of these locks and launches the
> +  ``test_rwlock_per_core()`` function on each core (except the master).
> +
> +  - The function takes the global write lock, display something,
> +    then releases the global lock.
> +  - Then, it takes the per-lcore write lock, display something, and
> +    releases the per-core lock.
> +  - Finally, a read lock is taken during 100 ms, then released.
> +
> +- The main function unlocks the per-lcore locks sequentially and
> +  waits between each lock. This triggers the display of a message
> +  for each core, in the correct order.
> +
> +  Then, it tries to take the global write lock and display the last
> +  message. The autotest script checks that the message order is correct.
> +
> +Atomic Variables
> +================
> +
> +- The main test function performs three subtests. The first test
> +  checks that the usual inc/dec/add/sub functions are working
> +  correctly:
> +
> +  - Initialize 32-bit and 64-bit atomic variables to specific
> +    values.
> +
> +  - These variables are incremented and decremented on each core at
> +    the same time in ``test_atomic_usual()``.
> +
> +  - The function checks that once all lcores finish their function,
> +    the value of the atomic variables are still the same.
> +
> +- The second test verifies the behavior of "test and set" functions.
> +
> +  - Initialize 32-bit and 64-bit atomic variables to zero.
> +
> +  - Invoke ``test_atomic_tas()`` on each lcore before doing anything
> +    else. The cores are awaiting synchronizatioin using the ``while
> +    (rte_atomic32_read(&val) == 0)`` statement which is triggered by the
> +    main test function. Then all cores do an
> +    ``rte_atomicXX_test_and_set()`` at the same time. If it is successful,
> +    it increments another atomic counter.
> +
> +  - The main function checks that the atomic counter was incremented
> +    twice only (one for 32-bit and one for 64-bit values).
> +
> +- Test "add/sub and return"
> +
> +  - Initialize 32-bit and 64-bit atomic variables to zero.
> +
> +  - Invoke ``test_atomic_addsub_return()`` on each lcore. Before doing
> +    anything else, the cores are waiting a synchro. Each lcore does
> +    this operation several times::
> +
> +      tmp = atomic_add_return(&a, 1);
> +      atomic_add(&count, tmp);
> +      tmp = atomic_sub_return(&a, 1);
> +      atomic_sub(&count, tmp+1);
> +
> +  - At the end of the test, the *count* value must be 0.
> +
> +Prefetch
> +========
> +
> +Just test that the macro can be called and validate the compilation.
> +The test always return success.
> +
> +Byteorder functions
> +===================
> +
> +Check the result of optimized byte swap functions for each size (16-,
> +32- and 64-bit).
> +
> +Cycles Test
> +===========
> +
> +- Loop N times and check that the timer alway increments and
> +  never decrements during this loop.
> +
> +- Wait one second using rte_usleep() and check that the increment
> +  of cycles is correct with regard to the frequency of the timer.
> +
> +Logs
> +====
> +
> +- Enable log types.
> +- Set log level.
> +- Execute logging functions with different types and levels; some should
> +  not be displayed.
> +
> +Memzone
> +=======
> +
> +- Search for three reserved zones or reserve them if they do not exist:
> +
> +  - One is on any socket id.
> +  - The second is on socket 0.
> +  - The last one is on socket 1 (if socket 1 exists).
> +
> +- Check that the zones exist.
> +
> +- Check that the zones are cache-aligned.
> +
> +- Check that zones do not overlap.
> +
> +- Check that the zones are on the correct socket id.
> +
> +- Check that a lookup of the first zone returns the same pointer.
> +
> +- Check that it is not possible to create another zone with the
> +  same name as an existing zone.
> +
> +Memcpy
> +======
> +
> +Create two buffers, and initialise one with random values. These are
> copied
> +to the second buffer and then compared to see if the copy was successfull.
> +The bytes outside the copied area are also checked to make sure they were
> not
> +changed.
> +
> +This is repeated for a number of different sizes and offsets, with
> +the second buffer being cleared before each test.
> +
> +Debug test
> +==========
> +
> +- Call rte_dump_stack() and rte_dump_registers().
> +
> +Alarm
> +=====
> +
> +- Check that the callback for the alarm can to be called.
> +- Check that it is not possible to set alarm with invalid time value.
> +- Check that it is not possible to set alarm without a callback.
> +- Check that it is not possible to cancel alarm without a callback
> pointer.
> +- Check that multiple callbacks for the alarm can be called.
> +- Check that the number of removed and unremoved alarms are correct.
> +- Check that no callback is called if all alarm removed.
> +- Check that it is not possible to cancel an alarm within the callback
> itself.
> +- Check that the callback which is the head of all is able to be removed.
> +- Check that all alarms for the same callback can be cancelled.
> +
> +
> +CPU flags
> +=========
> +
> +- Using the rte_cpu_get_flag_enabled() checks for CPU features from
> different CPUID tables
> +- Checks if rte_cpu_get_flag_enabled() properly fails on trying to check
> for invalid feature
> +
> +
> +Errno
> +=====
> +
> +Performs validation on the error message strings provided by the
> rte_strerror() call, to ensure that suitable strings are returned for the
> rte-specific error codes, as well as ensuring that for standard error
> codes the correct error message is returned.
> +
> +Interrupts
> +==========
> +- Check that the callback for the specific interrupt can be called.
> +- Check that it is not possible to register a callback to an invalid
> interrupt handle.
> +- Check that it is not possible to register no callback to an interrupt
> handle.
> +- Check that it is not possible to unregister a callback to an invalid
> interrupt handle.
> +- Check that multiple callbacks are registered to the same interrupt
> handle.
> +- Check that it is not possible to unregister a callback with invalid
> parameter.
> +- Check that it is not possible to enable an interrupt with invalid
> handle or wrong handle type.
> +- Check that it is not possible to disable an interrupt with invalid
> handle or wrong handle type.
> +
> +
> +Multiprocess
> +============
> +
> +Validates that a secondary Intel DPDK instance can be run alongside a
> primary when the appropriate EAL command-line flags are passed. Also
> validates that secondary processes cannot interfere with primary processes
> by creating memory objects, such as mempools or rings.
> +
> +String
> +======
> +
> +Performs validation on the new string functions provided in
> rte_string_fns.h, ensuring that all values returned are NULL terminated,
> and that suitable errors are returned when called with invalid parameters.
> +
> +Tailq
> +=====
> +
> +Validates that we can create and perform lookups on named tail queues
> within the EAL for various object types. Also ensures appropriate error
> codes are returned from the functions if invalid parameters are passed.
> +
> +Devargs
> +=======
> +To Be Filled
> +
> +Kvargs
> +======
> +To Be Filled
> +
> +Acl
> +===
> +To Be Filled
> +
> +Link_bonding
> +============
> +To Be Filled
> diff --git a/tests/TestSuite_unit_tests_cmdline.py
> b/tests/TestSuite_unit_tests_cmdline.py
> new file mode 100644
> index 0000000..8a13703
> --- /dev/null
> +++ b/tests/TestSuite_unit_tests_cmdline.py
> @@ -0,0 +1,60 @@
> +# <COPYRIGHT_TAG>
> +
> +"""
> +DPDK Test suite.
> +
> +Cmdline autotest
> +
> +"""
> +
> +from test_case import TestCase
> +
> +#
> +#
> +# Test class.
> +#
> +
> +
> +class TestUnitTestsCmdline(TestCase):
> +
> +    #
> +    #
> +    #
> +    # Test cases.
> +    #
> +
> +    def set_up_all(self):
> +        """
> +        Run at the start of each test suite.
> +        """
> +        out = self.dut.build_dpdk_apps('./app/test/')
> +        self.verify('make: Leaving directory' in out, "Compilation
> failed")
> +
> +    def set_up(self):
> +        """
> +        Run before each test case.
> +        """
> +        pass
> +
> +    def test_cmdline(self):
> +        """
> +        Run cmdline autotests in RTE comand line.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("cmdline_autotest", "RTE>>", 10)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +        return 'SUCCESS'
> +
> +    def tear_down(self):
> +        """
> +        Run after each test case.
> +        """
> +        pass
> +
> +    def tear_down_all(self):
> +        """
> +        Run after each test suite.
> +        """
> +        pass
> diff --git a/tests/TestSuite_unit_tests_dump.py
> b/tests/TestSuite_unit_tests_dump.py
> new file mode 100644
> index 0000000..ffcb158
> --- /dev/null
> +++ b/tests/TestSuite_unit_tests_dump.py
> @@ -0,0 +1,181 @@
> +# <COPYRIGHT_TAG>
> +import re
> +
> +"""
> +DPDK Test suite.
> +
> +Run Inter-VM share memory autotests
> +"""
> +
> +
> +from test_case import TestCase
> +
> +#
> +#
> +# Test class.
> +#
> +
> +
> +class TestUnitTestsDump(TestCase):
> +
> +    #
> +    #
> +    #
> +    # Test cases.
> +    #
> +
> +    def set_up_all(self):
> +        """
> +        Run at the start of each test suite.
> +        Nothing to do here.
> +        """
> +        # Based on h/w type, choose how many ports to use
> +        self.dut_ports = self.dut.get_ports(self.nic)
> +        self.verify(len(self.dut_ports) >= 1, "Insufficient ports for
> testing")
> +
> +    def set_up(self):
> +        """
> +        Run before each test case.
> +        Nothing to do here.
> +        """
> +        pass
> +
> +    def test_log_dump(self):
> +        """
> +        Run history log dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_log_history", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("EAL" in out, "Test failed")
> +
> +    def test_ring_dump(self):
> +        """
> +        Run history log dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_ring", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        elements = ['ring', 'address', 'flags', 'size', 'ct', 'ch', 'pt',
> 'ph', 'used', 'avail', 'watermark']
> +        match_regex = "ring <(.*?)>@0x(.*)\r\n"
> +        for element in elements[2:]:
> +            match_regex += "  %s=(\d*)\r\n" % element
> +        m = re.compile(r"%s" % match_regex, re.S)
> +        result = m.search(out)
> +        ring_info = dict(zip(elements, result.groups()))
> +
> +        self.verify(ring_info['ring'] == 'MP_log_history', "Test failed")
> +
> +    def test_mempool_dump(self):
> +        """
> +        Run mempool dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_mempool", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        elements = ['mempool', 'address', 'flags', 'ring', 'phys_addr',
> 'size', 'header_size', 'elt_size',
> +                    'trailer_size', 'total_obj_size', 'private_data_size',
> 'pg_num', 'pg_shift', 'pg_mask',
> +                    'elt_va_start', 'elt_va_end', 'elt_pa\[0\]', 'avg
> bytes/object'
> +                    ]
> +        match_regex = "mempool <(.*?)>@0x(.*?)\r\n"
> +        for element in elements[2:]:
> +            match_regex += "  %s=(.*?)\r\n" % element
> +        m = re.compile(r"%s" % match_regex, re.S)
> +        result = m.search(out)
> +        mempool_info = dict(zip(elements, result.groups()))
> +
> +        self.verify(mempool_info['mempool'] == 'log_history', "Test
> failed")
> +
> +    def test_physmem_dump(self):
> +        """
> +        Run physical memory dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_physmem", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        elements = ['Segment', 'phys', 'len', 'virt', 'socket_id',
> 'hugepage_sz', 'nchannel', 'nrank']
> +        match_regex = "Segment (\d)+:"
> +        for element in elements[1:-1]:
> +            match_regex += " %s:(.*?)," % element
> +        match_regex += " %s:(.*?)\n" % elements[-1]
> +        m = re.compile(r"%s" % match_regex, re.DOTALL)
> +        results = m.findall(out)
> +        phy_info = []
> +        for result in results:
> +            phy_info.append(dict(zip(elements, result)))
> +
> +        self.verify(len(phy_info) > 0, "Test failed")
> +
> +    def test_memzone_dump(self):
> +        """
> +        Run memzone dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_memzone", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +
> +        elements = ['Zone', 'name', 'phys', 'len', 'virt', 'socket_id',
> 'flags']
> +        match_regex = "Zone (\d):"
> +        for element in elements[1:-1]:
> +            match_regex += " %s:(.*?)," % element
> +        match_regex += " %s:(.*?)\n" % elements[-1]
> +        m = re.compile(r"%s" % match_regex, re.DOTALL)
> +        results = m.findall(out)
> +
> +        memzone_info = []
> +        for result in results:
> +            memzone_info.append(dict(zip(elements, result)))
> +
> +        self.verify(len(memzone_info) > 0, "Test failed")
> +
> +    def test_dump_struct_size(self):
> +        """
> +        Run struct size dump test case.
> +        """
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff" % (self.target),
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_struct_sizes", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +
> +        elements = ['struct rte_mbuf', 'struct rte_mempool', 'struct
> rte_ring']
> +        match_regex = ""
> +        for element in elements[:-1]:
> +            match_regex += "sizeof\(%s\) = (\d+)\r\n" % element
> +        match_regex += "sizeof\(%s\) = (\d+)" % elements[-1]
> +        m = re.compile(r"%s" % match_regex, re.S)
> +        result = m.search(out)
> +        struct_info = dict(zip(elements, result.groups()))
> +
> +    def test_dump_devargs(self):
> +        """
> +        Run devargs dump test case.
> +        """
> +        test_port = self.dut_ports[0]
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff -b 0000:%s"
> +                             % (self.target,
> self.dut.ports_info[test_port]['pci']), "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_devargs", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        black_str = "PCI blacklist 0000:%s" %
> self.dut.ports_info[test_port]['pci']
> +        self.verify(black_str in out, "Dump black list failed")
> +
> +        self.dut.send_expect("./%s/app/test -n 1 -c ffff -w 0000:%s"
> +                             % (self.target,
> self.dut.ports_info[test_port]['pci']), "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("dump_devargs", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +
> +        white_str = "PCI whitelist 0000:%s" %
> self.dut.ports_info[test_port]['pci']
> +        self.verify(white_str in out, "Dump white list failed")
> +
> +    def tear_down(self):
> +        """
> +        Run after each test case.
> +        Stop application test after every case.
> +        """
> +        self.dut.kill_all()
> +        pass
> +
> +    def tear_down_all(self):
> +        """
> +        Run after each test suite.
> +        Nothing to do here.
> +        """
> +        pass
> diff --git a/tests/TestSuite_unit_tests_eal.py
> b/tests/TestSuite_unit_tests_eal.py
> new file mode 100644
> index 0000000..e36adc5
> --- /dev/null
> +++ b/tests/TestSuite_unit_tests_eal.py
> @@ -0,0 +1,409 @@
> +# <COPYRIGHT_TAG>
> +
> +"""
> +DPDK Test suite.
> +
> +EAL autotest.
> +
> +"""
> +
> +import dts
> +
> +
> +from test_case import TestCase
> +
> +#
> +#
> +# Test class.
> +#
> +
> +
> +class TestUnitTestsEal(TestCase):
> +
> +    #
> +    #
> +    #
> +    # Test cases.
> +    #
> +
> +    def set_up_all(self):
> +        """
> +        Run at the start of each test suite.
> +        """
> +        out = self.dut.build_dpdk_apps('./app/test/')
> +        self.verify('make: Leaving directory' in out, "Compilation
> failed")
> +        [arch, machine, self.env, toolchain] = self.target.split('-')
> +
> +    def set_up(self):
> +        """
> +        Run before each test case.
> +        """
> +        pass
> +
> +    def test_version(self):
> +        """
> +        Run version autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("version_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_memcopy(self):
> +        """
> +        Run memcopy autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("memcpy_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_common(self):
> +        """
> +        Run common autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("common_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_eal_fs(self):
> +        """
> +        Run memcopy autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("eal_fs_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_memcpy(self):
> +        """
> +        Run memcopy autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("memcpy_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_memcpy_perf(self):
> +        """
> +        Run memcopy performance autotest.
> +        """
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c ffff" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("memcpy_perf_autotest", "RTE>>", 240)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_hash(self):
> +        """
> +        Run hash autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("hash_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_hash_perf(self):
> +        """
> +        Run has performance autotest.
> +        """
> +
> +        self.dut.send_expect("%s ./app/test/test -n 1 -c fffe" %
> self.dut.taskset(1),
> +                             "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("hash_perf_autotest", "RTE>>", 600)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_malloc(self):
> +        """
> +        Run malloc autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("malloc_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_func_reentrancy(self):
> +        """
> +        Run function reentrancy autotest.
> +        """
> +
> +        if self.dut.architecture == "x86_64":
> +            cmdline = "./app/test/test -n 1 -c ffff"
> +        else:
> +            # mask cores only on socket 0
> +            cmdline = "%s ./app/test/test -n 1 -c 5555" %
> self.dut.taskset(1)
> +        self.dut.send_expect(cmdline, "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("func_reentrancy_autotest", "RTE>>",
> 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_pci(self):
> +        """
> +        Run pci autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("pci_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_atomic(self):
> +        """
> +        Run atomic autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("atomic_autotest", "RTE>>", 30)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_memory(self):
> +        """
> +        Run memory autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect('memory_autotest', "RTE>>", 20)
> +        regexp = "phys:0x[0-9a-f]*, len:([0-9a-f]*), virt:0x[0-9a-f]*,
> socket_id:[0-9]*"
> +        match = dts.regexp(out, regexp)
> +        size = int(match, 16)
> +        self.verify(size > 0, "bad size")
> +        self.dut.send_expect("quit", "# ")
> +
> +    def test_lcore_launch(self):
> +        """
> +        Run lcore autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("per_lcore_autotest", "RTE>>", 20)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_spinlock(self):
> +        """
> +        Run spinlock autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("spinlock_autotest", "RTE>>", 120)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_rwlock(self):
> +        """
> +        Run rwlock autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("rwlock_autotest", "RTE>>", 20)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_prefetch(self):
> +        """
> +        Run prefetch autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("prefetch_autotest", "RTE>>", 20)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_byteorder(self):
> +        """
> +        Run byte order autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("byteorder_autotest", "RTE>>", 10)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_cycles(self):
> +        """
> +        Run cycles autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("cycles_autotest", "RTE>>", 20)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_logs(self):
> +        """
> +        Run logs autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("logs_autotest", "RTE>>", 10)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_memzone(self):
> +        """
> +        Run memzone autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("memzone_autotest", "RTE>>", 10)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_debug(self):
> +        """
> +        Run debug autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("debug_autotest", "RTE>>", 10)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_flags(self):
> +        """
> +        Run eal flags autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff -m 64",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("eal_flags_autotest", "RTE>>", 40)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_alarm(self):
> +        """
> +        Run alarm autotest.
> +        """
> +
> +        self.verify(self.env == "linuxapp", "Alarm only supported in
> linux env")
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("alarm_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_cpuflags(self):
> +        """
> +        Run CPU flags autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("cpuflags_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_errno(self):
> +        """
> +        Run errno autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*TE>>|RT.*E>>|RTE.*>>|RTE>.*>", 20)
> +        out = self.dut.send_expect("errno_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_interrupts(self):
> +        """
> +        Run interrupt autotest.
> +        """
> +
> +        self.verify(self.env == "linuxapp", "Interrupt only supported in
> linux env")
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*TE>>|RT.*E>>|RTE.*>>|RTE>.*>", 20)
> +        out = self.dut.send_expect("interrupt_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_multiprocess(self):
> +        """
> +        Run multiprocess autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff -m 64",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("multiprocess_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_string(self):
> +        """
> +        Run string autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("string_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_tailq(self):
> +        """
> +        Run tailq autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("tailq_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_devargs(self):
> +        """
> +        Run devargs autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("devargs_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_kvargs(self):
> +        """
> +        Run kvargs autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("kvargs_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_acl(self):
> +        """
> +        Run acl autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("acl_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def test_link_bonding(self):
> +        """
> +        Run acl autotest.
> +        """
> +
> +        self.dut.send_expect("./app/test/test -n 1 -c ffff",
> "R.*T.*E.*>.*>", 10)
> +        out = self.dut.send_expect("link_bonding_autotest", "RTE>>", 60)
> +        self.dut.send_expect("quit", "# ")
> +        self.verify("Test OK" in out, "Test failed")
> +
> +    def tear_down(self):
> +        """
> +        Run after each test case.
> +        """
> +        pass
> +
> +    def tear_down_all(self):
> +        """
> +        Run after each test suite.
> +        """
> +        pass
> --
> 1.7.4.4