← Back to branch summary

~ubuntu-branches/ubuntu/wily/spatialite/wily-proposed

« back to all changes in this revision

Viewing changes to test/check_init2.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-07-14 11:57:46 UTC
  • mfrom: (16.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20150714115746-e2iljfmb5sq7o5hh
Tags: 4.3.0-1
Move from experimental to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/check_init2.c
45
45
#include <stdio.h>
46
46
#include <string.h>
47
47
 
 
48
#include "config.h"
 
49
 
48
50
#include "sqlite3.h"
49
51
#include "spatialite.h"
50
52
 
51
 
int main (int argc, char *argv[])
 
53
int
 
54
main (int argc, char *argv[])
52
55
{
53
56
    int ret;
54
57
    sqlite3 *handle;
56
59
    char **results;
57
60
    int rows;
58
61
    int columns;
59
 
    void *cache = spatialite_alloc_connection();
 
62
    void *cache = spatialite_alloc_connection ();
60
63
 
61
64
    if (argc > 1 || argv[0] == NULL)
62
65
        argc = 1;               /* silencing stupid compiler warnings */
63
66
 
64
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
65
 
    if (ret != SQLITE_OK) {
66
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
67
 
        sqlite3_close(handle);
68
 
        return -1;
69
 
    }
70
 
 
71
 
    spatialite_init_ex (handle, cache, 0);
72
 
 
73
 
    ret = sqlite3_exec (handle, "SELECT InitSpatialMetadata(\"NONE\")", NULL, NULL, &err_msg);
74
 
    if (ret != SQLITE_OK) {
75
 
        fprintf (stderr, "InitSpatialMetadata(\"NONE\") error: %s\n", err_msg);
76
 
        sqlite3_free(err_msg);
77
 
        sqlite3_close(handle);
78
 
        return -2;
79
 
    }
80
 
    
81
 
    ret = sqlite3_exec (handle, "SELECT InsertEpsgSrid(4326)", NULL, NULL, &err_msg);
82
 
    if (ret != SQLITE_OK) {
83
 
        fprintf (stderr, "Insert SRID 4326 error: %s\n", err_msg);
84
 
        sqlite3_free(err_msg);
85
 
        sqlite3_close(handle);
86
 
        return -3;
87
 
    }
88
 
 
89
 
    ret = sqlite3_exec (handle, "SELECT InsertEpsgSrid(2998)", NULL, NULL, &err_msg);
90
 
    if (ret != SQLITE_OK) {
91
 
        fprintf (stderr, "Insert SRID 2998 error: %s\n", err_msg);
92
 
        sqlite3_free(err_msg);
93
 
        sqlite3_close(handle);
94
 
        return -4;
95
 
    }
96
 
    
97
 
    ret = sqlite3_close (handle);
98
 
    if (ret != SQLITE_OK) {
99
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
100
 
        return -5;
101
 
    }
102
 
    
103
 
    spatialite_cleanup_ex (cache);
104
 
    
105
 
    cache = spatialite_alloc_connection();
106
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
107
 
    if (ret != SQLITE_OK) {
108
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
109
 
        sqlite3_close(handle);
110
 
        return -6;
111
 
    }
112
 
 
113
 
    spatialite_init_ex (handle, cache, 0);
114
 
    
115
 
    ret = sqlite3_get_table (handle, "SELECT InitSpatialMetadata(3.4)", &results, &rows, &columns, &err_msg);
116
 
    if (ret != SQLITE_OK) {
117
 
      fprintf (stderr, "Error: %s\n", err_msg);
118
 
      sqlite3_free (err_msg);
119
 
      return -7;
120
 
    }
121
 
    if ((rows != 1) || (columns != 1)) {
122
 
        fprintf (stderr, "Unexpected result InitSpatialMetadata() bad result: %i/%i.\n", rows, columns);
123
 
        return  -8;
124
 
    }
125
 
    if (strcmp(results[1], "0") != 0) {
126
 
        fprintf (stderr, "Unexpected result: InitSpatialMetadata() with non-text passed: %s.\n", results[1]);
127
 
        return  -9;
128
 
    }
129
 
    sqlite3_free_table (results);
130
 
    
131
 
    ret = sqlite3_close (handle);
132
 
    if (ret != SQLITE_OK) {
133
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
134
 
        return -10;
135
 
    }
136
 
    
137
 
    spatialite_cleanup_ex (cache);
138
 
    
139
 
    cache = spatialite_alloc_connection();
140
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
141
 
    if (ret != SQLITE_OK) {
142
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
143
 
        sqlite3_close(handle);
144
 
        return -11;
145
 
    }
146
 
 
147
 
    spatialite_init_ex (handle, cache, 0);
148
 
    
149
 
    ret = sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"EMPTY\")", &results, &rows, &columns, &err_msg);
150
 
    if (ret != SQLITE_OK) {
151
 
      fprintf (stderr, "Error: %s\n", err_msg);
152
 
      sqlite3_free (err_msg);
153
 
      return -12;
154
 
    }
155
 
    if ((rows != 1) || (columns != 1)) {
156
 
        fprintf (stderr, "Unexpected result InitSpatialMetadata(\"EMPTY\") bad result: %i/%i.\n", rows, columns);
157
 
        return  -13;
158
 
    }
159
 
    if (strcmp(results[1], "1") != 0) {
160
 
        fprintf (stderr, "Unexpected error: InitSpatialMetadata(\"EMPTY\"): %s.\n", results[1]);
161
 
        return  -14;
162
 
    }
163
 
    sqlite3_free_table (results);
164
 
    
165
 
    ret = sqlite3_get_table (handle, "SELECT InsertEpsgSrid(4326)", &results, &rows, &columns, &err_msg);
166
 
    if (ret != SQLITE_OK) {
167
 
      fprintf (stderr, "Error: %s\n", err_msg);
168
 
      sqlite3_free (err_msg);
169
 
      return -15;
170
 
    }
171
 
    if ((rows != 1) || (columns != 1)) {
172
 
        fprintf (stderr, "Unexpected result InsertEpsgSrid(4326) bad result: %i/%i.\n", rows, columns);
173
 
        return  -16;
174
 
    }
175
 
    if (strcmp(results[1], "1") != 0) {
176
 
        fprintf (stderr, "Unexpected error: InsertEpsgSrid(4326): %s.\n", results[1]);
177
 
        return  -17;
178
 
    }
179
 
    sqlite3_free_table (results);
180
 
    
181
 
    ret = sqlite3_get_table (handle, "SELECT InsertEpsgSrid(\"Non-integer\")", &results, &rows, &columns, &err_msg);
182
 
    if (ret != SQLITE_OK) {
183
 
      fprintf (stderr, "Error: %s\n", err_msg);
184
 
      sqlite3_free (err_msg);
185
 
      return -18;
186
 
    }
187
 
    if ((rows != 1) || (columns != 1)) {
188
 
        fprintf (stderr, "Unexpected result InsertEpsgSrid(\"Non-integer\") bad result: %i/%i.\n", rows, columns);
189
 
        return  -19;
190
 
    }
191
 
    if (strcmp(results[1], "0") != 0) {
192
 
        fprintf (stderr, "Unexpected result: InsertEpsgSrid() with non-integer passed: %s.\n", results[1]);
193
 
        return  -20;
194
 
    }
195
 
    sqlite3_free_table (results);
196
 
    
197
 
    ret = sqlite3_close (handle);
198
 
    if (ret != SQLITE_OK) {
199
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
200
 
        return -21;
201
 
    }
202
 
    
203
 
    spatialite_cleanup_ex (cache);
204
 
     
205
 
    cache = spatialite_alloc_connection();
206
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
207
 
    if (ret != SQLITE_OK) {
208
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
209
 
        sqlite3_close(handle);
210
 
        return -22;
211
 
    }
212
 
 
213
 
    spatialite_init_ex (handle, cache, 0);
214
 
    
215
 
    ret = sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"WGS84\")", &results, &rows, &columns, &err_msg);
