CR2RE Pipeline Reference Manual 1.6.7
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
35static void fill_keywords(irplib_sdp_spectrum *a);
36static int test_get_set_functions(void);
37static int test_copy_functions(void);
38static int test_count_functions(void);
39static int test_column_functions(void);
40static int test_equal_function(void);
41static int test_io_functions(void);
42static int test_column_copy_update_functions(void);
43static int test_generic_copy_functions(void);
44static int test_append_provenance(void);
45
46static 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 -----------------------------------------------------------------------------*/
54int 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
72static 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
132static 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
376static 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
486static 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
661static 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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_TRUE);
676 cpl_test_error(CPL_ERROR_NONE);
677 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_TRUE);
678 cpl_test_error(CPL_ERROR_NONE);
679 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_TRUE);
680 cpl_test_error(CPL_ERROR_NONE);
681 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_TRUE);
711 cpl_test_error(CPL_ERROR_NONE);
712 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_TRUE);
713 cpl_test_error(CPL_ERROR_NONE);
714 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_TRUE);
715 cpl_test_error(CPL_ERROR_NONE);
716 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
724 cpl_test_error(CPL_ERROR_NONE);
725 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
726 cpl_test_error(CPL_ERROR_NONE);
727 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_FALSE);
728 cpl_test_error(CPL_ERROR_NONE);
729 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
741 cpl_test_error(CPL_ERROR_NONE);
742 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
743 cpl_test_error(CPL_ERROR_NONE);
744 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_TRUE);
745 cpl_test_error(CPL_ERROR_NONE);
746 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
758 cpl_test_error(CPL_ERROR_NONE);
759 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
760 cpl_test_error(CPL_ERROR_NONE);
761 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_FALSE);
762 cpl_test_error(CPL_ERROR_NONE);
763 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
772 cpl_test_error(CPL_ERROR_NONE);
773 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
774 cpl_test_error(CPL_ERROR_NONE);
775 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_TRUE);
776 cpl_test_error(CPL_ERROR_NONE);
777 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
785 cpl_test_error(CPL_ERROR_NONE);
786 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
787 cpl_test_error(CPL_ERROR_NONE);
788 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_FALSE);
789 cpl_test_error(CPL_ERROR_NONE);
790 cpl_test_eq(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_eq(irplib_sdp_spectrum_equal(a, b, CPL_FALSE), CPL_FALSE);
798 cpl_test_error(CPL_ERROR_NONE);
799 cpl_test_eq(irplib_sdp_spectrum_equal(b, a, CPL_FALSE), CPL_FALSE);
800 cpl_test_error(CPL_ERROR_NONE);
801 cpl_test_eq(irplib_sdp_spectrum_equal(a, b, CPL_TRUE), CPL_TRUE);
802 cpl_test_error(CPL_ERROR_NONE);
803 cpl_test_eq(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
812static 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_eq(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_eq(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_eq(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
1026static 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
1249static 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
1478static 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
1728static 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
1751cleanup:
1752 cpl_frame_delete(frame);
1753 cpl_propertylist_delete(plist);
1754 return CPL_FALSE;
1755}
1756
1757
1758static 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}
struct _irplib_sdp_spectrum_ irplib_sdp_spectrum
Data type for a Science Data Product 1D spectrum.