summaryrefslogtreecommitdiff
path: root/test/test_class.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/test_class.c')
-rw-r--r--test/test_class.c1158
1 files changed, 1158 insertions, 0 deletions
diff --git a/test/test_class.c b/test/test_class.c
new file mode 100644
index 0000000..2f6ef72
--- /dev/null
+++ b/test/test_class.c
@@ -0,0 +1,1158 @@
+/*
+ * test_class.c
+ *
+ * Tests for class related functions for the libsysfs testsuite
+ *
+ * Copyright (C) IBM Corp. 2004
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/**
+ ***************************************************************************
+ * this will test the class related functions provided by libsysfs.
+ *
+ * extern void sysfs_close_class_device(struct sysfs_class_device *dev);
+ * extern struct sysfs_class_device *sysfs_open_class_device_path
+ * (const char *path);
+ * extern struct sysfs_class_device *sysfs_open_class_device
+ * (const char *classname, const char *name);
+ * extern struct sysfs_device *sysfs_get_classdev_device
+ * (struct sysfs_class_device *clsdev);
+ * extern struct sysfs_driver *sysfs_get_classdev_driver
+ * (struct sysfs_class_device *clsdev);
+ * extern struct sysfs_class_device *sysfs_get_classdev_parent
+ * (struct sysfs_class_device *clsdev);
+ * extern void sysfs_close_class(struct sysfs_class *cls);
+ * extern struct sysfs_class *sysfs_open_class(const char *name);
+ * extern struct dlist *sysfs_get_class_devices(struct sysfs_class *cls);
+ * extern struct sysfs_class_device *sysfs_get_class_device
+ * (struct sysfs_class *cls, char *name);
+ * extern struct dlist *sysfs_get_classdev_attributes
+ * (struct sysfs_class_device *cdev);
+ * extern struct dlist *sysfs_refresh_classdev_attributes
+ * (struct sysfs_class_device *cdev);
+ * extern struct sysfs_attribute *sysfs_get_classdev_attr
+ * (struct sysfs_class_device *clsdev, const char *name);
+ * extern struct sysfs_attribute *sysfs_open_classdev_attr
+ * (const char *classname,
+ * const char *dev, const char *attrib);
+ *****************************************************************************
+ */
+
+#include "test-defs.h"
+#include <errno.h>
+
+/**
+ * this test the function:
+ * extern void sysfs_close_class_device(struct sysfs_class_device *dev);
+ * this has no return,
+ *
+ * flag:
+ * 0: dev -> valid
+ * 1: dev -> NULL
+ */
+int test_sysfs_close_class_device(int flag)
+{
+ struct sysfs_class_device *dev = NULL;
+ char *path = NULL;
+
+ switch (flag) {
+ case 0:
+ path = val_class_dev_path;
+ dev = sysfs_open_class_device_path(path);
+ if (dev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ dev = NULL;
+ break;
+ default:
+ return -1;
+ }
+ sysfs_close_class_device(dev);
+
+ dbg_print("%s: returns void\n", __FUNCTION__);
+ return 0;
+}
+
+/**
+ * extern struct sysfs_class_device *sysfs_open_class_device_path
+ * (const char *path);
+ * flag:
+ * 0: path -> valid
+ * 1: path -> invalid
+ * 2: path -> NULL
+ */
+int test_sysfs_open_class_device_path(int flag)
+{
+ struct sysfs_class_device *dev = NULL;
+ char *path = NULL;
+
+ switch (flag) {
+ case 0:
+ path = val_class_dev_path;
+ break;
+ case 1:
+ path = inval_path;
+ break;
+ case 2:
+ path = NULL;
+ break;
+ default:
+ return -1;
+ }
+ dev = sysfs_open_class_device_path(path);
+
+ switch (flag) {
+ case 0:
+ if (dev == NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_class_device(dev);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ case 2:
+ if (dev != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ default:
+ break;
+
+ }
+ if (dev != NULL)
+ sysfs_close_class_device(dev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_class_device *sysfs_open_class_device
+ * (const char *class, const char *name);
+ *
+ * flag:
+ * 0: class -> valid , name -> valid
+ * 1: class -> valid , name -> invalid
+ * 2: class -> valid , name -> NULL
+ * 3: class -> invalid , name -> valid
+ * 4: class -> invalid , name -> invalid
+ * 5: class -> invalid , name -> NULL
+ * 6: class -> NULL valid , name -> valid
+ * 7: class -> NULL , name -> invalid
+ * 8: class -> NULL , name -> NULL
+ */
+int test_sysfs_open_class_device(int flag)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ char *name = NULL;
+ char *class = NULL;
+
+ switch(flag) {
+ case 0:
+ class = val_class;
+ name = val_class_dev;
+ break;
+ case 1:
+ class = val_class;
+ name = inval_name;
+ break;
+ case 2:
+ class = val_class;
+ name = NULL;
+ break;
+ case 3:
+ class = inval_name;
+ name = val_class_dev;
+ break;
+ case 4:
+ class = inval_name;
+ name = inval_name;
+ break;
+ case 5:
+ class = inval_name;
+ name = NULL;
+ break;
+ case 6:
+ class = NULL;
+ name = val_class_dev;
+ break;
+ case 7:
+ class = NULL;
+ name = inval_name;
+ break;
+ case 8:
+ class = NULL;
+ name = NULL;
+ break;
+ default:
+ return -1;
+ }
+ clsdev = sysfs_open_class_device(class, name);
+
+ switch(flag) {
+ case 0:
+ if (clsdev == NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_class_device(clsdev);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ if (clsdev != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (clsdev != NULL)
+ sysfs_close_class_device(clsdev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_device *sysfs_get_classdev_device
+ * (struct sysfs_class_device *clsdev);
+ *
+ * flag:
+ * 0: clsdev -> valid
+ * 1: clsdev -> NULL
+ */
+int test_sysfs_get_classdev_device(int flag)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_device *dev = NULL;
+ char *path = NULL;
+
+ switch(flag) {
+ case 0:
+ path = val_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ clsdev = NULL;
+ break;
+ default:
+ return -1;
+ }
+ dev = sysfs_get_classdev_device(clsdev);
+
+ switch (flag) {
+ case 0:
+ if (dev == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device at %s does not have a device symlink\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_device(dev);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (dev != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (clsdev != NULL)
+ sysfs_close_class_device(clsdev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_driver *sysfs_get_classdev_driver
+ * (struct sysfs_class_device *clsdev);
+ *
+ * flag:
+ * 0: clsdev -> valid
+ * 1: clsdev -> NULL
+ */
+int test_sysfs_get_classdev_driver(int flag)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_driver *drv = NULL;
+ char *path = NULL;
+
+ switch(flag) {
+ case 0:
+ path = val_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ clsdev = NULL;
+ break;
+ default:
+ return -1;
+
+ }
+ drv = sysfs_get_classdev_driver(clsdev);
+
+ switch (flag) {
+ case 0:
+ if (drv == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device at %s does not have a driver symlink\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_driver(drv);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (drv != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (clsdev != NULL)
+ sysfs_close_class_device(clsdev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_class_device *sysfs_get_classdev_parent
+ * (struct sysfs_class_device *clsdev);
+ * flag:
+ * 0: clsdev -> valid
+ * 1: clsdev -> NULL
+ */
+int test_sysfs_get_classdev_parent(int flag)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_class_device *parent = NULL;
+ char *path = NULL;
+
+ switch(flag) {
+ case 0:
+ path = val_block_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ clsdev = NULL;
+ break;
+ default:
+ return -1;
+ }
+ parent = sysfs_get_classdev_parent(clsdev);
+
+ switch (flag) {
+ case 0:
+ if (parent == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device at %s does not have a parent\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_class_device(parent);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (parent != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (clsdev != NULL)
+ sysfs_close_class_device(clsdev);
+
+ return 0;
+}
+
+/**
+ * extern void sysfs_close_class(struct sysfs_class *cls);
+ *
+ * flag:
+ * 0: cls -> valid
+ * 1: cls -> NULL
+ */
+int test_sysfs_close_class(int flag)
+{
+ struct sysfs_class *cls = NULL;
+ char *class = NULL;
+
+ switch(flag) {
+ case 0:
+ class = val_class;
+ cls = sysfs_open_class(class);
+ if (cls == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, class);
+ return 0;
+ }
+ break;
+ case 1:
+ cls = NULL;
+ break;
+ default:
+ return -1;
+ }
+ sysfs_close_class(cls);
+ dbg_print("%s: returns void\n", __FUNCTION__);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_class *sysfs_open_class(const char *name);
+ *
+ * flag:
+ * 0: name -> valid
+ * 1: name -> invalid
+ * 2: name -> NULL
+ */
+int test_sysfs_open_class(int flag)
+{
+ struct sysfs_class *cls = NULL;
+ char *name = NULL;
+
+ switch(flag) {
+ case 0:
+ name = val_class;
+ break;
+ case 1:
+ name = inval_name;
+ break;
+ case 2:
+ name = NULL;
+ break;
+ default:
+ return -1;
+ }
+ cls = sysfs_open_class(name);
+
+ switch(flag) {
+ case 0:
+ if (cls == NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ dbg_print("Class %s is at %s\n\n",
+ cls->name, cls->path);
+ }
+ break;
+ case 1:
+ case 2:
+ if (cls != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (cls != NULL)
+ sysfs_close_class(cls);
+
+ return 0;
+}
+
+/**
+ * extern struct dlist *sysfs_get_class_devices(struct sysfs_class *cls);
+ *
+ * flag:
+ * 0: cls -> valid
+ * 1: cls -> NULL
+ */
+int test_sysfs_get_class_devices(int flag)
+{
+ struct sysfs_class *cls = NULL;
+ struct dlist *list = NULL;
+ char *class = NULL;
+
+ switch(flag) {
+ case 0:
+ class = val_class;
+ cls = sysfs_open_class(class);
+ if (cls == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, class);
+ return 0;
+ }
+ break;
+ case 1:
+ cls = NULL;
+ break;
+ default:
+ return -1;
+
+ }
+ list = sysfs_get_class_devices(cls);
+
+ switch(flag) {
+ case 0:
+ if (list == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class %s does not have devices\n",
+ __FUNCTION__, val_class);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_class_device_list(list);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (list != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+ default:
+ break;
+ }
+ if (cls != NULL)
+ sysfs_close_class(cls);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_class_device *sysfs_get_class_device
+ * (struct sysfs_class *class, char *name);
+ *
+ * flag:
+ * 0: class -> valid, name -> valid
+ * 1: class -> valid, name -> invalid
+ * 2: class -> valid, name -> NULL
+ * 3: class -> NULL, name -> valid
+ * 4: class -> NULL, name -> invalid
+ * 5: class -> NULL, name -> NULL
+ */
+int test_sysfs_get_class_device(int flag)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_class *class = NULL;
+ char *name = NULL;
+
+ switch(flag) {
+ case 0:
+ class = sysfs_open_class(val_class);
+ if (class == NULL) {
+ dbg_print("%s: failed opening class %s\n",
+ __FUNCTION__, val_class);
+ return 0;
+ }
+ name = val_class_dev;
+ break;
+ case 1:
+ class = sysfs_open_class(val_class);
+ if (class == NULL) {
+ dbg_print("%s: failed opening class %s\n",
+ __FUNCTION__, val_class);
+ return 0;
+ }
+ name = inval_name;
+ break;
+ case 2:
+ class = sysfs_open_class(val_class);
+ if (class == NULL) {
+ dbg_print("%s: failed opening class %s\n",
+ __FUNCTION__, val_class);
+ return 0;
+ }
+ name = NULL;
+ break;
+ case 3:
+ class = NULL;
+ name = val_class_dev;
+ break;
+ case 4:
+ class = NULL;
+ name = inval_name;
+ break;
+ case 5:
+ class = NULL;
+ name = NULL;
+ break;
+ default:
+ return -1;
+ }
+ clsdev = sysfs_get_class_device(class, name);
+
+ switch(flag) {
+ case 0:
+ if (clsdev == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device %s does not belong to the %s class\n",
+ __FUNCTION__, val_class_dev, val_class);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_class_device(clsdev);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ if (clsdev != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ default:
+ break;
+ }
+ if (class)
+ sysfs_close_class(class);
+
+ return 0;
+}
+
+/**
+ * extern struct dlist *sysfs_get_classdev_attributes
+ * (struct sysfs_class_device *cdev);
+ * flag:
+ * 0: cdev -> valid
+ * 1: cdev -> NULL
+ */
+int test_sysfs_get_classdev_attributes(int flag)
+{
+ struct dlist *list = NULL;
+ struct sysfs_class_device *cdev = NULL;
+ char *path = NULL;
+
+ switch (flag) {
+ case 0:
+ path = val_class_dev_path;
+ cdev = sysfs_open_class_device_path(path);
+ if (cdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ cdev = NULL;
+ break;
+ default:
+ return -1;
+ }
+ list = sysfs_get_classdev_attributes(cdev);
+
+ switch (flag) {
+ case 0:
+ if (list == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device at %s does not export attributes\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_attribute_list(list);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (list != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ default:
+ break;
+ }
+ if (cdev != NULL)
+ sysfs_close_class_device(cdev);
+
+ return 0;
+}
+
+/**
+ * extern struct dlist *sysfs_refresh_classdev_attributes
+ * (struct sysfs_class_device *cdev);
+ *
+ * flag:
+ * 0: cdev -> valid
+ * 1: cdev -> NULL
+ */
+int test_sysfs_refresh_classdev_attributes(int flag)
+{
+ struct dlist *list = NULL;
+ struct sysfs_class_device *cdev = NULL;
+ char *path = NULL;
+
+ switch (flag) {
+ case 0:
+ path = val_class_dev_path;
+ cdev = sysfs_open_class_device_path(path);
+ if (cdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ break;
+ case 1:
+ cdev = NULL;
+ break;
+ default:
+ return -1;
+ }
+ list = sysfs_refresh_classdev_attributes(cdev);
+
+ switch (flag) {
+ case 0:
+ if (list == NULL) {
+ if (errno == 0)
+ dbg_print("%s: Class device at %s does not export attributes\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_attribute_list(list);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ if (list != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ default:
+ break;
+ }
+
+ if (cdev != NULL)
+ sysfs_close_class_device(cdev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_attribute *sysfs_get_classdev_attr
+ * (struct sysfs_class_device *clsdev, const char *name);
+ *
+ * flag:
+ * 0: clsdev -> valid, name -> valid
+ * 1: clsdev -> valid, name -> invalid
+ * 2: clsdev -> valid, name -> NULL
+ * 3: clsdev -> NULL, name -> valid
+ * 4: clsdev -> NULL, name -> invalid
+ * 5: clsdev -> NULL, name -> NULL
+ */
+int test_sysfs_get_classdev_attr(int flag)
+{
+ struct sysfs_attribute *attr = NULL;
+ struct sysfs_class_device *clsdev = NULL;
+ char *name = NULL;
+ char *path = NULL;
+
+ switch (flag) {
+ case 0:
+ path = val_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ name = val_class_dev_attr;
+ break;
+ case 1:
+ path = val_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ name = inval_name;
+ break;
+ case 2:
+ path = val_class_dev_path;
+ clsdev = sysfs_open_class_device_path(path);
+ if (clsdev == NULL) {
+ dbg_print("%s: failed opening class device at %s\n",
+ __FUNCTION__, path);
+ return 0;
+ }
+ name = NULL;
+ break;
+ case 3:
+ clsdev = NULL;
+ name = val_class_dev_attr;
+ break;
+ case 4:
+ clsdev = NULL;
+ name = inval_name;
+ break;
+ case 5:
+ clsdev = NULL;
+ name = NULL;
+ break;
+ default:
+ return -1;
+ }
+ attr = sysfs_get_classdev_attr(clsdev, name);
+
+ switch (flag) {
+ case 0:
+ if (attr == NULL) {
+ if (errno == EACCES)
+ dbg_print("%s: attribute %s does not support READ\n",
+ __FUNCTION__, name);
+ else if (errno == ENOENT)
+ dbg_print("%s: attribute %s not defined for class device at %s\n",
+ __FUNCTION__, name, path);
+ else if (errno == 0)
+ dbg_print("%s: class device at %s does not export attributes\n",
+ __FUNCTION__, path);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_attribute(attr);
+ dbg_print("\n");
+ }
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ if (attr != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ default:
+ break;
+
+ }
+ if (clsdev != NULL)
+ sysfs_close_class_device(clsdev);
+
+ return 0;
+}
+
+/**
+ * extern struct sysfs_attribute *sysfs_open_classdev_attr
+ * (const char *classname,
+ * const char *dev,
+ * const char *attrib);
+ * flag:
+ * 0: classname -> valid, dev -> valid, attrib -> valid
+ * 1: classname -> valid, dev -> valid, attrib -> invalid
+ * 2: classname -> valid, dev -> valid, attrib -> NULL
+ * 3: classname -> valid, dev -> invalid, attrib -> valid
+ * 4: classname -> valid, dev -> invalid, attrib -> invalid
+ * 5: classname -> valid, dev -> invalid, attrib -> NULL
+ * 6: classname -> valid, dev -> NULL , attrib -> valid
+ * 7: classname -> valid, dev -> NULL , attrib -> invalid
+ * 8: classname -> valid, dev -> NULL , attrib -> NULL
+ * 9: classname -> invalid, dev -> valid, attrib -> valid
+ * 10: classname -> invalid, dev -> valid, attrib -> invalid
+ * 11: classname -> invalid, dev -> valid, attrib -> NULL
+ * 12: classname -> invalid, dev -> invalid, attrib -> valid
+ * 13: classname -> invalid, dev -> invalid, attrib -> invalid
+ * 14: classname -> invalid, dev -> invalid, attrib -> NULL
+ * 15: classname -> invalid, dev -> NULL , attrib -> valid
+ * 16: classname -> invalid, dev -> NULL , attrib -> invalid
+ * 17: classname -> invalid, dev -> NULL , attrib -> NULL
+ * 18: classname -> NULL, dev -> valid, attrib -> valid
+ * 19: classname -> NULL, dev -> valid, attrib -> invalid
+ * 20: classname -> NULL, dev -> valid, attrib -> NULL
+ * 21: classname -> NULL, dev -> invalid, attrib -> valid
+ * 22: classname -> NULL, dev -> invalid, attrib -> invalid
+ * 23: classname -> NULL, dev -> invalid, attrib -> NULL
+ * 24: classname -> NULL, dev -> NULL , attrib -> valid
+ * 25 classname -> NULL, dev -> NULL , attrib -> invalid
+ * 26: classname -> NULL, dev -> NULL , attrib -> NULL
+ */
+int test_sysfs_open_classdev_attr(int flag)
+{
+ struct sysfs_attribute *attr = NULL;
+ char *classname = NULL;
+ char *dev = NULL;
+ char *attrib = NULL;
+
+ switch (flag) {
+ case 0:
+ classname = val_class;
+ dev = val_class_dev;
+ attrib = val_class_dev_attr;
+ break;
+ case 1:
+ classname = val_class;
+ dev = val_class_dev;
+ attrib = inval_name;
+ break;
+ case 2:
+ classname = val_class;
+ dev = val_class_dev;
+ attrib = NULL;
+ break;
+ case 3:
+ classname = val_class;
+ dev= inval_name;
+ attrib = val_class_dev_attr;
+ break;
+ case 4:
+ classname = val_class;
+ dev= inval_name;
+ attrib = inval_name;
+ break;
+ case 5:
+ classname = val_class;
+ dev= inval_name;
+ attrib = NULL;
+ break;
+ case 6:
+ classname = val_class;
+ dev = NULL;
+ attrib = val_class_dev_attr;
+ break;
+ case 7:
+ classname = val_class;
+ dev = NULL;
+ attrib = inval_name;
+ break;
+ case 8:
+ classname = val_class;
+ dev = NULL;
+ attrib = NULL;
+ break;
+ case 9:
+ classname = inval_name;
+ dev = val_class_dev;
+ attrib = val_class_dev_attr;
+ break;
+ case 10:
+ classname = inval_name;
+ dev = val_class_dev;
+ attrib = inval_name;
+ break;
+ case 11:
+ classname = inval_name;
+ dev = val_class_dev;
+ attrib = NULL;
+ break;
+ case 12:
+ classname = inval_name;
+ dev= inval_name;
+ attrib = val_class_dev_attr;
+ break;
+ case 13:
+ classname = inval_name;
+ dev= inval_name;
+ attrib = inval_name;
+ break;
+ case 14:
+ classname = inval_name;
+ dev= inval_name;
+ attrib = NULL;
+ break;
+ case 15:
+ classname = inval_name;
+ dev = NULL;
+ attrib = val_class_dev_attr;
+ break;
+ case 16:
+ classname = inval_name;
+ dev = NULL;
+ attrib = inval_name;
+ break;
+ case 17:
+ classname = inval_name;
+ dev = NULL;
+ attrib = NULL;
+ break;
+ case 18:
+ classname = NULL;
+ dev = val_class_dev;
+ attrib = val_class_dev_attr;
+ break;
+ case 19:
+ classname = NULL;
+ dev = val_class_dev;
+ attrib = inval_name;
+ break;
+ case 20:
+ classname = NULL;
+ dev = val_class_dev;
+ attrib = NULL;
+ break;
+ case 21:
+ classname = NULL;
+ dev= inval_name;
+ attrib = val_class_dev_attr;
+ break;
+ case 22:
+ classname = NULL;
+ dev= inval_name;
+ attrib = inval_name;
+ break;
+ case 23:
+ classname = NULL;
+ dev= inval_name;
+ attrib = NULL;
+ break;
+ case 24:
+ classname = NULL;
+ dev = NULL;
+ attrib = val_class_dev_attr;
+ break;
+ case 25:
+ classname = NULL;
+ dev = NULL;
+ attrib = inval_name;
+ break;
+ case 27:
+ classname = NULL;
+ dev = NULL;
+ attrib = NULL;
+ break;
+ default:
+ return -1;
+ }
+ attr = sysfs_open_classdev_attr(classname, dev, attrib);
+
+ switch (flag) {
+ case 0:
+ if (attr == NULL) {
+ if (errno == EACCES)
+ dbg_print("%s: attribute %s does not support READ\n",
+ __FUNCTION__, attrib);
+ else if (errno == ENOENT)
+ dbg_print("%s: attribute %s not defined for class device %s\n",
+ __FUNCTION__, attrib, dev);
+ else if (errno == 0)
+ dbg_print("%s: class device %s does not export attributes\n",
+ __FUNCTION__, dev);
+ else
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ } else {
+ dbg_print("%s: SUCCEEDED with flag = %d\n\n",
+ __FUNCTION__, flag);
+ show_attribute(attr);
+ dbg_print("\n");
+ }
+ break;
+ default:
+ if (attr != NULL)
+ dbg_print("%s: FAILED with flag = %d errno = %d\n",
+ __FUNCTION__, flag, errno);
+ else
+ dbg_print("%s: SUCCEEDED with flag = %d\n",
+ __FUNCTION__, flag);
+ break;
+
+ }
+ if (attr != NULL)
+ sysfs_close_attribute(attr);
+
+ return 0;
+}
View Lorry Controller Status