216
 
    if (ret != SQLITE_OK) {
217
 
      fprintf (stderr, "Error: %s\n", err_msg);
218
 
      sqlite3_free (err_msg);
219
 
      return -23;
220
 
    }
221
 
    if ((rows != 1) || (columns != 1)) {
222
 
        fprintf (stderr, "Unexpected result InitSpatialMetadata(\"WGS84\") bad result: %i/%i.\n", rows, columns);
223
 
        return  -24;
224
 
    }
225
 
    if (strcmp(results[1], "1") != 0) {
226
 
        fprintf (stderr, "Unexpected error: InitSpatialMetadata(\"WGS84\"): %s.\n", results[1]);
227
 
        return  -25;
228
 
    }
229
 
    sqlite3_free_table (results);
230
 
    
231
 
    ret = sqlite3_get_table (handle, "SELECT InsertEpsgSrid(3003)", &results, &rows, &columns, &err_msg);
232
 
    if (ret != SQLITE_OK) {
233
 
      fprintf (stderr, "Error: %s\n", err_msg);
234
 
      sqlite3_free (err_msg);
235
 
      return -26;
236
 
    }
237
 
    if ((rows != 1) || (columns != 1)) {
238
 
        fprintf (stderr, "Unexpected result InsertEpsgSrid(3003) bad result: %i/%i.\n", rows, columns);
239
 
        return  -27;
240
 
    }
241
 
    if (strcmp(results[1], "1") != 0) {
242
 
        fprintf (stderr, "Unexpected error: InsertEpsgSrid(3003): %s.\n", results[1]);
243
 
        return  -28;
244
 
    }
245
 
    sqlite3_free_table (results);
246
 
    
247
 
    ret = sqlite3_get_table (handle, "SELECT InsertEpsgSrid(4326)", &results, &rows, &columns, &err_msg);
248
 
    if (ret != SQLITE_OK) {
249
 
      fprintf (stderr, "Error: %s\n", err_msg);
250
 
      sqlite3_free (err_msg);
251
 
      return -29;
252
 
    }
253
 
    if ((rows != 1) || (columns != 1)) {
254
 
        fprintf (stderr, "Unexpected result InsertEpsgSrid(4326) (dupe) bad result: %i/%i.\n", rows, columns);
255
 
        return  -30;
256
 
    }
257
 
    if (strcmp(results[1], "0") != 0) {
258
 
        fprintf (stderr, "Unexpected result: InsertEpsgSrid(4326) duplicate passed: %s.\n", results[1]);
259
 
        return  -31;
260
 
    }
261
 
    sqlite3_free_table (results);
262
 
    
263
 
    ret = sqlite3_close (handle);
264
 
    if (ret != SQLITE_OK) {
265
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
266
 
        return -32;
267
 
    }
268
 
    
269
 
    spatialite_cleanup_ex (cache);
270
 
        
271
 
    cache = spatialite_alloc_connection();
272
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
273
 
    if (ret != SQLITE_OK) {
274
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
275
 
        sqlite3_close(handle);
276
 
        return -33;
277
 
    }
278
 
 
279
 
    spatialite_init_ex (handle, cache, 0);
280
 
    
281
 
    ret = sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"WGS84_only\")", &results, &rows, &columns, &err_msg);
282
 
    if (ret != SQLITE_OK) {
283
 
      fprintf (stderr, "Error: %s\n", err_msg);
284
 
      sqlite3_free (err_msg);
285
 
      return -34;
286
 
    }
287
 
    if ((rows != 1) || (columns != 1)) {
288
 
        fprintf (stderr, "Unexpected result InitSpatialMetadata(\"WGS84_ONLY\") bad result: %i/%i.\n", rows, columns);
289
 
        return  -35;
290
 
    }
291
 
    if (strcmp(results[1], "1") != 0) {
292
 
        fprintf (stderr, "Unexpected error: InitSpatialMetadata(\"WGS84_ONLY\"): %s.\n", results[1]);
293
 
        return  -36;
294
 
    }
295
 
    sqlite3_free_table (results);
296
 
    
297
 
    ret = sqlite3_close (handle);
298
 
    if (ret != SQLITE_OK) {
299
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
300
 
        return -32;
301
 
    }
302
 
    
303
 
    spatialite_cleanup_ex (cache);
304
 
    
 
67
    ret =
 
68
        sqlite3_open_v2 (":memory:", &handle,
 
69
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
70
    if (ret != SQLITE_OK)
 
71
      {
 
72
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
73
                   sqlite3_errmsg (handle));
 
74
          sqlite3_close (handle);
 
75
          return -1;
 
76
      }
 
77
 
 
78
    spatialite_init_ex (handle, cache, 0);
 
79
 
 
80
    ret =
 
81
        sqlite3_exec (handle, "SELECT InitSpatialMetadata(\"NONE\")", NULL,
 
82
                      NULL, &err_msg);
 
83
    if (ret != SQLITE_OK)
 
84
      {
 
85
          fprintf (stderr, "InitSpatialMetadata(\"NONE\") error: %s\n",
 
86
                   err_msg);
 
87
          sqlite3_free (err_msg);
 
88
          sqlite3_close (handle);
 
89
          return -2;
 
90
      }
 
91
 
 
92
    ret =
 
93
        sqlite3_exec (handle, "SELECT InsertEpsgSrid(4326)", NULL, NULL,
 
94
                      &err_msg);
 
95
    if (ret != SQLITE_OK)
 
96
      {
 
97
          fprintf (stderr, "Insert SRID 4326 error: %s\n", err_msg);
 
98
          sqlite3_free (err_msg);
 
99
          sqlite3_close (handle);
 
100
          return -3;
 
101
      }
 
102
 
 
103
#ifndef OMIT_EPSG
 
104
/* only if full EPSG support is enabled */
 
105
    ret =
 
106
        sqlite3_exec (handle, "SELECT InsertEpsgSrid(2998)", NULL, NULL,
 
107
                      &err_msg);
 
108
    if (ret != SQLITE_OK)
 
109
      {
 
110
          fprintf (stderr, "Insert SRID 2998 error: %s\n", err_msg);
 
111
          sqlite3_free (err_msg);
 
112
          sqlite3_close (handle);
 
113
          return -4;
 
114
      }
 
115
#endif
 
116
 
 
117
    ret = sqlite3_close (handle);
 
118
    if (ret != SQLITE_OK)
 
119
      {
 
120
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
121
                   sqlite3_errmsg (handle));
 
122
          return -5;
 
123
      }
 
124
 
 
125
    spatialite_cleanup_ex (cache);
 
126
 
 
127
    cache = spatialite_alloc_connection ();
 
128
    ret =
 
129
        sqlite3_open_v2 (":memory:", &handle,
 
130
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
131
    if (ret != SQLITE_OK)
 
132
      {
 
133
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
134
                   sqlite3_errmsg (handle));
 
135
          sqlite3_close (handle);
 
136
          return -6;
 
137
      }
 
138
 
 
139
    spatialite_init_ex (handle, cache, 0);
 
140
 
 
141
    ret =
 
142
        sqlite3_get_table (handle, "SELECT InitSpatialMetadata(3.4)", &results,
 
143
                           &rows, &columns, &err_msg);
 
144
    if (ret != SQLITE_OK)
 
145
      {
 
146
          fprintf (stderr, "Error: %s\n", err_msg);
 
147
          sqlite3_free (err_msg);
 
148
          return -7;
 
149
      }
 
150
    if ((rows != 1) || (columns != 1))
 
151
      {
 
152
          fprintf (stderr,
 
153
                   "Unexpected result InitSpatialMetadata() bad result: %i/%i.\n",
 
154
                   rows, columns);
 
155
          return -8;
 
156
      }
 
157
    if (strcmp (results[1], "0") != 0)
 
158
      {
 
159
          fprintf (stderr,
 
160
                   "Unexpected result: InitSpatialMetadata() with non-text passed: %s.\n",
 
161
                   results[1]);
 
162
          return -9;
 
163
      }
 
164
    sqlite3_free_table (results);
 
165
 
 
166
    ret = sqlite3_close (handle);
 
167
    if (ret != SQLITE_OK)
 
168
      {
 
169
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
170
                   sqlite3_errmsg (handle));
 
171
          return -10;
 
172
      }
 
173
 
 
174
    spatialite_cleanup_ex (cache);
 
175
 
 
176
    cache = spatialite_alloc_connection ();
 
177
    ret =
 
178
        sqlite3_open_v2 (":memory:", &handle,
 
179
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
180
    if (ret != SQLITE_OK)
 
181
      {
 
182
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
183
                   sqlite3_errmsg (handle));
 
184
          sqlite3_close (handle);
 
185
          return -11;
 
186
      }
 
187
 
 
188
    spatialite_init_ex (handle, cache, 0);
 
189
 
 
190
    ret =
 
191
        sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"EMPTY\")",
 
192
                           &results, &rows, &columns, &err_msg);
 
193
    if (ret != SQLITE_OK)
 
194
      {
 
195
          fprintf (stderr, "Error: %s\n", err_msg);
 
196
          sqlite3_free (err_msg);
 
197
          return -12;
 
198
      }
 
199
    if ((rows != 1) || (columns != 1))
 
200
      {
 
201
          fprintf (stderr,
 
202
                   "Unexpected result InitSpatialMetadata(\"EMPTY\") bad result: %i/%i.\n",
 
203
                   rows, columns);
 
204
          return -13;
 
205
      }
 
