Hi,
here is the v4l-test 0.7 for LTP.
Changes: Test cases added for VIDIOC_G_AUDIO, VIDIOC_G_AUDOUT, VIDIOC_S_AUDIO
and VIDIOC_G_CROP. Added video_dummy kernel driver to verify the test
environment.
Some cleanup.
Signed-off-by: Márton Németh <[email protected]>
Regards,
Márton Németh
---
v4l-test project home page: http://v4l-test.sourceforge.net/
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/kernel_space/Makefile ltp/testcases/kernel/device-drivers/v4l/kernel_space/Makefile
--- ltp.orig/testcases/kernel/device-drivers/v4l/kernel_space/Makefile 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/kernel_space/Makefile 2009-02-08 11:57:08.000000000 +0100
@@ -0,0 +1,24 @@
+
+EXTRA_CFLAGS += -Wall -Wextra -Wno-unused-parameter
+
+ifneq ($(KERNELRELEASE),)
+
+obj-m := video_dummy.o
+else
+KDIR := /lib/modules/$(shell uname -r)/build
+PWD := $(shell pwd)
+
+modules:
+ $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
+
+clean:
+ $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean
+ rm -f modules.order
+
+help:
+ $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) help
+
+modules_install:
+ $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules_install
+
+endif
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/kernel_space/video_dummy.c ltp/testcases/kernel/device-drivers/v4l/kernel_space/video_dummy.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/kernel_space/video_dummy.c 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/kernel_space/video_dummy.c 2009-02-09 07:49:09.000000000 +0100
@@ -0,0 +1,106 @@
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-dev.h>
+
+
+struct dummy_dev {
+ struct video_device *vfd;
+};
+
+
+static int dummy_open(struct inode *inode, struct file *file)
+{
+ int minor = iminor(inode);
+
+ printk(KERN_DEBUG "video_dummy: open called (minor=%d)\n", minor);
+
+ return 0;
+}
+
+static int dummy_close(struct inode *inode, struct file *file)
+{
+ int minor = iminor(inode);
+
+ printk(KERN_DEBUG "video_dummy: close called (minor=%d)\n", minor);
+
+ return 0;
+}
+
+static int vidioc_querycap(struct file *file, void *priv,
+ struct v4l2_capability *cap)
+{
+ strcpy(cap->driver, "dummy");
+ strcpy(cap->card, "dummy");
+ cap->version = KERNEL_VERSION(0, 0, 1);
+ cap->capabilities = 0;
+ return 0;
+}
+
+static struct file_operations dummy_fops = {
+ .owner = THIS_MODULE,
+ .open = dummy_open,
+ .release = dummy_close,
+ .ioctl = video_ioctl2, /* V4L2 ioctl handler */
+ .compat_ioctl = v4l_compat_ioctl32,
+};
+
+
+static const struct v4l2_ioctl_ops dummy_ioctl_ops = {
+ .vidioc_querycap = vidioc_querycap,
+};
+
+static const struct video_device dummy_template = {
+ .name = "dummy",
+ .fops = &dummy_fops,
+ .ioctl_ops = &dummy_ioctl_ops,
+ .minor = -1,
+ .release = video_device_release,
+
+ .tvnorms = V4L2_STD_525_60,
+ .current_norm = V4L2_STD_NTSC_M,
+};
+
+static struct video_device *dummy_vfd = NULL;
+
+static int __init video_dummy_init(void)
+{
+ int ret;
+
+ dummy_vfd = video_device_alloc();
+ if (!dummy_vfd)
+ return -ENOMEM;
+
+ *dummy_vfd = dummy_template;
+
+ ret = video_register_device(dummy_vfd, VFL_TYPE_GRABBER, -1);
+ if (ret < 0) {
+ video_device_release(dummy_vfd);
+ dummy_vfd = NULL;
+ return ret;
+ }
+
+ printk(KERN_INFO "video_dummy: V4L2 device registered as /dev/video%d\n",
+ dummy_vfd->num);
+
+ return 0;
+}
+
+static void __exit video_dummy_exit(void)
+{
+
+ printk(KERN_INFO "video_dummy: removing /dev/video%d\n", dummy_vfd->num);
+ video_unregister_device(dummy_vfd);
+ dummy_vfd = NULL;
+
+}
+
+module_init(video_dummy_init);
+module_exit(video_dummy_exit);
+
+MODULE_DESCRIPTION("Dummy video module");
+MODULE_AUTHOR("Márton Németh <[email protected]>");
+MODULE_LICENSE("GPL");
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/index.html ltp/testcases/kernel/device-drivers/v4l/user_space/doc/index.html
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/index.html 2009-02-13 08:39:59.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/doc/index.html 2009-02-09 07:41:51.000000000 +0100
@@ -189,7 +189,7 @@ implemented test cases.</p>
</tr>
<tr>
<td>ioctl <a href="spec/r9539.htm">VIDIOC_S_AUDIO</a></td>
- <td>no</td>
+ <td>yes, only when STREAM_OFF</td>
<td>Opt.</td>
</tr>
<tr>
@@ -199,7 +199,7 @@ implemented test cases.</p>
</tr>
<tr>
<td>ioctl <a href="spec/r9688.htm">VIDIOC_S_AUDOUT</a></td>
- <td>no</td>
+ <td>yes, only when STREAM_OFF</td>
<td>Opt.</td>
</tr>
<tr>
@@ -219,7 +219,7 @@ implemented test cases.</p>
</tr>
<tr>
<td>ioctl <a href="spec/r10104.htm">VIDIOC_G_CTRL</a></td>
- <td>yes, only private and user controls; only user controls with V4L2_CTRL_FLAG_NEXT_CTRL</td>
+ <td>no</td>
<td><br></td>
</tr>
<tr>
@@ -364,7 +364,7 @@ implemented test cases.</p>
</tr>
<tr>
<td>ioctl <a href="spec/r12342.htm">VIDIOC_S_TUNER</a></td>
- <td>no</td>
+ <td>yes, only when STREAM_OFF</td>
<td><br></td>
</tr>
<tr>
@@ -492,12 +492,24 @@ So far I could find the following:
<p>
Please let me know if this list misses other V4L or V4L2 test project.
</p>
+<p>
+The following documents and articles are useful if you are dealing with V4L2:
+</p>
+<ul>
+ <li>
+ <a href="http://v4l2spec.bytesex.org/spec/";>Video for Linux Two API Specification</a>
+ </li>
+ <li>
+ <a href="http://lwn.net/Articles/203924/";>The Video4Linux2 API series</a> at
+ <a href="http://lwn.net/";>lwn.net</a>
+ </li>
+</ul>
<h2><a name="feedback">Feedbacks</a></h2>
<p>Any feedbacks, comments, ideas, etc. are welcome at the author's email address.</p>
<hr style="width: 100%; height: 2px;">
<p>Last changed:
-Tue Feb 3 22:20:46 2009
+Mon Feb 9 07:41:37 2009
</p>
<p>
<a href="http://validator.w3.org/check?uri=referer";><img
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/Makefile ltp/testcases/kernel/device-drivers/v4l/user_space/Makefile
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/Makefile 2009-02-13 08:39:58.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/Makefile 2009-02-07 21:22:49.000000000 +0100
@@ -1,6 +1,7 @@
#
# v4l-test: Test environment for Video For Linux Two API
#
+# 7 Feb 2009 0.8 test_VIDIOC_CROP.c added
# 3 Feb 2009 0.7 test_VIDIOC_AUDIO.c added,
# test_VIDIOC_AUDOUT.c added,
# 2 Feb 2009 0.6 test_VIDIOC_MODULATOR.c added,
@@ -36,6 +37,7 @@ OBJS = dev_video.o \
test_VIDIOC_ENUMSTD.o \
test_VIDIOC_LOG_STATUS.o \
test_VIDIOC_CROPCAP.o \
+ test_VIDIOC_CROP.o \
test_VIDIOC_QUERYCTRL.o \
test_VIDIOC_QUERYSTD.o \
test_VIDIOC_STD.o \
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/README ltp/testcases/kernel/device-drivers/v4l/user_space/README
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/README 2009-02-13 08:39:58.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/README 2009-02-09 08:32:19.000000000 +0100
@@ -4,6 +4,11 @@
Release History
---------------
+ 9 Feb 2009 0.10 Test cases added for VIDIOC_G_AUDIO, VIDIOC_G_AUDOUT,
+ VIDIOC_S_AUDIO and VIDIOC_G_CROP;
+ Added video_dummy kernel driver to verify the test
+ environment;
+ Some cleanup
4 Feb 2009 0.6 Test cases added for VIDIOC_G_AUDIO, VIDIOC_G_AUDOUT,
VIDIOC_G_MODULATOR, VIDIOC_G_PRIORITY, VIDIOC_S_PRIORITY
and VIDIOC_S_FREQUENCY
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.c 2009-02-03 21:55:45.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.c 2009-02-09 08:24:45.000000000 +0100
@@ -1,6 +1,8 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.3 Typo corrected; added some debug messages
+ * 7 Feb 2009 0.2 Test case test_VIDIOC_G_AUDIO_ignore_index added
* 3 Feb 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -61,7 +63,7 @@ void test_VIDIOC_G_AUDIO() {
memset(&audio, 0xff, sizeof(audio));
ret = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio);
- dprintf("VIDIOC_AUDIO, ret=%i\n", ret);
+ dprintf("VIDIOC_G_AUDIO, ret=%i\n", ret);
if (ret == 0) {
CU_ASSERT_EQUAL(ret, 0);
@@ -103,6 +105,43 @@ void test_VIDIOC_G_AUDIO() {
}
+void test_VIDIOC_G_AUDIO_ignore_index() {
+ int ret1;
+ int errno1;
+ int ret2;
+ int errno2;
+ struct v4l2_audio audio;
+ struct v4l2_audio audio2;
+
+ /* check whether the "index" field is ignored by VIDIOC_G_AUDIO */
+
+ memset(&audio, 0, sizeof(audio));
+ dprintf("&audio=%p\n", &audio);
+ dprintf("audio.index=%u\n", audio.index);
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ memset(&audio2, 0, sizeof(audio2));
+ audio2.index = U32_MAX;
+ ret2 = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio2);
+ errno2 = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret2, 0);
+ CU_ASSERT_EQUAL(memcmp(&audio, &audio2, sizeof(audio)), 0);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
+
+}
+
void test_VIDIOC_G_AUDIO_NULL() {
int ret1;
int errno1;
@@ -136,3 +175,302 @@ void test_VIDIOC_G_AUDIO_NULL() {
}
}
+
+void test_VIDIOC_S_AUDIO() {
+ int ret_orig, errno_orig;
+ int ret;
+ __u32 index;
+ __u32 i;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_enum;
+ struct v4l2_audio audio_set;
+
+ /* This testcase tries to find out the relations between the following
+ * commands:
+ * - VIDIOC_ENUMAUDIO
+ * - VIDIOC_G_AUDIO
+ * - VIDIOC_S_AUDIO
+ */
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ if (ret_orig == 0) {
+ CU_ASSERT_EQUAL(ret_orig, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret_orig, -1);
+ CU_ASSERT_EQUAL(errno_orig, EINVAL);
+ }
+
+ /* try to continue even if VIDIOC_G_AUDIO seems to be not supported */
+
+ index = 0;
+ do {
+ memset(&audio_enum, 0, sizeof(audio_enum));
+ audio_enum.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_ENUMAUDIO, &audio_enum);
+
+ if (ret == 0) {
+ memset(&audio_set, 0xff, sizeof(audio_set));
+ audio_set.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+
+ /* It shall be always possible to set the audio input to the
+ * enumerated values.
+ */
+ CU_ASSERT_EQUAL(ret, 0);
+
+ index++;
+ }
+
+ } while (ret == 0);
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* try to set audio input to beyond the enumerated values */
+ for (i=0; i<=32; i++) {
+ memset(&audio_set, 0xff, sizeof(audio_set));
+ audio_set.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ index++;
+ }
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDIO shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+ }
+
+}
+
+void test_VIDIOC_S_AUDIO_S32_MAX() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audio audio;
+ struct v4l2_audio audio2;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_set;
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ /* test invalid index */
+ memset(&audio, 0xff, sizeof(audio));
+ audio.index = (__u32)S32_MAX;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audio struct is untouched */
+ memset(&audio2, 0xff, sizeof(audio2));
+ audio2.index = (__u32)S32_MAX;
+ CU_ASSERT_EQUAL(memcmp(&audio, &audio2, sizeof(audio)), 0);
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDIO, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDIO shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+void test_VIDIOC_S_AUDIO_S32_MAX_1() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audio audio;
+ struct v4l2_audio audio2;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_set;
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ /* test invalid index */
+ memset(&audio, 0xff, sizeof(audio));
+ audio.index = ((__u32)S32_MAX)+1;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audio struct is untouched */
+ memset(&audio2, 0xff, sizeof(audio2));
+ audio2.index = ((__u32)S32_MAX)+1;
+ CU_ASSERT_EQUAL(memcmp(&audio, &audio2, sizeof(audio)), 0);
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDIO, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDIO shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+
+void test_VIDIOC_S_AUDIO_U32_MAX() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audio audio;
+ struct v4l2_audio audio2;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_set;
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDIO, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+ /* test invalid index */
+ memset(&audio, 0xff, sizeof(audio));
+ audio.index = U32_MAX;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audio struct is untouched */
+ memset(&audio2, 0xff, sizeof(audio2));
+ audio2.index = U32_MAX;
+ CU_ASSERT_EQUAL(memcmp(&audio, &audio2, sizeof(audio)), 0);
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDIO, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDIO shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+void test_VIDIOC_S_AUDIO_NULL() {
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ int ret1, errno1;
+ int ret2, errno2;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_set;
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDIO, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("\tVIDIOC_G_AUDIO, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ memset(&audio_set, 0, sizeof(audio_set));
+ ret1 = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+ errno1 = errno;
+
+ dprintf("\tVIDIOC_S_AUDIO, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ ret2 = ioctl(get_video_fd(), VIDIOC_S_AUDIO, NULL);
+ errno2 = errno;
+
+ dprintf("\tVIDIOC_S_AUDIO, ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EFAULT);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDIO, &audio_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDIO, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDIO shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.h ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.h 2009-02-03 21:30:34.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDIO.h 2009-02-07 14:50:47.000000000 +0100
@@ -1,6 +1,7 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 7 Feb 2009 0.2 Test case test_VIDIOC_G_AUDIO_ignore_index added
* 3 Feb 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -8,4 +9,11 @@
*/
void test_VIDIOC_G_AUDIO(void);
+void test_VIDIOC_G_AUDIO_ignore_index(void);
void test_VIDIOC_G_AUDIO_NULL(void);
+
+void test_VIDIOC_S_AUDIO(void);
+void test_VIDIOC_S_AUDIO_S32_MAX(void);
+void test_VIDIOC_S_AUDIO_S32_MAX_1(void);
+void test_VIDIOC_S_AUDIO_U32_MAX(void);
+void test_VIDIOC_S_AUDIO_NULL(void);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.c 2009-02-03 22:07:52.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.c 2009-02-09 08:27:29.000000000 +0100
@@ -1,6 +1,8 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.3 Typo corrected; added some debug messages
+ * 7 Feb 2009 0.2 Test case test_VIDIOC_G_AUDOUT_ignore_index added
* 3 Feb 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -90,6 +92,42 @@ void test_VIDIOC_G_AUDOUT() {
}
+void test_VIDIOC_G_AUDOUT_ignore_index() {
+ int ret1;
+ int errno1;
+ int ret2;
+ int errno2;
+ struct v4l2_audioout audioout;
+ struct v4l2_audioout audioout2;
+
+ /* check whether the "index" field is ignored by VIDIOC_G_AUDOUT */
+
+ memset(&audioout, 0, sizeof(audioout));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ memset(&audioout2, 0, sizeof(audioout2));
+ audioout2.index = U32_MAX;
+ ret2 = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout2);
+ errno2 = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret2, 0);
+ CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
+
+}
+
+
void test_VIDIOC_G_AUDOUT_NULL() {
int ret1;
int errno1;
@@ -127,3 +165,302 @@ void test_VIDIOC_G_AUDOUT_NULL() {
/* TODO: - try with all possible outputs (VIDIOC_ENUMOUTPUT)
* - try with STREAM_ON
*/
+
+void test_VIDIOC_S_AUDOUT() {
+ int ret_orig, errno_orig;
+ int ret;
+ __u32 index;
+ __u32 i;
+ struct v4l2_audioout audioout_orig;
+ struct v4l2_audioout audioout_enum;
+ struct v4l2_audioout audioout_set;
+
+ /* This testcase tries to find out the relations between the following
+ * commands:
+ * - VIDIOC_ENUMAUDOUT
+ * - VIDIOC_G_AUDOUT
+ * - VIDIOC_S_AUDOUT
+ */
+
+ /* remember the original settings */
+ memset(&audioout_orig, 0, sizeof(audioout_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ if (ret_orig == 0) {
+ CU_ASSERT_EQUAL(ret_orig, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret_orig, -1);
+ CU_ASSERT_EQUAL(errno_orig, EINVAL);
+ }
+
+ /* try to continue even if VIDIOC_G_AUDOUT seems to be not supported */
+
+ index = 0;
+ do {
+ memset(&audioout_enum, 0, sizeof(audioout_enum));
+ audioout_enum.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_ENUMAUDOUT, &audioout_enum);
+
+ if (ret == 0) {
+ memset(&audioout_set, 0xff, sizeof(audioout_set));
+ audioout_set.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+
+ /* It shall be always possible to set the audio output to the
+ * enumerated values.
+ */
+ CU_ASSERT_EQUAL(ret, 0);
+
+ index++;
+ }
+
+ } while (ret == 0);
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* try to set audio output to beyond the enumerated values */
+ for (i=0; i<=32; i++) {
+ memset(&audioout_set, 0xff, sizeof(audioout_set));
+ audioout_set.index = index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ index++;
+ }
+
+ /* restore the original audio output settings */
+ memset(&audioout_set, 0, sizeof(audioout_set));
+ audioout_set.index = audioout_orig.index;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio output then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ /* In case we could not fetch the audio output value at the start
+ * of this test case: the VIDIOC_S_AUDOUT shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+ }
+
+}
+
+void test_VIDIOC_S_AUDOUT_S32_MAX() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audioout audioout;
+ struct v4l2_audioout audioout2;
+ struct v4l2_audioout audioout_orig;
+ struct v4l2_audioout audioout_set;
+
+ /* remember the original settings */
+ memset(&audioout_orig, 0, sizeof(audioout_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ /* test invalid index */
+ memset(&audioout, 0xff, sizeof(audioout));
+ audioout.index = (__u32)S32_MAX;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audioout struct is untouched */
+ memset(&audioout2, 0xff, sizeof(audioout2));
+ audioout2.index = (__u32)S32_MAX;
+ CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
+
+ /* restore the original audio output settings */
+ memset(&audioout_set, 0, sizeof(audioout_set));
+ audioout_set.index = audioout_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio output then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio output value at the start
+ * of this test case: the VIDIOC_S_AUDOUT shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+void test_VIDIOC_S_AUDOUT_S32_MAX_1() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audioout audioout;
+ struct v4l2_audioout audioout2;
+ struct v4l2_audioout audioout_orig;
+ struct v4l2_audioout audioout_set;
+
+ /* remember the original settings */
+ memset(&audioout_orig, 0, sizeof(audioout_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ /* test invalid index */
+ memset(&audioout, 0xff, sizeof(audioout));
+ audioout.index = ((__u32)S32_MAX)+1;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audioout struct is untouched */
+ memset(&audioout2, 0xff, sizeof(audioout2));
+ audioout2.index = ((__u32)S32_MAX)+1;
+ CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
+
+ /* restore the original audio output settings */
+ memset(&audioout_set, 0, sizeof(audioout_set));
+ audioout_set.index = audioout_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio output then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio output value at the start
+ * of this test case: the VIDIOC_S_AUDOUT shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+
+void test_VIDIOC_S_AUDOUT_U32_MAX() {
+ int ret;
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ struct v4l2_audioout audioout;
+ struct v4l2_audioout audioout2;
+ struct v4l2_audioout audioout_orig;
+ struct v4l2_audioout audioout_set;
+
+ /* remember the original settings */
+ memset(&audioout_orig, 0, sizeof(audioout_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
+ errno_orig = errno;
+
+ dprintf("VIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+ /* test invalid index */
+ memset(&audioout, 0xff, sizeof(audioout));
+ audioout.index = U32_MAX;
+ ret = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+
+ /* Check whether the original audioout struct is untouched */
+ memset(&audioout2, 0xff, sizeof(audioout2));
+ audioout2.index = U32_MAX;
+ CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
+
+ /* restore the original audio output settings */
+ memset(&audioout_set, 0, sizeof(audioout_set));
+ audioout_set.index = audioout_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio output then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio output value at the start
+ * of this test case: the VIDIOC_S_AUDOUT shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
+
+void test_VIDIOC_S_AUDOUT_NULL() {
+ int ret_orig, errno_orig;
+ int ret_set, errno_set;
+ int ret1, errno1;
+ int ret2, errno2;
+ struct v4l2_audio audio_orig;
+ struct v4l2_audio audio_set;
+
+ /* remember the original settings */
+ memset(&audio_orig, 0, sizeof(audio_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audio_orig);
+ errno_orig = errno;
+
+ dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig, errno_orig);
+
+ memset(&audio_set, 0, sizeof(audio_set));
+ ret1 = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audio_set);
+ errno1 = errno;
+
+ dprintf("\tVIDIOC_S_AUDOUT, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ ret2 = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, NULL);
+ errno2 = errno;
+
+ dprintf("\tVIDIOC_S_AUDOUT, ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EFAULT);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
+
+ /* restore the original audio input settings */
+ memset(&audio_set, 0, sizeof(audio_set));
+ audio_set.index = audio_orig.index;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audio_set);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ if (ret_orig == 0) {
+ /* If it was possible at the beginning to get the audio input then
+ * it shall be possible to set it again.
+ */
+ CU_ASSERT_EQUAL(ret_set, 0);
+ } else {
+ /* In case we could not fetch the audio input value at the start
+ * of this test case: the VIDIOC_S_AUDOUT shall also fail.
+ */
+ CU_ASSERT_EQUAL(ret_set, -1);
+ CU_ASSERT_EQUAL(errno_set, EINVAL);
+ }
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.h ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.h 2009-02-03 22:04:56.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_AUDOUT.h 2009-02-07 15:03:14.000000000 +0100
@@ -1,6 +1,7 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 7 Feb 2009 0.2 Test case test_VIDIOC_G_AUDOUT_ignore_index added
* 3 Feb 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -8,4 +9,11 @@
*/
void test_VIDIOC_G_AUDOUT(void);
+void test_VIDIOC_G_AUDOUT_ignore_index(void);
void test_VIDIOC_G_AUDOUT_NULL(void);
+
+void test_VIDIOC_S_AUDOUT(void);
+void test_VIDIOC_S_AUDOUT_S32_MAX(void);
+void test_VIDIOC_S_AUDOUT_S32_MAX_1(void);
+void test_VIDIOC_S_AUDOUT_U32_MAX(void);
+void test_VIDIOC_S_AUDOUT_NULL(void);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.c 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.c 2009-02-07 21:29:05.000000000 +0100
@@ -0,0 +1,77 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 7 Feb 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+
+#include <linux/videodev2.h>
+#include <linux/errno.h>
+
+#include <CUnit/CUnit.h>
+
+#include "v4l2_test.h"
+#include "dev_video.h"
+#include "video_limits.h"
+
+#include "test_VIDIOC_CROP.h"
+
+
+void test_VIDIOC_G_CROP() {
+ int ret1, errno1;
+ struct v4l2_crop crop;
+
+ memset(&crop, 0xff, sizeof(crop));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_CROP, &crop);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_CROP ret1=%i, errno1=%i\n", ret1, errno1);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+
+ }
+
+}
+
+void test_VIDIOC_G_CROP_NULL() {
+ int ret1, errno1;
+ int ret2, errno2;
+ struct v4l2_crop crop;
+
+ memset(&crop, 0xff, sizeof(crop));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_CROP, &crop);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_CROP ret1=%i, errno1=%i\n", ret1, errno1);
+
+ memset(&crop, 0xff, sizeof(crop));
+ ret2 = ioctl(get_video_fd(), VIDIOC_G_CROP, NULL);
+ errno2 = errno;
+
+ dprintf("VIDIOC_G_CROP ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EFAULT);
+
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+
+ }
+
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROPCAP.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROPCAP.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROPCAP.c 2009-02-13 08:39:58.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROPCAP.c 2009-02-09 07:56:16.000000000 +0100
@@ -1,6 +1,8 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.3 Modify test_VIDIOC_CROPCAP_enum_INPUT() to support drivers
+ * without any inputs
* 3 Feb 2009 0.2 Typo fixed
* 21 Dec 2008 0.1 First release
*
@@ -151,8 +153,8 @@ void test_VIDIOC_CROPCAP_enum_INPUT() {
memset(&input_index_orig, 0xff, sizeof(input_index_orig));
ret = ioctl(f, VIDIOC_G_INPUT, &input_index_orig);
- CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
+ CU_ASSERT_EQUAL(ret, 0);
i = 0;
do {
memset(&input, 0xff, sizeof(input));
@@ -176,6 +178,9 @@ void test_VIDIOC_CROPCAP_enum_INPUT() {
/* Setting the original input_id should not fail */
ret = ioctl(f, VIDIOC_S_INPUT, &input_index_orig);
CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
}
}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.h ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.h 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_CROP.h 2009-02-07 21:22:01.000000000 +0100
@@ -0,0 +1,11 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 7 Feb 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+void test_VIDIOC_G_CROP(void);
+void test_VIDIOC_G_CROP_NULL(void);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_INPUT.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_INPUT.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_INPUT.c 2009-01-04 12:45:22.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_INPUT.c 2009-02-09 08:16:18.000000000 +0100
@@ -1,6 +1,7 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.3 Modify test cases to support drivers without any inputs
* 22 Dec 2008 0.2 Test case with NULL parameter added
* 18 Dec 2008 0.1 First release
*
@@ -63,14 +64,17 @@ void test_VIDIOC_G_INPUT() {
memset(&index, 0xff, sizeof(index));
ret = ioctl(f, VIDIOC_G_INPUT, &index);
- dprintf("VIDIOC_G_INPUT, ret=%i\n", ret);
+ dprintf("\tVIDIOC_G_INPUT, ret=%i, errno=%i\n", ret, errno);
- CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
+ CU_ASSERT_EQUAL(ret, 0);
CU_ASSERT(valid_input_index(f, index));
- dprintf("index=0x%X\n", index);
+ dprintf("\tindex=0x%X\n", index);
+ } else {
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
}
}
@@ -87,8 +91,9 @@ void test_VIDIOC_S_INPUT_from_enum() {
memset(&input_index_orig, 0xff, sizeof(input_index_orig));
ret = ioctl(f, VIDIOC_G_INPUT, &input_index_orig);
- CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
+ CU_ASSERT_EQUAL(ret, 0);
+
i = 0;
do {
memset(&input, 0xff, sizeof(input));
@@ -110,6 +115,9 @@ void test_VIDIOC_S_INPUT_from_enum() {
/* Setting the original input_id should not fail */
ret = ioctl(f, VIDIOC_S_INPUT, &input_index_orig);
CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
}
}
@@ -145,8 +153,8 @@ void test_VIDIOC_S_INPUT_invalid_inputs(
memset(&input_index_orig, 0xff, sizeof(input_index_orig));
ret = ioctl(f, VIDIOC_G_INPUT, &input_index_orig);
- CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
+ CU_ASSERT_EQUAL(ret, 0);
i = 0;
do {
memset(&input, 0xff, sizeof(input));
@@ -181,15 +189,38 @@ void test_VIDIOC_S_INPUT_invalid_inputs(
/* Setting the original input_id should not fail */
ret = ioctl(f, VIDIOC_S_INPUT, &input_index_orig);
CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
}
}
void test_VIDIOC_G_INPUT_NULL() {
- int ret;
+ int ret1, errno1;
+ int ret2, errno2;
+ __u32 index;
- ret = ioctl(get_video_fd(), VIDIOC_G_INPUT, NULL);
- CU_ASSERT_EQUAL(ret, -1);
- CU_ASSERT_EQUAL(errno, EFAULT);
+ memset(&index, 0xff, sizeof(index));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_INPUT, &index);
+ errno1 = errno;
+
+ dprintf("\tVIDIOC_G_INPUT, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ ret2 = ioctl(get_video_fd(), VIDIOC_G_INPUT, NULL);
+ errno2 = errno;
+
+ dprintf("\tVIDIOC_G_INPUT: ret2=%i, errno2=%i\n", ret2, errno2);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EFAULT);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_STD.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_STD.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_STD.c 2009-01-30 21:50:13.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_STD.c 2009-02-09 08:09:37.000000000 +0100
@@ -1,6 +1,8 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.3 Modify test cases to support drivers without any inputs;
+ * cleanup debug printouts
* 30 Jan 2009 0.5 valid_v4l2_std_id() moved to v4l2_validator.c
* 18 Jan 2009 0.4 Typo corrected
* 23 Dec 2008 0.3 Debug messages added
@@ -39,13 +41,13 @@ void test_VIDIOC_G_STD() {
memset(&std_id, 0xff, sizeof(std_id));
ret = ioctl(get_video_fd(), VIDIOC_G_STD, &std_id);
- dprintf("VIDIOC_G_STD, ret=%i\n", ret);
+ dprintf("\tVIDIOC_G_STD, ret=%i\n", ret);
CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
CU_ASSERT(valid_v4l2_std_id(std_id));
- dprintf("std_id=0x%llX\n", std_id);
+ dprintf("\tstd_id=0x%llX\n", std_id);
}
@@ -67,7 +69,7 @@ static int do_set_video_standard(int f,
CU_ASSERT( (id & std_id) == id);
if (std_id != id) {
- dprintf("ret=%i, errno=%i, std_id=0x%llX, id=0x%llX\n", ret, errno, std_id, id);
+ dprintf("\tret=%i, errno=%i, std_id=0x%llX, id=0x%llX\n", ret, errno, std_id, id);
}
}
@@ -76,7 +78,7 @@ static int do_set_video_standard(int f,
CU_ASSERT_EQUAL(errno, EINVAL);
if (ret_set != -1) {
- dprintf("ret_set=%i, errno=%i\n", ret_set, errno);
+ dprintf("\tret_set=%i, errno=%i\n", ret_set, errno);
}
}
@@ -92,8 +94,9 @@ void test_VIDIOC_S_STD() {
memset(&std_id_orig, 0xff, sizeof(std_id_orig));
ret = ioctl(f, VIDIOC_G_STD, &std_id_orig);
- CU_ASSERT_EQUAL(ret, 0);
if (ret == 0) {
+ CU_ASSERT_EQUAL(ret, 0);
+
ret = do_set_video_standard(f, V4L2_STD_PAL_B);
ret = do_set_video_standard(f, V4L2_STD_PAL_B1);
ret = do_set_video_standard(f, V4L2_STD_PAL_G);
@@ -124,6 +127,9 @@ void test_VIDIOC_S_STD() {
/* Setting the original std_id should not fail */
ret = do_set_video_standard(f, std_id_orig);
CU_ASSERT_EQUAL(ret, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
}
}
@@ -148,19 +154,21 @@ void test_VIDIOC_S_STD_from_enum() {
std.index = i;
enum_ret = ioctl(f, VIDIOC_ENUMSTD, &std);
- dprintf("ENUMSTD: i=%u, enum_ret=%i, errno=%i\n", i, enum_ret, errno);
+ dprintf("\tENUMSTD: i=%u, enum_ret=%i, errno=%i\n", i, enum_ret, errno);
if (enum_ret == 0) {
ret = do_set_video_standard(f, std.id);
CU_ASSERT_EQUAL(ret, 0);
- dprintf("std.id=0x%llX, ret=%i\n", std.id, ret);
+ dprintf("\tstd.id=0x%llX, ret=%i\n", std.id, ret);
}
i++;
} while (enum_ret == 0 && i != 0);
/* Setting the original std_id should not fail */
ret = do_set_video_standard(f, std_id_orig);
+ dprintf("\tVIDIOC_S_STD: ret=%i (expected %i), errno=%i\n",
+ ret, 0, errno);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -185,13 +193,14 @@ void test_VIDIOC_S_STD_invalid_standard(
ret = do_set_video_standard(f, std_id);
CU_ASSERT_EQUAL(ret, -1);
CU_ASSERT_EQUAL(errno, EINVAL);
- dprintf("ret=%i, errno=%i\n", ret, errno);
+ dprintf("\tVIDIOC_S_STD: ret=%i, errno=%i\n", ret, errno);
}
std_id = std_id<<1;
}
/* Setting the original std_id should not fail */
ret = do_set_video_standard(f, std_id_orig);
+ dprintf("\tVIDIOC_S_STD: ret=%i (expected 0), errno=%i\n", ret, errno);
CU_ASSERT_EQUAL(ret, 0);
}
}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.c 2009-02-13 08:39:59.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.c 2009-02-09 08:44:06.000000000 +0100
@@ -1,6 +1,9 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 9 Feb 2009 0.2 Added test cases for VIDIOC_S_TUNER;
+ * Some typos corrected;
+ * Add some debug messages
* 31 Jan 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -236,6 +239,7 @@ void test_VIDIOC_G_TUNER_NULL() {
tuner.index = 0;
ret1 = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner);
errno1 = errno;
+ dprintf("\t%s:%u: VIDIOC_G_TUNER: ret1=%i, errno1=%i\n", __FILE__, __LINE__, ret1, errno1);
ret2 = ioctl(get_video_fd(), VIDIOC_G_TUNER, NULL);
@@ -256,3 +260,229 @@ void test_VIDIOC_G_TUNER_NULL() {
}
}
+
+void do_set_tuner_audmode(__u32 index, __u32 audmode) {
+ int ret;
+ struct v4l2_tuner tuner;
+
+ memset(&tuner, 0xff, sizeof(tuner));
+ tuner.index = index;
+ tuner.audmode = audmode;
+ ret = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
+
+ dprintf("VIDIOC_S_TUNER: index=%u, audmode=%u, "
+ "ret=%i (expected %i), errno=%i\n",
+ index, audmode, ret, 0, errno);
+
+ CU_ASSERT_EQUAL(ret, 0);
+
+}
+
+void do_set_tuner_audmode_invalid(__u32 index, __u32 audmode) {
+ int ret;
+ struct v4l2_tuner tuner;
+
+ memset(&tuner, 0xff, sizeof(tuner));
+ tuner.index = index;
+ tuner.audmode = audmode;
+ ret = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
+
+ dprintf("VIDIOC_S_TUNER: index=%u, audmode=%u, "
+ "ret=%i (expected %i), errno=%i (expected %i)\n",
+ index, audmode, ret, -1, errno, EINVAL);
+
+ CU_ASSERT_EQUAL(ret, -1);
+ CU_ASSERT_EQUAL(errno, EINVAL);
+}
+
+void test_VIDIOC_S_TUNER() {
+ int ret1, errno1;
+ int ret_set, errno_set;
+ struct v4l2_tuner tuner_orig;
+ struct v4l2_tuner tuner_set;
+
+ /* remember the tuner settings */
+ memset(&tuner_orig, 0, sizeof(tuner_orig));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_TUNER, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_LANG1_LANG2);
+
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+
+ /* if VIDIOC_G_TUNER is not supported then VIDIOC_S_TUNER shall also
+ * not supported.
+ */
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode_invalid(tuner_orig.index, V4L2_TUNER_MODE_LANG1_LANG2);
+
+ }
+
+ if (ret1 == 0) {
+
+ /* restore the tuner settings */
+ memset(&tuner_set, 0xff, sizeof(tuner_set));
+ tuner_set.index = tuner_orig.index;
+ tuner_set.audmode = tuner_orig.audmode;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner_orig);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_TUNER, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ CU_ASSERT_EQUAL(ret_set, 0);
+ }
+
+}
+
+void test_VIDIOC_S_TUNER_invalid() {
+ int ret1, errno1;
+ int ret_set, errno_set;
+ struct v4l2_tuner tuner_orig;
+ struct v4l2_tuner tuner_set;
+
+ /* remember the tuner settings */
+ memset(&tuner_orig, 0, sizeof(tuner_orig));
+ ret1 = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
+ errno1 = errno;
+
+ dprintf("VIDIOC_G_TUNER, ret1=%i, errno1=%i\n", ret1, errno1);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+
+ /* try with invalid index */
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_MONO);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_MONO);
+
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_STEREO);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_STEREO);
+
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_LANG1);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_LANG1);
+
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_LANG2);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_LANG2);
+
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_SAP);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_SAP);
+
+ do_set_tuner_audmode_invalid(tuner_orig.index+1, V4L2_TUNER_MODE_LANG1_LANG2);
+ do_set_tuner_audmode_invalid(tuner_orig.index-1, V4L2_TUNER_MODE_LANG1_LANG2);
+ do_set_tuner_audmode_invalid((__u32)S32_MAX, V4L2_TUNER_MODE_LANG1_LANG2);
+ do_set_tuner_audmode_invalid(((__u32)S32_MAX)+1, V4L2_TUNER_MODE_LANG1_LANG2);
+ do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_LANG1_LANG2);
+
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+
+ }
+
+ /* try with invalid audmode */
+ do_set_tuner_audmode_invalid(tuner_orig.index, 5);
+ do_set_tuner_audmode_invalid(tuner_orig.index, (__u32)S32_MAX);
+ do_set_tuner_audmode_invalid(tuner_orig.index, ((__u32)S32_MAX)+1);
+ do_set_tuner_audmode_invalid(tuner_orig.index, U32_MAX);
+
+ if (ret1 == 0) {
+
+ /* restore the tuner settings */
+ memset(&tuner_set, 0xff, sizeof(tuner_set));
+ tuner_set.index = tuner_orig.index;
+ tuner_set.audmode = tuner_orig.audmode;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner_orig);
+ errno_set = errno;
+
+ dprintf("VIDIOC_S_TUNER, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ CU_ASSERT_EQUAL(ret_set, 0);
+ }
+
+}
+
+void test_VIDIOC_S_TUNER_NULL() {
+ int ret_orig, errno_orig;
+ int ret1, errno1;
+ int ret2, errno2;
+ int ret_set, errno_set;
+ struct v4l2_tuner tuner_orig;
+ struct v4l2_tuner tuner;
+ struct v4l2_tuner tuner_set;
+
+ /* remember the tuner settings */
+ memset(&tuner_orig, 0, sizeof(tuner_orig));
+ ret_orig = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
+ errno_orig = errno;
+
+ dprintf("\tVIDIOC_G_TUNER, ret_orig=%i, errno_orig=%i\n", ret_set, errno_set);
+
+ memset(&tuner, 0, sizeof(tuner));
+ tuner.index = tuner_orig.index;
+ tuner.audmode = tuner_orig.audmode;
+ ret1 = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
+ errno1 = errno;
+
+ dprintf("\tVIDIOC_S_TUNER: ret1=%i, errno1=%i\n", ret1, errno1);
+
+ ret2 = ioctl(get_video_fd(), VIDIOC_S_TUNER, NULL);
+ errno2 = errno;
+
+ dprintf("\tVIDIOC_S_TUNER: ret2=%i, errno2=%i\n", ret1, errno1);
+
+ if (ret1 == 0) {
+ CU_ASSERT_EQUAL(ret1, 0);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EFAULT);
+ } else {
+ CU_ASSERT_EQUAL(ret1, -1);
+ CU_ASSERT_EQUAL(errno1, EINVAL);
+ CU_ASSERT_EQUAL(ret2, -1);
+ CU_ASSERT_EQUAL(errno2, EINVAL);
+ }
+
+ if (ret_orig == 0) {
+
+ /* restore the tuner settings */
+ memset(&tuner_set, 0xff, sizeof(tuner_set));
+ tuner_set.index = tuner_orig.index;
+ tuner_set.audmode = tuner_orig.audmode;
+ ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner_orig);
+ errno_set = errno;
+
+ dprintf("\tVIDIOC_S_TUNER, ret_set=%i, errno_set=%i\n", ret_set, errno_set);
+
+ CU_ASSERT_EQUAL(ret_set, 0);
+ }
+
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.h ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.h 2009-01-31 08:35:05.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.h 2009-02-07 23:19:22.000000000 +0100
@@ -12,3 +12,7 @@ void test_VIDIOC_G_TUNER_S32_MAX(void);
void test_VIDIOC_G_TUNER_S32_MAX_1(void);
void test_VIDIOC_G_TUNER_U32_MAX(void);
void test_VIDIOC_G_TUNER_NULL(void);
+
+void test_VIDIOC_S_TUNER(void);
+void test_VIDIOC_S_TUNER_invalid(void);
+void test_VIDIOC_S_TUNER_NULL(void);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c 2009-02-13 08:39:59.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c 2009-02-07 23:35:06.000000000 +0100
@@ -1,6 +1,8 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 7 Feb 2009 0.10 Test cases added for VIDIOC_G_AUDIO, VIDIOC_G_AUDOUT,
+ * VIDIOC_S_AUDIO and VIDIOC_G_CROP
* 3 Feb 2009 0.9 Test cases for VIDIOC_G_AUDIO and VIDIOC_G_AUDOUT added
* 2 Feb 2009 0.8 Test cases for VIDIOC_G_MODULATOR, VIDIOC_G_PRIORITY
* and VIDIOC_S_PRIORITY added
@@ -60,6 +62,7 @@
#include "test_VIDIOC_PRIORITY.h"
#include "test_VIDIOC_AUDIO.h"
#include "test_VIDIOC_AUDOUT.h"
+#include "test_VIDIOC_CROP.h"
#include "test_VIDIOC_LOG_STATUS.h"
#include "test_invalid_ioctl.h"
@@ -147,6 +150,10 @@ static CU_TestInfo suite_get_set_try[] =
{ "VIDIOC_G_TUNER, index=U32_MAX", test_VIDIOC_G_TUNER_U32_MAX },
{ "VIDIOC_G_TUNER with NULL parameter", test_VIDIOC_G_TUNER_NULL },
+ { "VIDIOC_S_TUNER", test_VIDIOC_S_TUNER },
+ { "VIDIOC_S_TUNER with invalid index and audmode parameters", test_VIDIOC_S_TUNER_invalid },
+ { "VIDIOC_S_TUNER with NULL parameter", test_VIDIOC_S_TUNER_NULL },
+
{ "VIDIOC_G_MODULATOR", test_VIDIOC_G_MODULATOR },
{ "VIDIOC_G_MODULATOR, index=S32_MAX", test_VIDIOC_G_MODULATOR_S32_MAX },
{ "VIDIOC_G_MODULATOR, index=S32_MAX+1", test_VIDIOC_G_MODULATOR_S32_MAX_1 },
@@ -170,11 +177,28 @@ static CU_TestInfo suite_get_set_try[] =
{ "VIDIOC_S_PRIORITY with NULL parameter", test_VIDIOC_S_PRIORITY_NULL },
{ "VIDIOC_G_AUDIO", test_VIDIOC_G_AUDIO },
+ { "VIDIOC_G_AUDIO, ignore index value", test_VIDIOC_G_AUDIO_ignore_index },
{ "VIDIOC_G_AUDIO with NULL parameter", test_VIDIOC_G_AUDIO_NULL },
+ { "VIDIOC_S_AUDIO", test_VIDIOC_S_AUDIO },
+ { "VIDIOC_S_AUDIO, index=S32_MAX", test_VIDIOC_S_AUDIO_S32_MAX },
+ { "VIDIOC_S_AUDIO, index=S32_MAX+1", test_VIDIOC_S_AUDIO_S32_MAX_1 },
+ { "VIDIOC_S_AUDIO, index=U32_MAX", test_VIDIOC_S_AUDIO_U32_MAX },
+ { "VIDIOC_S_AUDIO with NULL parameter", test_VIDIOC_S_AUDIO_NULL },
+
{ "VIDIOC_G_AUDOUT", test_VIDIOC_G_AUDOUT },
+ { "VIDIOC_G_AUDOUT, ignore index value", test_VIDIOC_G_AUDOUT_ignore_index },
{ "VIDIOC_G_AUDOUT with NULL parameter", test_VIDIOC_G_AUDOUT_NULL },
+ { "VIDIOC_S_AUDOUT", test_VIDIOC_S_AUDOUT },
+ { "VIDIOC_S_AUDOUT, index=S32_MAX", test_VIDIOC_S_AUDOUT_S32_MAX },
+ { "VIDIOC_S_AUDOUT, index=S32_MAX+1", test_VIDIOC_S_AUDOUT_S32_MAX_1 },
+ { "VIDIOC_S_AUDOUT, index=U32_MAX", test_VIDIOC_S_AUDOUT_U32_MAX },
+ { "VIDIOC_S_AUDOUT with NULL parameter", test_VIDIOC_S_AUDOUT_NULL },
+
+ { "VIDIOC_G_CROP", test_VIDIOC_G_CROP },
+ { "VIDIOC_G_CROP with NULL parameter", test_VIDIOC_G_CROP_NULL },
+
CU_TEST_INFO_NULL,
};
------------------------------------------------------------------------------
Open Source Business Conference (OSBC), March 24-25, 2009, San Francisco, CA
-OSBC tackles the biggest issue in open source: Open Sourcing the Enterprise
-Strategies to boost innovation and cut costs with open source participation
-Receive a $600 discount off the registration fee with the source code: SFAD
http://p.sf.net/sfu/XcvMzF8H
_______________________________________________
Ltp-list mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/ltp-list
