← Back to branch summary

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

« back to all changes in this revision

Viewing changes to test/check_styling.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_styling.c
51
51
#include "sqlite3.h"
52
52
#include "spatialite.h"
53
53
 
54
 
#ifdef ENABLE_LIBXML2   /* only if LIBXML2 is supported */
55
 
#include <libxml/parser.h>
56
 
#endif
 
54
int
 
55
execute_check (sqlite3 * sqlite, const char *sql, char **error)
 
56
{
 
57
/* executing an SQL statement returning True/False */
 
58
    sqlite3_stmt *stmt;
 
59
    int ret;
 
60
    int retcode = 0;
 
61
 
 
62
    if (error != NULL)
 
63
        *error = NULL;
 
64
    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
 
65
    if (ret != SQLITE_OK)
 
66
      {
 
67
          if (error != NULL)
 
68
              *error = sqlite3_mprintf ("%s", sqlite3_errmsg (sqlite));
 
69
          return SQLITE_ERROR;
 
70
      }
 
71
    ret = sqlite3_step (stmt);
 
72
    if (ret == SQLITE_DONE || ret == SQLITE_ROW)
 
73
      {
 
74
          if (sqlite3_column_int (stmt, 0) == 1)
 
75
              retcode = 1;
 
76
      }
 
77
    sqlite3_finalize (stmt);
 
78
    if (retcode == 1)
 
79
        return SQLITE_OK;
 
80
    return SQLITE_ERROR;
 
81
}
57
82
 
58
83
static unsigned char *
59
 
load_blob(const char *path, int *blob_len)
 
84
load_blob (const char *path, int *blob_len)
60
85
{
61
86
/* loading an external image */
62
87
    unsigned char *blob;
63
88
    int sz = 0;
64
89
    int rd;
65
 
    FILE *fl = fopen(path, "rb");
66
 
    if (!fl) {
67
 
        fprintf (stderr, "cannot open \"%s\"\n", path);
68
 
        return NULL;
69
 
    }
70
 
    if (fseek(fl, 0, SEEK_END) == 0)
71
 
        sz = ftell(fl);
72
 
    blob = (unsigned char *) malloc(sz);
 
90
    FILE *fl = fopen (path, "rb");
 
91
    if (!fl)
 
92
      {
 
93
          fprintf (stderr, "cannot open \"%s\"\n", path);
 
94
          return NULL;
 
95
      }
 
96
    if (fseek (fl, 0, SEEK_END) == 0)
 
97
        sz = ftell (fl);
 
98
    blob = (unsigned char *) malloc (sz);
73
99
    *blob_len = sz;
74
 
    rewind(fl);
75
 
    rd = fread(blob, 1, sz, fl);
76
 
    if (rd != sz) {
77
 
        fprintf (stderr, "read error \"%s\"\n", path);
78
 
        return NULL;
79
 
    }
80
 
    fclose(fl);
 
100
    rewind (fl);
 
101
    rd = fread (blob, 1, sz, fl);
 
102
    if (rd != sz)
 
103
      {
 
104
          fprintf (stderr, "read error \"%s\"\n", path);
 
105
          return NULL;
 
106
      }
 
107
    fclose (fl);
81
108
    return blob;
82
109
}
83
110
 
84
111
static unsigned char *
85
 
load_xml(const char *path, int *len)
 
112
load_xml (const char *path, int *len)
86
113
{
87
114
/* loading an external XML */
88
115
    unsigned char *xml;
89
116
    int sz = 0;
90
117
    int rd;
91
 
    FILE *fl = fopen(path, "rb");
92
 
    if (!fl) {
93
 
        fprintf (stderr, "cannot open \"%s\"\n", path);
94
 
        return NULL;
95
 
    }
96
 
    if (fseek(fl, 0, SEEK_END) == 0)
97
 
        sz = ftell(fl);
98
 
    xml = malloc(sz + 1);
 
118
    FILE *fl = fopen (path, "rb");
 
119
    if (!fl)
 
120
      {
 
121
          fprintf (stderr, "cannot open \"%s\"\n", path);
 
122
          return NULL;
 
123
      }
 
124
    if (fseek (fl, 0, SEEK_END) == 0)
 
125
        sz = ftell (fl);
 
126
    xml = malloc (sz + 1);
99
127
    *len = sz;
100
 
    rewind(fl);
101
 
    rd = fread(xml, 1, sz, fl);
102
 
    if (rd != sz) {
103
 
        fprintf (stderr, "read error \"%s\"\n", path);
104
 
        return NULL;
105
 
    }
106
 
    fclose(fl);
 
128
    rewind (fl);
 
129
    rd = fread (xml, 1, sz, fl);
 
130
    if (rd != sz)
 
131
      {
 
132
          fprintf (stderr, "read error \"%s\"\n", path);
 
133
          return NULL;
 
134
      }
 
135
    fclose (fl);
107
136
    xml[rd] = '\0';
108
137
    return xml;
109
138
}
110
139
 
111
140
static char *
112
 
build_hex_blob(const unsigned char *blob, int blob_len)
 
141
build_hex_blob (const unsigned char *blob, int blob_len)
113
142
{
114
143
/* building an HEX blob */
115
144
    int i;
116
145
    const unsigned char *p_in = blob;
117
 
    char *hex = malloc((blob_len * 2) + 1);
 
146
    char *hex = malloc ((blob_len * 2) + 1);
118
147
    char *p_out = hex;
119
148
    for (i = 0; i < blob_len; i++)
120
 
    {
121
 
         sprintf(p_out, "%02x", *p_in);
122
 
         p_in++;
123
 
         p_out += 2;
124
 
    }
 
149
      {
 
150
          sprintf (p_out, "%02x", *p_in);
 
151
          p_in++;
 
152
          p_out += 2;
 
153
      }
125
154
    return hex;
126
155
}
127
156
 
128
 
int main (int argc, char *argv[])
 
157
static int
 