206
    if (strcmp (results[1], "1") != 0)
 
207
      {
 
208
          fprintf (stderr,
 
209
                   "Unexpected error: InitSpatialMetadata(\"EMPTY\"): %s.\n",
 
210
                   results[1]);
 
211
          return -14;
 
212
      }
 
213
    sqlite3_free_table (results);
 
214
 
 
215
    ret =
 
216
        sqlite3_get_table (handle, "SELECT InsertEpsgSrid(4326)", &results,
 
217
                           &rows, &columns, &err_msg);
 
218
    if (ret != SQLITE_OK)
 
219
      {
 
220
          fprintf (stderr, "Error: %s\n", err_msg);
 
221
          sqlite3_free (err_msg);
 
222
          return -15;
 
223
      }
 
224
    if ((rows != 1) || (columns != 1))
 
225
      {
 
226
          fprintf (stderr,
 
227
                   "Unexpected result InsertEpsgSrid(4326) bad result: %i/%i.\n",
 
228
                   rows, columns);
 
229
          return -16;
 
230
      }
 
231
    if (strcmp (results[1], "1") != 0)
 
232
      {
 
233
          fprintf (stderr, "Unexpected error: InsertEpsgSrid(4326): %s.\n",
 
234
                   results[1]);
 
235
          return -17;
 
236
      }
 
237
    sqlite3_free_table (results);
 
238
 
 
239
    ret =
 
240
        sqlite3_get_table (handle, "SELECT InsertEpsgSrid(\"Non-integer\")",
 
241
                           &results, &rows, &columns, &err_msg);
 
242
    if (ret != SQLITE_OK)
 
243
      {
 
244
          fprintf (stderr, "Error: %s\n", err_msg);
 
245
          sqlite3_free (err_msg);
 
246
          return -18;
 
247
      }
 
248
    if ((rows != 1) || (columns != 1))
 
249
      {
 
250
          fprintf (stderr,
 
251
                   "Unexpected result InsertEpsgSrid(\"Non-integer\") bad result: %i/%i.\n",
 
252
                   rows, columns);
 
253
          return -19;
 
254
      }
 
255
    if (strcmp (results[1], "0") != 0)
 
256
      {
 
257
          fprintf (stderr,
 
258
                   "Unexpected result: InsertEpsgSrid() with non-integer passed: %s.\n",
 
259
                   results[1]);
 
260
          return -20;
 
261
      }
 
262
    sqlite3_free_table (results);
 
263
 
 
264
    ret = sqlite3_close (handle);
 
265
    if (ret != SQLITE_OK)
 
266
      {
 
267
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
268
                   sqlite3_errmsg (handle));
 
269
          return -21;
 
270
      }
 
271
 
 
272
    spatialite_cleanup_ex (cache);
 
273
 
 
274
    cache = spatialite_alloc_connection ();
 
275
    ret =
 
276
        sqlite3_open_v2 (":memory:", &handle,
 
277
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
278
    if (ret != SQLITE_OK)
 
279
      {
 
280
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
281
                   sqlite3_errmsg (handle));
 
282
          sqlite3_close (handle);
 
283
          return -22;
 
284
      }
 
285
 
 
286
    spatialite_init_ex (handle, cache, 0);
 
287
 
 
288
    ret =
 
289
        sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"WGS84\")",
 
290
                           &results, &rows, &columns, &err_msg);
 
291
    if (ret != SQLITE_OK)
 
292
      {
 
293
          fprintf (stderr, "Error: %s\n", err_msg);
 
294
          sqlite3_free (err_msg);
 
295
          return -23;
 
296
      }
 
297
    if ((rows != 1) || (columns != 1))
 
298
      {
 
299
          fprintf (stderr,
 
300
                   "Unexpected result InitSpatialMetadata(\"WGS84\") bad result: %i/%i.\n",
 
301
                   rows, columns);
 
302
          return -24;
 
303
      }
 
304
    if (strcmp (results[1], "1") != 0)
 
305
      {
 
306
          fprintf (stderr,
 
307
                   "Unexpected error: InitSpatialMetadata(\"WGS84\"): %s.\n",
 
308
                   results[1]);
 
309
          return -25;
 
310
      }
 
311
    sqlite3_free_table (results);
 
312
 
 
313
#ifndef OMIT_EPSG
 
314
/* only if full EPSG support is enabled */
 
315
    ret =
 
316
        sqlite3_get_table (handle, "SELECT InsertEpsgSrid(3003)", &results,
 
317
                           &rows, &columns, &err_msg);
 
318
    if (ret != SQLITE_OK)
 
319
      {
 
320
          fprintf (stderr, "Error: %s\n", err_msg);
 
321
          sqlite3_free (err_msg);
 
322
          return -26;
 
323
      }
 
324
    if ((rows != 1) || (columns != 1))
 
325
      {
 
326
          fprintf (stderr,
 
327
                   "Unexpected result InsertEpsgSrid(3003) bad result: %i/%i.\n",
 
328
                   rows, columns);
 
329
          return -27;
 
330
      }
 
331
    if (strcmp (results[1], "1") != 0)
 
332
      {
 
333
          fprintf (stderr, "Unexpected error: InsertEpsgSrid(3003): %s.\n",
 
334
                   results[1]);
 
335
          return -28;
 
336
      }
 
337
    sqlite3_free_table (results);
 
338
#endif
 
339
 
 
340
    ret =
 
341
        sqlite3_get_table (handle, "SELECT InsertEpsgSrid(4326)", &results,
 
342
                           &rows, &columns, &err_msg);
 
343
    if (ret != SQLITE_OK)
 
344
      {
 
345
          fprintf (stderr, "Error: %s\n", err_msg);
 
346
          sqlite3_free (err_msg);
 
347
          return -29;
 
348
      }
 
349
    if ((rows != 1) || (columns != 1))
 
350
      {
 
351
          fprintf (stderr,
 
352
                   "Unexpected result InsertEpsgSrid(4326) (dupe) bad result: %i/%i.\n",
 
353
                   rows, columns);
 
354
          return -30;
 
355
      }
 
356
    if (strcmp (results[1], "0") != 0)
 
357
      {
 
358
          fprintf (stderr,
 
359
                   "Unexpected result: InsertEpsgSrid(4326) duplicate passed: %s.\n",
 
360
                   results[1]);
 
361
          return -31;
 
362
      }
 
363
    sqlite3_free_table (results);
 
364
 
 
365
    ret = sqlite3_close (handle);
 
366
    if (ret != SQLITE_OK)
 
367
      {
 
368
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
369
                   sqlite3_errmsg (handle));
 
370
          return -32;
 
371
      }
 
372
 
 
373
    spatialite_cleanup_ex (cache);
 
374
 
 
375
    cache = spatialite_alloc_connection ();
 
376
    ret =
 
377
        sqlite3_open_v2 (":memory:", &handle,
 
378
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
379
    if (ret != SQLITE_OK)
 
380
      {
 
381
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
382
                   sqlite3_errmsg (handle));
 
383
          sqlite3_close (handle);
 
384
          return -33;
 
385
      }
 
386
 
 
387
    spatialite_init_ex (handle, cache, 0);
 
388
 
 
389
    ret =
 
390
        sqlite3_get_table (handle, "SELECT InitSpatialMetadata(\"WGS84_only\")",
 
391
                           &results, &rows, &columns, &err_msg);
 
392
    if (ret != SQLITE_OK)
 
393
      {
 
394
          fprintf (stderr, "Error: %s\n", err_msg);
 
395
          sqlite3_free (err_msg);
 
396
          return -34;
 
397
      }
 
398
    if ((rows != 1) || (columns != 1))
 
399
      {
 
400
          fprintf (stderr,
 
401
                   "Unexpected result InitSpatialMetadata(\"WGS84_ONLY\") bad result: %i/%i.\n",
 
402
                   rows, columns);
 
403
          return -35;
 
404
      }
 
405
    if (strcmp (results[1], "1") != 0)
 
406
      {
 
407
          fprintf (stderr,
 
408
                   "Unexpected error: InitSpatialMetadata(\"WGS84_ONLY\"): %s.\n",
 
409
                   results[1]);
 
410
          return -36;
 
411
      }
 
412
    sqlite3_free_table (results);
 
413
 
 
414
    ret = sqlite3_close (handle);
 
415
    if (ret != SQLITE_OK)
 
416
      {
 
417
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
418
                   sqlite3_errmsg (handle));
 
419
          return -32;
 
420
      }
 
421
 
 
422
    spatialite_cleanup_ex (cache);
 
423
 
305
424
    return 0;
306
425
}