← Back to branch summary

~jan-kneschke/mysql-proxy/packet-tracking-assertions

« back to all changes in this revision

Viewing changes to tests/unit/check_sql_tokenizer.c

  • Committer: Kay Roepke
  • Date: 2009-09-02 14:04:24 UTC
  • Revision ID: kay@sun.com-20090902140424-j795532tpi1y06lt
Fix linking errors on Win32:
 * chassis-timing was missing CHASSIS_API
 * evutil_socketpair was not exported

Suppress superfluous warnings from MSVC and fix a couple of valid ones (unused variables etc).

Add third path to the dllexport macros, to be used in testcases which are statically linked (fixes linker warnings).
Fixes PR-237

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit/check_sql_tokenizer.c
1
1
/* $%BEGINLICENSE%$
2
 
 Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 
2
 Copyright (C) 2007-2008 MySQL AB, 2008 Sun Microsystems, Inc
3
3
 
4
 
 This program is free software; you can redistribute it and/or
5
 
 modify it under the terms of the GNU General Public License as
6
 
 published by the Free Software Foundation; version 2 of the
7
 
 License.
 
4
 This program is free software; you can redistribute it and/or modify
 
5
 it under the terms of the GNU General Public License as published by
 
6
 the Free Software Foundation; version 2 of the License.
8
7
 
9
8
 This program is distributed in the hope that it will be useful,
10
9
 but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
10
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
 GNU General Public License for more details.
13
12
 
14
13
 You should have received a copy of the GNU General Public License
15
14
 along with this program; if not, write to the Free Software
16
 
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17
 
 02110-1301  USA
 
15
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
 $%ENDLICENSE%$ */
20
18
 
24
22
#include <string.h>
25
23
 
26
24
#include <glib.h>
27
 
#include "glib-ext.h"
 
25
 
28
26
#include "sql-tokenizer.h"
29
27
 
30
28
#if GLIB_CHECK_VERSION(2, 16, 0)
76
74
                         /**
77
75
                          * a self-writing test-case 
78
76
                          */
79
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
 
77
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id), token->text->str);
80
78
                        break;
81
79
                }
82
80
        }
114
112
                         /**
115
113
                          * a self-writing test-case 
116
114
                          */
117
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
 
115
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id), token->text->str);
118
116
                        break;
119
117
                }
120
118
        }
135
133
        for (i = 0; i < TK_LAST_TOKEN; i++) {
136
134
                const char *name;
137
135
 
138
 
                g_assert((name = sql_token_get_name(i, NULL)));
139
 
        }
140
 
} END_TEST
 
136
                g_assert((name = sql_token_get_name(i)));
 
137
        }
 
138
} END_TEST
 
139
 
 
140
/**
 
141
 * @test check if we can map all tokens to a name and back again
 
142
 *   
 
143
 */
 
144
START_TEST(test_keyword2token) {
 
145
        gsize i;
 
146
 
 
147
        const struct {
 
148
                const char *token;
 
149
                sql_token_id id;
 
150
        } keywords[] = {
 
151
                { "SELECT", TK_SQL_SELECT },
 
152
                { "INSERT", TK_SQL_INSERT },
 
153
 
 
154
                { NULL, TK_UNKNOWN }
 
155
        };
 
156
 
 
157
        /* convert tokens to id and back to name */
 
158
        for (i = 0; keywords[i].token; i++) {
 
159
                g_assert_cmpint(keywords[i].id, ==, sql_token_get_id(keywords[i].token));
 
160
        }
 
161
 
 
162
        /* yeah, COMMIT should be a normal literal */
 
163
        g_assert_cmpint(TK_LITERAL, ==, sql_token_get_id("COMMIT"));
 
164
} END_TEST
 
165
 
141
166
 
142
167
/**
143
168
 * @test check if single line comments are recognized properly
340
365
} END_TEST
341
366
/* @} */
342
367
 
343
 
/**
344
 
 * get all keywords and try if we get all the ids
345
 
 */
346
 
void test_tokenizer_keywords() {
347
 
        gsize i;
348
 
 
349
 
        for (i = 0; sql_token_get_name(i, NULL); i++) {
350
 
                const char *keyword;
351
 
                size_t keyword_len;
352
 
 
353
 
                /** only tokens with TK_SQL_* are keyworks */
354
 
                if (0 != strncmp(sql_token_get_name(i, NULL), "TK_SQL_", sizeof("TK_SQL_") - 1)) continue;
355
 
                
356
 
                keyword = sql_token_get_name(i, &keyword_len);
357
 
                /* strip the TK_SQL_ prefix to get the keyword itself */
358
 
                keyword += sizeof("TK_SQL_") - 1;
359
 
                keyword_len -= sizeof("TK_SQL_") - 1;
360
 
 
361
 
                g_assert_cmpint(sql_token_get_id_len(keyword, keyword_len), ==, i);
362
 
        }
363
 
        
364
 
        /* check that some SQL commands are not keywords */
365
 
        g_assert_cmpint(sql_token_get_id_len(C("COMMIT")), ==, TK_LITERAL);
366
 
        g_assert_cmpint(sql_token_get_id_len(C("TRUNCATE")), ==, TK_LITERAL);
367
 
}
368
 
 
369
 
/**
370
 
 * @test literals can start with a digit, bug#49716
371
 
 *
372
 
 * - e1 is a literal ("e1")
373
 
 * - 1e is a literal ("1e")
374
 
 * - 1e + 1 is a literal ("1e"), a plus ("+") and  a int ("1")
375
 
 * - 1e+1 is a float ("1e+1")
376
 
 * - 1e+1e is a float ("1e+1") and literal ("e") 
377
 
 * - 1e1 is a float ("1e1")
378
 
 */
379
 
void test_literal_digit() {
380
 
        GPtrArray *tokens = NULL;
381
 
        gsize i;
382
 
 
383
 
#define T(t_id, t_text) \
384
 
                g_assert_cmpstr(sql_token_get_name(token->token_id, NULL), ==, sql_token_get_name(t_id, NULL)); \
385
 
                g_assert_cmpstr(token->text->str, ==, t_text);
386
 
 
387
 
        /* e1 is a literal ("e1") */
388
 
        tokens = sql_tokens_new();
389
 
 
390
 
        sql_tokenizer(tokens, C("e1"));
391
 
 
392
 
        for (i = 0; i < tokens->len; i++) {
393
 
                sql_token *token = tokens->pdata[i];
394
 
 
395
 
                switch (i) {
396
 
                case 0: T(TK_LITERAL, "e1"); break;
397
 
                default:
398
 
                         /**
399
 
                          * a self-writing test-case
400
 
                          */
401
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
402
 
                        g_assert_not_reached();
403
 
                }
404
 
        }
405
 
        sql_tokens_free(tokens);
406
 
 
407
 
        /* 1e is a literal ("1e") */
408
 
        tokens = sql_tokens_new();
409
 
 
410
 
        sql_tokenizer(tokens, C("1e"));
411
 
 
412
 
        for (i = 0; i < tokens->len; i++) {
413
 
                sql_token *token = tokens->pdata[i];
414
 
 
415
 
                switch (i) {
416
 
                case 0: T(TK_LITERAL, "1e"); break;
417
 
                default:
418
 
                         /**
419
 
                          * a self-writing test-case
420
 
                          */
421
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
422
 
                        g_assert_not_reached();
423
 
                }
424
 
        }
425
 
        sql_tokens_free(tokens);
426
 
 
427
 
        /* 1e + 1 is a literal ("1e"), a plus ("+") and a integer ("1") */
428
 
        tokens = sql_tokens_new();
429
 
 
430
 
        sql_tokenizer(tokens, C("1e + 1"));
431
 
 
432
 
        for (i = 0; i < tokens->len; i++) {
433
 
                sql_token *token = tokens->pdata[i];
434
 
 
435
 
                switch (i) {
436
 
                case 0: T(TK_LITERAL, "1e"); break;
437
 
                case 1: T(TK_PLUS, "+"); break;
438
 
                case 2: T(TK_INTEGER, "1"); break;
439
 
                default:
440
 
                         /**
441
 
                          * a self-writing test-case
442
 
                          */
443
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
444
 
                        g_assert_not_reached();
445
 
                }
446
 
        }
447
 
        sql_tokens_free(tokens);
448
 
 
449
 
        /* 1e+1 is a float ("1e+1") */
450
 
        tokens = sql_tokens_new();
451
 
 
452
 
        sql_tokenizer(tokens, C("1e+1"));
453
 
 
454
 
        for (i = 0; i < tokens->len; i++) {
455
 
                sql_token *token = tokens->pdata[i];
456
 
 
457
 
                switch (i) {
458
 
                case 0: T(TK_FLOAT, "1e+1"); break;
459
 
                default:
460
 
                         /**
461
 
                          * a self-writing test-case
462
 
                          */
463
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
464
 
                        g_assert_not_reached();
465
 
                }
466
 
        }
467
 
        sql_tokens_free(tokens);
468
 
 
469
 
        /* 1e1 is a float ("1e1") */
470
 
        tokens = sql_tokens_new();
471
 
 
472
 
        sql_tokenizer(tokens, C("1e1"));
473
 
 
474
 
        for (i = 0; i < tokens->len; i++) {
475
 
                sql_token *token = tokens->pdata[i];
476
 
 
477
 
                switch (i) {
478
 
                case 0: T(TK_FLOAT, "1e1"); break;
479
 
                default:
480
 
                         /**
481
 
                          * a self-writing test-case
482
 
                          */
483
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
484
 
                        g_assert_not_reached();
485
 
                }
486
 
        }
487
 
        sql_tokens_free(tokens);
488
 
 
489
 
        /* 1e+1e is a float ("1e+1") and a literal ("e") */
490
 
        tokens = sql_tokens_new();
491
 
 
492
 
        sql_tokenizer(tokens, C("1e+1e"));
493
 
 
494
 
        for (i = 0; i < tokens->len; i++) {
495
 
                sql_token *token = tokens->pdata[i];
496
 
 
497
 
                switch (i) {
498
 
                case 0: T(TK_FLOAT, "1e+1"); break;
499
 
                case 1: T(TK_LITERAL, "e"); break;
500
 
                default:
501
 
                         /**
502
 
                          * a self-writing test-case
503
 
                          */
504
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
505
 
                        g_assert_not_reached();
506
 
                }
507
 
        }
508
 
        sql_tokens_free(tokens);
509
 
 
510
 
        /* 1.1 is a float ("1.1") */
511
 
        tokens = sql_tokens_new();
512
 
 
513
 
        sql_tokenizer(tokens, C("1.1"));
514
 
 
515
 
        for (i = 0; i < tokens->len; i++) {
516
 
                sql_token *token = tokens->pdata[i];
517
 
 
518
 
                switch (i) {
519
 
                case 0: T(TK_FLOAT, "1.1"); break;
520
 
                default:
521
 
                         /**
522
 
                          * a self-writing test-case
523
 
                          */
524
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
525
 
                        g_assert_not_reached();
526
 
                }
527
 
        }
528
 
        sql_tokens_free(tokens);
529
 
 
530
 
        /* 1.1e+1 is a float ("1.1e+1") */
531
 
        tokens = sql_tokens_new();
532
 
 
533
 
        sql_tokenizer(tokens, C("1.1e+1"));
534
 
 
535
 
        for (i = 0; i < tokens->len; i++) {
536
 
                sql_token *token = tokens->pdata[i];
537
 
 
538
 
                switch (i) {
539
 
                case 0: T(TK_FLOAT, "1.1e+1"); break;
540
 
                default:
541
 
                         /**
542
 
                          * a self-writing test-case
543
 
                          */
544
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
545
 
                        g_assert_not_reached();
546
 
                }
547
 
        }
548
 
        sql_tokens_free(tokens);
549
 
 
550
 
        /* .1t is a float (".1") and a literal ("t")
551
 
         *
552
 
         * the same thing with 'e' is a parse-error in the server side
553
 
         */
554
 
        tokens = sql_tokens_new();
555
 
 
556
 
        sql_tokenizer(tokens, C(".1t"));
557
 
 
558
 
        for (i = 0; i < tokens->len; i++) {
559
 
                sql_token *token = tokens->pdata[i];
560
 
 
561
 
                switch (i) {
562
 
                case 0: T(TK_FLOAT, ".1"); break;
563
 
                case 1: T(TK_LITERAL, "t"); break;
564
 
                default:
565
 
                         /**
566
 
                          * a self-writing test-case
567
 
                          */
568
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
569
 
                        g_assert_not_reached();
570
 
                }
571
 
        }
572
 
        sql_tokens_free(tokens);
573
 
 
574
 
        /* t1.1t is a literal ("t1"), a dot and a literal ("1t") */
575
 
        tokens = sql_tokens_new();
576
 
 
577
 
        sql_tokenizer(tokens, C("t1.1t"));
578
 
 
579
 
        for (i = 0; i < tokens->len; i++) {
580
 
                sql_token *token = tokens->pdata[i];
581
 
 
582
 
                switch (i) {
583
 
                case 0: T(TK_LITERAL, "t1"); break;
584
 
                case 1: T(TK_DOT, "."); break;
585
 
                case 2: T(TK_LITERAL, "1t"); break;
586
 
                default:
587
 
                         /**
588
 
                          * a self-writing test-case
589
 
                          */
590
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
591
 
                        g_assert_not_reached();
592
 
                }
593
 
        }
594
 
        sql_tokens_free(tokens);
595
 
 
596
 
        /* e1.1e is a literal ("e1"), a dot and a literal ("1e") ... as 'e' is special */
597
 
        tokens = sql_tokens_new();
598
 
 
599
 
        sql_tokenizer(tokens, C("e1.1e"));
600
 
 
601
 
        for (i = 0; i < tokens->len; i++) {
602
 
                sql_token *token = tokens->pdata[i];
603
 
 
604
 
                switch (i) {
605
 
                case 0: T(TK_LITERAL, "e1"); break;
606
 
                case 1: T(TK_DOT, "."); break;
607
 
                case 2: T(TK_LITERAL, "1e"); break;
608
 
                default:
609
 
                         /**
610
 
                          * a self-writing test-case
611
 
                          */
612
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
613
 
                        g_assert_not_reached();
614
 
                }
615
 
        }
616
 
        sql_tokens_free(tokens);
617
 
 
618
 
        /* e1.1e + 1 is a literal ("e1"), a dot, a literal ("1e"), a plus ("+") and a integer ("1")*/
619
 
        tokens = sql_tokens_new();
620
 
 
621
 
        sql_tokenizer(tokens, C("e1.1e + 1"));
622
 
 
623
 
        for (i = 0; i < tokens->len; i++) {
624
 
                sql_token *token = tokens->pdata[i];
625
 
 
626
 
                switch (i) {
627
 
                case 0: T(TK_LITERAL, "e1"); break;
628
 
                case 1: T(TK_DOT, "."); break;
629
 
                case 2: T(TK_LITERAL, "1e"); break;
630
 
                case 3: T(TK_PLUS, "+"); break;
631
 
                case 4: T(TK_INTEGER, "1"); break;
632
 
                default:
633
 
                         /**
634
 
                          * a self-writing test-case
635
 
                          */
636
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
637
 
                        g_assert_not_reached();
638
 
                }
639
 
        }
640
 
        sql_tokens_free(tokens);
641
 
 
642
 
        /* e1 . 1e + 1 is a literal ("e1"), a dot, a literal ("1e"), a plus ("+") and a integer ("1")*/
643
 
        tokens = sql_tokens_new();
644
 
 
645
 
        sql_tokenizer(tokens, C("e1 . 1e + 1"));
646
 
 
647
 
        for (i = 0; i < tokens->len; i++) {
648
 
                sql_token *token = tokens->pdata[i];
649
 
 
650
 
                switch (i) {
651
 
                case 0: T(TK_LITERAL, "e1"); break;
652
 
                case 1: T(TK_DOT, "."); break;
653
 
                case 2: T(TK_LITERAL, "1e"); break;
654
 
                case 3: T(TK_PLUS, "+"); break;
655
 
                case 4: T(TK_INTEGER, "1"); break;
656
 
                default:
657
 
                         /**
658
 
                          * a self-writing test-case
659
 
                          */
660
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
661
 
                        g_assert_not_reached();
662
 
                }
663
 
        }
664
 
        sql_tokens_free(tokens);
665
 
 
666
 
        /* e1 . 1e+1 is a literal ("e1"), a dot, a float ("1e+1")
667
 
         * ... which is a invalid syntax as fieldnames can't be floats */
668
 
        tokens = sql_tokens_new();
669
 
 
670
 
        sql_tokenizer(tokens, C("e1 . 1e+1"));
671
 
 
672
 
        for (i = 0; i < tokens->len; i++) {
673
 
                sql_token *token = tokens->pdata[i];
674
 
 
675
 
                switch (i) {
676
 
                case 0: T(TK_LITERAL, "e1"); break;
677
 
                case 1: T(TK_DOT, "."); break;
678
 
                case 2: T(TK_FLOAT, "1e+1"); break;
679
 
                default:
680
 
                         /**
681
 
                          * a self-writing test-case
682
 
                          */
683
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
684
 
                        g_assert_not_reached();
685
 
                }
686
 
        }
687
 
        sql_tokens_free(tokens);
688
 
 
689
 
        /* e1.1e+1 is a literal ("e1"), a dot, a literal ("1e"), a plus ("+") and a integer ("1") */
690
 
        tokens = sql_tokens_new();
691
 
 
692
 
        sql_tokenizer(tokens, C("e1.1e+1"));
693
 
 
694
 
        for (i = 0; i < tokens->len; i++) {
695
 
                sql_token *token = tokens->pdata[i];
696
 
 
697
 
                switch (i) {
698
 
                case 0: T(TK_LITERAL, "e1"); break;
699
 
                case 1: T(TK_DOT, "."); break;
700
 
                case 2: T(TK_LITERAL, "1e"); break;
701
 
                case 3: T(TK_PLUS, "+"); break;
702
 
                case 4: T(TK_INTEGER, "1"); break;
703
 
                default:
704
 
                         /**
705
 
                          * a self-writing test-case
706
 
                          */
707
 
                        printf("case %"G_GSIZE_FORMAT": T(%s, \"%s\"); break;\n", i, sql_token_get_name(token->token_id, NULL), token->text->str);
708
 
                        g_assert_not_reached();
709
 
                }
710
 
        }
711
 
        sql_tokens_free(tokens);
712
 
 
713
 
#undef T
714
 
 
715
 
}
716
 
 
 
368
void test_g_istr_hash() {
 
369
        g_assert_cmpint(g_istr_hash("foo"), ==, g_istr_hash("foo"));
 
370
        g_assert_cmpint(g_istr_hash("foo"), !=, g_istr_hash("boo"));
 
371
}
717
372
 
718
373
int main(int argc, char **argv) {
719
374
        g_test_init(&argc, &argv, NULL);
720
375
        g_test_bug_base("http://bugs.mysql.com/");
721
376
 
722
 
        g_test_add_func("/core/tokenizer_keywords", test_tokenizer_keywords);
 
377
        g_test_add_func("/core/hash_str_i", test_g_istr_hash);
723
378
 
724
379
        g_test_add_func("/core/tokenizer", test_tokenizer);
725
380
        g_test_add_func("/core/tokenizer_token2name", test_token2name);
 
381
        g_test_add_func("/core/tokenizer_keywork2token", test_keyword2token);
726
382
        g_test_add_func("/core/tokenizer_table_name_underscore", test_table_name_underscore);
727
383
        g_test_add_func("/core/tokenizer_simple_dashdashcomment", test_simple_dashdashcomment);
728
384
        g_test_add_func("/core/tokenizer_dashdashcomment", test_dashdashcomment);
730
386
        g_test_add_func("/core/tokenizer_startstate_reset_quoted", test_startstate_reset_quoted);
731
387
        g_test_add_func("/core/tokenizer_startstate_reset_comment", test_startstate_reset_comment);
732
388
 
733
 
        g_test_add_func("/core/tokenizer_literal_digit", test_literal_digit);
734
 
 
735
389
        return g_test_run();
736
390
}
737
391
#else