158
check_vector (sqlite3 * handle, void *cache)
129
159
{
 
160
/* testing Vector Styles */
130
161
    int ret;
131
 
    sqlite3 *handle;
132
162
    char *err_msg = NULL;
133
 
    char **results;
134
 
    int rows;
135
 
    int columns;
 
163
    char *sql;
136
164
    unsigned char *blob;
137
165
    int blob_len;
138
166
    char *hexBlob;
139
167
    unsigned char *xml;
140
168
    int len;
141
 
    char *sql;
142
 
    void *cache = spatialite_alloc_connection();
143
 
 
144
 
    if (argc > 1 || argv[0] == NULL)
145
 
        argc = 1;               /* silencing stupid compiler warnings */
146
 
 
147
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
148
 
    if (ret != SQLITE_OK) {
149
 
        fprintf(stderr, "cannot open in-memory db: %s\n", sqlite3_errmsg (handle));
150
 
        sqlite3_close(handle);
151
 
        return -1;
152
 
    }
153
 
 
154
 
    spatialite_init_ex (handle, cache, 0);
155
 
 
156
 
    ret = sqlite3_exec (handle, "SELECT InitSpatialMetadata(1, 'WGS84')", NULL, NULL, &err_msg);
157
 
    if (ret != SQLITE_OK) {
158
 
        fprintf(stderr, "Unexpected InitSpatialMetadata result: %i, (%s)\n", ret, err_msg);
159
 
        sqlite3_free (err_msg);
160
 
        return -2;
161
 
    }
162
 
 
163
 
#ifdef ENABLE_LIBXML2   /* only if LIBXML2 is supported */
164
 
 
165
 
    ret = sqlite3_get_table (handle, "SELECT CreateStylingTables(1)", &results, &rows, &columns, &err_msg);
166
 
    if (ret != SQLITE_OK) {
167
 
      fprintf (stderr, "Error CreateStylingTables: %s\n", err_msg);
168
 
      sqlite3_free (err_msg);
169
 
      return -3;
170
 
    }
171
 
    if ((rows != 1) || (columns != 1))
172
 
    {
173
 
        sqlite3_free_table(results);
174
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
 
169
 
 
170
/* testing External Graphic */
 
171
    blob = load_blob ("empty.png", &blob_len);
 
172
    if (blob == NULL)
175
173
        return -4;
176
 
    }
177
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
178
 
    {
179
 
        fprintf (stderr, "Unexpected #0 result (got %s, expected 1)", results[1 * columns + 0]);
180
 
        sqlite3_free_table(results);
 
174
    hexBlob = build_hex_blob (blob, blob_len);
 
175
    free (blob);
 
176
    if (hexBlob == NULL)
181
177
        return -5;
182
 
    }
183
 
    sqlite3_free_table(results);
184
 
 
185
 
    blob = load_blob("empty.png", &blob_len);
186
 
    if (blob == NULL) 
187
 
        return -6;
188
 
    hexBlob = build_hex_blob(blob, blob_len);
189
 
    free(blob);
 
178
    sql =
 
179
        sqlite3_mprintf ("SELECT SE_RegisterExternalGraphic('url-A', x%Q)",
 
180
                         hexBlob);
 
181
    ret = execute_check (handle, sql, &err_msg);
 
182
    sqlite3_free (sql);
 
183
    if (ret != SQLITE_OK)
 
184
      {
 
185
          fprintf (stderr, "Error RegisterExternalGraphic #1: %s\n\n", err_msg);
 
186
          sqlite3_free (err_msg);
 
187
          return -6;
 
188
      }
 
189
 
 
190
    sql =
 
191
        sqlite3_mprintf
 
192
        ("SELECT SE_RegisterExternalGraphic('url-A', x%Q, 'title', 'abstract', 'file_name')",
 
193
         hexBlob);
 
194
    free (hexBlob);
 
195
    ret = execute_check (handle, sql, &err_msg);
 
196
    sqlite3_free (sql);
 
197
    if (ret != SQLITE_OK)
 
198
      {
 
199
          fprintf (stderr, "Error RegisterExternalGraphic #2: %s\n\n", err_msg);
 
200
          sqlite3_free (err_msg);
 
201
          return -7;
 
202
      }
 
203
 
 
204
    xml = load_xml ("thunderstorm_mild.svg", &len);
 
205
    if (xml == NULL)
 
206
        return -8;
 
207
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
208
    free (xml);
 
209
    hexBlob = build_hex_blob (blob, blob_len);
 
210
    free (blob);
190
211
    if (hexBlob == NULL)
191
 
        return -7;
192
 
    sql = sqlite3_mprintf("SELECT RegisterExternalGraphic('url-A', x%Q)", hexBlob);
193
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
194
 
    sqlite3_free(sql);
195
 
    if (ret != SQLITE_OK) {
196
 
      fprintf (stderr, "Error RegisterExternalGraphic #1: %s\n", err_msg);
197
 
      sqlite3_free (err_msg);
198
 
      return -8;
199
 
    }
200
 
    if ((rows != 1) || (columns != 1))
201
 
    {
202
 
        sqlite3_free_table(results);
203
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
204
212
        return -9;
205
 
    }
206
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
207
 
    {
208
 
        fprintf (stderr, "Unexpected #1 result (got %s, expected 1)", results[1 * columns + 0]);
209
 
        sqlite3_free_table(results);
 
213
    sql =
 
214
        sqlite3_mprintf ("SELECT SE_RegisterExternalGraphic('url-A', x%Q)",
 
215
                         hexBlob);
 
216
    ret = execute_check (handle, sql, &err_msg);
 
217
    sqlite3_free (sql);
 
218
    if (ret != SQLITE_OK)
 
219
      {
 
220
          fprintf (stderr, "Error RegisterExternalGraphic #3: %s\n\n", err_msg);
 
221
          sqlite3_free (err_msg);
 
222
          return -10;
 
223
      }
 
224
 
 
225
    sql =
 
226
        sqlite3_mprintf
 
227
        ("SELECT SE_RegisterExternalGraphic('url-B', x%Q, 'title', 'abstract', 'file_name')",
 
228
         hexBlob);
 
229
    free (hexBlob);
 
230
    ret = execute_check (handle, sql, &err_msg);
 
231
    sqlite3_free (sql);
 
232
    if (ret != SQLITE_OK)
 
233
      {
 
234
          fprintf (stderr, "Error RegisterExternalGraphic #4: %s\n\n", err_msg);
 
235
          sqlite3_free (err_msg);
 
236
          return -11;
 
237
      }
 
238
 
 
239
/* creating two  vector Tables */
 
240
    sql = "CREATE TABLE table1 (id INTEGER PRIMARY KEY AUTOINCREMENT)";
 
241
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
242
    if (ret != SQLITE_OK)
 
243
      {
 
244
          fprintf (stderr, "Error Create Table table1: %s\n\n", err_msg);
 
245
          sqlite3_free (err_msg);
 
246
          return -12;
 
247
      }
 
248
    sql = "CREATE TABLE table2 (id INTEGER PRIMARY KEY AUTOINCREMENT)";
 
249
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
250
    if (ret != SQLITE_OK)
 
251
      {
 
252
          fprintf (stderr, "Error Create Table table2: %s\n\n", err_msg);
 
253
          sqlite3_free (err_msg);
 
254
          return -13;
 
255
      }
 
256
    sql = "SELECT AddGeometryColumn('table1', 'geom', 4326, 'POINT', 'XY')";
 
257
    ret = execute_check (handle, sql, &err_msg);
 
258
    if (ret != SQLITE_OK)
 
259
      {
 
260
          fprintf (stderr, "Error AddGeometryColumn table1: %s\n\n", err_msg);
 
261
          sqlite3_free (err_msg);
 
262
          return -14;
 
263
      }
 
264
    sql = "SELECT AddGeometryColumn('table2', 'geom', 32632, 'POINT', 'XY')";
 
265
    ret = execute_check (handle, sql, &err_msg);
 
266
    if (ret != SQLITE_OK)
 
267
      {
 
268
          fprintf (stderr, "Error AddGeometryColumn table2: %s\n\n", err_msg);
 
269
          sqlite3_free (err_msg);
 
270
          return -15;
 
271
      }
 
272
 
 
273
/* registering two Vector Coverages */
 
274
    sql = "SELECT SE_RegisterVectorCoverage('table1', 'table1', 'geom')";
 
275
    ret = execute_check (handle, sql, &err_msg);
 
276
    if (ret != SQLITE_OK)
 
277
      {
 
278
          fprintf (stderr, "Error RegisterVectorCoverage table1: %s\n\n",
 
279
                   err_msg);
 
280
          sqlite3_free (err_msg);
 
281
          return -16;
 
282
      }
 
283
    sql =
 
284
        "SELECT SE_RegisterVectorCoverage('table2', 'table2', 'geom', 'title-2', 'abstract-2')";
 
285
    ret = execute_check (handle, sql, &err_msg);
 
286
    if (ret != SQLITE_OK)
 
287
      {
 
288
          fprintf (stderr, "Error RegisterVectorCoverage table2: %s\n\n",
 
289
                   err_msg);
 
290
          sqlite3_free (err_msg);
 
291
          return -17;
 
292
      }
 
293
    sql = "SELECT SE_SetVectorCoverageInfos('table1', 'title-1', 'abstract-1')";
 
294
    ret = execute_check (handle, sql, &err_msg);
 
295
    if (ret != SQLITE_OK)
 
296
      {
 
297
          fprintf (stderr, "Error RegisterVectorCoverage table1: %s\n\n",
 
298
                   err_msg);
 
299
          sqlite3_free (err_msg);
 
300
          return -18;
 
301
      }
 
302
 
 
303
/* testing Vector Styles */
 
304
    xml = load_xml ("stazioni_se.xml", &len);
 
305
    if (xml == NULL)
 
306
        return -19;
 
307
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
308
    free (xml);
 
309
    if (blob == NULL)
 
310
      {
 
311
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
312
          return -20;
 
313
      }
 
314
    hexBlob = build_hex_blob (blob, blob_len);
 
315
    free (blob);
 
316
    if (hexBlob == NULL)
 
317
        return -21;
 
318
 
 
319
/* Register Vector Styled Layer */
 
320
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyle(x%Q)", hexBlob);
 
321
    ret = execute_check (handle, sql, &err_msg);
 
322
    sqlite3_free (sql);
 
323
    if (ret != SQLITE_OK)
 
324
      {
 
325
          fprintf (stderr, "Error RegisterVectorStyle #1: %s\n\n", err_msg);
 
326
          sqlite3_free (err_msg);
 
327
          return -22;
 
328
      }
 
329
 
 
330
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyledLayer('table1',  1)");
 
331
    ret = execute_check (handle, sql, &err_msg);
 
332
    sqlite3_free (sql);
 
333
    if (ret != SQLITE_OK)
 
334
      {
 
335
          fprintf (stderr, "Error RegisterVectorStyledLayer #1: %s\n\n",
 
336
                   err_msg);
 
337
          sqlite3_free (err_msg);
 
338
          return -23;
 
339
      }
 
340
 
 
341
    sql =
 
342
        sqlite3_mprintf
 
343
        ("SELECT SE_RegisterVectorStyledLayer('table2', 'Railway Stations')");
 
344
    ret = execute_check (handle, sql, &err_msg);
 
345
    sqlite3_free (sql);
 
346
    if (ret != SQLITE_OK)
 
347
      {
 
348
          fprintf (stderr, "Error RegisterVectorStyledLayer #2: %s\n\n",
 
349
                   err_msg);
 
350
          sqlite3_free (err_msg);
 
351
          return -24;
 
352
      }
 
353
    free (hexBlob);
 
354
 
 
355
    xml = load_xml ("stazioni2_se.xml", &len);
 
356
    if (xml == NULL)
 
357
        return -25;
 
358
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
359
    free (xml);
 
360
    if (blob == NULL)
 
361
      {
 
362
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
363
          return -26;
 
364
      }
 
365
    hexBlob = build_hex_blob (blob, blob_len);
 
366
    free (blob);
 
367
    if (hexBlob == NULL)
 
368
        return -27;
 
369
 
 
370
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyle(x%Q)", hexBlob);
 
371
    ret = execute_check (handle, sql, &err_msg);
 
372
    sqlite3_free (sql);
 
373
    if (ret != SQLITE_OK)
 
374
      {
 
375
          fprintf (stderr, "Error RegisterVectorStyle #2: %s\n\n", err_msg);
 
376
          sqlite3_free (err_msg);
 
377
          return -29;
 
378
      }
 
379
 
 
380
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyledLayer('table2', 2)");
 
381
    ret = execute_check (handle, sql, &err_msg);
 
382
    sqlite3_free (sql);
 
383
    if (ret != SQLITE_OK)
 
384
      {
 
385
          fprintf (stderr, "Error RegisterVectorStyledLayer #3: %s\n\n",
 
386
                   err_msg);
 
387
          sqlite3_free (err_msg);
 
388
          return -30;
 
389
      }
 
390
 
 
391
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyle(x%Q)", hexBlob);
 
392
    ret = execute_check (handle, sql, NULL);
 
393
    sqlite3_free (sql);
 
394
    if (ret == SQLITE_OK)
 
395
      {
 
396
          fprintf (stderr, "Error RegisterVectorStyle #3: %s\n\n",
 
397
                   "expected failure");
 
398
          return -31;
 
399
      }
 
400
 
 
401
/* Reload Vector Style */
 
402
    sql = sqlite3_mprintf ("SELECT SE_ReloadVectorStyle(12, x%Q)", hexBlob);
 
403
    ret = execute_check (handle, sql, NULL);
 
404
    sqlite3_free (sql);
 
405
    if (ret == SQLITE_OK)
 
406
      {
 
407
          fprintf (stderr, "Error ReloadVectorStyle #1: %s\n\n",
 
408
                   "expected failure");
 
409
          return -33;
 
410
      }
 
411
 
 
412
    sql = sqlite3_mprintf ("SELECT SE_ReloadVectorStyle(1, x%Q)", hexBlob);
 
413
    ret = execute_check (handle, sql, NULL);
 
414
    sqlite3_free (sql);
 
415
    if (ret == SQLITE_OK)
 
416
      {
 
417
          fprintf (stderr, "Error ReloadVectorStyle #2: %s\n\n",
 
418
                   "expected failure");
 
419
          return -34;
 
420
      }
 
421
 
 
422
    sql =
 
423
        sqlite3_mprintf
 
424
        ("SELECT SE_ReloadVectorStyle('Railway Stations', x%Q)", hexBlob);
 
425
    ret = execute_check (handle, sql, NULL);
 
426
    sqlite3_free (sql);
 
427
    if (ret == SQLITE_OK)
 
428
      {
 
429
          fprintf (stderr, "Error ReloadVectorStyle #4: %s\n\n",
 
430
                   "expected failure");
 
431
          return -36;
 
432
      }
 
433
 
 
434
    sql =
 
435
        sqlite3_mprintf
 
436
        ("SELECT SE_ReloadVectorStyle('Railway Stations', x%Q)", hexBlob);
 
437
    ret = execute_check (handle, sql, NULL);
 
438
    sqlite3_free (sql);
 
439
    if (ret == SQLITE_OK)
 
440
      {
 
441
          fprintf (stderr, "Error ReloadVectorStyle #5: %s\n\n",
 
442
                   "expected failure");
 
443
          return -37;
 
444
      }
 
445
    free (hexBlob);
 
446
 
 
447
    xml = load_xml ("stazioni_se.xml", &len);
 
448
    if (xml == NULL)
 
449
        return -35;
 
450
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
451
    free (xml);
 
452
    if (blob == NULL)
 
453
      {
 
454
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
455
          return -39;
 
456
      }
 
457
    hexBlob = build_hex_blob (blob, blob_len);
 
458
    free (blob);
 
459
    if (hexBlob == NULL)
 
460
        return -40;
 
461
    sql = sqlite3_mprintf ("SELECT SE_ReloadVectorStyle(1, x%Q)", hexBlob);
 
462
    ret = execute_check (handle, sql, &err_msg);
 
463
    sqlite3_free (sql);
 
464
    if (ret != SQLITE_OK)
 
465
      {
 
466
          fprintf (stderr, "Error ReloadVectorStyle #7: %s\n\n", err_msg);
 
467
          sqlite3_free (err_msg);
 
468
          return -41;
 
469
      }
 
470
 
 
471
    sql =
 
472
        sqlite3_mprintf
 
473
        ("SELECT SE_ReloadVectorStyle('Railway Stations 2', x%Q)", hexBlob);
 
474
    ret = execute_check (handle, sql, NULL);
 
475
    sqlite3_free (sql);
 
476
    if (ret == SQLITE_OK)
 
477
      {
 
478
          fprintf (stderr, "Error ReloadVectorStyle #8: %s\n\n",
 
479
                   "expected failure");
 
480
          return -42;
 
481
      }
 
482
    free (hexBlob);
 
483
 
 
484
/* Unregister Vector Style */
 
485
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorStyle(5)");
 
486
    ret = execute_check (handle, sql, NULL);
 
487
    sqlite3_free (sql);
 
488
    if (ret == SQLITE_OK)
 
489
      {
 
490
          fprintf (stderr, "Error UnRegisterVectorStyle #1: %s\n\n",
 
491
                   "expected failure");
 
492
          return -43;
 
493
      }
 
494
 
 
495
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorStyle('alpha')");
 
496
    ret = execute_check (handle, sql, NULL);
 
497
    sqlite3_free (sql);
 
498
    if (ret == SQLITE_OK)
 
499
      {
 
500
          fprintf (stderr, "Error UnRegisterVectorStyle #2: %s\n\n",
 
501
                   "expected failure");
 
502
          return -44;
 
503
      }
 
504
 
 
505
    sql =
 
506
        sqlite3_mprintf
 
507
        ("SELECT SE_UnRegisterVectorStyle('Railway Stations 2')");
 
508
    ret = execute_check (handle, sql, NULL);
 
509
    sqlite3_free (sql);
 
510
    if (ret == SQLITE_OK)
 
511
      {
 
512
          fprintf (stderr, "Error UnRegisterVectorStyle #3: %s\n\n",
 
513
                   "expected failure");
 
514
          return -45;
 
515
      }
 
516
 
 
517
    sql =
 
518
        sqlite3_mprintf
 
519
        ("SELECT SE_UnRegisterVectorStyle('Railway Stations 2', 1)");
 
520
    ret = execute_check (handle, sql, &err_msg);
 
521
    sqlite3_free (sql);
 
522
    if (ret != SQLITE_OK)
 
523
      {
 
524
          fprintf (stderr, "Error UnRegisterVectorStyle #5: %s\n\n", err_msg);
 
525
          sqlite3_free (err_msg);
 
526
          return -47;
 
527
      }
 
528
 
 
529
/* Register Vector Styled Layer: again */
 
530
    xml = load_xml ("stazioni2_se.xml", &len);
 
531
    if (xml == NULL)
 
532
        return -48;
 
533
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
534
    free (xml);
 
535
    if (blob == NULL)
 
536
      {
 
537
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
538
          return -49;
 
539
      }
 
540
    hexBlob = build_hex_blob (blob, blob_len);
 
541
    free (blob);
 
542
    if (hexBlob == NULL)
 
543
        return -50;
 
544
 
 
545
    sql = sqlite3_mprintf ("SELECT SE_RegisterVectorStyle(x%Q)", hexBlob);
 
546
    ret = execute_check (handle, sql, &err_msg);
 
547
    sqlite3_free (sql);
 
548
    if (ret != SQLITE_OK)
 
549
      {
 
550
          fprintf (stderr, "Error RegisterVectorStyle #3: %s\n\n", err_msg);
 
551
          sqlite3_free (err_msg);
 
552
          return -51;
 
553
      }
 
554
    free (hexBlob);
 
555
 
 
556
    sql =
 
557
        sqlite3_mprintf
 
558
        ("SELECT SE_RegisterVectorStyledLayer('table1', 'Railway Stations 2')");
 
559
    ret = execute_check (handle, sql, &err_msg);
 
560
    sqlite3_free (sql);
 
561
    if (ret != SQLITE_OK)
 
562
      {
 
563
          fprintf (stderr, "Error RegisterVectorStyledLayer #5: %s\n\n",
 
564
                   err_msg);
 
565
          sqlite3_free (err_msg);
 
566
          return -53;
 
567
      }
 
568
 
 
569
/* Unregister Vector Style Layer */
 
570
    sql =
 
571
        sqlite3_mprintf
 
572
        ("SELECT SE_UnRegisterVectorStyledLayer('table1', 'Railway Stations 2')");
 
573
    ret = execute_check (handle, sql, &err_msg);
 
574
    sqlite3_free (sql);
 
575
    if (ret != SQLITE_OK)
 
576
      {
 
577
          fprintf (stderr, "Error UnregisterVectorStyledLayer #1: %s\n\n",
 
578
                   err_msg);
 
579
          sqlite3_free (err_msg);
 
580
          return -54;
 
581
      }
 
582
 
 
583
    sql =
 
584
        sqlite3_mprintf ("SELECT SE_UnRegisterVectorStyledLayer('table1', 1)");
 
585
    ret = execute_check (handle, sql, &err_msg);
 
586
    sqlite3_free (sql);
 
587
    if (ret != SQLITE_OK)
 
588
      {
 
589
          fprintf (stderr, "Error UnregisterVectorStyledLayer #2: %s\n\n",
 
590
                   err_msg);
 
591
          sqlite3_free (err_msg);
 
592
          return -55;
 
593
      }
 
594
 
 
595
/* unregister External Graphic */
 
596
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterExternalGraphic('url-A')");
 
597
    ret = execute_check (handle, sql, &err_msg);
 
598
    sqlite3_free (sql);
 
599
    if (ret != SQLITE_OK)
 
600
      {
 
601
          fprintf (stderr, "Error UnRegisterExternalGraphic #1: %s\n\n",
 
602
                   err_msg);
 
603
          sqlite3_free (err_msg);
 
604
          return -56;
 
605
      }
 
606
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterExternalGraphic('jeroboam')");
 
607
    ret = execute_check (handle, sql, NULL);
 
608
    sqlite3_free (sql);
 
609
    if (ret == SQLITE_OK)
 
610
      {
 
611
          fprintf (stderr, "Error UnRegisterExternalGraphic #2: %s\n\n",
 
612
                   "expected failure");
 
613
          return -57;
 
614
      }
 
615
 
 
616
    return 0;
 
617
}
 
618
 
 
619
static int
 
620
check_raster (sqlite3 * handle, void *cache)
 
621
{
 
622
/* testing Raster Styles */
 
623
    int ret;
 
624
    char *err_msg = NULL;
 
625
    char *sql;
 
626
    unsigned char *blob;
 
627
    int blob_len;
 
628
    char *hexBlob;
 
629
    unsigned char *xml;
 
630
    int len;
 
631
 
 
632
/* testing Raster Styles */
 
633
    xml = load_xml ("raster_se.xml", &len);
 
634
    if (xml == NULL)
 
635
        return -4;
 
636
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
637
    free (xml);
 
638
    if (blob == NULL)
 
639
      {
 
640
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
641
          return -5;
 
642
      }
 
643
    hexBlob = build_hex_blob (blob, blob_len);
 
644
    free (blob);
 
645
    if (hexBlob == NULL)
 
646
        return -6;
 
647
 
 
648
/* Register Raster Styled Layer */
 
649
    sql = sqlite3_mprintf ("SELECT SE_RegisterRasterStyle(x%Q)", hexBlob);
 
650
    ret = execute_check (handle, sql, &err_msg);
 
651
    sqlite3_free (sql);
 
652
    if (ret != SQLITE_OK)
 
653
      {
 
654
          fprintf (stderr, "Error RegisterRasterStyle #1: %s\n\n", err_msg);
 
655
          sqlite3_free (err_msg);
 
656
          return -7;
 
657
      }
 
658
 
 
659
    sql =
 
660
        sqlite3_mprintf
 
661
        ("SELECT SE_RegisterRasterStyledLayer('coverage_srtm1', 1)");
 
662
    ret = execute_check (handle, sql, &err_msg);
 
663
    sqlite3_free (sql);
 
664
    if (ret != SQLITE_OK)
 
665
      {
 
666
          fprintf (stderr, "Error RegisterRasterStyledLayer #1: %s\n\n",
 
667
                   err_msg);
 
668
          sqlite3_free (err_msg);
 
669
          return -8;
 
670
      }
 
671
 
 
672
    sql =
 
673
        sqlite3_mprintf
 
674
        ("SELECT SE_RegisterRasterStyledLayer('coverage_srtm2', 'srtm_style')");
 
675
    ret = execute_check (handle, sql, &err_msg);
 
676
    sqlite3_free (sql);
 
677
    if (ret != SQLITE_OK)
 
678
      {
 
679
          fprintf (stderr, "Error RegisterRasterStyledLayer #2: %s\n\n",
 
680
                   err_msg);
 
681
          sqlite3_free (err_msg);
 
682
          return -9;
 
683
      }
 
684
    free (hexBlob);
 
685
 
 
686
    xml = load_xml ("raster2_se.xml", &len);
 
687
    if (xml == NULL)
210
688
        return -10;
211
 
    }
212
 
    sqlite3_free_table(results);
213
 
 
214
 
    sql = sqlite3_mprintf("SELECT RegisterExternalGraphic('url-A', x%Q, 'title', 'abstract', 'file_name')", hexBlob);
215
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
216
 
    free(hexBlob);
217
 
    sqlite3_free(sql);
218
 
    if (ret != SQLITE_OK) {
219
 
      fprintf (stderr, "Error RegisterExternalGraphic #2: %s\n", err_msg);
220
 
      sqlite3_free (err_msg);
221
 
      return -11;
222
 
    }
223
 
    if ((rows != 1) || (columns != 1))
224
 
    {
225
 
        sqlite3_free_table(results);
226
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
 
689
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
690
    free (xml);
 
691
    if (blob == NULL)
 
692
      {
 
693
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
694
          return -11;
 
695
      }
 
696
    hexBlob = build_hex_blob (blob, blob_len);
 
697
    free (blob);
 
698
    if (hexBlob == NULL)
227
699
        return -12;
228
 
    }
229
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
230
 
    {
231
 
        fprintf (stderr, "Unexpected #2 result (got %s, expected 1)", results[1 * columns + 0]);
232
 
        sqlite3_free_table(results);
233
 
        return -13;
234
 
    }
235
 
    sqlite3_free_table(results);
236
 
 
237
 
    xml = load_xml("thunderstorm_mild.svg", &len);
238
 
    if (xml == NULL) 
239
 
        return -14;
240
 
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL); 
241
 
    free(xml);
242
 
    if (blob == NULL) {
243
 
        fprintf (stderr, "this is not a well-formed XML !!!\n");
244
 
        return -15;
245
 
    }
246
 
    hexBlob = build_hex_blob(blob, blob_len);
247
 
    free(blob);
248
 
    if (hexBlob == NULL)
249
 
        return -16;
250
 
    sql = sqlite3_mprintf("SELECT RegisterExternalGraphic('url-B', x%Q, 'title', 'abstract', 'file_name')", hexBlob);
251
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
252
 
    sqlite3_free(sql);
253
 
    if (ret != SQLITE_OK) {
254
 
      fprintf (stderr, "Error RegisterExternalGraphic #3: %s\n", err_msg);
255
 
      sqlite3_free (err_msg);
256
 
      return -17;
257
 
    }
258
 
    if ((rows != 1) || (columns != 1))
259
 
    {
260
 
        sqlite3_free_table(results);
261
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
262
 
        return -18;
263
 
    }
264
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
265
 
    {
266
 
        fprintf (stderr, "Unexpected #3 result (got %s, expected 1)", results[1 * columns + 0]);
267
 
        sqlite3_free_table(results);
268
 
        return -19;
269
 
    }
270
 
    sqlite3_free_table(results);
271
 
 
272
 
    sql = sqlite3_mprintf("SELECT RegisterExternalGraphic('url-B', x%Q)", hexBlob);
273
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
274
 
    free(hexBlob);
275
 
    sqlite3_free(sql);
276
 
    if (ret != SQLITE_OK) {
277
 
      fprintf (stderr, "Error RegisterExternalGraphic #4: %s\n", err_msg);
278
 
      sqlite3_free (err_msg);
279
 
      return -20;
280
 
    }
281
 
    if ((rows != 1) || (columns != 1))
282
 
    {
283
 
        sqlite3_free_table(results);
284
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
285
 
        return -21;
286
 
    }
287
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
288
 
    {
289
 
        fprintf (stderr, "Unexpected #4 result (got %s, expected 1)", results[1 * columns + 0]);
290
 
        sqlite3_free_table(results);
 
700
 
 
701
    sql = sqlite3_mprintf ("SELECT SE_RegisterRasterStyle(x%Q)", hexBlob);
 
702
    ret = execute_check (handle, sql, &err_msg);
 
703
    sqlite3_free (sql);
 
704
    if (ret != SQLITE_OK)
 
705
      {
 
706
          fprintf (stderr, "Error RegisterRasterStyle #2: %s\n\n", err_msg);
 
707
          sqlite3_free (err_msg);
 
708
          return -13;
 
709
      }
 
710
 
 
711
    sql =
 
712
        sqlite3_mprintf
 
713
        ("SELECT SE_RegisterRasterStyledLayer('srtm2_style', 2)");
 
714
    ret = execute_check (handle, sql, &err_msg);
 
715
    sqlite3_free (sql);
 
716
    if (ret != SQLITE_OK)
 
717
      {
 
718
          fprintf (stderr, "Error RegisterRasterStyledLayer #3: %s\n\n",
 
719
                   err_msg);
 
720
          sqlite3_free (err_msg);
 
721
          return -14;
 
722
      }
 
723
 
 
724
    sql = sqlite3_mprintf ("SELECT SE_RegisterRasterStyle(x%Q)", hexBlob);
 
725
    ret = execute_check (handle, sql, NULL);
 
726
    sqlite3_free (sql);
 
727
    if (ret == SQLITE_OK)
 
728
      {
 
729
          fprintf (stderr, "Error RegisterRasterStyle #3: %s\n\n",
 
730
                   "expected failure");
 
731
          return -15;
 
732
      }
 
733
 
 
734
/* Reload Raster Style */
 
735
    sql = sqlite3_mprintf ("SELECT SE_ReloadRasterStyle(12, x%Q)", hexBlob);
 
736
    ret = execute_check (handle, sql, NULL);
 
737
    sqlite3_free (sql);
 
738
    if (ret == SQLITE_OK)
 
739
      {
 
740
          fprintf (stderr, "Error ReloadRasterStyle #1: %s\n\n",
 
741
                   "expected failure");
 
742
          return -17;
 
743
      }
 
744
 
 
745
    sql = sqlite3_mprintf ("SELECT SE_ReloadRasterStyle(1, x%Q)", hexBlob);
 
746
    ret = execute_check (handle, sql, NULL);
 
747
    sqlite3_free (sql);
 
748
    if (ret == SQLITE_OK)
 
749
      {
 
750
          fprintf (stderr, "Error ReloadRasterStyle #2: %s\n\n",
 
751
                   "expected failure");
 
752
          return -18;
 
753
      }
 
754
 
 
755
    sql =
 
756
        sqlite3_mprintf ("SELECT SE_ReloadRasterStyle('srtm_style', x%Q)",
 
757
                         hexBlob);
 
758
    ret = execute_check (handle, sql, NULL);
 
759
    sqlite3_free (sql);
 
760
    if (ret == SQLITE_OK)
 
761
      {
 
762
          fprintf (stderr, "Error ReloadRasterStyle #4: %s\n\n",
 
763
                   "expected failure");
 
764
          return -20;
 
765
      }
 
766
    free (hexBlob);
 
767
 
 
768
    xml = load_xml ("raster_se.xml", &len);
 
769
    if (xml == NULL)
291
770
        return -22;
292
 
    }
