UVES Pipeline Reference Manual  5.4.6
irplib_sdp_spectrum-test.c
1 /*
2  * This file is part of the ESO Common Pipeline Library
3  * Copyright (C) 2014 European Southern Observatory
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19 
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 
24 #include <cpl_test.h>
25 #include <stdio.h>
26 #include <math.h>
27 #include <float.h>
28 #include <errno.h>
29 #include "irplib_sdp_spectrum.h"
30 
31 /*-----------------------------------------------------------------------------
32  Static functions
33  -----------------------------------------------------------------------------*/
34 
35 static void fill_keywords(irplib_sdp_spectrum *a);
36 static int test_get_set_functions(void);
37 static int test_copy_functions(void);
38 static int test_count_functions(void);
39 static int test_column_functions(void);
40 static int test_equal_function(void);
41 static int test_io_functions(void);
42 static int test_column_copy_update_functions(void);
43 static int test_generic_copy_functions(void);
44 static int test_append_provenance(void);
45 
46 static cpl_boolean create_file_with_key(cpl_frameset* frames,
47  const char *filename,
48  const char *keyword,
49  const char *value);
50 
51 /*-----------------------------------------------------------------------------
52  Main
53  -----------------------------------------------------------------------------*/
54 int main(void)
55 {
56  cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
57 
58  cpl_test_assert(test_get_set_functions() == EXIT_SUCCESS);
59  cpl_test_assert(test_copy_functions() == EXIT_SUCCESS);
60  cpl_test_assert(test_count_functions() == EXIT_SUCCESS);
61  cpl_test_assert(test_column_functions() == EXIT_SUCCESS);
62  cpl_test_assert(test_equal_function() == EXIT_SUCCESS);
63  cpl_test_assert(test_io_functions() == EXIT_SUCCESS);
64  cpl_test_assert(test_column_copy_update_functions() == EXIT_SUCCESS);
65  cpl_test_assert(test_generic_copy_functions() == EXIT_SUCCESS);
66  cpl_test_assert(test_append_provenance() == EXIT_SUCCESS);
67 
68  return cpl_test_end(0);
69 }
70 
71 
72 static void fill_keywords(irplib_sdp_spectrum *a)
73 {
74  cpl_test_eq_error(irplib_sdp_spectrum_set_ra(a, 1.23), CPL_ERROR_NONE);
75  cpl_test_eq_error(irplib_sdp_spectrum_set_dec(a, 2.34), CPL_ERROR_NONE);
76  cpl_test_eq_error(irplib_sdp_spectrum_set_exptime(a, 3.45), CPL_ERROR_NONE);
77  cpl_test_eq_error(irplib_sdp_spectrum_set_texptime(a, 5.34), CPL_ERROR_NONE);
78  cpl_test_eq_error(irplib_sdp_spectrum_set_timesys(a, "gmt"), CPL_ERROR_NONE);
79  cpl_test_eq_error(irplib_sdp_spectrum_set_mjdobs(a, 4.56), CPL_ERROR_NONE);
80  cpl_test_eq_error(irplib_sdp_spectrum_set_mjdend(a, 5.67), CPL_ERROR_NONE);
81  cpl_test_eq_error(irplib_sdp_spectrum_set_prodlvl(a, 678), CPL_ERROR_NONE);
82  cpl_test_eq_error(irplib_sdp_spectrum_set_procsoft(a, "abc"), CPL_ERROR_NONE);
83  cpl_test_eq_error(irplib_sdp_spectrum_set_prodcatg(a, "bcd"), CPL_ERROR_NONE);
84  cpl_test_eq_error(irplib_sdp_spectrum_set_origin(a, "cde"), CPL_ERROR_NONE);
85  cpl_test_eq_error(irplib_sdp_spectrum_set_extobj(a, CPL_TRUE), CPL_ERROR_NONE);
86  cpl_test_eq_error(irplib_sdp_spectrum_set_dispelem(a, "def"), CPL_ERROR_NONE);
87  cpl_test_eq_error(irplib_sdp_spectrum_set_specsys(a, "efg"), CPL_ERROR_NONE);
88  cpl_test_eq_error(irplib_sdp_spectrum_set_progid(a, "fgh"), CPL_ERROR_NONE);
89  cpl_test_eq_error(irplib_sdp_spectrum_set_obid(a, 1, 789), CPL_ERROR_NONE);
90  cpl_test_eq_error(irplib_sdp_spectrum_set_mepoch(a, CPL_TRUE), CPL_ERROR_NONE);
91  cpl_test_eq_error(irplib_sdp_spectrum_set_obstech(a, "ghi"), CPL_ERROR_NONE);
92  cpl_test_eq_error(irplib_sdp_spectrum_set_fluxcal(a, "hij"), CPL_ERROR_NONE);
93  cpl_test_eq_error(irplib_sdp_spectrum_set_contnorm(a, CPL_TRUE), CPL_ERROR_NONE);
94  cpl_test_eq_error(irplib_sdp_spectrum_set_wavelmin(a, 8.90), CPL_ERROR_NONE);
95  cpl_test_eq_error(irplib_sdp_spectrum_set_wavelmax(a, 9.01), CPL_ERROR_NONE);
96  cpl_test_eq_error(irplib_sdp_spectrum_set_specbin(a, 10.12), CPL_ERROR_NONE);
97  cpl_test_eq_error(irplib_sdp_spectrum_set_totflux(a, CPL_TRUE), CPL_ERROR_NONE);
98  cpl_test_eq_error(irplib_sdp_spectrum_set_fluxerr(a, 432.19), CPL_ERROR_NONE);
99  cpl_test_eq_error(irplib_sdp_spectrum_set_referenc(a, "ijk"), CPL_ERROR_NONE);
100  cpl_test_eq_error(irplib_sdp_spectrum_set_specres(a, 23.45), CPL_ERROR_NONE);
101  cpl_test_eq_error(irplib_sdp_spectrum_set_specerr(a, 34.56), CPL_ERROR_NONE);
102  cpl_test_eq_error(irplib_sdp_spectrum_set_specsye(a, 45.67), CPL_ERROR_NONE);
103  cpl_test_eq_error(irplib_sdp_spectrum_set_lamnlin(a, 5678), CPL_ERROR_NONE);
104  cpl_test_eq_error(irplib_sdp_spectrum_set_lamrms(a, 67.89), CPL_ERROR_NONE);
105  cpl_test_eq_error(irplib_sdp_spectrum_set_gain(a, 78.90), CPL_ERROR_NONE);
106  cpl_test_eq_error(irplib_sdp_spectrum_set_detron(a, 89.01), CPL_ERROR_NONE);
107  cpl_test_eq_error(irplib_sdp_spectrum_set_effron(a, 90.12), CPL_ERROR_NONE);
108  cpl_test_eq_error(irplib_sdp_spectrum_set_snr(a, 93.75), CPL_ERROR_NONE);
109  cpl_test_eq_error(irplib_sdp_spectrum_set_ncombine(a, 12345), CPL_ERROR_NONE);
110  cpl_test_eq_error(irplib_sdp_spectrum_set_voclass(a, "jkl"), CPL_ERROR_NONE);
111  cpl_test_eq_error(irplib_sdp_spectrum_set_vopub(a, "klm"), CPL_ERROR_NONE);
112  cpl_test_eq_error(irplib_sdp_spectrum_set_title(a, "lmn"), CPL_ERROR_NONE);
113  cpl_test_eq_error(irplib_sdp_spectrum_set_object(a, "mno"), CPL_ERROR_NONE);
114  cpl_test_eq_error(irplib_sdp_spectrum_set_aperture(a, 234.56), CPL_ERROR_NONE);
115  cpl_test_eq_error(irplib_sdp_spectrum_set_telapse(a, 345.67), CPL_ERROR_NONE);
116  cpl_test_eq_error(irplib_sdp_spectrum_set_tmid(a, 456.78), CPL_ERROR_NONE);
117  cpl_test_eq_error(irplib_sdp_spectrum_set_specval(a, 567.89), CPL_ERROR_NONE);
118  cpl_test_eq_error(irplib_sdp_spectrum_set_specbw(a, 678.90), CPL_ERROR_NONE);
119  cpl_test_eq_error(irplib_sdp_spectrum_set_extname(a, "nop"), CPL_ERROR_NONE);
120  cpl_test_eq_error(irplib_sdp_spectrum_set_inherit(a, CPL_TRUE), CPL_ERROR_NONE);
121  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 78901), CPL_ERROR_NONE);
122  cpl_test_eq_error(irplib_sdp_spectrum_set_tdmin(a, 890.12), CPL_ERROR_NONE);
123  cpl_test_eq_error(irplib_sdp_spectrum_set_tdmax(a, 901.23), CPL_ERROR_NONE);
124  cpl_test_eq_error(irplib_sdp_spectrum_set_prov(a, 1, "opq"), CPL_ERROR_NONE);
125  cpl_test_eq_error(irplib_sdp_spectrum_set_prov(a, 2, "pqr"), CPL_ERROR_NONE);
126  cpl_test_eq_error(irplib_sdp_spectrum_set_asson(a, 1, "qrs"), CPL_ERROR_NONE);
127  cpl_test_eq_error(irplib_sdp_spectrum_set_assoc(a, 1, "rst"), CPL_ERROR_NONE);
128  cpl_test_eq_error(irplib_sdp_spectrum_set_assom(a, 1, "stu"), CPL_ERROR_NONE);
129 }
130 
131 
132 static int test_get_set_functions(void)
133 {
134  /* Create a new spectrum structure and set all keywords with dummy values. */
135  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
137  cpl_test_assert(a != NULL);
138  fill_keywords(a);
139 
140  /* Duplicate the spectrum and check if the new spectrum's keywords are the
141  * same as for the first spectrum. */
142  b = irplib_sdp_spectrum_duplicate(a);
143  cpl_test_assert(b != NULL);
144  cpl_test_abs(irplib_sdp_spectrum_get_ra(b), 1.23, DBL_EPSILON);
145  cpl_test_abs(irplib_sdp_spectrum_get_dec(b), 2.34, DBL_EPSILON);
146  cpl_test_abs(irplib_sdp_spectrum_get_exptime(b), 3.45, DBL_EPSILON);
147  cpl_test_abs(irplib_sdp_spectrum_get_texptime(b), 5.34, DBL_EPSILON);
148  cpl_test_eq_string(irplib_sdp_spectrum_get_timesys(b), "gmt");
149  cpl_test_abs(irplib_sdp_spectrum_get_mjdobs(b), 4.56, DBL_EPSILON);
150  cpl_test_abs(irplib_sdp_spectrum_get_mjdend(b), 5.67, DBL_EPSILON);
151  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(b), 678);
152  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(b), "abc");
153  cpl_test_eq_string(irplib_sdp_spectrum_get_prodcatg(b), "bcd");
154  cpl_test_eq_string(irplib_sdp_spectrum_get_origin(b), "cde");
155  cpl_test_eq(irplib_sdp_spectrum_get_extobj(b), CPL_TRUE);
156  cpl_test_eq_string(irplib_sdp_spectrum_get_dispelem(b), "def");
157  cpl_test_eq_string(irplib_sdp_spectrum_get_specsys(b), "efg");
158  cpl_test_eq_string(irplib_sdp_spectrum_get_progid(b), "fgh");
159  cpl_test_eq(irplib_sdp_spectrum_get_obid(b, 1), 789);
160  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(b), CPL_TRUE);
161  cpl_test_eq_string(irplib_sdp_spectrum_get_obstech(b), "ghi");
162  cpl_test_eq_string(irplib_sdp_spectrum_get_fluxcal(b), "hij");
163  cpl_test_eq(irplib_sdp_spectrum_get_contnorm(b), CPL_TRUE);
164  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(b), 8.90, DBL_EPSILON);
165  cpl_test_abs(irplib_sdp_spectrum_get_wavelmax(b), 9.01, DBL_EPSILON);
166  cpl_test_abs(irplib_sdp_spectrum_get_specbin(b), 10.12, DBL_EPSILON);
167  cpl_test_eq(irplib_sdp_spectrum_get_totflux(b), CPL_TRUE);
168  cpl_test_abs(irplib_sdp_spectrum_get_fluxerr(b), 432.19, DBL_EPSILON);
169  cpl_test_eq_string(irplib_sdp_spectrum_get_referenc(b), "ijk");
170  cpl_test_abs(irplib_sdp_spectrum_get_specres(b), 23.45, DBL_EPSILON);
171  cpl_test_abs(irplib_sdp_spectrum_get_specerr(b), 34.56, DBL_EPSILON);
172  cpl_test_abs(irplib_sdp_spectrum_get_specsye(b), 45.67, DBL_EPSILON);
173  cpl_test_eq(irplib_sdp_spectrum_get_lamnlin(b), 5678);
174  cpl_test_abs(irplib_sdp_spectrum_get_lamrms(b), 67.89, DBL_EPSILON);
175  cpl_test_abs(irplib_sdp_spectrum_get_gain(b), 78.90, DBL_EPSILON);
176  cpl_test_abs(irplib_sdp_spectrum_get_detron(b), 89.01, DBL_EPSILON);
177  cpl_test_abs(irplib_sdp_spectrum_get_effron(b), 90.12, DBL_EPSILON);
178  cpl_test_abs(irplib_sdp_spectrum_get_snr(b), 93.75, DBL_EPSILON);
179  cpl_test_eq(irplib_sdp_spectrum_get_ncombine(b), 12345);
180  cpl_test_eq_string(irplib_sdp_spectrum_get_voclass(b), "jkl");
181  cpl_test_eq_string(irplib_sdp_spectrum_get_vopub(b), "klm");
182  cpl_test_eq_string(irplib_sdp_spectrum_get_title(b), "lmn");
183  cpl_test_eq_string(irplib_sdp_spectrum_get_object(b), "mno");
184  cpl_test_abs(irplib_sdp_spectrum_get_aperture(b), 234.56, DBL_EPSILON);
185  cpl_test_abs(irplib_sdp_spectrum_get_telapse(b), 345.67, DBL_EPSILON);
186  cpl_test_abs(irplib_sdp_spectrum_get_tmid(b), 456.78, DBL_EPSILON);
187  cpl_test_abs(irplib_sdp_spectrum_get_specval(b), 567.89, DBL_EPSILON);
188  cpl_test_abs(irplib_sdp_spectrum_get_specbw(b), 678.90, DBL_EPSILON);
189  cpl_test_eq_string(irplib_sdp_spectrum_get_extname(b), "nop");
190  cpl_test_eq(irplib_sdp_spectrum_get_inherit(b), CPL_TRUE);
191  cpl_test_eq(irplib_sdp_spectrum_get_nelem(b), 78901);
192  cpl_test_abs(irplib_sdp_spectrum_get_tdmin(b), 890.12, DBL_EPSILON);
193  cpl_test_abs(irplib_sdp_spectrum_get_tdmax(b), 901.23, DBL_EPSILON);
194  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(b, 1), "opq");
195  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(b, 2), "pqr");
196  cpl_test_eq_string(irplib_sdp_spectrum_get_asson(b, 1), "qrs");
197  cpl_test_eq_string(irplib_sdp_spectrum_get_assoc(b, 1), "rst");
198  cpl_test_eq_string(irplib_sdp_spectrum_get_assom(b, 1), "stu");
199 
200  /* Remove the keywords from the second spectrum and check no errors occur. */
201  cpl_test_eq_error(irplib_sdp_spectrum_reset_ra(b), CPL_ERROR_NONE);
202  cpl_test_error(CPL_ERROR_NONE);
203  cpl_test_eq_error(irplib_sdp_spectrum_reset_dec(b), CPL_ERROR_NONE);
204  cpl_test_error(CPL_ERROR_NONE);
205  cpl_test_eq_error(irplib_sdp_spectrum_reset_exptime(b), CPL_ERROR_NONE);
206  cpl_test_error(CPL_ERROR_NONE);
207  cpl_test_eq_error(irplib_sdp_spectrum_reset_texptime(b), CPL_ERROR_NONE);
208  cpl_test_error(CPL_ERROR_NONE);
209  cpl_test_eq_error(irplib_sdp_spectrum_reset_timesys(b), CPL_ERROR_NONE);
210  cpl_test_error(CPL_ERROR_NONE);
211  cpl_test_eq_error(irplib_sdp_spectrum_reset_mjdobs(b), CPL_ERROR_NONE);
212  cpl_test_error(CPL_ERROR_NONE);
213  cpl_test_eq_error(irplib_sdp_spectrum_reset_mjdend(b), CPL_ERROR_NONE);
214  cpl_test_error(CPL_ERROR_NONE);
215  cpl_test_eq_error(irplib_sdp_spectrum_reset_prodlvl(b), CPL_ERROR_NONE);
216  cpl_test_error(CPL_ERROR_NONE);
217  cpl_test_eq_error(irplib_sdp_spectrum_reset_procsoft(b), CPL_ERROR_NONE);
218  cpl_test_error(CPL_ERROR_NONE);
219  cpl_test_eq_error(irplib_sdp_spectrum_reset_prodcatg(b), CPL_ERROR_NONE);
220  cpl_test_error(CPL_ERROR_NONE);
221  cpl_test_eq_error(irplib_sdp_spectrum_reset_origin(b), CPL_ERROR_NONE);
222  cpl_test_error(CPL_ERROR_NONE);
223  cpl_test_eq_error(irplib_sdp_spectrum_reset_extobj(b), CPL_ERROR_NONE);
224  cpl_test_error(CPL_ERROR_NONE);
225  cpl_test_eq_error(irplib_sdp_spectrum_reset_dispelem(b), CPL_ERROR_NONE);
226  cpl_test_error(CPL_ERROR_NONE);
227  cpl_test_eq_error(irplib_sdp_spectrum_reset_specsys(b), CPL_ERROR_NONE);
228  cpl_test_error(CPL_ERROR_NONE);
229  cpl_test_eq_error(irplib_sdp_spectrum_reset_progid(b), CPL_ERROR_NONE);
230  cpl_test_error(CPL_ERROR_NONE);
231  cpl_test_eq_error(irplib_sdp_spectrum_reset_obid(b, 1), CPL_ERROR_NONE);
232  cpl_test_error(CPL_ERROR_NONE);
233  cpl_test_eq_error(irplib_sdp_spectrum_reset_mepoch(b), CPL_ERROR_NONE);
234  cpl_test_error(CPL_ERROR_NONE);
235  cpl_test_eq_error(irplib_sdp_spectrum_reset_obstech(b), CPL_ERROR_NONE);
236  cpl_test_error(CPL_ERROR_NONE);
237  cpl_test_eq_error(irplib_sdp_spectrum_reset_fluxcal(b), CPL_ERROR_NONE);
238  cpl_test_error(CPL_ERROR_NONE);
239  cpl_test_eq_error(irplib_sdp_spectrum_reset_contnorm(b), CPL_ERROR_NONE);
240  cpl_test_error(CPL_ERROR_NONE);
241  cpl_test_eq_error(irplib_sdp_spectrum_reset_wavelmin(b), CPL_ERROR_NONE);
242  cpl_test_error(CPL_ERROR_NONE);
243  cpl_test_eq_error(irplib_sdp_spectrum_reset_wavelmax(b), CPL_ERROR_NONE);
244  cpl_test_error(CPL_ERROR_NONE);
245  cpl_test_eq_error(irplib_sdp_spectrum_reset_specbin(b), CPL_ERROR_NONE);
246  cpl_test_error(CPL_ERROR_NONE);
247  cpl_test_eq_error(irplib_sdp_spectrum_reset_totflux(b), CPL_ERROR_NONE);
248  cpl_test_error(CPL_ERROR_NONE);
249  cpl_test_eq_error(irplib_sdp_spectrum_reset_fluxerr(b), CPL_ERROR_NONE);
250  cpl_test_error(CPL_ERROR_NONE);
251  cpl_test_eq_error(irplib_sdp_spectrum_reset_referenc(b), CPL_ERROR_NONE);
252  cpl_test_error(CPL_ERROR_NONE);
253  cpl_test_eq_error(irplib_sdp_spectrum_reset_specres(b), CPL_ERROR_NONE);
254  cpl_test_error(CPL_ERROR_NONE);
255  cpl_test_eq_error(irplib_sdp_spectrum_reset_specerr(b), CPL_ERROR_NONE);
256  cpl_test_error(CPL_ERROR_NONE);
257  cpl_test_eq_error(irplib_sdp_spectrum_reset_specsye(b), CPL_ERROR_NONE);
258  cpl_test_error(CPL_ERROR_NONE);
259  cpl_test_eq_error(irplib_sdp_spectrum_reset_lamnlin(b), CPL_ERROR_NONE);
260  cpl_test_error(CPL_ERROR_NONE);
261  cpl_test_eq_error(irplib_sdp_spectrum_reset_lamrms(b), CPL_ERROR_NONE);
262  cpl_test_error(CPL_ERROR_NONE);
263  cpl_test_eq_error(irplib_sdp_spectrum_reset_gain(b), CPL_ERROR_NONE);
264  cpl_test_error(CPL_ERROR_NONE);
265  cpl_test_eq_error(irplib_sdp_spectrum_reset_detron(b), CPL_ERROR_NONE);
266  cpl_test_error(CPL_ERROR_NONE);
267  cpl_test_eq_error(irplib_sdp_spectrum_reset_effron(b), CPL_ERROR_NONE);
268  cpl_test_error(CPL_ERROR_NONE);
269  cpl_test_eq_error(irplib_sdp_spectrum_reset_snr(b), CPL_ERROR_NONE);
270  cpl_test_error(CPL_ERROR_NONE);
271  cpl_test_eq_error(irplib_sdp_spectrum_reset_ncombine(b), CPL_ERROR_NONE);
272  cpl_test_error(CPL_ERROR_NONE);
273  cpl_test_eq_error(irplib_sdp_spectrum_reset_voclass(b), CPL_ERROR_NONE);
274  cpl_test_error(CPL_ERROR_NONE);
275  cpl_test_eq_error(irplib_sdp_spectrum_reset_vopub(b), CPL_ERROR_NONE);
276  cpl_test_error(CPL_ERROR_NONE);
277  cpl_test_eq_error(irplib_sdp_spectrum_reset_title(b), CPL_ERROR_NONE);
278  cpl_test_error(CPL_ERROR_NONE);
279  cpl_test_eq_error(irplib_sdp_spectrum_reset_object(b), CPL_ERROR_NONE);
280  cpl_test_error(CPL_ERROR_NONE);
281  cpl_test_eq_error(irplib_sdp_spectrum_reset_aperture(b), CPL_ERROR_NONE);
282  cpl_test_error(CPL_ERROR_NONE);
283  cpl_test_eq_error(irplib_sdp_spectrum_reset_telapse(b), CPL_ERROR_NONE);
284  cpl_test_error(CPL_ERROR_NONE);
285  cpl_test_eq_error(irplib_sdp_spectrum_reset_tmid(b), CPL_ERROR_NONE);
286  cpl_test_error(CPL_ERROR_NONE);
287  cpl_test_eq_error(irplib_sdp_spectrum_reset_specval(b), CPL_ERROR_NONE);
288  cpl_test_error(CPL_ERROR_NONE);
289  cpl_test_eq_error(irplib_sdp_spectrum_reset_specbw(b), CPL_ERROR_NONE);
290  cpl_test_error(CPL_ERROR_NONE);
291  cpl_test_eq_error(irplib_sdp_spectrum_reset_extname(b), CPL_ERROR_NONE);
292  cpl_test_error(CPL_ERROR_NONE);
293  cpl_test_eq_error(irplib_sdp_spectrum_reset_inherit(b), CPL_ERROR_NONE);
294  cpl_test_error(CPL_ERROR_NONE);
295  cpl_test_eq_error(irplib_sdp_spectrum_reset_nelem(b), CPL_ERROR_NONE);
296  cpl_test_error(CPL_ERROR_NONE);
297  cpl_test_eq_error(irplib_sdp_spectrum_reset_tdmin(b), CPL_ERROR_NONE);
298  cpl_test_error(CPL_ERROR_NONE);
299  cpl_test_eq_error(irplib_sdp_spectrum_reset_tdmax(b), CPL_ERROR_NONE);
300  cpl_test_error(CPL_ERROR_NONE);
301  cpl_test_eq_error(irplib_sdp_spectrum_reset_prov(b, 1), CPL_ERROR_NONE);
302  cpl_test_error(CPL_ERROR_NONE);
303  cpl_test_eq_error(irplib_sdp_spectrum_reset_prov(b, 2), CPL_ERROR_NONE);
304  cpl_test_error(CPL_ERROR_NONE);
305  cpl_test_eq_error(irplib_sdp_spectrum_reset_asson(b, 1), CPL_ERROR_NONE);
306  cpl_test_error(CPL_ERROR_NONE);
307  cpl_test_eq_error(irplib_sdp_spectrum_reset_assoc(b, 1), CPL_ERROR_NONE);
308  cpl_test_error(CPL_ERROR_NONE);
309  cpl_test_eq_error(irplib_sdp_spectrum_reset_assom(b, 1), CPL_ERROR_NONE);
310  cpl_test_error(CPL_ERROR_NONE);
311 
312  /* Check that default values are returned for all keywords that were reset. */
313  cpl_test(isnan(irplib_sdp_spectrum_get_ra(b)));
314  cpl_test(isnan(irplib_sdp_spectrum_get_dec(b)));
315  cpl_test(isnan(irplib_sdp_spectrum_get_exptime(b)));
316  cpl_test(isnan(irplib_sdp_spectrum_get_texptime(b)));
317  cpl_test_null(irplib_sdp_spectrum_get_timesys(b));
318  cpl_test(isnan(irplib_sdp_spectrum_get_mjdobs(b)));
319  cpl_test(isnan(irplib_sdp_spectrum_get_mjdend(b)));
320  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(b), -1);
321  cpl_test_null(irplib_sdp_spectrum_get_procsoft(b));
322  cpl_test_null(irplib_sdp_spectrum_get_prodcatg(b));
323  cpl_test_null(irplib_sdp_spectrum_get_origin(b));
324  cpl_test_eq(irplib_sdp_spectrum_get_extobj(b), CPL_FALSE);
325  cpl_test_null(irplib_sdp_spectrum_get_dispelem(b));
326  cpl_test_null(irplib_sdp_spectrum_get_specsys(b));
327  cpl_test_null(irplib_sdp_spectrum_get_progid(b));
328  cpl_test_eq(irplib_sdp_spectrum_get_obid(b, 1), -1);
329  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(b), CPL_FALSE);
330  cpl_test_null(irplib_sdp_spectrum_get_obstech(b));
331  cpl_test_null(irplib_sdp_spectrum_get_fluxcal(b));
332  cpl_test_eq(irplib_sdp_spectrum_get_contnorm(b), CPL_FALSE);
333  cpl_test(isnan(irplib_sdp_spectrum_get_wavelmin(b)));
334  cpl_test(isnan(irplib_sdp_spectrum_get_wavelmax(b)));
335  cpl_test(isnan(irplib_sdp_spectrum_get_specbin(b)));
336  cpl_test_eq(irplib_sdp_spectrum_get_totflux(b), CPL_FALSE);
337  cpl_test(isnan(irplib_sdp_spectrum_get_fluxerr(b)));
338  cpl_test_null(irplib_sdp_spectrum_get_referenc(b));
339  cpl_test(isnan(irplib_sdp_spectrum_get_specres(b)));
340  cpl_test(isnan(irplib_sdp_spectrum_get_specerr(b)));
341  cpl_test(isnan(irplib_sdp_spectrum_get_specsye(b)));
342  cpl_test_eq(irplib_sdp_spectrum_get_lamnlin(b), -1);
343  cpl_test(isnan(irplib_sdp_spectrum_get_lamrms(b)));
344  cpl_test(isnan(irplib_sdp_spectrum_get_gain(b)));
345  cpl_test(isnan(irplib_sdp_spectrum_get_detron(b)));
346  cpl_test(isnan(irplib_sdp_spectrum_get_effron(b)));
347  cpl_test(isnan(irplib_sdp_spectrum_get_snr(b)));
348  cpl_test_eq(irplib_sdp_spectrum_get_ncombine(b), -1);
349  cpl_test_null(irplib_sdp_spectrum_get_voclass(b));
350  cpl_test_null(irplib_sdp_spectrum_get_vopub(b));
351  cpl_test_null(irplib_sdp_spectrum_get_title(b));
352  cpl_test_null(irplib_sdp_spectrum_get_object(b));
353  cpl_test(isnan(irplib_sdp_spectrum_get_aperture(b)));
354  cpl_test(isnan(irplib_sdp_spectrum_get_telapse(b)));
355  cpl_test(isnan(irplib_sdp_spectrum_get_tmid(b)));
356  cpl_test(isnan(irplib_sdp_spectrum_get_specval(b)));
357  cpl_test(isnan(irplib_sdp_spectrum_get_specbw(b)));
358  cpl_test_null(irplib_sdp_spectrum_get_extname(b));
359  cpl_test_eq(irplib_sdp_spectrum_get_inherit(b), CPL_FALSE);
360  cpl_test_eq(irplib_sdp_spectrum_get_nelem(b), 0);
361  cpl_test(isnan(irplib_sdp_spectrum_get_tdmin(b)));
362  cpl_test(isnan(irplib_sdp_spectrum_get_tdmax(b)));
363  cpl_test_null(irplib_sdp_spectrum_get_prov(b, 1));
364  cpl_test_null(irplib_sdp_spectrum_get_prov(b, 2));
365  cpl_test_null(irplib_sdp_spectrum_get_asson(b, 1));
366  cpl_test_null(irplib_sdp_spectrum_get_assoc(b, 1));
367  cpl_test_null(irplib_sdp_spectrum_get_assom(b, 1));
368 
369  irplib_sdp_spectrum_delete(b);
370  irplib_sdp_spectrum_delete(a);
371 
372  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
373 }
374 
375 
376 static int test_count_functions(void)
377 {
378  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
379  cpl_test_assert(a != NULL);
380 
381  /* Test that the irplib_sdp_spectrum_count_* functions return the correct
382  * values as we add keywords to the spectrum object. */
383  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 0);
384  irplib_sdp_spectrum_set_obid(a, 1, 1234);
385  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 1);
386  irplib_sdp_spectrum_set_obid(a, 2, 2345);
387  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 2);
388  irplib_sdp_spectrum_set_obid(a, 3, 3456);
389  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 3);
390  irplib_sdp_spectrum_set_obid(a, 901, 9012);
391  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 4);
392 
393  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 0);
394  irplib_sdp_spectrum_set_prov(a, 1, "a");
395  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 1);
396  irplib_sdp_spectrum_set_prov(a, 2, "b");
397  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 2);
398  irplib_sdp_spectrum_set_prov(a, 3, "c");
399  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 3);
400  irplib_sdp_spectrum_set_prov(a, 901, "d");
401  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 4);
402 
403  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 0);
404  irplib_sdp_spectrum_set_asson(a, 1, "a");
405  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 1);
406  irplib_sdp_spectrum_set_asson(a, 2, "b");
407  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 2);
408  irplib_sdp_spectrum_set_asson(a, 3, "c");
409  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 3);
410  irplib_sdp_spectrum_set_asson(a, 901, "d");
411  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 4);
412 
413  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 0);
414  irplib_sdp_spectrum_set_assoc(a, 1, "a");
415  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 1);
416  irplib_sdp_spectrum_set_assoc(a, 2, "b");
417  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 2);
418  irplib_sdp_spectrum_set_assoc(a, 3, "c");
419  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 3);
420  irplib_sdp_spectrum_set_assoc(a, 901, "d");
421  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 4);
422 
423  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 0);
424  irplib_sdp_spectrum_set_assom(a, 1, "a");
425  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 1);
426  irplib_sdp_spectrum_set_assom(a, 2, "b");
427  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 2);
428  irplib_sdp_spectrum_set_assom(a, 3, "c");
429  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 3);
430  irplib_sdp_spectrum_set_assom(a, 901, "d");
431  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 4);
432 
433  /* Now remove the keywords one by one and check if we still get the correct
434  * counts. First remove the middle keywords to check how the count routine
435  * deals with gaps in the keyword series. */
436  irplib_sdp_spectrum_reset_obid(a, 901);
437  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 3);
438  irplib_sdp_spectrum_reset_obid(a, 2);
439  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 2);
440  irplib_sdp_spectrum_reset_obid(a, 1);
441  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 1);
442  irplib_sdp_spectrum_reset_obid(a, 3);
443  cpl_test_eq(irplib_sdp_spectrum_count_obid(a), 0);
444 
445  irplib_sdp_spectrum_reset_prov(a, 901);
446  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 3);
447  irplib_sdp_spectrum_reset_prov(a, 2);
448  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 2);
449  irplib_sdp_spectrum_reset_prov(a, 1);
450  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 1);
451  irplib_sdp_spectrum_reset_prov(a, 3);
452  cpl_test_eq(irplib_sdp_spectrum_count_prov(a), 0);
453 
454  irplib_sdp_spectrum_reset_asson(a, 901);
455  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 3);
456  irplib_sdp_spectrum_reset_asson(a, 2);
457  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 2);
458  irplib_sdp_spectrum_reset_asson(a, 1);
459  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 1);
460  irplib_sdp_spectrum_reset_asson(a, 3);
461  cpl_test_eq(irplib_sdp_spectrum_count_asson(a), 0);
462 
463  irplib_sdp_spectrum_reset_assoc(a, 901);
464  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 3);
465  irplib_sdp_spectrum_reset_assoc(a, 2);
466  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 2);
467  irplib_sdp_spectrum_reset_assoc(a, 1);
468  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 1);
469  irplib_sdp_spectrum_reset_assoc(a, 3);
470  cpl_test_eq(irplib_sdp_spectrum_count_assoc(a), 0);
471 
472  irplib_sdp_spectrum_reset_assom(a, 901);
473  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 3);
474  irplib_sdp_spectrum_reset_assom(a, 2);
475  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 2);
476  irplib_sdp_spectrum_reset_assom(a, 1);
477  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 1);
478  irplib_sdp_spectrum_reset_assom(a, 3);
479  cpl_test_eq(irplib_sdp_spectrum_count_assom(a), 0);
480 
481  irplib_sdp_spectrum_delete(a);
482  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
483 }
484 
485 
486 static int test_column_functions(void)
487 {
488  const cpl_array *data;
489  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
490  cpl_test_assert(a != NULL);
491 
492  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
493 
494  /* Test simple column creation function. */
495  cpl_test_eq_error(irplib_sdp_spectrum_new_column(a, "A", CPL_TYPE_INT),
496  CPL_ERROR_NONE);
497  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
498  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 0);
499  cpl_test_eq(irplib_sdp_spectrum_get_column_type(a, "A"),
500  CPL_TYPE_INT | CPL_TYPE_POINTER);
501  cpl_test_null(irplib_sdp_spectrum_get_column_unit(a, "A"));
502  cpl_test_nonnull(irplib_sdp_spectrum_get_column_format(a, "A"));
503  cpl_test_null(irplib_sdp_spectrum_get_column_tutyp(a, "A"));
504  cpl_test_null(irplib_sdp_spectrum_get_column_tucd(a, "A"));
505  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
506  cpl_test_null(irplib_sdp_spectrum_get_column_data(a, "A"));
507  cpl_test_error(CPL_ERROR_NONE);
508 
509  /* Test setter functions. First set to a known values. Check that its correct.
510  * Then set the values to NULL and see that we get that again without error.
511  */
512  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(a, "A", "x"),
513  CPL_ERROR_NONE);
514  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "x");
515  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tucd(a, "A", "y"),
516  CPL_ERROR_NONE);
517  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "y");
518  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tcomm(a, "A", "z"),
519  CPL_ERROR_NONE);
520  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tcomm(a, "A"), "z");
521 
522  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(a, "A", NULL),
523  CPL_ERROR_NONE);
524  cpl_test_null(irplib_sdp_spectrum_get_column_tutyp(a, "A"));
525  cpl_test_error(CPL_ERROR_NONE);
526  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tucd(a, "A", NULL),
527  CPL_ERROR_NONE);
528  cpl_test_null(irplib_sdp_spectrum_get_column_tucd(a, "A"));
529  cpl_test_error(CPL_ERROR_NONE);
530  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tcomm(a, "A", NULL),
531  CPL_ERROR_NONE);
532  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
533  cpl_test_error(CPL_ERROR_NONE);
534 
535  /* Test column deletion. */
536  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
537  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
538  cpl_test_null(irplib_sdp_spectrum_get_column_tutyp(a, "A"));
539  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
540  cpl_test_null(irplib_sdp_spectrum_get_column_tucd(a, "A"));
541  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
542  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
543  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
544  cpl_test_null(irplib_sdp_spectrum_get_column_data(a, "A"));
545  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
546 
547  /* Test the add function with all extra parameters NULL. */
548  cpl_test_eq_error(
549  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_FLOAT,
550  NULL, NULL, NULL, NULL, NULL),
551  CPL_ERROR_NONE
552  );
553  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
554  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 0);
555  cpl_test_eq(irplib_sdp_spectrum_get_column_type(a, "A"),
556  CPL_TYPE_FLOAT | CPL_TYPE_POINTER);
557  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), " ");
558  cpl_test_nonnull(irplib_sdp_spectrum_get_column_format(a, "A"));
559  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
560  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
561  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
562  cpl_test_nonnull(irplib_sdp_spectrum_get_column_data(a, "A"));
563  cpl_test_error(CPL_ERROR_NONE);
564 
565  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
566  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
567 
568  /* Add a column and check the properties are correct. */
569  cpl_test_eq_error(
570  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_DOUBLE, "s", "1E",
571  NULL, NULL, NULL),
572  CPL_ERROR_NONE
573  );
574  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
575  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 0);
576  cpl_test_eq(irplib_sdp_spectrum_get_column_type(a, "A"),
577  CPL_TYPE_DOUBLE | CPL_TYPE_POINTER);
578  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "s");
579  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "1E");
580  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
581  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
582  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
583  cpl_test_nonnull(irplib_sdp_spectrum_get_column_data(a, "A"));
584 
585  /* Check setting of the column keywords. */
586  cpl_test_eq_error(irplib_sdp_spectrum_set_column_unit(a, "A", "sec"),
587  CPL_ERROR_NONE);
588  cpl_test_eq_error(irplib_sdp_spectrum_set_column_format(a, "A", "2E"),
589  CPL_ERROR_NONE);
590  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(a, "A", "t1"),
591  CPL_ERROR_NONE);
592  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tucd(a, "A", "u1"),
593  CPL_ERROR_NONE);
594  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tcomm(a, "A", "cmnt 1"),
595  CPL_ERROR_NONE);
596  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "sec");
597  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "2E");
598  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "t1");
599  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "u1");
600  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tcomm(a, "A"), "cmnt 1");
601  data = irplib_sdp_spectrum_get_column_data(a, "A");
602  cpl_test_nonnull(data);
603  cpl_test_eq(cpl_array_get_size(data), 0);
604 
605  /* Resize data arrays and check they were updated. */
606  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 10), CPL_ERROR_NONE);
607  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 10);
608  data = irplib_sdp_spectrum_get_column_data(a, "A");
609  cpl_test_nonnull(data);
610  cpl_test_eq(cpl_array_get_size(data), 10);
611 
612  /* Check for correct error response when trying to use a missing column. */
613  cpl_test_eq(irplib_sdp_spectrum_get_column_type(a, "C"), CPL_TYPE_INVALID);
614  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
615  cpl_test_null(irplib_sdp_spectrum_get_column_unit(a, "C"));
616  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
617  cpl_test_null(irplib_sdp_spectrum_get_column_format(a, "C"));
618  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
619  cpl_test_null(irplib_sdp_spectrum_get_column_tutyp(a, "C"));
620  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
621  cpl_test_null(irplib_sdp_spectrum_get_column_tucd(a, "C"));
622  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
623  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "C"));
624  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
625  cpl_test_null(irplib_sdp_spectrum_get_column_data(a, "C"));
626  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
627 
628  /* Add another column and check its properties are correct. */
629  cpl_test_eq_error(
630  irplib_sdp_spectrum_add_column(a, "B", CPL_TYPE_INT, "adu", "1J",
631  NULL, NULL, NULL),
632  CPL_ERROR_NONE
633  );
634  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 2);
635  cpl_test_eq(irplib_sdp_spectrum_get_column_type(a, "B"),
636  CPL_TYPE_INT | CPL_TYPE_POINTER);
637  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "B"), "adu");
638  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "B"), "1J");
639  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "");
640  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "");
641  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "B"));
642  data = irplib_sdp_spectrum_get_column_data(a, "B");
643  cpl_test_nonnull(data);
644  cpl_test_eq(cpl_array_get_size(data), 10);
645 
646  /* Resize data arrays again and check they were updated. */
647  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 5), CPL_ERROR_NONE);
648  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 5);
649  data = irplib_sdp_spectrum_get_column_data(a, "A");
650  cpl_test_nonnull(data);
651  cpl_test_eq(cpl_array_get_size(data), 5);
652  data = irplib_sdp_spectrum_get_column_data(a, "B");
653  cpl_test_nonnull(data);
654  cpl_test_eq(cpl_array_get_size(data), 5);
655 
656  irplib_sdp_spectrum_delete(a);
657  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
658 }
659 
660 
661 static int test_equal_function(void)
662 {
663  cpl_array *data;
664  double datapoints1[5] = {1.2, 2.3, 3.4, 4.5, 5.6};
665  double datapoints2[5] = {1.1, 2.4, 5.4, 4.6, 3.6};
666  irplib_sdp_spectrum *a, *b;
667 
668  /* Setup two empty spectra, and compare.
669  * Note: we compare both orders for the arguments, i.e. a, b and then b, a to
670  * make sure the behaviour is symmetric as expected. */
671  a = irplib_sdp_spectrum_new();
672  cpl_test_assert(a != NULL);
673  b = irplib_sdp_spectrum_new();
674  cpl_test_assert(b != NULL);
675  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_TRUE);
676  cpl_test_error(CPL_ERROR_NONE);
677  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_TRUE);
678  cpl_test_error(CPL_ERROR_NONE);
679  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_TRUE);
680  cpl_test_error(CPL_ERROR_NONE);
681  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_TRUE);
682  cpl_test_error(CPL_ERROR_NONE);
683  irplib_sdp_spectrum_delete(b);
684  irplib_sdp_spectrum_delete(a);
685 
686  /* Setup a spectrum, duplicated it and compare. */
687  a = irplib_sdp_spectrum_new();
688  cpl_test_assert(a != NULL);
689  fill_keywords(a);
690  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 5), CPL_ERROR_NONE);
691  cpl_test_eq_error(
692  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_DOUBLE, "s", "1E",
693  NULL, NULL, NULL),
694  CPL_ERROR_NONE
695  );
696  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(a, "A", "t1"),
697  CPL_ERROR_NONE);
698  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tucd(a, "A", "u1"),
699  CPL_ERROR_NONE);
700  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tcomm(a, "A", "c1"),
701  CPL_ERROR_NONE);
702  data = cpl_array_wrap_double(datapoints1, 5);
703  cpl_test_nonnull(data);
704  cpl_test_eq_error(irplib_sdp_spectrum_set_column_data(a, "A", data),
705  CPL_ERROR_NONE);
706  cpl_array_unwrap(data);
707 
708  b = irplib_sdp_spectrum_duplicate(a);
709  cpl_test_assert(b != NULL);
710  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_TRUE);
711  cpl_test_error(CPL_ERROR_NONE);
712  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_TRUE);
713  cpl_test_error(CPL_ERROR_NONE);
714  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_TRUE);
715  cpl_test_error(CPL_ERROR_NONE);
716  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_TRUE);
717  cpl_test_error(CPL_ERROR_NONE);
718 
719  /* Make a change to b's column keyword values and see if we still get the
720  * correct results. */
721  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(b, "A", "T3"),
722  CPL_ERROR_NONE);
723  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
724  cpl_test_error(CPL_ERROR_NONE);
725  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
726  cpl_test_error(CPL_ERROR_NONE);
727  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_FALSE);
728  cpl_test_error(CPL_ERROR_NONE);
729  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_FALSE);
730  cpl_test_error(CPL_ERROR_NONE);
731 
732  /* Check result if a column is added to b. */
733  irplib_sdp_spectrum_delete(b);
734  b = irplib_sdp_spectrum_duplicate(a);
735  cpl_test_eq_error(
736  irplib_sdp_spectrum_add_column(b, "B", CPL_TYPE_DOUBLE, "adu", "1J",
737  NULL, NULL, NULL),
738  CPL_ERROR_NONE
739  );
740  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
741  cpl_test_error(CPL_ERROR_NONE);
742  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
743  cpl_test_error(CPL_ERROR_NONE);
744  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_TRUE);
745  cpl_test_error(CPL_ERROR_NONE);
746  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_TRUE);
747  cpl_test_error(CPL_ERROR_NONE);
748 
749  /* Check if changes in the column data points are picked up. */
750  irplib_sdp_spectrum_delete(b);
751  b = irplib_sdp_spectrum_duplicate(a);
752  data = cpl_array_wrap_double(datapoints2, 5);
753  cpl_test_nonnull(data);
754  cpl_test_eq_error(irplib_sdp_spectrum_set_column_data(b, "A", data),
755  CPL_ERROR_NONE);
756  cpl_array_unwrap(data);
757  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
758  cpl_test_error(CPL_ERROR_NONE);
759  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
760  cpl_test_error(CPL_ERROR_NONE);
761  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_FALSE);
762  cpl_test_error(CPL_ERROR_NONE);
763  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_FALSE);
764  cpl_test_error(CPL_ERROR_NONE);
765 
766  /* Check results if the NELEM values are different, but we still have the same
767  * data point values for the overlapping part. */
768  irplib_sdp_spectrum_delete(b);
769  b = irplib_sdp_spectrum_duplicate(a);
770  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 4), CPL_ERROR_NONE);
771  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
772  cpl_test_error(CPL_ERROR_NONE);
773  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
774  cpl_test_error(CPL_ERROR_NONE);
775  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_TRUE);
776  cpl_test_error(CPL_ERROR_NONE);
777  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_TRUE);
778  cpl_test_error(CPL_ERROR_NONE);
779 
780  /* Check result if a primary keyword value is different. */
781  irplib_sdp_spectrum_delete(b);
782  b = irplib_sdp_spectrum_duplicate(a);
783  cpl_test_eq_error(irplib_sdp_spectrum_set_dec(b, 999), CPL_ERROR_NONE);
784  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
785  cpl_test_error(CPL_ERROR_NONE);
786  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
787  cpl_test_error(CPL_ERROR_NONE);
788  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_FALSE);
789  cpl_test_error(CPL_ERROR_NONE);
790  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_FALSE);
791  cpl_test_error(CPL_ERROR_NONE);
792 
793  /* Check result if b has some keywords missing. */
794  irplib_sdp_spectrum_delete(b);
795  b = irplib_sdp_spectrum_duplicate(a);
796  cpl_test_eq_error(irplib_sdp_spectrum_reset_dec(a), CPL_ERROR_NONE);
797  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_FALSE);
798  cpl_test_error(CPL_ERROR_NONE);
799  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_FALSE) == CPL_FALSE);
800  cpl_test_error(CPL_ERROR_NONE);
801  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_TRUE) == CPL_TRUE);
802  cpl_test_error(CPL_ERROR_NONE);
803  cpl_test(irplib_sdp_spectrum_equal(b, a, CPL_TRUE) == CPL_TRUE);
804  cpl_test_error(CPL_ERROR_NONE);
805 
806  irplib_sdp_spectrum_delete(b);
807  irplib_sdp_spectrum_delete(a);
808  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
809 }
810 
811 
812 static int test_io_functions(void)
813 {
814  cpl_frameset *emptyframes = cpl_frameset_new();
815  cpl_frameset *allframes = cpl_frameset_new();
816  cpl_propertylist *header = cpl_propertylist_new();
817  cpl_parameterlist *parlist = cpl_parameterlist_new();
818  cpl_frameset *usedframes = cpl_frameset_new();
819  const cpl_frame *inherit = NULL;
820  const char *recipe = "test_recipe";
821  cpl_propertylist *applist = cpl_propertylist_new();
822  cpl_propertylist *tablelist = cpl_propertylist_new();
823  const char *remregexp = "^(CHECKSUM|DATASUM)$";
824  const char *pipe_id = "iiinstrument";
825  const char *dict_id = "TEST_DICT";
826  cpl_error_code error;
827  const char *filename1 = "dummy_raw_input1.fits";
828  const char *filename2 = "dummy_test_sdp_spectrum1.fits";
829  const char *filename3 = "dummy_test_sdp_spectrum2.fits";
830  const char *filename4 = "dummy_test_sdp_spectrum3.fits";
831  cpl_array *data = NULL;
832  double datapoints[5] = {1.2, 2.3, 3.4, 4.5, 5.6};
833  irplib_sdp_spectrum *b = NULL;
834  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
835  const irplib_sdp_spectrum *spectrum = a;
836  cpl_frame *frame = cpl_frame_new();
837  cpl_propertylist *plist = cpl_propertylist_new();
838  cpl_image *image = cpl_image_new(10, 10, CPL_TYPE_FLOAT);
839 
840  cpl_test_assert(allframes != NULL);
841  cpl_test_assert(header != NULL);
842  cpl_test_assert(parlist != NULL);
843  cpl_test_assert(usedframes != NULL);
844  cpl_test_assert(applist != NULL);
845  cpl_test_assert(tablelist != NULL);
846  cpl_test_assert(a != NULL);
847 
848  /* Make sure to delete dummy test files so no stale date gets used. */
849  (void) remove(filename1);
850  (void) remove(filename2);
851  (void) remove(filename3);
852  (void) remove(filename4);
853  errno = 0; /* In case of expected failure so that CPL tests done fail. */
854 
855  /* Save an empty spectrum to file and check we can load it back. */
856  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 2), CPL_ERROR_NONE);
857  cpl_test_eq_error( /* Have to setup at least one column or load will fail. */
858  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_DOUBLE, "s", "5D",
859  NULL, NULL, NULL),
860  CPL_ERROR_NONE
861  );
862  cpl_test_eq_error(irplib_sdp_spectrum_save(a, filename2, NULL, NULL),
863  CPL_ERROR_NONE);
864  b = irplib_sdp_spectrum_load(filename2);
865  cpl_test_nonnull(b);
866  cpl_test_error(CPL_ERROR_NONE);
867  cpl_test_eq_error(irplib_sdp_spectrum_reset_origin(b), CPL_ERROR_NONE);
868  cpl_test_eq_error(irplib_sdp_spectrum_reset_prodlvl(b), CPL_ERROR_NONE);
869  cpl_test_eq_error(irplib_sdp_spectrum_reset_specsys(b), CPL_ERROR_NONE);
870  cpl_test_eq_error(irplib_sdp_spectrum_reset_fluxerr(b), CPL_ERROR_NONE);
871  cpl_test_eq_error(irplib_sdp_spectrum_reset_referenc(b), CPL_ERROR_NONE);
872  cpl_test_eq_error(irplib_sdp_spectrum_reset_voclass(b), CPL_ERROR_NONE);
873  cpl_test_eq_error(irplib_sdp_spectrum_reset_vopub(b), CPL_ERROR_NONE);
874  cpl_test_eq_error(irplib_sdp_spectrum_reset_extname(b), CPL_ERROR_NONE);
875  cpl_test_eq_error(irplib_sdp_spectrum_reset_inherit(b), CPL_ERROR_NONE);
876  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_TRUE);
877 
878  /* Setup a dummy spectrum and save to file. */
879  fill_keywords(a);
880  cpl_test_eq_error(irplib_sdp_spectrum_set_nelem(a, 5), CPL_ERROR_NONE);
881  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tutyp(a, "A", "t1"),
882  CPL_ERROR_NONE);
883  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tucd(a, "A", "u1"),
884  CPL_ERROR_NONE);
885  cpl_test_eq_error(irplib_sdp_spectrum_set_column_tcomm(a, "A", "c1"),
886  CPL_ERROR_NONE);
887 
888  data = cpl_array_wrap_double(datapoints, 5);
889  cpl_test_nonnull(data);
890  cpl_test_eq_error(irplib_sdp_spectrum_set_column_data(a, "A", data),
891  CPL_ERROR_NONE);
892  cpl_array_unwrap(data);
893 
894  cpl_test_eq_error(irplib_sdp_spectrum_save(a, filename3, NULL, NULL),
895  CPL_ERROR_NONE);
896 
897  /* Now load back the spectrum and see that we have the same structure. */
898  irplib_sdp_spectrum_delete(b);
899  b = irplib_sdp_spectrum_load(filename3);
900  cpl_test_nonnull(b);
901  cpl_test_error(CPL_ERROR_NONE);
902  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_TRUE);
903 
904  /* Save the spectrum with the DFS version and see if we get the same
905  * value after loading it back. */
906  cpl_test_eq_error(cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
907  "TEST_SPECTRUM"),
908  CPL_ERROR_NONE);
909 
910  cpl_test_eq_error(cpl_image_save(image, filename1, CPL_TYPE_FLOAT, plist, CPL_IO_CREATE),
911  CPL_ERROR_NONE);
912 
913  cpl_test_eq_error(cpl_frame_set_filename(frame, filename1),
914  CPL_ERROR_NONE);
915  cpl_test_eq_error(cpl_frame_set_tag(frame, "RAW_IMAGE"),
916  CPL_ERROR_NONE);
917  cpl_test_eq_error(cpl_frame_set_type(frame, CPL_FRAME_TYPE_IMAGE),
918  CPL_ERROR_NONE);
919  cpl_test_eq_error(cpl_frame_set_group(frame, CPL_FRAME_GROUP_RAW),
920  CPL_ERROR_NONE);
921  cpl_test_eq_error(cpl_frame_set_level(frame, CPL_FRAME_LEVEL_FINAL),
922  CPL_ERROR_NONE);
923  cpl_test_eq_error(cpl_frameset_insert(usedframes, frame), CPL_ERROR_NONE);
924 
925  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
926  inherit, spectrum, recipe, applist, tablelist, remregexp,
927  pipe_id, dict_id, filename4);
928  cpl_test_eq_error(error, CPL_ERROR_NONE);
929 
930  irplib_sdp_spectrum_delete(b);
931  b = irplib_sdp_spectrum_load(filename4);
932  cpl_test_nonnull(b);
933  cpl_test_error(CPL_ERROR_NONE);
934  cpl_test(irplib_sdp_spectrum_equal(a, b, CPL_FALSE) == CPL_TRUE);
935 
936  /* Check error handling for NULL input. */
937  error = irplib_dfs_save_spectrum(NULL, header, parlist, usedframes,
938  inherit, spectrum, recipe, applist, tablelist, remregexp,
939  pipe_id, dict_id, filename4);
940  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
941 
942  error = irplib_dfs_save_spectrum(allframes, header, NULL, usedframes,
943  inherit, spectrum, recipe, applist, tablelist, remregexp,
944  pipe_id, dict_id, filename4);
945  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
946 
947  error = irplib_dfs_save_spectrum(allframes, header, parlist, NULL,
948  inherit, spectrum, recipe, applist, tablelist, remregexp,
949  pipe_id, dict_id, filename4);
950  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
951 
952  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
953  inherit, NULL, recipe, applist, tablelist, remregexp,
954  pipe_id, dict_id, filename4);
955  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
956 
957  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
958  inherit, spectrum, NULL, applist, tablelist, remregexp,
959  pipe_id, dict_id, filename4);
960  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
961 
962  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
963  inherit, spectrum, recipe, NULL, tablelist, remregexp,
964  pipe_id, dict_id, filename4);
965  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
966 
967  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
968  inherit, spectrum, recipe, applist, tablelist, remregexp,
969  NULL, dict_id, filename4);
970  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
971 
972  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
973  inherit, spectrum, recipe, applist, tablelist, remregexp,
974  pipe_id, NULL, filename4);
975  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
976 
977  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
978  inherit, spectrum, recipe, applist, tablelist, remregexp,
979  pipe_id, dict_id, NULL);
980  cpl_test_eq_error(error, CPL_ERROR_NULL_INPUT);
981 
982  /* Check error handling of irplib_dfs_save_spectrum. */
983  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
984  inherit, spectrum, recipe, applist, tablelist, remregexp,
985  pipe_id, dict_id, "./invalid/");
986  cpl_test_eq_error(error, CPL_ERROR_FILE_NOT_CREATED);
987 
988  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
989  inherit, spectrum, recipe, applist, tablelist, "^^[[((",
990  pipe_id, dict_id, filename4);
991  cpl_test_eq_error(error, CPL_ERROR_ILLEGAL_INPUT);
992 
993  error = irplib_dfs_save_spectrum(allframes, header, parlist, emptyframes,
994  inherit, spectrum, recipe, applist, tablelist, remregexp,
995  pipe_id, dict_id, filename4);
996  cpl_test_eq_error(error, CPL_ERROR_DATA_NOT_FOUND);
997 
998  cpl_propertylist_empty(applist);
999  error = irplib_dfs_save_spectrum(allframes, header, parlist, usedframes,
1000  inherit, spectrum, recipe, applist, tablelist, remregexp,
1001  pipe_id, dict_id, filename4);
1002  cpl_test_eq_error(error, CPL_ERROR_DATA_NOT_FOUND);
1003 
1004  /* Remove the FITS files if no errors were detected and clean up memory. */
1005  if (cpl_test_get_failed() == 0) {
1006  (void) remove(filename1);
1007  (void) remove(filename2);
1008  (void) remove(filename3);
1009  (void) remove(filename4);
1010  }
1011  irplib_sdp_spectrum_delete(b);
1012  irplib_sdp_spectrum_delete(a);
1013  cpl_image_delete(image);
1014  cpl_propertylist_delete(plist);
1015  cpl_frameset_delete(emptyframes);
1016  cpl_frameset_delete(allframes);
1017  cpl_propertylist_delete(header);
1018  cpl_parameterlist_delete(parlist);
1019  cpl_frameset_delete(usedframes);
1020  cpl_propertylist_delete(applist);
1021  cpl_propertylist_delete(tablelist);
1022  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1023 }
1024 
1025 
1026 static int test_copy_functions(void)
1027 {
1028  /* Create a property list with some dummy test keywords. We then test that the
1029  * copy functions behave correctly when trying to copy from this list to an
1030  * SDP spectrum object. */
1031  cpl_propertylist *plist = cpl_propertylist_new();
1032  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
1033  cpl_test_assert(plist != NULL);
1034  cpl_test_assert(a != NULL);
1035 
1036  cpl_test_assert(cpl_propertylist_append_bool(plist, "TEST_BOOL", CPL_TRUE)
1037  == CPL_ERROR_NONE);
1038  cpl_test_assert(cpl_propertylist_append_int(plist, "TEST_INT", 123)
1039  == CPL_ERROR_NONE);
1040  cpl_test_assert(cpl_propertylist_append_long_long(plist, "TEST_LONGLONG", 432)
1041  == CPL_ERROR_NONE);
1042  cpl_test_assert(cpl_propertylist_append_double(plist, "TEST_DOUBLE", 2.34)
1043  == CPL_ERROR_NONE);
1044  cpl_test_assert(cpl_propertylist_append_string(plist, "TEST_STRING", "abc")
1045  == CPL_ERROR_NONE);
1046 
1047  cpl_test_eq_error(irplib_sdp_spectrum_copy_ra(a, plist, "TEST_DOUBLE"),
1048  CPL_ERROR_NONE);
1049  cpl_test_abs(irplib_sdp_spectrum_get_ra(a), 2.34, DBL_EPSILON);
1050  cpl_test_eq_error(irplib_sdp_spectrum_copy_dec(a, plist, "TEST_DOUBLE"),
1051  CPL_ERROR_NONE);
1052  cpl_test_abs(irplib_sdp_spectrum_get_dec(a), 2.34, DBL_EPSILON);
1053  cpl_test_eq_error(irplib_sdp_spectrum_copy_exptime(a, plist, "TEST_DOUBLE"),
1054  CPL_ERROR_NONE);
1055  cpl_test_abs(irplib_sdp_spectrum_get_exptime(a), 2.34, DBL_EPSILON);
1056  cpl_test_eq_error(irplib_sdp_spectrum_copy_texptime(a, plist, "TEST_DOUBLE"),
1057  CPL_ERROR_NONE);
1058  cpl_test_abs(irplib_sdp_spectrum_get_texptime(a), 2.34, DBL_EPSILON);
1059  cpl_test_eq_error(irplib_sdp_spectrum_copy_timesys(a, plist, "TEST_STRING"),
1060  CPL_ERROR_NONE);
1061  cpl_test_eq_string(irplib_sdp_spectrum_get_timesys(a), "abc");
1062  cpl_test_eq_error(irplib_sdp_spectrum_copy_mjdobs(a, plist, "TEST_DOUBLE"),
1063  CPL_ERROR_NONE);
1064  cpl_test_abs(irplib_sdp_spectrum_get_mjdobs(a), 2.34, DBL_EPSILON);
1065  cpl_test_eq_error(irplib_sdp_spectrum_copy_mjdend(a, plist, "TEST_DOUBLE"),
1066  CPL_ERROR_NONE);
1067  cpl_test_abs(irplib_sdp_spectrum_get_mjdend(a), 2.34, DBL_EPSILON);
1068  cpl_test_eq_error(irplib_sdp_spectrum_copy_prodlvl(a, plist, "TEST_INT"),
1069  CPL_ERROR_NONE);
1070  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(a), 123);
1071  cpl_test_eq_error(irplib_sdp_spectrum_copy_procsoft(a, plist, "TEST_STRING"),
1072  CPL_ERROR_NONE);
1073  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(a), "abc");
1074  cpl_test_eq_error(irplib_sdp_spectrum_copy_prodcatg(a, plist, "TEST_STRING"),
1075  CPL_ERROR_NONE);
1076  cpl_test_eq_string(irplib_sdp_spectrum_get_prodcatg(a), "abc");
1077  cpl_test_eq_error(irplib_sdp_spectrum_copy_origin(a, plist, "TEST_STRING"),
1078  CPL_ERROR_NONE);
1079  cpl_test_eq_string(irplib_sdp_spectrum_get_origin(a), "abc");
1080  cpl_test_eq_error(irplib_sdp_spectrum_copy_extobj(a, plist, "TEST_BOOL"),
1081  CPL_ERROR_NONE);
1082  cpl_test_eq(irplib_sdp_spectrum_get_extobj(a), CPL_TRUE);
1083  cpl_test_eq_error(irplib_sdp_spectrum_copy_dispelem(a, plist, "TEST_STRING"),
1084  CPL_ERROR_NONE);
1085  cpl_test_eq_string(irplib_sdp_spectrum_get_dispelem(a), "abc");
1086  cpl_test_eq_error(irplib_sdp_spectrum_copy_specsys(a, plist, "TEST_STRING"),
1087  CPL_ERROR_NONE);
1088  cpl_test_eq_string(irplib_sdp_spectrum_get_specsys(a), "abc");
1089  cpl_test_eq_error(irplib_sdp_spectrum_copy_progid(a, plist, "TEST_STRING"),
1090  CPL_ERROR_NONE);
1091  cpl_test_eq_string(irplib_sdp_spectrum_get_progid(a), "abc");
1092  cpl_test_eq_error(irplib_sdp_spectrum_copy_obid(a, 1, plist, "TEST_INT"),
1093  CPL_ERROR_NONE);
1094  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 1), 123);
1095  cpl_test_eq_error(irplib_sdp_spectrum_copy_mepoch(a, plist, "TEST_BOOL"),
1096  CPL_ERROR_NONE);
1097  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(a), CPL_TRUE);
1098  cpl_test_eq_error(irplib_sdp_spectrum_copy_obstech(a, plist, "TEST_STRING"),
1099  CPL_ERROR_NONE);
1100  cpl_test_eq_string(irplib_sdp_spectrum_get_obstech(a), "abc");
1101  cpl_test_eq_error(irplib_sdp_spectrum_copy_fluxcal(a, plist, "TEST_STRING"),
1102  CPL_ERROR_NONE);
1103  cpl_test_eq_string(irplib_sdp_spectrum_get_fluxcal(a), "abc");
1104  cpl_test_eq_error(irplib_sdp_spectrum_copy_contnorm(a, plist, "TEST_BOOL"),
1105  CPL_ERROR_NONE);
1106  cpl_test_eq(irplib_sdp_spectrum_get_contnorm(a), CPL_TRUE);
1107  cpl_test_eq_error(irplib_sdp_spectrum_copy_wavelmin(a, plist, "TEST_DOUBLE"),
1108  CPL_ERROR_NONE);
1109  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(a), 2.34, DBL_EPSILON);
1110  cpl_test_eq_error(irplib_sdp_spectrum_copy_wavelmax(a, plist, "TEST_DOUBLE"),
1111  CPL_ERROR_NONE);
1112  cpl_test_abs(irplib_sdp_spectrum_get_wavelmax(a), 2.34, DBL_EPSILON);
1113  cpl_test_eq_error(irplib_sdp_spectrum_copy_specbin(a, plist, "TEST_DOUBLE"),
1114  CPL_ERROR_NONE);
1115  cpl_test_abs(irplib_sdp_spectrum_get_specbin(a), 2.34, DBL_EPSILON);
1116  cpl_test_eq_error(irplib_sdp_spectrum_copy_totflux(a, plist, "TEST_BOOL"),
1117  CPL_ERROR_NONE);
1118  cpl_test_eq(irplib_sdp_spectrum_get_totflux(a), CPL_TRUE);
1119  cpl_test_eq_error(irplib_sdp_spectrum_copy_fluxerr(a, plist, "TEST_DOUBLE"),
1120  CPL_ERROR_NONE);
1121  cpl_test_abs(irplib_sdp_spectrum_get_fluxerr(a), 2.34, DBL_EPSILON);
1122  cpl_test_eq_error(irplib_sdp_spectrum_copy_referenc(a, plist, "TEST_STRING"),
1123  CPL_ERROR_NONE);
1124  cpl_test_eq_string(irplib_sdp_spectrum_get_referenc(a), "abc");
1125  cpl_test_eq_error(irplib_sdp_spectrum_copy_specres(a, plist, "TEST_DOUBLE"),
1126  CPL_ERROR_NONE);
1127  cpl_test_abs(irplib_sdp_spectrum_get_specres(a), 2.34, DBL_EPSILON);
1128  cpl_test_eq_error(irplib_sdp_spectrum_copy_specerr(a, plist, "TEST_DOUBLE"),
1129  CPL_ERROR_NONE);
1130  cpl_test_abs(irplib_sdp_spectrum_get_specerr(a), 2.34, DBL_EPSILON);
1131  cpl_test_eq_error(irplib_sdp_spectrum_copy_specsye(a, plist, "TEST_DOUBLE"),
1132  CPL_ERROR_NONE);
1133  cpl_test_abs(irplib_sdp_spectrum_get_specsye(a), 2.34, DBL_EPSILON);
1134  cpl_test_eq_error(irplib_sdp_spectrum_copy_lamnlin(a, plist, "TEST_INT"),
1135  CPL_ERROR_NONE);
1136  cpl_test_eq(irplib_sdp_spectrum_get_lamnlin(a), 123);
1137  cpl_test_eq_error(irplib_sdp_spectrum_copy_lamrms(a, plist, "TEST_DOUBLE"),
1138  CPL_ERROR_NONE);
1139  cpl_test_abs(irplib_sdp_spectrum_get_lamrms(a), 2.34, DBL_EPSILON);
1140  cpl_test_eq_error(irplib_sdp_spectrum_copy_gain(a, plist, "TEST_DOUBLE"),
1141  CPL_ERROR_NONE);
1142  cpl_test_abs(irplib_sdp_spectrum_get_gain(a), 2.34, DBL_EPSILON);
1143  cpl_test_eq_error(irplib_sdp_spectrum_copy_detron(a, plist, "TEST_DOUBLE"),
1144  CPL_ERROR_NONE);
1145  cpl_test_abs(irplib_sdp_spectrum_get_detron(a), 2.34, DBL_EPSILON);
1146  cpl_test_eq_error(irplib_sdp_spectrum_copy_effron(a, plist, "TEST_DOUBLE"),
1147  CPL_ERROR_NONE);
1148  cpl_test_abs(irplib_sdp_spectrum_get_effron(a), 2.34, DBL_EPSILON);
1149  cpl_test_eq_error(irplib_sdp_spectrum_copy_snr(a, plist, "TEST_DOUBLE"),
1150  CPL_ERROR_NONE);
1151  cpl_test_abs(irplib_sdp_spectrum_get_snr(a), 2.34, DBL_EPSILON);
1152  cpl_test_eq_error(irplib_sdp_spectrum_copy_ncombine(a, plist, "TEST_INT"),
1153  CPL_ERROR_NONE);
1154  cpl_test_eq(irplib_sdp_spectrum_get_ncombine(a), 123);
1155  cpl_test_eq_error(irplib_sdp_spectrum_copy_prov(a, 1, plist, "TEST_STRING"),
1156  CPL_ERROR_NONE);
1157  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 1), "abc");
1158  cpl_test_eq_error(irplib_sdp_spectrum_copy_asson(a, 1, plist, "TEST_STRING"),
1159  CPL_ERROR_NONE);
1160  cpl_test_eq_string(irplib_sdp_spectrum_get_asson(a, 1), "abc");
1161  cpl_test_eq_error(irplib_sdp_spectrum_copy_assoc(a, 1, plist, "TEST_STRING"),
1162  CPL_ERROR_NONE);
1163  cpl_test_eq_string(irplib_sdp_spectrum_get_assoc(a, 1), "abc");
1164  cpl_test_eq_error(irplib_sdp_spectrum_copy_assom(a, 1, plist, "TEST_STRING"),
1165  CPL_ERROR_NONE);
1166  cpl_test_eq_string(irplib_sdp_spectrum_get_assom(a, 1), "abc");
1167  cpl_test_eq_error(irplib_sdp_spectrum_copy_voclass(a, plist, "TEST_STRING"),
1168  CPL_ERROR_NONE);
1169  cpl_test_eq_string(irplib_sdp_spectrum_get_voclass(a), "abc");
1170  cpl_test_eq_error(irplib_sdp_spectrum_copy_vopub(a, plist, "TEST_STRING"),
1171  CPL_ERROR_NONE);
1172  cpl_test_eq_string(irplib_sdp_spectrum_get_vopub(a), "abc");
1173  cpl_test_eq_error(irplib_sdp_spectrum_copy_title(a, plist, "TEST_STRING"),
1174  CPL_ERROR_NONE);
1175  cpl_test_eq_string(irplib_sdp_spectrum_get_title(a), "abc");
1176  cpl_test_eq_error(irplib_sdp_spectrum_copy_object(a, plist, "TEST_STRING"),
1177  CPL_ERROR_NONE);
1178  cpl_test_eq_string(irplib_sdp_spectrum_get_object(a), "abc");
1179  cpl_test_eq_error(irplib_sdp_spectrum_copy_aperture(a, plist, "TEST_DOUBLE"),
1180  CPL_ERROR_NONE);
1181  cpl_test_abs(irplib_sdp_spectrum_get_aperture(a), 2.34, DBL_EPSILON);
1182  cpl_test_eq_error(irplib_sdp_spectrum_copy_telapse(a, plist, "TEST_DOUBLE"),
1183  CPL_ERROR_NONE);
1184  cpl_test_abs(irplib_sdp_spectrum_get_telapse(a), 2.34, DBL_EPSILON);
1185  cpl_test_eq_error(irplib_sdp_spectrum_copy_tmid(a, plist, "TEST_DOUBLE"),
1186  CPL_ERROR_NONE);
1187  cpl_test_abs(irplib_sdp_spectrum_get_tmid(a), 2.34, DBL_EPSILON);
1188  cpl_test_eq_error(irplib_sdp_spectrum_copy_specval(a, plist, "TEST_DOUBLE"),
1189  CPL_ERROR_NONE);
1190  cpl_test_abs(irplib_sdp_spectrum_get_specval(a), 2.34, DBL_EPSILON);
1191  cpl_test_eq_error(irplib_sdp_spectrum_copy_specbw(a, plist, "TEST_DOUBLE"),
1192  CPL_ERROR_NONE);
1193  cpl_test_abs(irplib_sdp_spectrum_get_specbw(a), 2.34, DBL_EPSILON);
1194  cpl_test_eq_error(irplib_sdp_spectrum_copy_extname(a, plist, "TEST_STRING"),
1195  CPL_ERROR_NONE);
1196  cpl_test_eq_string(irplib_sdp_spectrum_get_extname(a), "abc");
1197  cpl_test_eq_error(irplib_sdp_spectrum_copy_inherit(a, plist, "TEST_BOOL"),
1198  CPL_ERROR_NONE);
1199  cpl_test_eq(irplib_sdp_spectrum_get_inherit(a), CPL_TRUE);
1200  cpl_test_eq_error(irplib_sdp_spectrum_copy_nelem(a, plist, "TEST_LONGLONG"),
1201  CPL_ERROR_NONE);
1202  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 432);
1203  cpl_test_eq_error(irplib_sdp_spectrum_copy_tdmin(a, plist, "TEST_DOUBLE"),
1204  CPL_ERROR_NONE);
1205  cpl_test_abs(irplib_sdp_spectrum_get_tdmin(a), 2.34, DBL_EPSILON);
1206  cpl_test_eq_error(irplib_sdp_spectrum_copy_tdmax(a, plist, "TEST_DOUBLE"),
1207  CPL_ERROR_NONE);
1208  cpl_test_abs(irplib_sdp_spectrum_get_tdmax(a), 2.34, DBL_EPSILON);
1209 
1210  /* We check the error handling for a few examples. Dont need to check all
1211  * since most functions derive from the same template code. However, we do
1212  * check every function for successful operation above to make sure the
1213  * function is declared properly and links correctly. */
1214  cpl_test_eq_error(irplib_sdp_spectrum_copy_ra(a, plist, "TEST_STRING"),
1215  CPL_ERROR_TYPE_MISMATCH);
1216  cpl_test_eq_error(irplib_sdp_spectrum_copy_ra(a, plist, "SOME_KEY"),
1217  CPL_ERROR_DATA_NOT_FOUND);
1218  cpl_test_eq_error(irplib_sdp_spectrum_copy_prodlvl(a, plist, "TEST_STRING"),
1219  CPL_ERROR_TYPE_MISMATCH);
1220  cpl_test_eq_error(irplib_sdp_spectrum_copy_prodlvl(a, plist, "SOME_KEY"),
1221  CPL_ERROR_DATA_NOT_FOUND);
1222  cpl_test_eq_error(irplib_sdp_spectrum_copy_procsoft(a, plist, "TEST_INT"),
1223  CPL_ERROR_TYPE_MISMATCH);
1224  cpl_test_eq_error(irplib_sdp_spectrum_copy_procsoft(a, plist, "SOME_KEY"),
1225  CPL_ERROR_DATA_NOT_FOUND);
1226  cpl_test_eq_error(irplib_sdp_spectrum_copy_obid(a, 1, plist, "TEST_STRING"),
1227  CPL_ERROR_TYPE_MISMATCH);
1228  cpl_test_eq_error(irplib_sdp_spectrum_copy_obid(a, 1, plist, "SOME_KEY"),
1229  CPL_ERROR_DATA_NOT_FOUND);
1230  cpl_test_eq_error(irplib_sdp_spectrum_copy_mepoch(a, plist, "TEST_STRING"),
1231  CPL_ERROR_TYPE_MISMATCH);
1232  cpl_test_eq_error(irplib_sdp_spectrum_copy_mepoch(a, plist, "SOME_KEY"),
1233  CPL_ERROR_DATA_NOT_FOUND);
1234  cpl_test_eq_error(irplib_sdp_spectrum_copy_prov(a, 1, plist, "TEST_INT"),
1235  CPL_ERROR_TYPE_MISMATCH);
1236  cpl_test_eq_error(irplib_sdp_spectrum_copy_prov(a, 1, plist, "SOME_KEY"),
1237  CPL_ERROR_DATA_NOT_FOUND);
1238  cpl_test_eq_error(irplib_sdp_spectrum_copy_nelem(a, plist, "TEST_STRING"),
1239  CPL_ERROR_TYPE_MISMATCH);
1240  cpl_test_eq_error(irplib_sdp_spectrum_copy_nelem(a, plist, "SOME_KEY"),
1241  CPL_ERROR_DATA_NOT_FOUND);
1242 
1243  irplib_sdp_spectrum_delete(a);
1244  cpl_propertylist_delete(plist);
1245  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1246 }
1247 
1248 
1249 static int test_column_copy_update_functions(void)
1250 {
1251  const cpl_array *testdata;
1252  int valuesA[2] = {678, 890};
1253  int valuesD[2] = {345, 765};
1254  cpl_array *data;
1255  cpl_table *table = cpl_table_new(1);
1256  cpl_propertylist *plist = cpl_propertylist_new();
1257  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
1258  cpl_test_assert(table != NULL);
1259  cpl_test_assert(a != NULL);
1260 
1261  /* Create a test table and test copying the columns using the column copy
1262  * functions. */
1263  cpl_test_assert(cpl_table_new_column_array(table, "A", CPL_TYPE_INT, 2)
1264  == CPL_ERROR_NONE);
1265  cpl_test_assert(cpl_table_set_column_unit(table, "A", "x")
1266  == CPL_ERROR_NONE);
1267  cpl_test_assert(cpl_table_set_column_format(table, "A", "%d")
1268  == CPL_ERROR_NONE);
1269  data = cpl_array_wrap_int(valuesA, 2);
1270  cpl_test_assert(data != NULL);
1271  cpl_test_assert(cpl_table_set_array(table, "A", 0, data)
1272  == CPL_ERROR_NONE);
1273  cpl_array_unwrap(data);
1274  cpl_test_assert(cpl_table_new_column(table, "B", CPL_TYPE_DOUBLE)
1275  == CPL_ERROR_NONE);
1276  cpl_test_assert(cpl_table_new_column(table, "C", CPL_TYPE_STRING)
1277  == CPL_ERROR_NONE);
1278 
1279  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1280  CPL_ERROR_NONE);
1281  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1282  cpl_test(! irplib_sdp_spectrum_has_column(a, "B"));
1283  cpl_test(! irplib_sdp_spectrum_has_column(a, "C"));
1284  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1285  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1286  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1287  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1288  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1289  cpl_test_null(irplib_sdp_spectrum_get_column_tutyp(a, "A"));
1290  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
1291  cpl_test_null(irplib_sdp_spectrum_get_column_tucd(a, "A"));
1292  cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
1293 
1294  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_regexp(a, table, "A|B", 0),
1295  CPL_ERROR_NONE);
1296  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1297  cpl_test(irplib_sdp_spectrum_has_column(a, "B"));
1298  cpl_test(! irplib_sdp_spectrum_has_column(a, "C"));
1299  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 2);
1300  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1301  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1302  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "");
1303  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "");
1304  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1305  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "B"), CPL_ERROR_NONE);
1306  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1307 
1308  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_regexp(a, table, "A|B", 1),
1309  CPL_ERROR_NONE);
1310  cpl_test(! irplib_sdp_spectrum_has_column(a, "A"));
1311  cpl_test(! irplib_sdp_spectrum_has_column(a, "B"));
1312  cpl_test(irplib_sdp_spectrum_has_column(a, "C"));
1313  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1314  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "C"), "");
1315  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "C"), "");
1316  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "C"), CPL_ERROR_NONE);
1317  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1318 
1319  /* Fill the dummy property list and test the individual keyword copy
1320  * functions. */
1321  cpl_test_assert(cpl_propertylist_append_string(plist, "TS", "abc")
1322  == CPL_ERROR_NONE);
1323 
1324  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1325  CPL_ERROR_NONE);
1326  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1327  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1328  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1329  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1330  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1331  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_unit(a, "A", plist, "TS"),
1332  CPL_ERROR_NONE);
1333  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "abc");
1334  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1335  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1336  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1337  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1338  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1339  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1340 
1341  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1342  CPL_ERROR_NONE);
1343  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1344  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1345  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1346  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1347  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1348  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_tutyp(a, "A", plist, "TS"),
1349  CPL_ERROR_NONE);
1350  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1351  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1352  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "abc");
1353  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1354  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1355  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1356  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1357 
1358  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1359  CPL_ERROR_NONE);
1360  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1361  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1362  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1363  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1364  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1365  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_tucd(a, "A", plist, "TS"),
1366  CPL_ERROR_NONE);
1367  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1368  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1369  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1370  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "abc");
1371  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1372  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1373  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1374 
1375  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1376  CPL_ERROR_NONE);
1377  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1378  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1379  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1380  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1381  cpl_test_null(irplib_sdp_spectrum_get_column_tcomm(a, "A"));
1382  cpl_test_eq_error(irplib_sdp_spectrum_copy_column_tcomm(a, "A", plist, "TS"),
1383  CPL_ERROR_NONE);
1384  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1385  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1386  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1387  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1388  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tcomm(a, "A"), "abc");
1389  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1390  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1391 
1392  /* Add another column to the test table to check behaviour of the update
1393  * function. */
1394  cpl_test_assert(cpl_table_new_column_array(table, "D", CPL_TYPE_INT, 2)
1395  == CPL_ERROR_NONE);
1396  cpl_test_assert(cpl_table_set_column_unit(table, "D", "y")
1397  == CPL_ERROR_NONE);
1398  cpl_test_assert(cpl_table_set_column_format(table, "D", "%5d")
1399  == CPL_ERROR_NONE);
1400  data = cpl_array_wrap_int(valuesD, 2);
1401  cpl_test_assert(data != NULL);
1402  cpl_test_assert(cpl_table_set_array(table, "D", 0, data)
1403  == CPL_ERROR_NONE);
1404  cpl_array_unwrap(data);
1405  cpl_test_eq_error(irplib_sdp_spectrum_copy_column(a, table, "A"),
1406  CPL_ERROR_NONE);
1407 
1408  cpl_test_eq_error(irplib_sdp_spectrum_update_column(a, "A", table, "D",
1409  IRPLIB_COLUMN_UNIT),
1410  CPL_ERROR_NONE);
1411  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1412  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1413  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "y");
1414  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1415  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1416  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1417  testdata = irplib_sdp_spectrum_get_column_data(a, "A");
1418  cpl_test_nonnull(data);
1419  cpl_test_eq(cpl_array_get_int(testdata, 0, NULL), valuesA[0]);
1420  cpl_test_eq(cpl_array_get_int(testdata, 1, NULL), valuesA[1]);
1421  cpl_test_eq_error(irplib_sdp_spectrum_set_column_unit(a, "A", "x"),
1422  CPL_ERROR_NONE);
1423 
1424  cpl_test_eq_error(irplib_sdp_spectrum_update_column(a, "A", table, "D",
1425  IRPLIB_COLUMN_FORMAT),
1426  CPL_ERROR_NONE);
1427  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1428  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1429  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1430  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%5d");
1431  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1432  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1433  testdata = irplib_sdp_spectrum_get_column_data(a, "A");
1434  cpl_test_nonnull(data);
1435  cpl_test_eq(cpl_array_get_int(testdata, 0, NULL), valuesA[0]);
1436  cpl_test_eq(cpl_array_get_int(testdata, 1, NULL), valuesA[1]);
1437  cpl_test_eq_error(irplib_sdp_spectrum_set_column_format(a, "A", "%d"),
1438  CPL_ERROR_NONE);
1439 
1440  cpl_test_eq_error(irplib_sdp_spectrum_update_column(a, "A", table, "D",
1441  IRPLIB_COLUMN_DATA),
1442  CPL_ERROR_NONE);
1443  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1444  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1445  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "x");
1446  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%d");
1447  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1448  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1449  testdata = irplib_sdp_spectrum_get_column_data(a, "A");
1450  cpl_test_nonnull(data);
1451  cpl_test_eq(cpl_array_get_int(testdata, 0, NULL), valuesD[0]);
1452  cpl_test_eq(cpl_array_get_int(testdata, 1, NULL), valuesD[1]);
1453 
1454  /* Test update behaves like copy when column is missing. */
1455  cpl_test_eq_error(irplib_sdp_spectrum_delete_column(a, "A"), CPL_ERROR_NONE);
1456  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 0);
1457  cpl_test_eq_error(irplib_sdp_spectrum_update_column(a, "A", table, "D",
1458  IRPLIB_COLUMN_DATA),
1459  CPL_ERROR_NONE);
1460  cpl_test(irplib_sdp_spectrum_has_column(a, "A"));
1461  cpl_test_eq(irplib_sdp_spectrum_get_ncol(a), 1);
1462  cpl_test_eq_string(irplib_sdp_spectrum_get_column_unit(a, "A"), "y");
1463  cpl_test_eq_string(irplib_sdp_spectrum_get_column_format(a, "A"), "%5d");
1464  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "");
1465  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "");
1466  testdata = irplib_sdp_spectrum_get_column_data(a, "A");
1467  cpl_test_nonnull(data);
1468  cpl_test_eq(cpl_array_get_int(testdata, 0, NULL), valuesD[0]);
1469  cpl_test_eq(cpl_array_get_int(testdata, 1, NULL), valuesD[1]);
1470 
1471  irplib_sdp_spectrum_delete(a);
1472  cpl_propertylist_delete(plist);
1473  cpl_table_delete(table);
1474  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1475 }
1476 
1477 
1478 static int test_generic_copy_functions(void)
1479 {
1480  /* Create a property list with some test keywords and test copying of these
1481  * using the generic copy functions. */
1482  const cpl_property *p;
1483  cpl_propertylist *plist = cpl_propertylist_new();
1484  irplib_sdp_spectrum *a = irplib_sdp_spectrum_new();
1485  cpl_test_assert(plist != NULL);
1486  cpl_test_assert(a != NULL);
1487 
1488  cpl_test_assert(cpl_propertylist_append_bool(plist, "M_EPOCH", CPL_TRUE)
1489  == CPL_ERROR_NONE);
1490  cpl_test_assert(cpl_propertylist_append_int(plist, "PRODLVL", 123)
1491  == CPL_ERROR_NONE);
1492  cpl_test_assert(cpl_propertylist_append_int(plist, "OBID1", 234)
1493  == CPL_ERROR_NONE);
1494  cpl_test_assert(cpl_propertylist_append_int(plist, "OBID2", 345)
1495  == CPL_ERROR_NONE);
1496  cpl_test_assert(cpl_propertylist_append_long_long(plist, "NELEM", 456)
1497  == CPL_ERROR_NONE);
1498  cpl_test_assert(cpl_propertylist_append_double(plist, "EXPTIME", 1.35)
1499  == CPL_ERROR_NONE);
1500  cpl_test_assert(cpl_propertylist_append_string(plist, "PROCSOFT", "abc")
1501  == CPL_ERROR_NONE);
1502  cpl_test_assert(cpl_propertylist_append_string(plist, "PROV1", "bcd")
1503  == CPL_ERROR_NONE);
1504  cpl_test_assert(cpl_propertylist_append_string(plist, "PROV2", "cde")
1505  == CPL_ERROR_NONE);
1506  cpl_test_assert(cpl_propertylist_append_string(plist, "TUTYP1", "def")
1507  == CPL_ERROR_NONE);
1508  cpl_test_assert(cpl_propertylist_append_string(plist, "TUTYP2", "efg")
1509  == CPL_ERROR_NONE);
1510  cpl_test_assert(cpl_propertylist_append_string(plist, "TUCD1", "fgh")
1511  == CPL_ERROR_NONE);
1512  cpl_test_assert(cpl_propertylist_append_string(plist, "TUCD2", "ghi")
1513  == CPL_ERROR_NONE);
1514  cpl_test_assert(cpl_propertylist_append_double(plist, "APERTURE", 2.46)
1515  == CPL_ERROR_NONE);
1516  cpl_test_assert(cpl_propertylist_append_double(plist, "WAVELMIN", 3.57)
1517  == CPL_ERROR_NONE);
1518 
1519  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "M_EPOCH"),
1520  CPL_ERROR_NONE);
1521  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(a), CPL_TRUE);
1522  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "PRODLVL"),
1523  CPL_ERROR_NONE);
1524  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(a), 123);
1525  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "OBID1"),
1526  CPL_ERROR_NONE);
1527  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "OBID2"),
1528  CPL_ERROR_NONE);
1529  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 1), 234);
1530  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 2), 345);
1531  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "EXPTIME"),
1532  CPL_ERROR_NONE);
1533  cpl_test_abs(irplib_sdp_spectrum_get_exptime(a), 1.35, DBL_EPSILON);
1534  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "PROCSOFT"),
1535  CPL_ERROR_NONE);
1536  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(a), "abc");
1537  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "PROV1"),
1538  CPL_ERROR_NONE);
1539  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "PROV2"),
1540  CPL_ERROR_NONE);
1541  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 1), "bcd");
1542  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 2), "cde");
1543 
1544  cpl_test_eq_error(
1545  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_INT, "s", "%2d", "", "",
1546  NULL),
1547  CPL_ERROR_NONE
1548  );
1549  cpl_test_eq_error(
1550  irplib_sdp_spectrum_add_column(a, "B", CPL_TYPE_INT, "m", "%5d", "", "",
1551  NULL),
1552  CPL_ERROR_NONE
1553  );
1554  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "TUTYP1"),
1555  CPL_ERROR_NONE);
1556  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "TUTYP2"),
1557  CPL_ERROR_NONE);
1558  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "def");
1559  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "efg");
1560  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "TUCD1"),
1561  CPL_ERROR_NONE);
1562  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "TUCD2"),
1563  CPL_ERROR_NONE);
1564  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "fgh");
1565  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "ghi");
1566 
1567  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "APERTURE"),
1568  CPL_ERROR_NONE);
1569  cpl_test_abs(irplib_sdp_spectrum_get_aperture(a), 2.46, DBL_EPSILON);
1570  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "WAVELMIN"),
1571  CPL_ERROR_NONE);
1572  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(a), 3.57, DBL_EPSILON);
1573  cpl_test_eq_error(irplib_sdp_spectrum_copy_keyword(a, plist, "NELEM"),
1574  CPL_ERROR_NONE);
1575  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 456);
1576 
1577  /* Test the usage of the irplib_sdp_spectrum_copy_property function. */
1578  irplib_sdp_spectrum_delete(a);
1579  a = irplib_sdp_spectrum_new();
1580 
1581  p = cpl_propertylist_get_property_const(plist, "M_EPOCH");
1582  cpl_test_assert(p != NULL);
1583  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1584  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(a), CPL_TRUE);
1585  p = cpl_propertylist_get_property_const(plist, "PRODLVL");
1586  cpl_test_assert(p != NULL);
1587  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1588  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(a), 123);
1589  p = cpl_propertylist_get_property_const(plist, "OBID1");
1590  cpl_test_assert(p != NULL);
1591  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1592  p = cpl_propertylist_get_property_const(plist, "OBID2");
1593  cpl_test_assert(p != NULL);
1594  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1595  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 1), 234);
1596  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 2), 345);
1597  p = cpl_propertylist_get_property_const(plist, "EXPTIME");
1598  cpl_test_assert(p != NULL);
1599  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1600  cpl_test_abs(irplib_sdp_spectrum_get_exptime(a), 1.35, DBL_EPSILON);
1601  p = cpl_propertylist_get_property_const(plist, "PROCSOFT");
1602  cpl_test_assert(p != NULL);
1603  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1604  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(a), "abc");
1605  p = cpl_propertylist_get_property_const(plist, "PROV1");
1606  cpl_test_assert(p != NULL);
1607  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1608  p = cpl_propertylist_get_property_const(plist, "PROV2");
1609  cpl_test_assert(p != NULL);
1610  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1611  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 1), "bcd");
1612  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 2), "cde");
1613 
1614  cpl_test_eq_error(
1615  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_INT, "s", "%2d", "", "",
1616  NULL),
1617  CPL_ERROR_NONE
1618  );
1619  cpl_test_eq_error(
1620  irplib_sdp_spectrum_add_column(a, "B", CPL_TYPE_INT, "m", "%5d", "", "",
1621  NULL),
1622  CPL_ERROR_NONE
1623  );
1624  p = cpl_propertylist_get_property_const(plist, "TUTYP1");
1625  cpl_test_assert(p != NULL);
1626  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1627  p = cpl_propertylist_get_property_const(plist, "TUTYP2");
1628  cpl_test_assert(p != NULL);
1629  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1630  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "def");
1631  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "efg");
1632  p = cpl_propertylist_get_property_const(plist, "TUCD1");
1633  cpl_test_assert(p != NULL);
1634  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1635  p = cpl_propertylist_get_property_const(plist, "TUCD2");
1636  cpl_test_assert(p != NULL);
1637  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1638  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "fgh");
1639  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "ghi");
1640 
1641  p = cpl_propertylist_get_property_const(plist, "APERTURE");
1642  cpl_test_assert(p != NULL);
1643  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1644  cpl_test_abs(irplib_sdp_spectrum_get_aperture(a), 2.46, DBL_EPSILON);
1645  p = cpl_propertylist_get_property_const(plist, "WAVELMIN");
1646  cpl_test_assert(p != NULL);
1647  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1648  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(a), 3.57, DBL_EPSILON);
1649  p = cpl_propertylist_get_property_const(plist, "NELEM");
1650  cpl_test_assert(p != NULL);
1651  cpl_test_eq_error(irplib_sdp_spectrum_copy_property(a, p), CPL_ERROR_NONE);
1652  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 456);
1653 
1654  /* Test the regular expression copy function. */
1655  irplib_sdp_spectrum_delete(a);
1656  a = irplib_sdp_spectrum_new();
1657  cpl_test_eq_error(
1658  irplib_sdp_spectrum_add_column(a, "A", CPL_TYPE_INT, "s", "%2d", "", "",
1659  NULL),
1660  CPL_ERROR_NONE
1661  );
1662  cpl_test_eq_error(
1663  irplib_sdp_spectrum_add_column(a, "B", CPL_TYPE_INT, "m", "%5d", "", "",
1664  NULL),
1665  CPL_ERROR_NONE
1666  );
1667 
1668  cpl_test_eq_error(irplib_sdp_spectrum_copy_property_regexp(a, plist,
1669  "PROV.*", 1),
1670  CPL_ERROR_NONE);
1671  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(a), CPL_TRUE);
1672  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(a), 123);
1673  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 1), 234);
1674  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 2), 345);
1675  cpl_test_abs(irplib_sdp_spectrum_get_exptime(a), 1.35, DBL_EPSILON);
1676  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(a), "abc");
1677  cpl_test_null(irplib_sdp_spectrum_get_prov(a, 1));
1678  cpl_test_null(irplib_sdp_spectrum_get_prov(a, 2));
1679  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "def");
1680  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "efg");
1681  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "fgh");
1682  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "ghi");
1683  cpl_test_abs(irplib_sdp_spectrum_get_aperture(a), 2.46, DBL_EPSILON);
1684  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(a), 3.57, DBL_EPSILON);
1685  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 456);
1686 
1687  cpl_test_eq_error(irplib_sdp_spectrum_copy_property_regexp(a, plist,
1688  ".*", 0),
1689  CPL_ERROR_NONE);
1690  cpl_test_eq(irplib_sdp_spectrum_get_mepoch(a), CPL_TRUE);
1691  cpl_test_eq(irplib_sdp_spectrum_get_prodlvl(a), 123);
1692  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 1), 234);
1693  cpl_test_eq(irplib_sdp_spectrum_get_obid(a, 2), 345);
1694  cpl_test_abs(irplib_sdp_spectrum_get_exptime(a), 1.35, DBL_EPSILON);
1695  cpl_test_eq_string(irplib_sdp_spectrum_get_procsoft(a), "abc");
1696  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 1), "bcd");
1697  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(a, 2), "cde");
1698  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "A"), "def");
1699  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tutyp(a, "B"), "efg");
1700  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "A"), "fgh");
1701  cpl_test_eq_string(irplib_sdp_spectrum_get_column_tucd(a, "B"), "ghi");
1702  cpl_test_abs(irplib_sdp_spectrum_get_aperture(a), 2.46, DBL_EPSILON);
1703  cpl_test_abs(irplib_sdp_spectrum_get_wavelmin(a), 3.57, DBL_EPSILON);
1704  cpl_test_eq(irplib_sdp_spectrum_get_nelem(a), 456);
1705 
1706  irplib_sdp_spectrum_delete(a);
1707  cpl_propertylist_delete(plist);
1708  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1709 }
1710 
1711 
1728 static cpl_boolean create_file_with_key(cpl_frameset* frames,
1729  const char *filename,
1730  const char *keyword,
1731  const char *value)
1732 {
1733  cpl_error_code error = CPL_ERROR_NONE;
1734  cpl_frame *frame = cpl_frame_new();
1735  cpl_propertylist *plist = cpl_propertylist_new();
1736  if (frame == NULL || plist == NULL) goto cleanup;
1737  if (keyword != NULL) {
1738  error |= cpl_propertylist_append_string(plist, keyword, value);
1739  }
1740  error |= cpl_propertylist_save(plist, filename, CPL_IO_CREATE);
1741  if (error) goto cleanup;
1742  cpl_propertylist_delete(plist);
1743  error |= cpl_frame_set_filename(frame, filename);
1744  error |= cpl_frame_set_tag(frame, "RAW");
1745  error |= cpl_frame_set_group(frame, CPL_FRAME_GROUP_RAW);
1746  error |= cpl_frame_set_level(frame, CPL_FRAME_LEVEL_FINAL);
1747  error |= cpl_frameset_insert(frames, frame);
1748  if (error) goto cleanup;
1749  return CPL_TRUE;
1750 
1751 cleanup:
1752  cpl_frame_delete(frame);
1753  cpl_propertylist_delete(plist);
1754  return CPL_FALSE;
1755 }
1756 
1757 
1758 static int test_append_provenance(void)
1759 {
1760  cpl_error_code error;
1761  const char *filename1 = "dummy_raw_input1_for_prov_test.fits";
1762  const char *filename2 = "dummy_raw_input2_for_prov_test.fits";
1763  const char *filename3 = "dummy_raw_input3_for_prov_test.fits";
1764  cpl_frameset *frames = cpl_frameset_new();
1765  irplib_sdp_spectrum *spec = irplib_sdp_spectrum_new();
1766  cpl_test_assert(frames != NULL);
1767  cpl_test_assert(spec != NULL);
1768 
1769  /* Test behaviour of irplib_sdp_spectrum_append_prov.
1770  * We first need to create a number of test input files and add them to the
1771  * frameset. One file should contain the ARCFILE keyword, another ORIGFILE and
1772  * the one should contain neither. */
1773  cpl_test_assert(create_file_with_key(frames, filename1, "ARCFILE", "fileA"));
1774  cpl_test_assert(create_file_with_key(frames, filename2, "ORIGFILE", "fileB"));
1775  cpl_test_assert(create_file_with_key(frames, filename3, NULL, NULL));
1776  cpl_test_eq(cpl_frameset_get_size(frames), 3);
1777 
1778  /* Now execute irplib_sdp_spectrum_append_prov and check that the PROVi
1779  * keywords are setup as expected. */
1780  error = irplib_sdp_spectrum_append_prov(spec, 2, frames);
1781  cpl_test_error(CPL_ERROR_NONE);
1782  cpl_test_eq_error(error, CPL_ERROR_NONE);
1783  cpl_test_eq(irplib_sdp_spectrum_count_prov(spec),
1784  cpl_frameset_get_size(frames));
1785  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(spec, 2), "fileA");
1786  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(spec, 3), "fileB");
1787  cpl_test_eq_string(irplib_sdp_spectrum_get_prov(spec, 4), filename3);
1788 
1789  /* Remove the FITS files if no errors were detected and clean up memory. */
1790  if (cpl_test_get_failed() == 0) {
1791  (void) remove(filename1);
1792  (void) remove(filename2);
1793  (void) remove(filename3);
1794  }
1795  irplib_sdp_spectrum_delete(spec);
1796  cpl_frameset_delete(frames);
1797  return cpl_test_get_failed() == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1798 }
int main(void)
Various tests of low-level library functions.
Definition: uves-test.c:393
struct _irplib_sdp_spectrum_ irplib_sdp_spectrum
Data type for a Science Data Product 1D spectrum.