← Back to branch summary

~ubuntu-branches/ubuntu/maverick/avr-libc/maverick

« back to all changes in this revision

Viewing changes to tests/simulate/scanf/sscanf_flt-f2.c

  • Committer: Bazaar Package Importer
  • Author(s): Hakan Ardo
  • Date: 2009-10-31 11:52:10 UTC
  • mfrom: (1.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20091031115210-crjd42sn6ezrj52c
http://bugs.debian.org/544030
http://bugs.debian.org/553265
* New upstream relese (closes: #544030)
* Added lintian overrides (closes: #553265)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/simulate/scanf/sscanf_flt-f2.c
1
 
/* Test of scanf(): float conversion.
2
 
   $Id: sscanf_flt-f2.c,v 1.1.2.3 2008/03/20 21:42:36 joerg_wunsch Exp $        */
3
 
 
4
 
#include <stdio.h>
5
 
#include <stdlib.h>
6
 
#include <string.h>
7
 
#include "progmem.h"
8
 
 
9
 
#ifdef  __AVR__
10
 
# define ASSERT(expr)                   \
11
 
    do {                                \
12
 
        if (!(expr)) exit(__LINE__);    \
13
 
    } while (0)
14
 
# define EXIT(v)        exit (v)
15
 
# if defined(__AVR_ATmega128__)
16
 
  /* ATmega128 has enough RAM for sprintf(), print to 0x2000 in XRAM. */
17
 
#  define PRINTF(f...)  sprintf((char *)0x2000, f)
18
 
# else
19
 
  /* small AVR */
20
 
#  define PRINTF(f...)
21
 
# endif
22
 
#else
23
 
# include <assert.h>
24
 
# define ASSERT(expr)   assert (expr)
25
 
# define EXIT(v)        exit ((v) < 256 ? (v) : 255)
26
 
# define PRINTF(f...)   printf (f)
27
 
# define sscanf_P       sscanf
28
 
# define memcmp_P       memcmp
29
 
#endif
30
 
 
31
 
/* Next variables are useful to debug the AVR.  */
32
 
int vrslt = 1;
33
 
struct {
34
 
    float x[10];
35
 
} v = { {1.0} };
36
 
 
37
 
void Check (int line, int expval, int rslt)
38
 
{
39
 
    vrslt = rslt;
40
 
    if (rslt != expval) {
41
 
        PRINTF ("\nLine %d:  expect= %d, rslt= %d\n", line, expval, rslt);
42
 
        EXIT (line);
43
 
    }
44
 
}
45
 
 
46
 
/* The sscanf() is called 4 times: SRAM and FLASH format, 2 values
47
 
   to fill before run.  */
48
 
#define CHECK(expval, ass_expr, str, fmt, ...)                          \
49
 
    do {                                                                \
50
 
        PROGMEM static char fmt_p[] = fmt;                              \
51
 
        char str_s[220];                                                \
52
 
        char fmt_s[40];                                                 \
53
 
        char FILL;                                                      \
54
 
        int i;                                                          \
55
 
        int (* volatile vp)(const char *, const char *, ...);           \
56
 
                                                                        \
57
 
        ASSERT (sizeof(str_s) >= sizeof(str));                          \
58
 
        ASSERT (sizeof(fmt_s) >= sizeof(fmt_p));                        \
59
 
        strcpy_P (str_s, PSTR(str));                                    \
60
 
        strcpy_P (fmt_s, fmt_p);                                        \
61
 
                                                                        \
62
 
        for (FILL = 0; FILL < 4; FILL++) {                              \
63
 
            memset (&v, FILL, sizeof(v));                               \
64
 
            vp = (FILL & 1) ? sscanf_P : sscanf;                        \
65
 
            i = vp (str_s, (FILL & 1) ? fmt_p : fmt_s, ##__VA_ARGS__);  \
66
 
            Check (__LINE__, expval, i);                                \
67
 
            ASSERT (ass_expr);                                          \
68
 
        }                                                               \
69
 
    } while (0)
70
 
 
71
 
int main ()
72
 
{
73
 
    PROGMEM static const float ones[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
74
 
 
75
 
    /* All symbols.     */
76
 
    CHECK (
77
 
        4,
78
 
        v.x[0] == 12345678 && v.x[1] == 0.25
79
 
        && v.x[2] == 90 && v.x[3] == -0.5,
80
 
        "12345678 .25e0 +9e+01 -0.5E-00",
81
 
        "%e %e %e %e",
82
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3]);
83
 
 
84
 
    /* 1.0      */
85
 
    CHECK (
86
 
        10,
87
 
        !memcmp_P (v.x, ones, 10 * sizeof(float)),
88
 
        "1. 1.0 01 001. 0001.0 00001.00 1.e0 1.00000e000000 1e+00 1e-0",
89
 
        "%e %e %e %e %e %e %e %e %e %e",
90
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3], & v.x[4],
91
 
        & v.x[5], & v.x[6], & v.x[7], & v.x[8], & v.x[9]);
92
 
 
93
 
    /* Negative exponents.      */
94
 
    CHECK (
95
 
        10,
96
 
        !memcmp_P (v.x, ones, 10 * sizeof(float)),
97
 
        "10e-1 "
98
 
        "100e-2 "
99
 
        "1000e-3 "
100
 
        "10000e-4 "
101
 
        "100000e-5 "
102
 
        "1000000e-6 "
103
 
        "10000000e-7 "
104
 
        "100000000e-8 "
105
 
        "1000000000e-9 "
106
 
        "10000000000e-10 ",
107
 
        "%e %e %e %e %e %e %e %e %e %e",
108
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3], & v.x[4],
109
 
        & v.x[5], & v.x[6], & v.x[7], & v.x[8], & v.x[9]);
110
 
 
111
 
    CHECK (
112
 
        10,
113
 
        !memcmp_P (v.x, ones, 10 * sizeof(float)),
114
 
        "100000000000e-11 "
115
 
        "1000000000000e-12 "
116
 
        "10000000000000e-13 "
117
 
        "100000000000000e-14 "
118
 
        "1000000000000000e-15 "
119
 
        "10000000000000000e-16 "
120
 
        "100000000000000000e-17 "
121
 
        "1000000000000000000e-18 "
122
 
        "10000000000000000000e-19 "
123
 
        "100000000000000000000e-20 ",
124
 
        "%e %e %e %e %e %e %e %e %e %e",
125
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3], & v.x[4],
126
 
        & v.x[5], & v.x[6], & v.x[7], & v.x[8], & v.x[9]);
127
 
 
128
 
    /* Positive exponents.      */
129
 
    CHECK (
130
 
        10,
131
 
        !memcmp_P (v.x, ones, 10 * sizeof(float)),
132
 
        ".1e1 "
133
 
        ".01e2 "
134
 
        ".001e3 "
135
 
        ".0001e4 "
136
 
        ".00001e5 "
137
 
        ".000001e6 "
138
 
        ".0000001e7 "
139
 
        ".00000001e8 "
140
 
        ".000000001e9 "
141
 
        ".0000000001e10 ",
142
 
        "%e %e %e %e %e %e %e %e %e %e",
143
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3], & v.x[4],
144
 
        & v.x[5], & v.x[6], & v.x[7], & v.x[8], & v.x[9]);
145
 
 
146
 
    CHECK (
147
 
        10,
148
 
        !memcmp_P (v.x, ones, 10 * sizeof(float)),
149
 
        ".00000000001e11 "
150
 
        ".000000000001e12 "
151
 
        ".0000000000001e13 "
152
 
        ".00000000000001e14 "
153
 
        ".000000000000001e15 "
154
 
        ".0000000000000001e16 "
155
 
        ".00000000000000001e17 "
156
 
        ".000000000000000001e18 "
157
 
        ".0000000000000000001e19 "
158
 
        ".00000000000000000001e20 ",
159
 
        "%e %e %e %e %e %e %e %e %e %e",
160
 
        & v.x[0], & v.x[1], & v.x[2], & v.x[3], & v.x[4],
161
 
        & v.x[5], & v.x[6], & v.x[7], & v.x[8], & v.x[9]);
162
 
 
163
 
    return 0;
164
 
}