293
 
    sqlite3_free_table(results);
294
 
 
295
 
    ret = sqlite3_exec (handle, "CREATE TABLE table1 (id INTEGER PRIMARY KEY AUTOINCREMENT)", NULL, NULL, &err_msg);
296
 
    if (ret != SQLITE_OK) {
297
 
      fprintf (stderr, "Error Create Table table1: %s\n", err_msg);
298
 
      sqlite3_free (err_msg);
299
 
      return -23;
300
 
    }
301
 
    ret = sqlite3_get_table (handle, "SELECT AddGeometryColumn('table1', 'geom', 4326, 'POINT', 'XY')", &results, &rows, &columns, &err_msg);
302
 
    if (ret != SQLITE_OK) {
303
 
      fprintf (stderr, "Error AddGeometryColumn: %s\n", err_msg);
304
 
      sqlite3_free (err_msg);
305
 
      return -24;
306
 
    }
307
 
    if ((rows != 1) || (columns != 1))
308
 
    {
309
 
        sqlite3_free_table(results);
310
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
311
 
        return -25;
312
 
    }
313
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
314
 
    {
315
 
        fprintf (stderr, "Unexpected #5 result (got %s, expected 1)", results[1 * columns + 0]);
316
 
        sqlite3_free_table(results);
317
 
        return -26;
318
 
    }
319
 
    sqlite3_free_table(results);
320
 
 
321
 
    xml = load_xml("stazioni_se.xml", &len);
322
 
    if (xml == NULL) 
323
 
        return -27;
324
 
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL); 
325
 
    free(xml);
326
 
    if (blob == NULL) {
327
 
        fprintf (stderr, "this is not a well-formed XML !!!\n");
328
 
        return -28;
329
 
    }
330
 
    hexBlob = build_hex_blob(blob, blob_len);
331
 
    free(blob);
 
771
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
772
    free (xml);
 
773
    if (blob == NULL)
 
774
      {
 
775
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
776
          return -23;
 
777
      }
 
778
    hexBlob = build_hex_blob (blob, blob_len);
 
779
    free (blob);
332
780
    if (hexBlob == NULL)
333
 
        return -29;
334
 
    sql = sqlite3_mprintf("SELECT RegisterVectorStyledLayer('table1', 'geom', x%Q)", hexBlob);
335
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
336
 
    sqlite3_free(sql);
337
 
    if (ret != SQLITE_OK) {
338
 
      fprintf (stderr, "Error RegisterVectorStyledLayer #6: %s\n", err_msg);
339
 
      sqlite3_free (err_msg);
340
 
      return -30;
341
 
    }
342
 
    if ((rows != 1) || (columns != 1))
343
 
    {
344
 
        sqlite3_free_table(results);
345
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
346
 
        return -31;
347
 
    }
348
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
349
 
    {
350
 
        fprintf (stderr, "Unexpected #6 result (got %s, expected 1)", results[1 * columns + 0]);
351
 
        sqlite3_free_table(results);
 
781
        return -24;
 
782
    sql = sqlite3_mprintf ("SELECT SE_ReloadRasterStyle(1, x%Q)", hexBlob);
 
783
    ret = execute_check (handle, sql, &err_msg);
 
784
    sqlite3_free (sql);
 
785
    if (ret != SQLITE_OK)
 
786
      {
 
787
          fprintf (stderr, "Error ReloadRasterStyle #6: %s\n\n", err_msg);
 
788
          sqlite3_free (err_msg);
 
789
          return -25;
 
790
      }
 
791
 
 
792
    sql =
 
793
        sqlite3_mprintf
 
794
        ("SELECT SE_ReloadRasterrStyle('Railway Stations 2', x%Q)", hexBlob);
 
795
    ret = execute_check (handle, sql, NULL);
 
796
    sqlite3_free (sql);
 
797
    if (ret == SQLITE_OK)
 
798
      {
 
799
          fprintf (stderr, "Error ReloadVRasterStyle #4: %s\n\n",
 
800
                   "expected failure");
 
801
          return -26;
 
802
      }
 
803
    free (hexBlob);
 
804
 
 
805
/* Unregister Raster Style */
 
806
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterRasterStyle(5)");
 
807
    ret = execute_check (handle, sql, NULL);
 
808
    sqlite3_free (sql);
 
809
    if (ret == SQLITE_OK)
 
810
      {
 
811
          fprintf (stderr, "Error UnRegisterRasterStyle #1: %s\n\n",
 
812
                   "expected failure");
 
813
          return -27;
 
814
      }
 
815
 
 
816
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterRasterStyle('alpha')");
 
817
    ret = execute_check (handle, sql, &err_msg);
 
818
    sqlite3_free (sql);
 
819
    if (ret == SQLITE_OK)
 
820
      {
 
821
          fprintf (stderr, "Error UnRegisterRasterStyle #2: %s\n\n",
 
822
                   "expected failure");
 
823
          return -28;
 
824
      }
 
825
 
 
826
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterRasterStyle('srtm2_style')");
 
827
    ret = execute_check (handle, sql, NULL);
 
828
    sqlite3_free (sql);
 
829
    if (ret == SQLITE_OK)
 
830
      {
 
831
          fprintf (stderr, "Error UnRegisterRasterStyle #3: %s\n\n",
 
832
                   "expected failure");
 
833
          return -29;
 
834
      }
 
835
 
 
836
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterRasterStyle('srtm2_style', 1)");
 
837
    ret = execute_check (handle, sql, &err_msg);
 
838
    sqlite3_free (sql);
 
839
    if (ret != SQLITE_OK)
 
840
      {
 
841
          fprintf (stderr, "Error UnRegisterRasterStyle #4: %s\n\n", err_msg);
 
842
          sqlite3_free (err_msg);
 
843
          return -31;
 
844
      }
 
845
 
 
846
/* Register Raster Styled Layer: again */
 
847
    xml = load_xml ("raster2_se.xml", &len);
 
848
    if (xml == NULL)
352
849
        return -32;
353
 
    }
354
 
    sqlite3_free_table(results);
355
 
    
356
 
    sql = sqlite3_mprintf("SELECT RegisterVectorStyledLayer('table1', 'geom', 0, x%Q)", hexBlob);
357
 
    free(hexBlob);
358
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
359
 
    sqlite3_free(sql);
360
 
    if (ret != SQLITE_OK) {
361
 
      fprintf (stderr, "Error RegisterVectorStyledLayer #7: %s\n", err_msg);
362
 
      sqlite3_free (err_msg);
363
 
      return -33;
364
 
    }
365
 
    if ((rows != 1) || (columns != 1))
366
 
    {
367
 
        sqlite3_free_table(results);
368
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
 
850
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
851
    free (xml);
 
852
    if (blob == NULL)
 
853
      {
 
854
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
855
          return -33;
 
856
      }
 
857
    hexBlob = build_hex_blob (blob, blob_len);
 
858
    free (blob);
 
859
    if (hexBlob == NULL)
369
860
        return -34;
370
 
    }
371
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
372
 
    {
373
 
        fprintf (stderr, "Unexpected #7 result (got %s, expected 1)", results[1 * columns + 0]);
374
 
        sqlite3_free_table(results);
 
861
 
 
862
    sql = sqlite3_mprintf ("SELECT SE_RegisterRasterStyle(x%Q)", hexBlob);
 
863
    ret = execute_check (handle, sql, &err_msg);
 
864
    sqlite3_free (sql);
 
865
    if (ret != SQLITE_OK)
 
866
      {
 
867
          fprintf (stderr, "Error RegisterRasterStyle #5: %s\n\n", err_msg);
 
868
          sqlite3_free (err_msg);
 
869
          return -35;
 
870
      }
 
871
    free (hexBlob);
 
872
 
 
873
    sql =
 
874
        sqlite3_mprintf
 
875
        ("SELECT SE_RegisterRasterStyledLayer('coverage_srtm1', 'srtm2_style')");
 
876
    ret = execute_check (handle, sql, &err_msg);
 
877
    sqlite3_free (sql);
 
878
    if (ret != SQLITE_OK)
 
879
      {
 
880
          fprintf (stderr, "Error RegisterRasterStyledLayer #5: %s\n\n",
 
881
                   err_msg);
 
882
          sqlite3_free (err_msg);
 
883
          return -37;
 
884
      }
 
885
 
 
886
/* Unregister Raster Style Layer */
 
887
    sql =
 
888
        sqlite3_mprintf
 
889
        ("SELECT SE_UnRegisterRasterStyledLayer('coverage_srtm1', 'srtm2_style')");
 
890
    ret = execute_check (handle, sql, &err_msg);
 
891
    sqlite3_free (sql);
 
892
    if (ret != SQLITE_OK)
 
893
      {
 
894
          fprintf (stderr, "Error UnregisterRasterStyledLayer #1: %s\n\n",
 
895
                   err_msg);
 
896
          sqlite3_free (err_msg);
 
897
          return -39;
 
898
      }
 
899
 
 
900
    sql =
 
901
        sqlite3_mprintf
 
902
        ("SELECT SE_UnRegisterRasterStyledLayer('coverage_srtm1', 1)");
 
903
    ret = execute_check (handle, sql, &err_msg);
 
904
    sqlite3_free (sql);
 
905
    if (ret != SQLITE_OK)
 
906
      {
 
907
          fprintf (stderr, "Error UnregisterRasterStyledLayer #2: %s\n\n",
 
908
                   err_msg);
 
909
          sqlite3_free (err_msg);
 
910
          return -40;
 
911
      }
 
912
 
 
913
    return 0;
 
914
}
 
915
 
 
916
static int
 
917
check_group (sqlite3 * handle, void *cache)
 
918
{
 
919
/* testing Group Styles */
 
920
    int ret;
 
921
    char *err_msg = NULL;
 
922
    char *sql;
 
923
    unsigned char *blob;
 
924
    int blob_len;
 
925
    char *hexBlob;
 
926
    unsigned char *xml;
 
927
    int len;
 
928
 
 
929
/* testing Groups */
 
930
    sql =
 
931
        sqlite3_mprintf
 
932
        ("SELECT SE_RegisterStyledGroupRaster('group1', 'coverage_srtm1')");
 
933
    ret = execute_check (handle, sql, &err_msg);
 
934
    sqlite3_free (sql);
 
935
    if (ret != SQLITE_OK)
 
936
      {
 
937
          fprintf (stderr, "Error RegisterStyledGroupRaster #1: %s\n\n",
 
938
                   err_msg);
 
939
          sqlite3_free (err_msg);
 
940
          return -4;
 
941
      }
 
942
 
 
943
    sql =
 
944
        sqlite3_mprintf
 
945
        ("SELECT SE_SetStyledGroupInfos('group1', 'title', 'abstract')");
 
946
    ret = execute_check (handle, sql, &err_msg);
 
947
    sqlite3_free (sql);
 
948
    if (ret != SQLITE_OK)
 
949
      {
 
950
          fprintf (stderr, "Error SetStyledGroupInfos #1: %s\n\n", err_msg);
 
951
          sqlite3_free (err_msg);
 
952
          return -5;
 
953
      }
 
954
 
 
955
    sql =
 
956
        sqlite3_mprintf
 
957
        ("SELECT SE_RegisterStyledGroupVector('group1', 'table1')");
 
958
    ret = execute_check (handle, sql, &err_msg);
 
959
    sqlite3_free (sql);
 
960
    if (ret != SQLITE_OK)
 
961
      {
 
962
          fprintf (stderr, "Error RegisterStyledGroupVector #1: %s\n\n",
 
963
                   err_msg);
 
964
          sqlite3_free (err_msg);
 
965
          return -6;
 
966
      }
 
967
 
 
968
    sql =
 
969
        sqlite3_mprintf
 
970
        ("SELECT SE_RegisterStyledGroupVector('group1', 'table2')");
 
971
    ret = execute_check (handle, sql, &err_msg);
 
972
    sqlite3_free (sql);
 
973
    if (ret != SQLITE_OK)
 
974
      {
 
975
          fprintf (stderr, "Error RegisterStyledGroupVector #2: %s\n\n",
 
976
                   err_msg);
 
977
          sqlite3_free (err_msg);
 
978
          return -7;
 
979
      }
 
980
 
 
981
    sql =
 
982
        sqlite3_mprintf
 
983
        ("SELECT SE_SetStyledGroupInfos('group1', 'changed title', 'changed abstract')");
 
984
    ret = execute_check (handle, sql, &err_msg);
 
985
    sqlite3_free (sql);
 
986
    if (ret != SQLITE_OK)
 
987
      {
 
988
          fprintf (stderr, "Error SetStyledGroupInfos #2: %s\n\n", err_msg);
 
989
          sqlite3_free (err_msg);
 
990
          return -8;
 
991
      }
 
992
 
 
993
    sql =
 
994
        sqlite3_mprintf
 
995
        ("SELECT SE_SetStyledGroupInfos('group2', 'title2', 'abstract2')");
 
996
    ret = execute_check (handle, sql, &err_msg);
 
997
    sqlite3_free (sql);
 
998
    if (ret != SQLITE_OK)
 
999
      {
 
1000
          fprintf (stderr, "Error SetStyledGroupInfos #3: %s\n\n", err_msg);
 
1001
          sqlite3_free (err_msg);
 
1002
          return -9;
 
1003
      }
 
1004
 
 
1005
    sql =
 
1006
        sqlite3_mprintf
 
1007
        ("SELECT SE_RegisterStyledGroupRaster('group2', 'coverage_srtm2')");
 
1008
    ret = execute_check (handle, sql, &err_msg);
 
1009
    sqlite3_free (sql);
 
1010
    if (ret != SQLITE_OK)
 
1011
      {
 
1012
          fprintf (stderr, "Error RegisterStyledGroupRaster #2: %s\n\n",
 
1013
                   err_msg);
 
1014
          sqlite3_free (err_msg);
 
1015
          return -10;
 
1016
      }
 
1017
 
 
1018
    sql =
 
1019
        sqlite3_mprintf
 
1020
        ("SELECT SE_RegisterStyledGroupVector('group2', 'table1')");
 
1021
    ret = execute_check (handle, sql, &err_msg);
 
1022
    sqlite3_free (sql);
 
1023
    if (ret != SQLITE_OK)
 
1024
      {
 
1025
          fprintf (stderr, "Error RegisterStyledGroupVector #3: %s\n\n",
 
1026
                   err_msg);
 
1027
          sqlite3_free (err_msg);
 
1028
          return -11;
 
1029
      }
 
1030
 
 
1031
    sql =
 
1032
        sqlite3_mprintf
 
1033
        ("SELECT SE_UnregisterStyledGroupVector('group2', 'table1')");
 
1034
    ret = execute_check (handle, sql, &err_msg);
 
1035
    sqlite3_free (sql);
 
1036
    if (ret != SQLITE_OK)
 
1037
      {
 
1038
          fprintf (stderr, "Error UnregisterStyledGroupVector #1: %s\n\n",
 
1039
                   err_msg);
 
1040
          sqlite3_free (err_msg);
 
1041
          return -12;
 
1042
      }
 
1043
 
 
1044
    sql =
 
1045
        sqlite3_mprintf
 
1046
        ("SELECT SE_RegisterStyledGroupVector('group2', 'table2')");
 
1047
    ret = execute_check (handle, sql, &err_msg);
 
1048
    sqlite3_free (sql);
 
1049
    if (ret != SQLITE_OK)
 
1050
      {
 
1051
          fprintf (stderr, "Error RegisterStyledGroupVector #4: %s\n\n",
 
1052
                   err_msg);
 
1053
          sqlite3_free (err_msg);
 
1054
          return -13;
 
1055
      }
 
1056
 
 
1057
    sql =
 
1058
        sqlite3_mprintf
 
1059
        ("SELECT SE_RegisterStyledGroupVector('group2', 'table1')");
 
1060
    ret = execute_check (handle, sql, &err_msg);
 
1061
    sqlite3_free (sql);
 
1062
    if (ret != SQLITE_OK)
 
1063
      {
 
1064
          fprintf (stderr, "Error RegisterStyledGroupVector #5: %s\n\n",
 
1065
                   err_msg);
 
1066
          sqlite3_free (err_msg);
 
1067
          return -14;
 
1068
      }
 
1069
 
 
1070
    sql =
 
1071
        sqlite3_mprintf
 
1072
        ("SELECT SE_UnregisterStyledGroupRaster('group2', 'coverage_srtm2')");
 
1073
    ret = execute_check (handle, sql, &err_msg);
 
1074
    sqlite3_free (sql);
 
1075
    if (ret != SQLITE_OK)
 
1076
      {
 
1077
          fprintf (stderr, "Error UnregisterStyledGroupRaster #2: %s\n\n",
 
1078
                   err_msg);
 
1079
          sqlite3_free (err_msg);
 
1080
          return -15;
 
1081
      }
 
1082
 
 
1083
    sql =
 
1084
        sqlite3_mprintf
 
1085
        ("SELECT SE_RegisterStyledGroupRaster('group2', 'coverage_srtm1')");
 
1086
    ret = execute_check (handle, sql, &err_msg);
 
1087
    sqlite3_free (sql);
 
1088
    if (ret != SQLITE_OK)
 
1089
      {
 
1090
          fprintf (stderr, "Error RegisterStyledGroupRaster #3: %s\n\n",
 
1091
                   err_msg);
 
1092
          sqlite3_free (err_msg);
 
1093
          return -16;
 
1094
      }
 
1095
 
 
1096
    sql =
 
1097
        sqlite3_mprintf
 
1098
        ("SELECT SE_RegisterStyledGroupRaster('group2', 'coverage_srtm2')");
 
1099
    ret = execute_check (handle, sql, &err_msg);
 
1100
    sqlite3_free (sql);
 
1101
    if (ret != SQLITE_OK)
 
1102
      {
 
1103
          fprintf (stderr, "Error RegisterStyledGroupRaster #4: %s\n\n",
 
1104
                   err_msg);
 
1105
          sqlite3_free (err_msg);
 
1106
          return -17;
 
1107
      }
 
1108
 
 
1109
    sql = sqlite3_mprintf ("SELECT SE_UnregisterStyledGroupLayer(8)");
 
1110
    ret = execute_check (handle, sql, &err_msg);
 
1111
    sqlite3_free (sql);
 
1112
    if (ret != SQLITE_OK)
 
1113
      {
 
1114
          fprintf (stderr, "Error UnregisterStyledGroupLayer #3: %s\n\n",
 
1115
                   err_msg);
 
1116
          sqlite3_free (err_msg);
 
1117
          return -18;
 
1118
      }
 
1119
 
 
1120
    sql =
 
1121
        sqlite3_mprintf
 
1122
        ("SELECT SE_SetStyledGroupInfos('group3', 'title', 'abstract')");
 
1123
    ret = execute_check (handle, sql, &err_msg);
 
1124
    sqlite3_free (sql);
 
1125
    if (ret != SQLITE_OK)
 
1126
      {
 
1127
          fprintf (stderr, "Error SetStyledGroupInfos #4: %s\n\n", err_msg);
 
1128
          sqlite3_free (err_msg);
 
1129
          return -19;
 
1130
      }
 
1131
 
 
1132
    sql =
 
1133
        sqlite3_mprintf
 
1134
        ("SELECT SE_RegisterStyledGroupRaster('group3', 'coverage_srtm1')");
 
1135
    ret = execute_check (handle, sql, &err_msg);
 
1136
    sqlite3_free (sql);
 
1137
    if (ret != SQLITE_OK)
 
1138
      {
 
1139
          fprintf (stderr, "Error RegisterStyledGroup #10: %s\n\n", err_msg);
 
1140
          sqlite3_free (err_msg);
 
1141
          return -20;
 
1142
      }
 
1143
 
 
1144
/* testing Paint Order */
 
1145
    sql = sqlite3_mprintf ("SELECT SE_SetStyledGroupLayerPaintOrder(7, 11)");
 
1146
    ret = execute_check (handle, sql, &err_msg);
 
1147
    sqlite3_free (sql);
 
1148
    if (ret != SQLITE_OK)
 
1149
      {
 
1150
          fprintf (stderr, "Error SetStyledGroupLayerPaintOrder #1: %s\n\n",
 
1151
                   err_msg);
 
1152
          sqlite3_free (err_msg);
 
1153
          return -21;
 
1154
      }
 
1155
 
 
1156
    sql =
 
1157
        sqlite3_mprintf
 
1158
        ("SELECT SE_SetStyledGroupVectorPaintOrder('group2', 'table2', 12)");
 
1159
    ret = execute_check (handle, sql, &err_msg);
 
1160
    sqlite3_free (sql);
 
1161
    if (ret != SQLITE_OK)
 
1162
      {
 
1163
          fprintf (stderr, "Error SetStyledGroupVectorPaintOrder #1: %s\n\n",
 
1164
                   err_msg);
 
1165
          sqlite3_free (err_msg);
 
1166
          return -22;
 
1167
      }
 
1168
 
 
1169
    sql =
 
1170
        sqlite3_mprintf
 
1171
        ("SELECT SE_SetStyledGroupRasterPaintOrder('group2', 'coverage_srtm2', 10)");
 
1172
    ret = execute_check (handle, sql, &err_msg);
 
1173
    sqlite3_free (sql);
 
1174
    if (ret != SQLITE_OK)
 
1175
      {
 
1176
          fprintf (stderr, "Error SetStyledGroupRasterPaintOrder #1: %s\n\n",
 
1177
                   err_msg);
 
1178
          sqlite3_free (err_msg);
 
1179
          return -23;
 
1180
      }
 
1181
 
 
1182
    sql = sqlite3_mprintf ("SELECT SE_SetStyledGroupLayerPaintOrder(3, -1)");
 
1183
    ret = execute_check (handle, sql, &err_msg);
 
1184
    sqlite3_free (sql);
 
1185
    if (ret != SQLITE_OK)
 
1186
      {
 
1187
          fprintf (stderr, "Error SetStyledGroupLayerPaintOrder #2: %s\n\n",
 
1188
                   err_msg);
 
1189
          sqlite3_free (err_msg);
 
1190
          return -24;
 
1191
      }
 
1192
 
 
1193
    sql =
 
1194
        sqlite3_mprintf
 
1195
        ("SELECT SE_SetStyledGroupVectorPaintOrder('group1', 'table1', -1)");
 
1196
    ret = execute_check (handle, sql, &err_msg);
 
1197
    sqlite3_free (sql);
 
1198
    if (ret != SQLITE_OK)
 
1199
      {
 
1200
          fprintf (stderr, "Error SetStyledGroupLayerPaintOrder #3: %s\n\n",
 
1201
                   err_msg);
 
1202
          sqlite3_free (err_msg);
 
1203
          return -25;
 
1204
      }
 
1205
 
 
1206
    sql =
 
1207
        sqlite3_mprintf
 
1208
        ("SELECT SE_SetStyledGroupRasterPaintOrder('group1', 'coverage_srtm1', -1)");
 
1209
    ret = execute_check (handle, sql, &err_msg);
 
1210
    sqlite3_free (sql);
 
1211
    if (ret != SQLITE_OK)
 
1212
      {
 
1213
          fprintf (stderr, "Error SetStyledGroupRasterPaintOrder #2: %s\n\n",
 
1214
                   err_msg);
 
1215
          sqlite3_free (err_msg);
 
1216
          return -26;
 
1217
      }
 
1218
 
 
1219
    sql = sqlite3_mprintf ("SELECT SE_UnregisterStyledGroup('group2')");
 
1220
    ret = execute_check (handle, sql, &err_msg);
 
1221
    sqlite3_free (sql);
 
1222
    if (ret != SQLITE_OK)
 
1223
      {
 
1224
          fprintf (stderr, "Error UnregisterStyledGroup #1: %s\n\n", err_msg);
 
1225
          sqlite3_free (err_msg);
 
1226
          return -27;
 
1227
      }
 
1228
 
 
1229
    xml = load_xml ("sld_sample.xml", &len);
 
1230
    if (xml == NULL)
 
1231
        return -29;
 
1232
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
1233
    free (xml);
 
1234
    if (blob == NULL)
 
1235
      {
 
1236
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
1237
          return -30;
 
1238
      }
 
1239
    hexBlob = build_hex_blob (blob, blob_len);
 
1240
    free (blob);
 
1241
    if (hexBlob == NULL)
 
1242
        return -31;
 
1243
 
 
1244
/* Register Styled Group Style */
 
1245
    sql = sqlite3_mprintf ("SELECT SE_RegisterGroupStyle(x%Q)", hexBlob);
 
1246
    ret = execute_check (handle, sql, &err_msg);
 
1247
    sqlite3_free (sql);
 
1248
    if (ret != SQLITE_OK)
 
1249
      {
 
1250
          fprintf (stderr, "Error RegisterGroupStyle #1: %s\n\n", err_msg);
 
1251
          sqlite3_free (err_msg);
 
1252
          return -32;
 
1253
      }
 
1254
    free (hexBlob);
 
1255
 
 
1256
    xml = load_xml ("sld_sample2.xml", &len);
 
1257
    if (xml == NULL)
 
1258
        return -33;
 
1259
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
1260
    free (xml);
 
1261
    if (blob == NULL)
 
1262
      {
 
1263
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
1264
          return -34;
 
1265
      }
 
1266
    hexBlob = build_hex_blob (blob, blob_len);
 
1267
    free (blob);
 
1268
    if (hexBlob == NULL)
375
1269
        return -35;
376
 
    }
