diff options
Diffstat (limited to 'testsuite/sanei/sanei_constrain_test.c')
| -rw-r--r-- | testsuite/sanei/sanei_constrain_test.c | 795 |
1 files changed, 795 insertions, 0 deletions
diff --git a/testsuite/sanei/sanei_constrain_test.c b/testsuite/sanei/sanei_constrain_test.c new file mode 100644 index 0000000..0f66bbb --- /dev/null +++ b/testsuite/sanei/sanei_constrain_test.c @@ -0,0 +1,795 @@ +#include "../../include/sane/config.h" + +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <string.h> +#include <assert.h> + +/* sane includes for the sanei functions called */ +#include "../include/sane/sane.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei.h" + +static SANE_Option_Descriptor none_opt = { + SANE_NAME_SCAN_TL_X, + SANE_TITLE_SCAN_TL_X, + SANE_DESC_SCAN_TL_X, + SANE_TYPE_INT, + SANE_UNIT_NONE, + sizeof (SANE_Word), + 0, + SANE_CONSTRAINT_NONE, + {NULL} +}; + + +static SANE_Option_Descriptor none_bool_opt = { + SANE_NAME_SCAN_TL_X, + SANE_TITLE_SCAN_TL_X, + SANE_DESC_SCAN_TL_X, + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + 0, + SANE_CONSTRAINT_NONE, + {NULL} +}; + +/* range for int constraint */ +static const SANE_Range int_range = { + 3, /* minimum */ + 18, /* maximum */ + 3 /* quantization */ +}; + +/* range for sane fixed constraint */ +static const SANE_Range fixed_range = { + SANE_FIX(1.0), /* minimum */ + SANE_FIX(431.8), /* maximum */ + SANE_FIX(0.01) /* quantization */ +}; + +static SANE_Option_Descriptor int_opt = { + SANE_NAME_SCAN_TL_X, + SANE_TITLE_SCAN_TL_X, + SANE_DESC_SCAN_TL_X, + SANE_TYPE_FIXED, + SANE_UNIT_MM, + sizeof (SANE_Word), + 0, + SANE_CONSTRAINT_RANGE, + {NULL} +}; + +static SANE_Option_Descriptor fixed_opt = { + SANE_NAME_SCAN_TL_X, + SANE_TITLE_SCAN_TL_X, + SANE_DESC_SCAN_TL_X, + SANE_TYPE_FIXED, + SANE_UNIT_MM, + sizeof (SANE_Word), + 0, + SANE_CONSTRAINT_RANGE, + {NULL} +}; + +#define ARRAY_SIZE 7 + +static SANE_Option_Descriptor array_opt = { + SANE_NAME_SCAN_TL_X, + SANE_TITLE_SCAN_TL_X, + SANE_DESC_SCAN_TL_X, + SANE_TYPE_FIXED, + SANE_UNIT_MM, + sizeof (SANE_Word) * ARRAY_SIZE, + 0, + SANE_CONSTRAINT_RANGE, + {NULL} +}; + +#define WORD_SIZE 9 +static const SANE_Int dpi_list[] = + { WORD_SIZE - 1, 100, 200, 300, 400, 500, 600, 700, 800 }; + +static SANE_Option_Descriptor word_array_opt = { + SANE_NAME_SCAN_RESOLUTION, + SANE_TITLE_SCAN_RESOLUTION, + SANE_DESC_SCAN_RESOLUTION, + SANE_TYPE_INT, + SANE_UNIT_DPI, + sizeof (SANE_Word) * WORD_SIZE, + 100, + SANE_CONSTRAINT_WORD_LIST, + {NULL} +}; + +static const SANE_String_Const string_list[] = { + SANE_VALUE_SCAN_MODE_LINEART, + SANE_VALUE_SCAN_MODE_HALFTONE, + SANE_VALUE_SCAN_MODE_GRAY, + "linelength", + 0 +}; + +static SANE_Option_Descriptor string_array_opt = { + SANE_NAME_SCAN_MODE, + SANE_TITLE_SCAN_MODE, + SANE_DESC_SCAN_MODE, + SANE_TYPE_STRING, + SANE_UNIT_NONE, + 8, + 0, + SANE_CONSTRAINT_STRING_LIST, + {NULL} +}; + + +/******************************/ +/* start of tests definitions */ +/******************************/ + +/* + * constrained int + */ +static void +min_int_value (void) +{ + SANE_Int value = int_range.min; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == int_range.min); +} + +static void +max_int_value (void) +{ + SANE_Int value = int_range.max; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == int_range.max); +} + +static void +below_min_int_value (void) +{ + SANE_Int value = int_range.min - 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == int_range.min); +} + +/* rounded to lower value */ +static void +quant1_int_value (void) +{ + SANE_Int value = int_range.min + 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == int_range.min); +} + +/* rounded to higher value */ +static void +quant2_int_value (void) +{ + SANE_Int value = int_range.min + int_range.quant - 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == int_range.min + int_range.quant); +} + +static void +in_range_int_value (void) +{ + SANE_Int value = int_range.min + int_range.quant; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == int_range.min + int_range.quant); +} + +static void +above_max_int_value (void) +{ + SANE_Int value = int_range.max + 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&int_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == int_range.max); +} + +/* + * constrained fixed value + */ +static void +min_fixed_value (void) +{ + SANE_Int value = fixed_range.min; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == fixed_range.min); +} + +static void +max_fixed_value (void) +{ + SANE_Int value = fixed_range.max; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == fixed_range.max); +} + +static void +below_min_fixed_value (void) +{ + SANE_Int value = fixed_range.min - 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == fixed_range.min); +} + +/* rounded to lower value */ +static void +quant1_fixed_value (void) +{ + SANE_Int value = fixed_range.min + fixed_range.quant/3; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == fixed_range.min); +} + +/* rounded to higher value */ +static void +quant2_fixed_value (void) +{ + SANE_Int value = fixed_range.min + fixed_range.quant - fixed_range.quant/3; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == fixed_range.min + fixed_range.quant); +} + +static void +in_range_fixed_value (void) +{ + SANE_Int value = fixed_range.min + fixed_range.quant; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == fixed_range.min + fixed_range.quant); +} + +static void +above_max_fixed_value (void) +{ + SANE_Int value = fixed_range.max + 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&fixed_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == fixed_range.max); +} + + +static void +above_max_word (void) +{ + SANE_Word value = 25000; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&word_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == 800); +} + + +static void +below_max_word (void) +{ + SANE_Word value = 1; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&word_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == 100); +} + +static void +closest_200_word (void) +{ + SANE_Word value = 249; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&word_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == 200); +} + + +static void +closest_300_word (void) +{ + SANE_Word value = 251; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&word_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + assert (value == 300); +} + + +static void +exact_400_word (void) +{ + SANE_Word value = 400; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&word_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + assert (value == 400); +} + +/* + * constrained int array + */ +static void +min_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.min; + } + status = sanei_constrain_value (&array_opt, value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.min); + } +} + +static void +max_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.max; + } + + status = sanei_constrain_value (&array_opt, value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.max); + } +} + +static void +below_min_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.min - 1; + } + + status = sanei_constrain_value (&array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.min); + } +} + +/* rounded to lower value */ +static void +quant1_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.min + 1; + } + status = sanei_constrain_value (&array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.min); + } +} + +/* rounded to higher value */ +static void +quant2_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.min + int_range.quant - 1; + } + status = sanei_constrain_value (&array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.min + int_range.quant); + } +} + +static void +in_range_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.min + int_range.quant; + } + + status = sanei_constrain_value (&array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.min + int_range.quant); + } +} + +static void +above_max_int_array (void) +{ + SANE_Int value[ARRAY_SIZE]; + SANE_Word info = 0; + SANE_Status status; + int i; + + for (i = 0; i < ARRAY_SIZE; i++) + { + value[i] = int_range.max + 1; + } + status = sanei_constrain_value (&array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == SANE_INFO_INEXACT); + for (i = 0; i < ARRAY_SIZE; i++) + { + assert (value[i] == int_range.max); + } +} + +static void +wrong_string_array (void) +{ + SANE_Char value[9] = "wrong"; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&string_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_INVAL); + assert (info == 0); +} + + +static void +none_int (void) +{ + SANE_Int value = 555; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&none_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); +} + + +static void +none_bool_nok (void) +{ + SANE_Bool value = 555; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&none_bool_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_INVAL); + assert (info == 0); +} + + +static void +none_bool_ok (void) +{ + SANE_Bool value = SANE_FALSE; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&none_bool_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); +} + +/** + * several partial match + */ +static void +string_array_several (void) +{ + SANE_Char value[9] = "Line"; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&string_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_INVAL); + assert (info == 0); +} + +/** + * unique partial match + */ +static void +partial_string_array (void) +{ + SANE_Char value[9] = "Linea"; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&string_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); +} + +static void +string_array_ignorecase (void) +{ + SANE_Char value[9] = "lineart"; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&string_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); +} + +static void +string_array_ok (void) +{ + SANE_Char value[9] = "Lineart"; + SANE_Word info = 0; + SANE_Status status; + + status = sanei_constrain_value (&string_array_opt, &value, &info); + + /* check results */ + assert (status == SANE_STATUS_GOOD); + assert (info == 0); +} + +/** + * run the test suite for sanei constrain related tests + */ +static void +sanei_constrain_suite (void) +{ + /* to be compatible with pre-C99 compilers */ + int_opt.constraint.range = &int_range; + fixed_opt.constraint.range = &fixed_range; + array_opt.constraint.range = &int_range; + word_array_opt.constraint.word_list = dpi_list; + string_array_opt.constraint.string_list = string_list; + + /* tests for constrained int value */ + min_int_value (); + max_int_value (); + below_min_int_value (); + above_max_int_value (); + quant1_int_value (); + quant2_int_value (); + in_range_int_value (); + + /* tests for sane fixed constrained value */ + min_fixed_value (); + max_fixed_value (); + below_min_fixed_value (); + above_max_fixed_value (); + quant1_fixed_value (); + quant2_fixed_value (); + in_range_fixed_value (); + + /* tests for constrained int array */ + min_int_array (); + max_int_array (); + below_min_int_array (); + above_max_int_array (); + quant1_int_array (); + quant2_int_array (); + in_range_int_array (); + + /* tests for word lists */ + above_max_word (); + below_max_word (); + closest_200_word (); + closest_300_word (); + exact_400_word (); + + /* tests for string lists */ + wrong_string_array (); + partial_string_array (); + string_array_ok (); + string_array_ignorecase (); + string_array_several (); + + /* constraint none tests */ + none_int (); + none_bool_nok (); + none_bool_ok (); +} + +/** + * main function to run the test suites + */ +int +main (void) +{ + /* run suites */ + sanei_constrain_suite (); + + return 0; +} + +/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */ |