Acceptance tests: add Linux initrd checking test
PATCH 1/1 Acceptance tests: add Linux initrd checking test
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_t
This change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.py
tests/acceptance/linux_initrd.py new file +47 -0
@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile + +from avocado_qemu import Test +from avocado.utils.process import run + + +class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64 + """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB + and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1) + initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*' + self.assertRegex(res.stderr_text, expected_msg)
Signature · 1 line
2.17.2
Quoted 37 lines · Wainer dos Santos Moschetta
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_tThis change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
Signed-off-by Wainer dos Santos Moschetta <[email protected]>--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.pytests/acceptance/linux_initrd.py new file +12
-0@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile +
tests/acceptance/linux_initrd.py line 22
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+from avocado_qemu import Test +from avocado.utils.process import run + + +class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64
I'll let Cleber check if he wants we use 'tags=arch:x86_64' here.
Regardless:
Quoted 26 lines
tests/acceptance/linux_initrd.py new file +25
-0+ """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB + and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1) + initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*' + self.assertRegex(res.stderr_text, expected_msg)
Quoted 42 lines · Philippe Mathieu-Daudé
Quoted 41 lines · Wainer dos Santos Moschetta
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_tThis change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
Signed-off-by Wainer dos Santos Moschetta <[email protected]>--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.pytests/acceptance/linux_initrd.py new file +16
-0@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile + +from avocado_qemu import Test +from avocado.utils.process import run + +
Quoted 9 lines
tests/acceptance/linux_initrd.py line 22
Quoted 6 lines
tests/acceptance/linux_initrd.py new file +6
-0+class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64I'll let Cleber check if he wants we use 'tags=arch:x86_64' here.
Yes, I have no objections. Like I said elsewhere, most good standards are born like this.
- Cleber.
Quoted 31 lines
Regardless:
Reviewed-by Philippe Mathieu-Daudé <[email protected]>Quoted 26 lines
tests/acceptance/linux_initrd.py new file +25
-0+ """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB + and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1) + initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*' + self.assertRegex(res.stderr_text, expected_msg)
Signature · 4 lines
Cleber Rosa [ Sr Software Engineer - Virtualization Team - Red Hat ] [ Avocado Test Framework - avocado-framework.github.io ] [ 7ABB 96EB 8B46 B94D 5E0F E9BB 657E 8D33 A5F2 09F3 ]
Hi Wainer,
Quoted 13 lines · Wainer dos Santos Moschetta
[...]
tests/acceptance/linux_initrd.py new file +11
-0+ def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB + and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) +
tests/acceptance/linux_initrd.py line 47
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+ with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1) + initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*' + self.assertRegex(res.stderr_text, expected_msg)
At least on my run this test is the first one to fail (with error) due Python version (on Py2 there's no assertRegex method). AFIK we're moving towards only Py3 support on the acceptance tests, right? The current behavior (error) is the expected?
Since the comment above is just for clarification and not a blocking issue:
Signature · 4 lines
Caio Carrara Software Engineer, Virt Team Red Hat [email protected]
Quoted 27 lines · Caio Carrara
Hi Wainer,
Quoted 13 lines · Wainer dos Santos Moschetta
[...]
tests/acceptance/linux_initrd.py new file +11
-0+ def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB + and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) +tests/acceptance/linux_initrd.py line 47
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+ with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1) + initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*' + self.assertRegex(res.stderr_text, expected_msg)
Quoted 5 lines
At least on my run this test is the first one to fail (with error) due Python version (on Py2 there's no assertRegex method). AFIK we're moving towards only Py3 support on the acceptance tests, right? The current behavior (error) is the expected?
We have verbalized and agreed on that indeed. Wainer, can you please add a simple line in the acceptance tests documentation mentioning that?
- Cleber.
Quoted 5 lines
Since the comment above is just for clarification and not a blocking issue:
Reviewed-by Caio Carrara <[email protected]>Tested-by Caio Carrara <[email protected]>
Quoted 54 lines · Wainer dos Santos Moschetta
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_tThis change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
Signed-off-by Wainer dos Santos Moschetta <[email protected]>--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.pytests/acceptance/linux_initrd.py new file +29
-0@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile + +from avocado_qemu import Test +from avocado.utils.process import run + + +class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64 + """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GB
tests/acceptance/linux_initrd.py line 39
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+ and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1)
It's a style issue, but I'd go with spaces between operators:
initrd.seek(2048 * (1024 ** 2) - 1)
One other possibility that may improve code readability is:
from avocado.utils.data_structures import DataSize initrd.seek(DataSize('2G').b - 1)
Or finally, just set a "max_size" variable to the 2GB literal value.
tests/acceptance/linux_initrd.py line 46
Quoted 7 lines
tests/acceptance/linux_initrd.py new file +7
-0+ initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0) + expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*'
I'd be a bit more assertive here and do something like:
expected_msg = r'.*initrd is too large.*max: \d+, need %d\)' %
max_size
And if "134053887" (which appears in "max"), is a QEMU constant, that can be added there as well.
- Cleber.
Quoted 2 lines
tests/acceptance/linux_initrd.py new file +1
-0+ self.assertRegex(res.stderr_text, expected_msg)
Quoted 70 lines · Cleber Rosa
Quoted 54 lines · Wainer dos Santos Moschetta
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_tThis change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
Signed-off-by Wainer dos Santos Moschetta <[email protected]>--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.pytests/acceptance/linux_initrd.py new file +29
-0@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile + +from avocado_qemu import Test +from avocado.utils.process import run + + +class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64 + """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GBtests/acceptance/linux_initrd.py line 39
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+ and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1)It's a style issue, but I'd go with spaces between operators:
Quoted 7 lines
initrd.seek(2048 * (1024 ** 2) - 1)One other possibility that may improve code readability is:
from avocado.utils.data_structures import DataSize
initrd.seek(DataSize('2G').b - 1)
I'd agree if "2G" weren't ambiguous (I would expect it to mean 2,000,000,000, not 1,073,741,824).
I can live with the ambiguity of 2GB in the commit message, class name, and docstring. But having to look for the avocado.utils.data_structures.DataSize documentation to find out what's the file size makes the code less readable to me.
Quoted 8 lines
Or finally, just set a "
max_size" variable to the 2GB literal value.Quoted 6 lines
tests/acceptance/linux_initrd.py new file +6
-0+ initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0)
I would prefer to ensure exit code is 1. We don't want the test to pass if QEMU crashed with a signal, for example.
Quoted 9 lines
tests/acceptance/linux_initrd.py line 46
Quoted 1 line
tests/acceptance/linux_initrd.py new file +1
-0+ expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*'I'd be a bit more assertive here and do something like:
expected_msg = r'.*initrd is too large.*max: \d+, need %d\)' %
max_sizeAnd if "134053887" (which appears in "max"), is a QEMU constant, that can be added there as well.
I was going to suggest the opposite: just checking if the error message contains "initrd is too large". If we ensure the exit status is 1, the exact format of the error message isn't very important.
Signature · 1 line
Eduardo
Quoted 79 lines · Eduardo Habkost
Quoted 70 lines · Cleber Rosa
Quoted 54 lines · Wainer dos Santos Moschetta
QEMU used to exits with a not accurate error message when an initrd >= 2GB was passed. That was fixed on patch:
commit f3839fda5771596152b75dd1e1a6d050e6e6e380 Author: Li Zhijian <[email protected]> Date: Thu Sep 13 18:07:13 2018 +0800 change get_image_size return type to int64_tThis change adds a regression test for that fix. It starts QEMU with a 2GB dummy initrd, and check it evaluates the file size correctly and prints accurate message.
Signed-off-by Wainer dos Santos Moschetta <[email protected]>--- tests/acceptance/linux_initrd.py | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/acceptance/linux_initrd.pytests/acceptance/linux_initrd.py new file +29
-0@@ -0,0 +1,47 @@ +# Linux initrd acceptance test. +# +# Copyright (c) 2018 Red Hat, Inc. +# +# Author: +# Wainer dos Santos Moschetta <[email protected]> +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import tempfile + +from avocado_qemu import Test +from avocado.utils.process import run + + +class LinuxInitrd(Test): + """ + Checks QEMU evaluates correctly the initrd file passed as -initrd option. + + :avocado: enable + :avocado: tags=x86_64 + """ + + timeout = 60 + + def test_with_2GB_file_should_exit_error_msg(self): + """ + Pretends to boot QEMU with an initrd file with size of 2GBtests/acceptance/linux_initrd.py line 39
Quoted 10 lines
tests/acceptance/linux_initrd.py new file +10
-0+ and expect it exits with error message. + Regression test for bug fixed on commit f3839fda5771596152. + """ + kernel_url = ('https://mirrors.kernel.org/fedora/releases/28/' + 'Everything/x86_64/os/images/pxeboot/vmlinuz') + kernel_hash = '238e083e114c48200f80d889f7e32eeb2793e02a' + kernel_path = self.fetch_asset(kernel_url, asset_hash=kernel_hash) + + with tempfile.NamedTemporaryFile() as initrd: + initrd.seek(2048*(1024**2) -1)It's a style issue, but I'd go with spaces between operators:
Quoted 7 lines
initrd.seek(2048 * (1024 ** 2) - 1)One other possibility that may improve code readability is:
from avocado.utils.data_structures import DataSize
initrd.seek(DataSize('2G').b - 1)
Quoted 9 lines
I'd agree if "2G" weren't ambiguous (I would expect it to mean 2,000,000,000, not 1,073,741,824).
I can live with the ambiguity of 2GB in the commit message, class name, and docstring. But having to look for the avocado.utils.data_structures.DataSize documentation to find out what's the file size makes the code less readable to me.
Fair enough. The "G" here isn't clear about gibibyte/gigabyte.
Quoted 9 lines
Quoted 8 lines
Or finally, just set a "
max_size" variable to the 2GB literal value.Quoted 6 lines
tests/acceptance/linux_initrd.py new file +6
-0+ initrd.write(b'\0') + initrd.flush() + cmd = "%s -kernel %s -initrd %s" % (self.qemu_bin, kernel_path, + initrd.name) + res = run(cmd, ignore_status=True) + self.assertNotEqual(res.exit_status, 0)
Quoted 4 lines
I would prefer to ensure exit code is 1. We don't want the test to pass if QEMU crashed with a signal, for example.
Agreed.
Quoted 7 lines
Quoted 7 lines
tests/acceptance/linux_initrd.py line 46
Quoted 1 line
tests/acceptance/linux_initrd.py new file +1
-0+ expected_msg = r'.*initrd is too large.*max: \d+, need \d+.*'I'd be a bit more assertive here and do something like:
expected_msg = r'.*initrd is too large.*max: \d+, need %d\)' %
max_size
Quoted 8 lines
Quoted 2 lines
And if "134053887" (which appears in "max"), is a QEMU constant, that can be added there as well.
I was going to suggest the opposite: just checking if the error message contains "initrd is too large". If we ensure the exit status is 1, the exact format of the error message isn't very important.
It's certainly a matter of style here, and both are fine to me, but I'd rather have someone touching that part of the code to also have to touch the test if the message changes.
Note that I can't predict if this will eventually catch a regression that the simpler message you suggest wouldn't, but, I, personally, prefer to be safe than sorry.
- Cleber.
On Thu, Oct 18, 2018 at 07:52:58PM -0400, Cleber Rosa wrote:
[...]
Quoted 16 lines
Quoted 7 lines
Quoted 7 lines
Quoted 1 line
+
expected_msg= r'.*initrd is too large.*max: \d+, need \d+.*'I'd be a bit more assertive here and do something like:
expected_msg = r'.*initrd is too large.*max: \d+, need %d\)' %
max_sizeQuoted 8 lines
Quoted 2 lines
And if "134053887" (which appears in "max"), is a QEMU constant, that can be added there as well.
I was going to suggest the opposite: just checking if the error message contains "initrd is too large". If we ensure the exit status is 1, the exact format of the error message isn't very important.
Quoted 7 lines
It's certainly a matter of style here, and both are fine to me, but I'd rather have someone touching that part of the code to also have to touch the test if the message changes.
Note that I can't predict if this will eventually catch a regression that the simpler message you suggest wouldn't, but, I, personally, prefer to be safe than sorry.
I see your point, and I would probably prefer your approach if we already had QEMU developers used to writing and running acceptance tests once in a while.
Anyway, both approaches would be good enough to me.
Signature · 1 line
Eduardo