377
 
    sqlite3_free_table(results);
378
 
 
379
 
    xml = load_xml("raster_se.xml", &len);
380
 
    if (xml == NULL) 
381
 
        return -36;
382
 
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL); 
383
 
    free(xml);
384
 
    if (blob == NULL) {
385
 
        fprintf (stderr, "this is not a well-formed XML !!!\n");
386
 
        return -37;
387
 
    }
388
 
    hexBlob = build_hex_blob(blob, blob_len);
389
 
    free(blob);
 
1270
 
 
1271
    sql = sqlite3_mprintf ("SELECT SE_RegisterGroupStyle(x%Q)", hexBlob);
 
1272
    ret = execute_check (handle, sql, &err_msg);
 
1273
    sqlite3_free (sql);
 
1274
    if (ret != SQLITE_OK)
 
1275
      {
 
1276
          fprintf (stderr, "Error RegisterGroupStyle #2: %s\n\n", err_msg);
 
1277
          sqlite3_free (err_msg);
 
1278
          return -36;
 
1279
      }
 
1280
 
 
1281
    sql = sqlite3_mprintf ("SELECT SE_ReloadGroupStyle(1, x%Q)", hexBlob);
 
1282
    ret = execute_check (handle, sql, NULL);
 
1283
    sqlite3_free (sql);
 
1284
    if (ret == SQLITE_OK)
 
1285
      {
 
1286
          fprintf (stderr, "Error ReloadGroupStyle #1: %s\n\n",
 
1287
                   "expected failure");
 
1288
          return -37;
 
1289
      }
 
1290
 
 
1291
    sql =
 
1292
        sqlite3_mprintf ("SELECT SE_ReloadGroupStyle('group style 1', x%Q)",
 
1293
                         hexBlob);
 
1294
    ret = execute_check (handle, sql, NULL);
 
1295
    sqlite3_free (sql);
 
1296
    if (ret == SQLITE_OK)
 
1297
      {
 
1298
          fprintf (stderr, "Error ReloadGroupStyle #2: %s\n\n",
 
1299
                   "expected failure");
 
1300
          return -38;
 
1301
      }
 
1302
 
 
1303
    sql =
 
1304
        sqlite3_mprintf ("SELECT SE_ReloadGroupStyle('group style 2', x%Q)",
 
1305
                         hexBlob);
 
1306
    ret = execute_check (handle, sql, &err_msg);
 
1307
    sqlite3_free (sql);
 
1308
    if (ret != SQLITE_OK)
 
1309
      {
 
1310
          fprintf (stderr, "Error ReloadGroupStyle #3: %s\n\n", err_msg);
 
1311
          sqlite3_free (err_msg);
 
1312
          return -39;
 
1313
      }
 
1314
    free (hexBlob);
 
1315
 
 
1316
    xml = load_xml ("sld_sample.xml", &len);
 
1317
    if (xml == NULL)
 
1318
        return -42;
 
1319
    gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
 
1320
    free (xml);
 
1321
    if (blob == NULL)
 
1322
      {
 
1323
          fprintf (stderr, "this is not a well-formed XML !!!\n");
 
1324
          return -43;
 
1325
      }
 
1326
    hexBlob = build_hex_blob (blob, blob_len);
 
1327
    free (blob);
390
1328
    if (hexBlob == NULL)
391
 
        return -38;
392
 
    sql = sqlite3_mprintf("SELECT RegisterRasterStyledLayer('srtm', x%Q)", hexBlob);
393
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
394
 
    sqlite3_free(sql);
395
 
    if (ret != SQLITE_OK) {
396
 
      fprintf (stderr, "Error RegisterRasterStyledLayer #8: %s\n", err_msg);
397
 
      sqlite3_free (err_msg);
398
 
      return -39;
399
 
    }
400
 
    if ((rows != 1) || (columns != 1))
401
 
    {
402
 
        sqlite3_free_table(results);
403
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
404
 
        return -40;
405
 
    }
406
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
407
 
    {
408
 
        fprintf (stderr, "Unexpected #8 result (got %s, expected 1)", results[1 * columns + 0]);
409
 
        sqlite3_free_table(results);
410
 
        return -41;
411
 
    }
412
 
    sqlite3_free_table(results);
413
 
    
414
 
    sql = sqlite3_mprintf("SELECT RegisterRasterStyledLayer('srtm', 0, x%Q)", hexBlob);
415
 
    free(hexBlob);
416
 
    ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
417
 
    sqlite3_free(sql);
418
 
    if (ret != SQLITE_OK) {
419
 
      fprintf (stderr, "Error RegisterRasterStyledLayer #9: %s\n", err_msg);
420
 
      sqlite3_free (err_msg);
421
 
      return -42;
422
 
    }
423
 
    if ((rows != 1) || (columns != 1))
424
 
    {
425
 
        sqlite3_free_table(results);
426
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
427
 
        return -43;
428
 
    }
429
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
430
 
    {
431
 
        fprintf (stderr, "Unexpected #9 result (got %s, expected 1)", results[1 * columns + 0]);
432
 
        sqlite3_free_table(results);
433
1329
        return -44;
434
 
    }
435
 
    sqlite3_free_table(results);
436
 
    
437
 
    ret = sqlite3_get_table (handle, "SELECT RegisterStyledGroup('group', 'srtm', 0)", &results, &rows, &columns, &err_msg);
438
 
    if (ret != SQLITE_OK) {
439
 
      fprintf (stderr, "Error RegisterStyledGroup #10: %s\n", err_msg);
440
 
      sqlite3_free (err_msg);
441
 
      return -45;
442
 
    }
443
 
    if ((rows != 1) || (columns != 1))
444
 
    {
445
 
        sqlite3_free_table(results);
446
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
447
 
        return -46;
448
 
    }
449
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
450
 
    {
451
 
        fprintf (stderr, "Unexpected #10 result (got %s, expected 1)", results[1 * columns + 0]);
452
 
        sqlite3_free_table(results);
453
 
        return -47;
454
 
    }
455
 
    sqlite3_free_table(results);
456
 
    
457
 
    ret = sqlite3_get_table (handle, "SELECT RegisterStyledGroup('group', 'table1', 'geom', 0)", &results, &rows, &columns, &err_msg);
458
 
    if (ret != SQLITE_OK) {
459
 
      fprintf (stderr, "Error RegisterStyledGroup #11: %s\n", err_msg);
460
 
      sqlite3_free (err_msg);
461
 
      return -48;
462
 
    }
463
 
    if ((rows != 1) || (columns != 1))
464
 
    {
465
 
        sqlite3_free_table(results);
466
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
467
 
        return -49;
468
 
    }
469
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
470
 
    {
471
 
        fprintf (stderr, "Unexpected #12 result (got %s, expected 1)", results[1 * columns + 0]);
472
 
        sqlite3_free_table(results);
473
 
        return -50;
474
 
    }
475
 
    sqlite3_free_table(results);
476
 
    
477
 
    ret = sqlite3_get_table (handle, "SELECT RegisterStyledGroup('group', 'srtm', 0, 4)", &results, &rows, &columns, &err_msg);
478
 
    if (ret != SQLITE_OK) {
479
 
      fprintf (stderr, "Error RegisterStyledGroup #13: %s\n", err_msg);
480
 
      sqlite3_free (err_msg);
481
 
      return -51;
482
 
    }
483
 
    if ((rows != 1) || (columns != 1))
484
 
    {
485
 
        sqlite3_free_table(results);
486
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
487
 
        return -52;
488
 
    }
489
 
    if (strcmp(results[1 * columns + 0], "0") != 0)
490
 
    {
491
 
        fprintf (stderr, "Unexpected #13 result (got %s, expected 1)", results[1 * columns + 0]);
492
 
        sqlite3_free_table(results);
493
 
        return -53;
494
 
    }
495
 
    sqlite3_free_table(results);
496
 
    
497
 
    ret = sqlite3_get_table (handle, "SELECT RegisterStyledGroup('group', 'table1', 'geom', 0, 1)", &results, &rows, &columns, &err_msg);
498
 
    if (ret != SQLITE_OK) {
499
 
      fprintf (stderr, "Error RegisterStyledGroup #14: %s\n", err_msg);
500
 
      sqlite3_free (err_msg);
501
 
      return -54;
502
 
    }
503
 
    if ((rows != 1) || (columns != 1))
504
 
    {
505
 
        sqlite3_free_table(results);
506
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
507
 
        return -55;
508
 
    }
509
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
510
 
    {
511
 
        fprintf (stderr, "Unexpected #14 result (got %s, expected 1)", results[1 * columns + 0]);
512
 
        sqlite3_free_table(results);
513
 
        return -56;
514
 
    }
515
 
    sqlite3_free_table(results);
516
 
    
517
 
    ret = sqlite3_get_table (handle, "SELECT SetStyledGroupInfos('group', 'title', 'abstract')", &results, &rows, &columns, &err_msg);
518
 
    if (ret != SQLITE_OK) {
519
 
      fprintf (stderr, "Error RegisterStyledGroup #15: %s\n", err_msg);
520
 
      sqlite3_free (err_msg);
521
 
      return -57;
522
 
    }
523
 
    if ((rows != 1) || (columns != 1))
524
 
    {
525
 
        sqlite3_free_table(results);
526
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
527
 
        return -58;
528
 
    }
529
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
530
 
    {
531
 
        fprintf (stderr, "Unexpected #15 result (got %s, expected 1)", results[1 * columns + 0]);
532
 
        sqlite3_free_table(results);
533
 
        return -59;
534
 
    }
