tests/hkl-parameter-t.c

   1 /* This file is part of the hkl library.
   2  *
   3  * The hkl library is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * The hkl library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright (C) 2003-2014 Synchrotron SOLEIL
  17  *                         L'Orme des Merisiers Saint-Aubin
  18  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  19  *
  20  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  21  */
  22 #include "hkl.h"
  23 #include <tap/basic.h>
  24 #include <tap/float.h>
  25
  26 #include "hkl-parameter-private.h"
  27
  28 static void new(void)
  29 {
  30         HklParameter *p;
  31
  32         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  33                                      FALSE, TRUE,
  34                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  35         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  36                                      FALSE, TRUE,
  37                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  38         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  39                                      FALSE, TRUE,
  40                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  41         ok(NULL == hkl_parameter_new("toto", 2, 1, 3,
  42                                      FALSE, TRUE,
  43                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  44
  45         ok(NULL == hkl_parameter_new("toto", 1, 2, 3,
  46                                      FALSE, TRUE,
  47                                      &hkl_unit_angle_rad, &hkl_unit_length_nm), __func__);
  48
  49         p = hkl_parameter_new("toto", 1, 2, 3,
  50                               FALSE, TRUE,
  51                               &hkl_unit_angle_rad, &hkl_unit_angle_deg);
  52         ok(0 == !p, __func__);
  53         is_double(1., p->range.min, HKL_EPSILON, __func__);
  54         is_double(2., p->_value, HKL_EPSILON, __func__);
  55         is_double(3., p->range.max, HKL_EPSILON, __func__);
  56         ok(FALSE == p->fit, __func__);
  57         ok(TRUE == p->changed, __func__);
  58         ok(&hkl_unit_angle_rad == p->unit, __func__);
  59         ok(&hkl_unit_angle_deg == p->punit, __func__);
  60
  61         hkl_parameter_free(p);
  62 }
  63
  64 static void new_copy(void)
  65 {
  66         HklParameter *copy, *p;
  67
  68         p = hkl_parameter_new("toto", 1, 2, 3,
  69                               FALSE, TRUE,
  70                               &hkl_unit_angle_rad, &hkl_unit_angle_deg);
  71
  72         copy = hkl_parameter_new_copy(p);
  73
  74         ok(copy->name == p->name, __func__);
  75         is_double(copy->range.min, p->range.min, HKL_EPSILON, __func__);
  76         is_double(copy->_value, p->_value, HKL_EPSILON, __func__);
  77         is_double(copy->range.max, p->range.max, HKL_EPSILON, __func__);
  78         ok(copy->fit == p->fit, __func__);
  79         ok(copy->changed == p->changed, __func__);
  80         ok(&hkl_unit_angle_rad == copy->unit, __func__);
  81         ok(&hkl_unit_angle_deg == copy->punit, __func__);
  82
  83         hkl_parameter_free(copy);
  84         hkl_parameter_free(p);
  85 }
  86
  87 static void init(void)
  88 {
  89         HklParameter *p;
  90
  91         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  92                                      FALSE, TRUE,
  93                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  94         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  95                                      FALSE, TRUE,
  96                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
  97         ok(NULL == hkl_parameter_new("", 2, 1, 3,
  98                                      FALSE, TRUE,
  99                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
 100         ok(NULL == hkl_parameter_new("toto", 2, 1, 3,
 101                                      FALSE, TRUE,
 102                                      &hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
 103         ok(NULL == hkl_parameter_new("toto", 1, 2, 3,
 104                                      FALSE, TRUE,
 105                                      &hkl_unit_angle_rad, &hkl_unit_length_nm), __func__);
 106         p = hkl_parameter_new("toto", 1, 2, 3,
 107                               FALSE, TRUE,
 108                               &hkl_unit_angle_rad, &hkl_unit_angle_deg);
 109         ok(NULL != p, __func__);
 110
 111         hkl_parameter_free(p);
 112 }
 113
 114 static void is_valid(void)
 115 {
 116         HklParameter *p;
 117         GError *error;
 118
 119         p = hkl_parameter_new("toto", 1, 2, 3,
 120                               FALSE, TRUE,
 121                               &hkl_unit_angle_rad, &hkl_unit_angle_deg);
 122         ok(TRUE == hkl_parameter_is_valid(p), __func__);
 123
 124         error= NULL;
 125         ok(TRUE == hkl_parameter_value_set(p, 10, HKL_UNIT_DEFAULT, &error), __func__);
 126         ok(error == NULL, __func__);
 127         ok(FALSE == hkl_parameter_is_valid(p), __func__);
 128
 129         hkl_parameter_free(p);
 130 }
 131
 132 static void min_max(void)
 133 {
 134         HklParameter *p;
 135         double min, max;
 136         GError *error;
 137
 138         p = hkl_parameter_new("toto", 1, 2, 3,
 139                               FALSE, TRUE,
 140                               &hkl_unit_angle_rad, &hkl_unit_angle_deg);
 141         hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
 142         is_double(1, min, HKL_EPSILON, __func__);
 143         is_double(3, max, HKL_EPSILON, __func__);
 144
 145         ok(TRUE == hkl_parameter_min_max_set(p, 1.1, 4, HKL_UNIT_DEFAULT, NULL), __func__);
 146         hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
 147         is_double(1.1, min, HKL_EPSILON, __func__);
 148         is_double(4, max, HKL_EPSILON, __func__);
 149
 150         error = NULL;
 151         ok(FALSE == hkl_parameter_min_max_set(p, 4, 1, HKL_UNIT_DEFAULT, &error), __func__);
 152         ok(error != NULL, __func__);
 153         g_clear_error(&error);
 154
 155         /* nothing should have changed */
 156         hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
 157         is_double(1.1, min, HKL_EPSILON, __func__);
 158         is_double(4, max, HKL_EPSILON, __func__);
 159
 160         hkl_parameter_free(p);
 161 }
 162
 163 int main(int argc, char** argv)
 164 {
 165         plan(40);
 166
 167         new();
 168         new_copy();
 169         init();
 170         is_valid();
 171         min_max();
 172
 173         return 0;
 174 }