1 #include "SupportTestsF64.h"
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include "Error.h"
5 #include "Test.h"
6 
7 #define SNR_THRESHOLD 120
8 #define REL_ERROR (1.0e-5)
9 #define ABS_Q15_ERROR ((q15_t)10)
10 #define ABS_Q31_ERROR ((q31_t)80)
11 #define ABS_Q7_ERROR ((q7_t)10)
12 
13 /*
14 void SupportTestsF64::test_weighted_average_f64()
15 {
16  const float64_t *inp = input.ptr();
17  const float64_t *coefsp = coefs.ptr();
18  float64_t *refp = ref.ptr();
19 
20  float64_t *outp = output.ptr();
21 
22 
23  *outp=arm_weighted_average_f64(inp, coefsp,this->nbSamples);
24 
25 
26  ASSERT_REL_ERROR(*outp,refp[this->offset],REL_ERROR);
27  ASSERT_EMPTY_TAIL(output);
28 
29 }
30 */
test_copy_f64()31 void SupportTestsF64::test_copy_f64()
32 {
33  const float64_t *inp = input.ptr();
34  float64_t *outp = output.ptr();
35 
36 
37  arm_copy_f64(inp, outp,this->nbSamples);
38 
39 
40  ASSERT_EQ(input,output);
41  ASSERT_EMPTY_TAIL(output);
42 
43 }
44 
test_fill_f64()45 void SupportTestsF64::test_fill_f64()
46 {
47  float64_t *outp = output.ptr();
48  float64_t val = 1.1;
49  int i;
50 
51 
52  arm_fill_f64(val, outp,this->nbSamples);
53 
54 
55  for(i=0 ; i < this->nbSamples; i++)
56  {
57   ASSERT_EQ(val,outp[i]);
58 }
59 ASSERT_EMPTY_TAIL(output);
60 
61 }
62 
test_f64_to_float()63 void SupportTestsF64::test_f64_to_float()
64 {
65  const float64_t *inp = input.ptr();
66  float32_t *outp = outputF32.ptr();
67 
68 
69  arm_f64_to_float(inp, outp,this->nbSamples);
70 
71  ASSERT_REL_ERROR(refF32,outputF32,REL_ERROR);
72  ASSERT_EMPTY_TAIL(outputF32);
73 
74 }
75 
76 
test_f64_to_q15()77 void SupportTestsF64::test_f64_to_q15()
78 {
79  const float64_t *inp = input.ptr();
80  q15_t *outp = outputQ15.ptr();
81 
82 
83  arm_f64_to_q15(inp, outp,this->nbSamples);
84 
85 
86  ASSERT_NEAR_EQ(refQ15,outputQ15,ABS_Q15_ERROR);
87  ASSERT_EMPTY_TAIL(outputQ15);
88 
89 }
90 
test_f64_to_q31()91 void SupportTestsF64::test_f64_to_q31()
92 {
93  const float64_t *inp = input.ptr();
94  q31_t *outp = outputQ31.ptr();
95 
96 
97  arm_f64_to_q31(inp, outp,this->nbSamples);
98 
99 
100  ASSERT_NEAR_EQ(refQ31,outputQ31,ABS_Q31_ERROR);
101  ASSERT_EMPTY_TAIL(outputQ31);
102 
103 }
104 
test_f64_to_q7()105 void SupportTestsF64::test_f64_to_q7()
106 {
107  const float64_t *inp = input.ptr();
108  q7_t *outp = outputQ7.ptr();
109 
110 
111  arm_f64_to_q7(inp, outp,this->nbSamples);
112 
113 
114  ASSERT_NEAR_EQ(refQ7,outputQ7,ABS_Q7_ERROR);
115  ASSERT_EMPTY_TAIL(outputQ7);
116 
117 }
118 
119 /*
120 void SupportTestsF64::test_bitonic_sort_out_f64()
121 {
122  float64_t *inp = input.ptr();
123  float64_t *outp = output.ptr();
124  arm_sort_instance_f64 S;
125 
126  arm_sort_init_f64(&S, ARM_SORT_BITONIC, ARM_SORT_ASCENDING);
127 
128  arm_sort_f64(&S,inp,outp,this->nbSamples);
129 
130  ASSERT_EMPTY_TAIL(output);
131 
132  ASSERT_EQ(output,ref);
133 
134 }
135 
136 void SupportTestsF64::test_bitonic_sort_in_f64()
137 {
138  float64_t *inp = input.ptr();
139  arm_sort_instance_f64 S;
140 
141  arm_sort_init_f64(&S, ARM_SORT_BITONIC, ARM_SORT_ASCENDING);
142 
143  arm_sort_f64(&S,inp,inp,this->nbSamples);
144 
145  ASSERT_EMPTY_TAIL(input);
146 
147  ASSERT_EQ(input,ref);
148 
149 }
150 
151 void SupportTestsF64::test_bitonic_sort_const_f64()
152 {
153  float64_t *inp = input.ptr();
154  float64_t *outp = output.ptr();
155  arm_sort_instance_f64 S;
156 
157  arm_sort_init_f64(&S, ARM_SORT_BITONIC, ARM_SORT_ASCENDING);
158 
159  arm_sort_f64(&S,inp,outp,this->nbSamples);
160 
161  ASSERT_EMPTY_TAIL(output);
162 
163  ASSERT_EQ(output,ref);
164 
165 }
166 
167 void SupportTestsF64::test_bubble_sort_out_f64()
168 {
169  float64_t *inp = input.ptr();
170  float64_t *outp = output.ptr();
171  arm_sort_instance_f64 S;
172 
173  arm_sort_init_f64(&S, ARM_SORT_BUBBLE, ARM_SORT_ASCENDING);
174 
175  arm_sort_f64(&S,inp,outp,this->nbSamples);
176 
177  ASSERT_EMPTY_TAIL(output);
178 
179  ASSERT_EQ(output,ref);
180 
181 }
182 
183 void SupportTestsF64::test_bubble_sort_in_f64()
184 {
185  float64_t *inp = input.ptr();
186  arm_sort_instance_f64 S;
187 
188  arm_sort_init_f64(&S, ARM_SORT_BUBBLE, ARM_SORT_ASCENDING);
189 
190  arm_sort_f64(&S,inp,inp,this->nbSamples);
191 
192  ASSERT_EMPTY_TAIL(input);
193 
194  ASSERT_EQ(input,ref);
195 
196 }
197 
198 void SupportTestsF64::test_bubble_sort_const_f64()
199 {
200  float64_t *inp = input.ptr();
201  float64_t *outp = output.ptr();
202  arm_sort_instance_f64 S;
203 
204  arm_sort_init_f64(&S, ARM_SORT_BUBBLE, ARM_SORT_ASCENDING);
205 
206  arm_sort_f64(&S,inp,outp,this->nbSamples);
207 
208  ASSERT_EMPTY_TAIL(output);
209 
210  ASSERT_EQ(output,ref);
211 
212 }
213 
214 void SupportTestsF64::test_heap_sort_out_f64()
215 {
216  float64_t *inp = input.ptr();
217  float64_t *outp = output.ptr();
218  arm_sort_instance_f64 S;
219 
220  arm_sort_init_f64(&S, ARM_SORT_HEAP, ARM_SORT_ASCENDING);
221 
222  arm_sort_f64(&S,inp,outp,this->nbSamples);
223 
224  ASSERT_EMPTY_TAIL(output);
225 
226  ASSERT_EQ(output,ref);
227 
228 }
229 
230 void SupportTestsF64::test_heap_sort_in_f64()
231 {
232  float64_t *inp = input.ptr();
233  arm_sort_instance_f64 S;
234 
235  arm_sort_init_f64(&S, ARM_SORT_HEAP, ARM_SORT_ASCENDING);
236 
237  arm_sort_f64(&S,inp,inp,this->nbSamples);
238 
239  ASSERT_EMPTY_TAIL(input);
240 
241  ASSERT_EQ(input,ref);
242 }
243 
244 void SupportTestsF64::test_heap_sort_const_f64()
245 {
246  float64_t *inp = input.ptr();
247  float64_t *outp = output.ptr();
248  arm_sort_instance_f64 S;
249 
250  arm_sort_init_f64(&S, ARM_SORT_HEAP, ARM_SORT_ASCENDING);
251 
252  arm_sort_f64(&S,inp,outp,this->nbSamples);
253 
254  ASSERT_EMPTY_TAIL(output);
255 
256  ASSERT_EQ(output,ref);
257 
258 }
259 
260 void SupportTestsF64::test_insertion_sort_out_f64()
261 {
262  float64_t *inp = input.ptr();
263  float64_t *outp = output.ptr();
264  arm_sort_instance_f64 S;
265 
266  arm_sort_init_f64(&S, ARM_SORT_INSERTION, ARM_SORT_ASCENDING);
267 
268  arm_sort_f64(&S,inp,outp,this->nbSamples);
269 
270  ASSERT_EMPTY_TAIL(output);
271 
272  ASSERT_EQ(output,ref);
273 
274 }
275 
276 void SupportTestsF64::test_insertion_sort_in_f64()
277 {
278  float64_t *inp = input.ptr();
279  arm_sort_instance_f64 S;
280 
281  arm_sort_init_f64(&S, ARM_SORT_INSERTION, ARM_SORT_ASCENDING);
282 
283  arm_sort_f64(&S,inp,inp,this->nbSamples);
284 
285  ASSERT_EMPTY_TAIL(input);
286 
287  ASSERT_EQ(input,ref);
288 
289 }
290 
291 void SupportTestsF64::test_insertion_sort_const_f64()
292 {
293  float64_t *inp = input.ptr();
294  float64_t *outp = output.ptr();
295  arm_sort_instance_f64 S;
296 
297  arm_sort_init_f64(&S, ARM_SORT_INSERTION, ARM_SORT_ASCENDING);
298 
299  arm_sort_f64(&S,inp,outp,this->nbSamples);
300 
301  ASSERT_EMPTY_TAIL(output);
302 
303  ASSERT_EQ(output,ref);
304 
305 }
306 
307 void SupportTestsF64::test_merge_sort_out_f64()
308 {
309  float64_t *inp = input.ptr();
310  float64_t *outp = output.ptr();
311  float64_t *buf = buffer.ptr();
312  buf = (float64_t *)malloc((this->nbSamples)*sizeof(float64_t) );
313  arm_merge_sort_instance_f64 S;
314 
315  arm_merge_sort_init_f64(&S, ARM_SORT_ASCENDING, buf);
316  arm_merge_sort_f64(&S,inp,outp,this->nbSamples);
317 
318  ASSERT_EMPTY_TAIL(output);
319 
320  ASSERT_EQ(output,ref);
321 
322 }
323 
324 void SupportTestsF64::test_merge_sort_const_f64()
325 {
326  float64_t *inp = input.ptr();
327  float64_t *outp = output.ptr();
328  float64_t *buf = buffer.ptr();
329  buf = (float64_t *)malloc((this->nbSamples)*sizeof(float64_t) );
330  arm_merge_sort_instance_f64 S;
331 
332  arm_merge_sort_init_f64(&S, ARM_SORT_ASCENDING, buf);
333  arm_merge_sort_f64(&S,inp,outp,this->nbSamples);
334 
335  ASSERT_EMPTY_TAIL(output);
336 
337  ASSERT_EQ(output,ref);
338 }
339 
340 void SupportTestsF64::test_quick_sort_out_f64()
341 {
342  float64_t *inp = input.ptr();
343  float64_t *outp = output.ptr();
344  arm_sort_instance_f64 S;
345 
346  arm_sort_init_f64(&S, ARM_SORT_QUICK, ARM_SORT_ASCENDING);
347 
348  arm_sort_f64(&S,inp,outp,this->nbSamples);
349 
350  ASSERT_EMPTY_TAIL(output);
351 
352  ASSERT_EQ(output,ref);
353 
354 }
355 
356 void SupportTestsF64::test_quick_sort_in_f64()
357 {
358  float64_t *inp = input.ptr();
359  arm_sort_instance_f64 S;
360 
361  arm_sort_init_f64(&S, ARM_SORT_QUICK, ARM_SORT_ASCENDING);
362 
363  arm_sort_f64(&S,inp,inp,this->nbSamples);
364 
365  ASSERT_EMPTY_TAIL(input);
366 
367  ASSERT_EQ(input,ref);
368 
369 }
370 
371 void SupportTestsF64::test_quick_sort_const_f64()
372 {
373  float64_t *inp = input.ptr();
374  float64_t *outp = output.ptr();
375  arm_sort_instance_f64 S;
376 
377  arm_sort_init_f64(&S, ARM_SORT_QUICK, ARM_SORT_ASCENDING);
378 
379  arm_sort_f64(&S,inp,outp,this->nbSamples);
380 
381  ASSERT_EMPTY_TAIL(output);
382 
383  ASSERT_EQ(output,ref);
384 
385 }
386 
387 void SupportTestsF64::test_selection_sort_out_f64()
388 {
389  float64_t *inp = input.ptr();
390  float64_t *outp = output.ptr();
391  arm_sort_instance_f64 S;
392 
393  arm_sort_init_f64(&S, ARM_SORT_SELECTION, ARM_SORT_ASCENDING);
394 
395  arm_sort_f64(&S,inp,outp,this->nbSamples);
396 
397  ASSERT_EMPTY_TAIL(output);
398 
399  ASSERT_EQ(output,ref);
400 
401 }
402 
403 void SupportTestsF64::test_selection_sort_in_f64()
404 {
405  float64_t *inp = input.ptr();
406  arm_sort_instance_f64 S;
407 
408  arm_sort_init_f64(&S, ARM_SORT_SELECTION, ARM_SORT_ASCENDING);
409 
410  arm_sort_f64(&S,inp,inp,this->nbSamples);
411 
412  ASSERT_EMPTY_TAIL(input);
413 
414  ASSERT_EQ(input,ref);
415 
416 }
417 
418 void SupportTestsF64::test_selection_sort_const_f64()
419 {
420  float64_t *inp = input.ptr();
421  float64_t *outp = output.ptr();
422  arm_sort_instance_f64 S;
423 
424  arm_sort_init_f64(&S, ARM_SORT_SELECTION, ARM_SORT_ASCENDING);
425 
426  arm_sort_f64(&S,inp,outp,this->nbSamples);
427 
428  ASSERT_EMPTY_TAIL(output);
429 
430  ASSERT_EQ(output,ref);
431 
432 }
433 
434 */
setUp(Testing::testID_t id,std::vector<Testing::param_t> & paramsArgs,Client::PatternMgr * mgr)435 void SupportTestsF64::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
436 {
437 
438   (void)paramsArgs;
439   switch(id)
440   {
441     /*case TEST_WEIGHTED_SUM_F64_1:
442     this->nbSamples = 2;
443     input.reload(SupportTestsF64::INPUTS_F64_ID,mgr,this->nbSamples);
444     coefs.reload(SupportTestsF64::WEIGHTS_F64_ID,mgr,this->nbSamples);
445     ref.reload(SupportTestsF64::REF_F64_ID,mgr);
446 
447     output.create(1,SupportTestsF64::OUT_F64_ID,mgr);
448 
449     this->offset=0;
450     break;
451 
452     case TEST_WEIGHTED_SUM_F64_2:
453     this->nbSamples = 4;
454     input.reload(SupportTestsF64::INPUTS_F64_ID,mgr,this->nbSamples);
455     coefs.reload(SupportTestsF64::WEIGHTS_F64_ID,mgr,this->nbSamples);
456     ref.reload(SupportTestsF64::REF_F64_ID,mgr);
457 
458     output.create(1,SupportTestsF64::OUT_F64_ID,mgr);
459 
460     this->offset=1;
461     break;
462 
463     case TEST_WEIGHTED_SUM_F64_3:
464     this->nbSamples = 5;
465     input.reload(SupportTestsF64::INPUTS_F64_ID,mgr,this->nbSamples);
466     coefs.reload(SupportTestsF64::WEIGHTS_F64_ID,mgr,this->nbSamples);
467     ref.reload(SupportTestsF64::REF_F64_ID,mgr);
468 
469     output.create(1,SupportTestsF64::OUT_F64_ID,mgr);
470 
471     this->offset=2;
472     break;
473 */
474     case TEST_COPY_F64_4:
475     this->nbSamples = 2;
476     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
477 
478     output.create(input.nbSamples(),SupportTestsF64::OUT_F64_ID,mgr);
479 
480     break;
481 
482     case TEST_COPY_F64_5:
483     this->nbSamples = 4;
484     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
485 
486     output.create(input.nbSamples(),SupportTestsF64::OUT_F64_ID,mgr);
487 
488     break;
489 
490     case TEST_COPY_F64_6:
491     this->nbSamples = 5;
492     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
493 
494     output.create(input.nbSamples(),SupportTestsF64::OUT_F64_ID,mgr);
495 
496     break;
497 
498     case TEST_FILL_F64_7:
499     this->nbSamples = 2;
500 
501     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
502 
503     break;
504 
505     case TEST_FILL_F64_8:
506     this->nbSamples = 4;
507 
508     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
509 
510     break;
511 
512     case TEST_FILL_F64_9:
513     this->nbSamples = 5;
514 
515     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
516 
517     break;
518 
519 
520 /*
521     case TEST_BITONIC_SORT_OUT_F64_19:
522     this->nbSamples = 16;
523     input.reload(SupportTestsF64::INPUT_BITONIC_SORT_16_F64_ID,mgr,this->nbSamples);
524     ref.reload(SupportTestsF64::REF_BITONIC_SORT_16_F64_ID,mgr);
525     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
526     break;
527 
528     case TEST_BITONIC_SORT_OUT_F64_20:
529     this->nbSamples = 32;
530     input.reload(SupportTestsF64::INPUT_BITONIC_SORT_64_F64_ID,mgr,this->nbSamples);
531     ref.reload(SupportTestsF64::REF_BITONIC_SORT_64_F64_ID,mgr);
532     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
533     break;
534 
535     case TEST_BITONIC_SORT_IN_F64_21:
536     this->nbSamples = 32;
537     input.reload(SupportTestsF64::INPUT_BITONIC_SORT_64_F64_ID,mgr,this->nbSamples);
538     ref.reload(SupportTestsF64::REF_BITONIC_SORT_64_F64_ID,mgr);
539     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
540     break;
541 
542     case TEST_BITONIC_SORT_CONST_F64_22:
543     this->nbSamples = 16;
544     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
545     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
546     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
547     break;
548 
549     case TEST_BUBBLE_SORT_OUT_F64_23:
550     this->nbSamples = 11;
551     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
552     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
553     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
554     break;
555 
556     case TEST_BUBBLE_SORT_IN_F64_24:
557     this->nbSamples = 11;
558     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
559     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
560     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
561     break;
562 
563     case TEST_BUBBLE_SORT_CONST_F64_25:
564     this->nbSamples = 16;
565     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
566     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
567     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
568     break;
569 
570     case TEST_HEAP_SORT_OUT_F64_26:
571     this->nbSamples = 11;
572     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
573     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
574     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
575     break;
576 
577     case TEST_HEAP_SORT_IN_F64_27:
578     this->nbSamples = 11;
579     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
580     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
581     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
582     break;
583 
584     case TEST_HEAP_SORT_CONST_F64_28:
585     this->nbSamples = 16;
586     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
587     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
588     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
589     break;
590 
591     case TEST_INSERTION_SORT_OUT_F64_29:
592     this->nbSamples = 11;
593     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
594     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
595     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
596     break;
597 
598     case TEST_INSERTION_SORT_IN_F64_30:
599     this->nbSamples = 11;
600     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
601     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
602     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
603     break;
604 
605     case TEST_INSERTION_SORT_CONST_F64_31:
606     this->nbSamples = 16;
607     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
608     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
609     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
610     break;
611 
612     case TEST_MERGE_SORT_OUT_F64_32:
613     this->nbSamples = 11;
614     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
615     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
616     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
617     break;
618 
619     case TEST_MERGE_SORT_CONST_F64_33:
620     this->nbSamples = 16;
621     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
622     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
623     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
624     break;
625 
626     case TEST_QUICK_SORT_OUT_F64_34:
627     this->nbSamples = 11;
628     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
629     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
630     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
631     break;
632 
633     case TEST_QUICK_SORT_IN_F64_35:
634     this->nbSamples = 11;
635     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
636     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
637     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
638     break;
639 
640     case TEST_QUICK_SORT_CONST_F64_36:
641     this->nbSamples = 16;
642     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
643     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
644     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
645     break;
646 
647     case TEST_SELECTION_SORT_OUT_F64_37:
648     this->nbSamples = 11;
649     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
650     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
651     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
652     break;
653 
654     case TEST_SELECTION_SORT_IN_F64_38:
655     this->nbSamples = 11;
656     input.reload(SupportTestsF64::INPUT_SORT_F64_ID,mgr,this->nbSamples);
657     ref.reload(SupportTestsF64::REF_SORT_F64_ID,mgr);
658     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
659     break;
660 
661     case TEST_SELECTION_SORT_CONST_F64_39:
662     this->nbSamples = 16;
663     input.reload(SupportTestsF64::INPUT_SORT_CONST_F64_ID,mgr,this->nbSamples);
664     ref.reload(SupportTestsF64::REF_SORT_CONST_F64_ID,mgr);
665     output.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
666     break;
667 */
668 
669     case TEST_F64_TO_Q15_31:
670     this->nbSamples = 1;
671     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
672     refQ15.reload(SupportTestsF64::SAMPLES_Q15_ID,mgr,this->nbSamples);
673     outputQ15.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
674 
675     break;
676 
677     case TEST_F64_TO_Q15_32:
678     this->nbSamples = 4;
679     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
680     refQ15.reload(SupportTestsF64::SAMPLES_Q15_ID,mgr,this->nbSamples);
681     outputQ15.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
682 
683     break;
684 
685     case TEST_F64_TO_Q15_33:
686     this->nbSamples = 5;
687     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
688     refQ15.reload(SupportTestsF64::SAMPLES_Q15_ID,mgr,this->nbSamples);
689     outputQ15.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
690 
691     break;
692 
693     case TEST_F64_TO_Q31_34:
694     this->nbSamples = 1;
695     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
696     refQ31.reload(SupportTestsF64::SAMPLES_Q31_ID,mgr,this->nbSamples);
697     outputQ31.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
698 
699     break;
700 
701     case TEST_F64_TO_Q31_35:
702     this->nbSamples = 4;
703     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
704     refQ31.reload(SupportTestsF64::SAMPLES_Q31_ID,mgr,this->nbSamples);
705     outputQ31.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
706 
707     break;
708 
709     case TEST_F64_TO_Q31_36:
710     this->nbSamples = 6;
711     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
712     refQ31.reload(SupportTestsF64::SAMPLES_Q31_ID,mgr,this->nbSamples);
713     outputQ31.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
714 
715     break;
716 
717     case TEST_F64_TO_Q7_37:
718     this->nbSamples = 1;
719     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
720     refQ7.reload(SupportTestsF64::SAMPLES_Q7_ID,mgr,this->nbSamples);
721     outputQ7.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
722 
723     break;
724 
725     case TEST_F64_TO_Q7_38:
726     this->nbSamples = 4;
727     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
728     refQ7.reload(SupportTestsF64::SAMPLES_Q7_ID,mgr,this->nbSamples);
729     outputQ7.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
730 
731     break;
732 
733     case TEST_F64_TO_Q7_39:
734     this->nbSamples = 5;
735     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
736     refQ7.reload(SupportTestsF64::SAMPLES_Q7_ID,mgr,this->nbSamples);
737     outputQ7.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
738 
739     break;
740 
741     case TEST_F64_TO_FLOAT_40:
742     this->nbSamples = 1;
743     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
744     refF32.reload(SupportTestsF64::SAMPLES_F32_ID,mgr,this->nbSamples);
745     outputF32.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
746 
747     break;
748 
749     case TEST_F64_TO_FLOAT_41:
750     this->nbSamples = 4;
751     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
752     refF32.reload(SupportTestsF64::SAMPLES_F32_ID,mgr,this->nbSamples);
753     outputF32.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
754 
755     break;
756 
757     case TEST_F64_TO_FLOAT_42:
758     this->nbSamples = 5;
759     input.reload(SupportTestsF64::SAMPLES_F64_ID,mgr,this->nbSamples);
760     refF32.reload(SupportTestsF64::SAMPLES_F32_ID,mgr,this->nbSamples);
761     outputF32.create(this->nbSamples,SupportTestsF64::OUT_F64_ID,mgr);
762 
763     break;
764 
765   }
766 
767 }
768 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)769 void SupportTestsF64::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
770 {
771   (void)id;
772   output.dump(mgr);
773 }
774