535
 
    sqlite3_free_table(results);
536
 
    
537
 
    ret = sqlite3_get_table (handle, "SELECT SetStyledGroupInfos('group-bis', 'title', 'abstract')", &results, &rows, &columns, &err_msg);
538
 
    if (ret != SQLITE_OK) {
539
 
      fprintf (stderr, "Error RegisterStyledGroup #16: %s\n", err_msg);
540
 
      sqlite3_free (err_msg);
541
 
      return 60;
542
 
    }
543
 
    if ((rows != 1) || (columns != 1))
544
 
    {
545
 
        sqlite3_free_table(results);
546
 
        fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows, columns);
547
 
        return -61;
548
 
    }
549
 
    if (strcmp(results[1 * columns + 0], "1") != 0)
550
 
    {
551
 
        fprintf (stderr, "Unexpected #16 result (got %s, expected 1)", results[1 * columns + 0]);
552
 
        sqlite3_free_table(results);
553
 
        return -62;
554
 
    }
555
 
    sqlite3_free_table(results);
556
 
 
 
1330
 
 
1331
    sql = sqlite3_mprintf ("SELECT SE_UnregisterGroupStyle('group style 1')");
 
1332
    ret = execute_check (handle, sql, &err_msg);
 
1333
    sqlite3_free (sql);
 
1334
    if (ret != SQLITE_OK)
 
1335
      {
 
1336
          fprintf (stderr, "Error UnregisterGroupStyle #2: %s\n\n", err_msg);
 
1337
          sqlite3_free (err_msg);
 
1338
          return -46;
 
1339
      }
 
1340
 
 
1341
    sql = sqlite3_mprintf ("SELECT SE_RegisterGroupStyle(x%Q)", hexBlob);
 
1342
    ret = execute_check (handle, sql, &err_msg);
 
1343
    sqlite3_free (sql);
 
1344
    if (ret != SQLITE_OK)
 
1345
      {
 
1346
          fprintf (stderr, "Error RegisterGroupStyle #4: %s\n\n", err_msg);
 
1347
          sqlite3_free (err_msg);
 
1348
          return -47;
 
1349
      }
 
1350
    free (hexBlob);
 
1351
 
 
1352
    /* testing Styled Group Styles */
 
1353
    sql = sqlite3_mprintf ("SELECT SE_RegisterStyledGroupStyle('group1', 2)");
 
1354
    ret = execute_check (handle, sql, &err_msg);
 
1355
    sqlite3_free (sql);
 
1356
    if (ret != SQLITE_OK)
 
1357
      {
 
1358
          fprintf (stderr, "Error RegisterStyledGroupStyle #2: %s\n\n",
 
1359
                   err_msg);
 
1360
          sqlite3_free (err_msg);
 
1361
          return -50;
 
1362
      }
 
1363
 
 
1364
    sql =
 
1365
        sqlite3_mprintf
 
1366
        ("SELECT SE_RegisterStyledGroupStyle('group1', 'group style 1')");
 
1367
    ret = execute_check (handle, sql, &err_msg);
 
1368
    sqlite3_free (sql);
 
1369
    if (ret != SQLITE_OK)
 
1370
      {
 
1371
          fprintf (stderr, "Error RegisterStyledGroupStyle #3: %s\n\n",
 
1372
                   err_msg);
 
1373
          sqlite3_free (err_msg);
 
1374
          return -51;
 
1375
      }
 
1376
 
 
1377
    sql =
 
1378
        sqlite3_mprintf
 
1379
        ("SELECT SE_RegisterStyledGroupStyle('group2', 'group style 1')");
 
1380
    ret = execute_check (handle, sql, &err_msg);
 
1381
    sqlite3_free (sql);
 
1382
    if (ret != SQLITE_OK)
 
1383
      {
 
1384
          fprintf (stderr, "Error RegisterStyledGroupStyle #3: %s\n\n",
 
1385
                   err_msg);
 
1386
          sqlite3_free (err_msg);
 
1387
          return -52;
 
1388
      }
 
1389
 
 
1390
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterStyledGroupStyle('group1', 3)");
 
1391
    ret = execute_check (handle, sql, &err_msg);
 
1392
    sqlite3_free (sql);
 
1393
    if (ret != SQLITE_OK)
 
1394
      {
 
1395
          fprintf (stderr, "Error UnRegisterStyledGroupStyle #1: %s\n\n",
 
1396
                   err_msg);
 
1397
          sqlite3_free (err_msg);
 
1398
          return -53;
 
1399
      }
 
1400
 
 
1401
    sql =
 
1402
        sqlite3_mprintf
 
1403
        ("SELECT SE_UnRegisterStyledGroupStyle('group2', 'group style 1')");
 
1404
    ret = execute_check (handle, sql, &err_msg);
 
1405
    sqlite3_free (sql);
 
1406
    if (ret != SQLITE_OK)
 
1407
      {
 
1408
          fprintf (stderr, "Error UnRegisterStyledGroupStyle #2: %s\n\n",
 
1409
                   err_msg);
 
1410
          sqlite3_free (err_msg);
 
1411
          return -54;
 
1412
      }
 
1413
 
 
1414
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterGroupStyle(2, 1)");
 
1415
    ret = execute_check (handle, sql, &err_msg);
 
1416
    sqlite3_free (sql);
 
1417
    if (ret != SQLITE_OK)
 
1418
      {
 
1419
          fprintf (stderr, "Error UnRegisterGroupStyle #3: %s\n\n", err_msg);
 
1420
          sqlite3_free (err_msg);
 
1421
          return -55;
 
1422
      }
 
1423
 
 
1424
    sql =
 
1425
        sqlite3_mprintf ("SELECT SE_UnRegisterGroupStyle('group style 1', 1)");
 
1426
    ret = execute_check (handle, sql, &err_msg);
 
1427
    sqlite3_free (sql);
 
1428
    if (ret != SQLITE_OK)
 
1429
      {
 
1430
          fprintf (stderr, "Error UnRegisterGroupStyle #4: %s\n\n", err_msg);
 
1431
          sqlite3_free (err_msg);
 
1432
          return -56;
 
1433
      }
 
1434
 
 
1435
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorStyle(1, 1)");
 
1436
    ret = execute_check (handle, sql, &err_msg);
 
1437
    sqlite3_free (sql);
 
1438
    if (ret != SQLITE_OK)
 
1439
      {
 
1440
          fprintf (stderr, "Error UnregisterVectorStyle #6: %s\n\n", err_msg);
 
1441
          sqlite3_free (err_msg);
 
1442
          return -57;
 
1443
      }
 
1444
 
 
1445
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterRasterStyle(1)");
 
1446
    ret = execute_check (handle, sql, NULL);
 
1447
    sqlite3_free (sql);
 
1448
    if (ret == SQLITE_OK)
 
1449
      {
 
1450
          fprintf (stderr, "Error UnregisterRasterStyle #5: %s\n\n",
 
1451
                   "expected failure");
 
1452
          return -58;
 
1453
      }
 
1454
 
 
1455
    return 0;
 
1456
}
 
1457
 
 
1458
static int
 
1459
check_extent (sqlite3 * handle)
 
1460
{
 
1461
/* testing Vector Coverage Extents */
 
1462
    int ret;
 
1463
    char *err_msg = NULL;
 
1464
    char *sql;
 
1465
 
 
1466
/* inserting more alternative SRIDs */
 
1467
    sql =
 
1468
        sqlite3_mprintf
 
1469
        ("SELECT SE_RegisterVectorCoverageSrid('table1', 32632)");
 
1470
    ret = execute_check (handle, sql, &err_msg);
 
1471
    sqlite3_free (sql);
 
1472
    if (ret != SQLITE_OK)
 
1473
      {
 
1474
          fprintf (stderr, "Error RegisterVectorCoverageSrid #1 %s\n\n",
 
1475
                   err_msg);
 
1476
          sqlite3_free (err_msg);
 
1477
          return -1;
 
1478
      }
 
1479
 
 
1480
    sql =
 
1481
        sqlite3_mprintf
 
1482
        ("SELECT SE_RegisterVectorCoverageSrid('table2', 4326)");
 
1483
    ret = execute_check (handle, sql, &err_msg);
 
1484
    sqlite3_free (sql);
 
1485
    if (ret != SQLITE_OK)
 
1486
      {
 
1487
          fprintf (stderr, "Error RegisterVectorCoverageSrid #2 %s\n\n",
 
1488
                   err_msg);
 
1489
          sqlite3_free (err_msg);
 
1490
          return -2;
 
1491
      }
 
1492
 
 
1493
    sql =
 
1494
        sqlite3_mprintf
 
1495
        ("SELECT SE_RegisterVectorCoverageSrid('table2', 32633)");
 
1496
    ret = execute_check (handle, sql, &err_msg);
 
1497
    sqlite3_free (sql);
 
1498
    if (ret != SQLITE_OK)
 
1499
      {
 
1500
          fprintf (stderr, "Error RegisterVectorCoverageSrid #3 %s\n\n",
 
1501
                   err_msg);
 
1502
          sqlite3_free (err_msg);
 
1503
          return -3;
 
1504
      }
 
1505
 
 
1506
    sql =
 
1507
        sqlite3_mprintf
 
1508
        ("SELECT SE_RegisterVectorCoverageSrid('table2', 32632)");
 
1509
    ret = execute_check (handle, sql, NULL);
 
1510
    sqlite3_free (sql);
 
1511
    if (ret == SQLITE_OK)
 
1512
      {
 
1513
          fprintf (stderr, "Error RegisterVectorCoverageSrid #4 %s\n\n",
 
1514
                   "expected failure");
 
1515
          return -4;
 
1516
      }
 
1517
 
 
1518
    sql =
 
1519
        sqlite3_mprintf
 
1520
        ("SELECT SE_RegisterVectorCoverageSrid('table99', 4326)");
 
1521
    ret = execute_check (handle, sql, NULL);
 
1522
    sqlite3_free (sql);
 
1523
    if (ret == SQLITE_OK)
 
1524
      {
 
1525
          fprintf (stderr, "Error RegisterVectorCoverageSrid #5 %s\n\n",
 
1526
                   "expected failure");
 
1527
          return -5;
 
1528
      }
 
1529
 
 
1530
    sql =
 
1531
        sqlite3_mprintf
 
1532
        ("SELECT SE_RegisterVectorCoverageSrid('table99', 4326)");
 
1533
    ret = execute_check (handle, sql, NULL);
 
1534
    sqlite3_free (sql);
 
1535
    if (ret == SQLITE_OK)
 
1536
      {
 
1537
          fprintf (stderr, "Error RegisterVectorCoverageSrid #6 %s\n\n",
 
1538
                   "expected failure");
 
1539
          return -6;
 
1540
      }
 
1541
 
 
1542
/* inserting few Points just to set an Extent */
 
1543
    sql =
 
1544
        sqlite3_mprintf
 
1545
        ("INSERT INTO table1 (id, geom) VALUES (NULL, MakePoint(11.4, 42.3, 4326))");
 
1546
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1547
    sqlite3_free (sql);
 
1548
    if (ret != SQLITE_OK)
 
1549
      {
 
1550
          fprintf (stderr, "Error Insert Point #1 %s\n\n", err_msg);
 
1551
          sqlite3_free (err_msg);
 
1552
          return -7;
 
1553
      }
 
1554
 
 
1555
    sql =
 
1556
        sqlite3_mprintf
 
1557
        ("INSERT INTO table1 (id, geom) VALUES (NULL, MakePoint(11.8, 42.3, 4326))");
 
1558
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1559
    sqlite3_free (sql);
 
1560
    if (ret != SQLITE_OK)
 
1561
      {
 
1562
          fprintf (stderr, "Error Insert Point #2 %s\n\n", err_msg);
 
1563
          sqlite3_free (err_msg);
 
1564
          return -8;
 
1565
      }
 
1566
 
 
1567
    sql =
 
1568
        sqlite3_mprintf
 
1569
        ("INSERT INTO table1 (id, geom) VALUES (NULL, MakePoint(11.8, 43.2, 4326))");
 
1570
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1571
    sqlite3_free (sql);
 
1572
    if (ret != SQLITE_OK)
 
1573
      {
 
1574
          fprintf (stderr, "Error Insert Point #3 %s\n\n", err_msg);
 
1575
          sqlite3_free (err_msg);
 
1576
          return -9;
 
1577
      }
 
1578
 
 
1579
    sql =
 
1580
        sqlite3_mprintf
 
1581
        ("INSERT INTO table2 (id, geom) VALUES (NULL, MakePoint(697831.5121, 4685875.1570, 32632))");
 
1582
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1583
    sqlite3_free (sql);
 
1584
    if (ret != SQLITE_OK)
 
1585
      {
 
1586
          fprintf (stderr, "Error Insert Point #4 %s\n\n", err_msg);
 
1587
          sqlite3_free (err_msg);
 
1588
          return -10;
 
1589
      }
 
1590
 
 
1591
    sql =
 
1592
        sqlite3_mprintf
 
1593
        ("INSERT INTO table2 (id, geom) VALUES (NULL, MakePoint(696831.123, 4685875.456, 32632))");
 
1594
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1595
    sqlite3_free (sql);
 
1596
    if (ret != SQLITE_OK)
 
1597
      {
 
1598
          fprintf (stderr, "Error Insert Point #5 %s\n\n", err_msg);
 
1599
          sqlite3_free (err_msg);
 
1600
          return -11;
 
1601
      }
 
1602
 
 
1603
    sql =
 
1604
        sqlite3_mprintf
 
1605
        ("INSERT INTO table2 (id, geom) VALUES (NULL, MakePoint(696531.9876, 4688875.4321, 32632))");
 
1606
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1607
    sqlite3_free (sql);
 
1608
    if (ret != SQLITE_OK)
 
1609
      {
 
1610
          fprintf (stderr, "Error Insert Point #6 %s\n\n", err_msg);
 
1611
          sqlite3_free (err_msg);
 
1612
          return -12;
 
1613
      }
 
1614
 
 
1615
    sql = sqlite3_mprintf ("SELECT SE_UpdateVectorCoverageExtent(1)");
 
1616
    ret = execute_check (handle, sql, &err_msg);
 
1617
    sqlite3_free (sql);
 
1618
    if (ret != SQLITE_OK)
 
1619
      {
 
1620
          fprintf (stderr, "Error UpdateVectorCoverageExtent #1 %s\n\n",
 
1621
                   err_msg);
 
1622
          sqlite3_free (err_msg);
 
1623
          return -13;
 
1624
      }
 
1625
 
 
1626
    sql =
 
1627
        sqlite3_mprintf
 
1628
        ("SELECT SE_UnRegisterVectorCoverageSrid('table2', 4326)");
 
1629
    ret = execute_check (handle, sql, &err_msg);
 
1630
    sqlite3_free (sql);
 
1631
    if (ret != SQLITE_OK)
 
1632
      {
 
1633
          fprintf (stderr, "Error UnRegisterVectorCoverageSrid #1 %s\n\n",
 
1634
                   err_msg);
 
1635
          sqlite3_free (err_msg);
 
1636
          return -14;
 
1637
      }
 
1638
 
 
1639
    sql =
 
1640
        sqlite3_mprintf
 
1641
        ("SELECT SE_UnRegisterVectorCoverageSrid('table2', 32632)");
 
1642
    ret = execute_check (handle, sql, NULL);
 
1643
    sqlite3_free (sql);
 
1644
    if (ret == SQLITE_OK)
 
1645
      {
 
1646
          fprintf (stderr, "Error UnRegisterVectorCoverageSrid #2 %s\n\n",
 
1647
                   "expected failure");
 
1648
          return -15;
 
1649
      }
 
1650
 
 
1651
    sql =
 
1652
        sqlite3_mprintf
 
1653
        ("SELECT SE_UnRegisterVectorCoverageSrid('table99', 4326)");
 
1654
    ret = execute_check (handle, sql, NULL);
 
1655
    sqlite3_free (sql);
 
1656
    if (ret == SQLITE_OK)
 
1657
      {
 
1658
          fprintf (stderr, "Error UnRegisterVectorCoverageSrid #3 %s\n\n",
 
1659
                   "expected failure");
 
1660
          return -16;
 
1661
      }
 
1662
 
 
1663
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorCoverage('table1')");
 
1664
    ret = execute_check (handle, sql, &err_msg);
 
1665
    sqlite3_free (sql);
 
1666
    if (ret != SQLITE_OK)
 
1667
      {
 
1668
          fprintf (stderr, "Error UnRegisterVectorCoverage #1 %s\n\n", err_msg);
 
1669
          sqlite3_free (err_msg);
 
1670
          return -17;
 
1671
      }
 
1672
 
 
1673
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorCoverage('table99')");
 
1674
    ret = execute_check (handle, sql, NULL);
 
1675
    sqlite3_free (sql);
 
1676
    if (ret == SQLITE_OK)
 
1677
      {
 
1678
          fprintf (stderr, "Error UnRegisterVectorCoverage #2 %s\n\n",
 
1679
                   "expected failure");
 
1680
          return -18;
 
1681
      }
 
1682
 
 
1683
    sql = sqlite3_mprintf ("SELECT SE_UpdateVectorCoverageExtent('table2', 1)");
 
1684
    ret = execute_check (handle, sql, &err_msg);
 
1685
    sqlite3_free (sql);
 
1686
    if (ret != SQLITE_OK)
 
1687
      {
 
1688
          fprintf (stderr, "Error UpdateVectorCoverageExtent #2 %s\n\n",
 
1689
                   err_msg);
 
1690
          sqlite3_free (err_msg);
 
1691
          return -19;
 
1692
      }
 
1693
 
 
1694
    sql = sqlite3_mprintf ("SELECT SE_UnRegisterVectorCoverage('table1')");
 
1695
    ret = execute_check (handle, sql, NULL);
 
1696
    sqlite3_free (sql);
 
1697
    if (ret == SQLITE_OK)
 
1698
      {
 
1699
          fprintf (stderr, "Error UnRegisterVectorCoverage #3 %s\n\n",
 
1700
                   "expected failure");
 
1701
          return -20;
 
1702
      }
 
1703
 
 
1704
/* creating a furher vector Tables */
 
1705
    sql = "CREATE TABLE tablex (id INTEGER PRIMARY KEY AUTOINCREMENT)";
 
1706
    ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
 
1707
    if (ret != SQLITE_OK)
 
1708
      {
 
1709
          fprintf (stderr, "Error Create Table table3: %s\n\n", err_msg);
 
1710
          sqlite3_free (err_msg);
 
1711
          return -21;
 
1712
      }
 
1713
    sql = "SELECT AddGeometryColumn('tablex', 'geom', 4326, 'POINT', 'XY')";
 
1714
    ret = execute_check (handle, sql, &err_msg);
 
1715
    if (ret != SQLITE_OK)
 
1716
      {
 
1717
          fprintf (stderr, "Error AddGeometryColumn tablex: %s\n\n", err_msg);
 
1718
          sqlite3_free (err_msg);
 
1719
          return -22;
 
1720
      }
 
1721
    sql = "SELECT SE_RegisterVectorCoverage('tablex', 'tablex', 'geom')";
 
1722
    ret = execute_check (handle, sql, &err_msg);
 
1723
    if (ret != SQLITE_OK)
 
1724
      {
 
1725
          fprintf (stderr, "Error RegisterVectorCoverage tablex: %s\n\n",
 
1726
                   err_msg);
 
1727
          sqlite3_free (err_msg);
 
1728
          return -23;
 
1729
      }
 
1730
    sql =
 
1731
        sqlite3_mprintf
 
1732
        ("SELECT SE_RegisterVectorCoverageSrid('tablex', 32632)");
 
1733
    ret = execute_check (handle, sql, &err_msg);
 
1734
    sqlite3_free (sql);
 
1735
    if (ret != SQLITE_OK)
 
1736
      {
 
1737
          fprintf (stderr, "Error RegisterVectorCoverageSrid #7 %s\n\n",
 
1738
                   err_msg);
 
1739
          sqlite3_free (err_msg);
 
1740
          return -24;
 
1741
      }
 
1742
    sql = sqlite3_mprintf ("SELECT SE_UpdateVectorCoverageExtent('tablex')");
 
1743
    ret = execute_check (handle, sql, &err_msg);
 
1744
    sqlite3_free (sql);
 
1745
    if (ret != SQLITE_OK)
 
1746
      {
 
1747
          fprintf (stderr, "Error UpdateVectorCoverageExtent #3 %s\n\n",
 
1748
                   err_msg);
 
1749
          sqlite3_free (err_msg);
 
1750
          return -25;
 
1751
      }
 
1752
 
 
1753
    return 0;
 
1754
}
 
1755
 
 
1756
int
 
1757
main (int argc, char *argv[])
 
1758
{
 
1759
    int ret;
 
1760
    sqlite3 *handle;
 
1761
    char *err_msg = NULL;
 
1762
    char *sql;
 
1763
    void *cache = spatialite_alloc_connection ();
 
1764
 
 
1765
    if (argc > 1 || argv[0] == NULL)
 
1766
        argc = 1;               /* silencing stupid compiler warnings */
 
1767
 
 
1768
    ret =
 
1769
        sqlite3_open_v2 (":memory:", &handle,
 
1770
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
1771
    if (ret != SQLITE_OK)
 
1772
      {
 
1773
          fprintf (stderr, "cannot open in-memory db: %s\n",
 
1774
                   sqlite3_errmsg (handle));
 
1775
          sqlite3_close (handle);
 
1776
          return -1;
 
1777
      }
 
1778
 
 
1779
    spatialite_init_ex (handle, cache, 0);
 
1780
 
 
1781
    sql = "SELECT InitSpatialMetadata(1, 'WGS84')";
 
1782
    ret = execute_check (handle, sql, &err_msg);
 
1783
    if (ret != SQLITE_OK)
 
1784
      {
 
1785
          fprintf (stderr,
 
1786
                   "Unexpected InitSpatialMetadata result: %i, (%s)\n", ret,
 
1787
                   err_msg);
 
1788
          sqlite3_free (err_msg);
 
1789
          return -2;
 
1790
      }
 
1791
 
 
1792
#ifdef ENABLE_LIBXML2           /* only if LIBXML2 is supported */
 
1793
 
 
1794
/* creating the Styling Tables */
 
1795
    sql = "SELECT CreateStylingTables(1)";
 
1796
    ret = execute_check (handle, sql, &err_msg);
 
1797
    if (ret != SQLITE_OK)
 
1798
      {
 
1799
          fprintf (stderr, "Error CreateStylingTables %s\n\n", err_msg);
 
1800
          sqlite3_free (err_msg);
 
1801
          return -3;
 
1802
      }
 
1803
 
 
1804
    ret = check_vector (handle, cache);
 
1805
    if (ret != 0)
 
1806
        return -100 - ret;
 
1807
 
 
1808
    ret = check_raster (handle, cache);
 
1809
    if (ret != 0)
 
1810
        return -200 - ret;
 
1811
 
 
1812
    ret = check_group (handle, cache);
 
1813
    if (ret != 0)
 
1814
        return -300 - ret;
 
1815
 
 
1816
    ret = check_extent (handle);
 
1817
    if (ret != 0)
 
1818
        return -400 - ret;
557
1819
 
558
1820
#endif
559
 
    
 
1821
 
560
1822
    ret = sqlite3_close (handle);
561
 
    if (ret != SQLITE_OK) {
562
 
        fprintf (stderr, "sqlite3_close() error: %s\n", sqlite3_errmsg (handle));
563
 
        return -57;
564
 
    }
565
 
        
 
1823
    if (ret != SQLITE_OK)
 
1824
      {
 
1825
          fprintf (stderr, "sqlite3_close() error: %s\n",
 
1826
                   sqlite3_errmsg (handle));
 
1827
          return -57;
 
1828
      }
 
1829
 
566
1830
    spatialite_cleanup_ex (cache);
567
1831
 
568
 
#ifdef ENABLE_LIBXML2   /* only if LIBXML2 is supported */
569
 
    xmlCleanupParser();
570
 
#endif
571
 
    
 
1832
    spatialite_shutdown ();
572
1833
    return 0;
573
1834
}