← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/lib/mtr_cases.pl

  • Committer: Jay Pipes
  • Date: 2009-09-15 21:01:42 UTC
  • mto: (1126.2.5 merge)
  • mto: This revision was merged to the branch mainline in revision 1128.
  • Revision ID: jpipes@serialcoder-20090915210142-x8mwiqn1q0vzjspp
Moves Alter_info out into its own header and source file, cleans up some related include mess in sql_lex.h, and renames Alter_info to AlterInfo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/mtr_cases.pl
 
1
# -*- cperl -*-
 
2
# Copyright (C) 2005-2006 MySQL AB
 
3
# 
 
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.
 
7
# 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
# 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
16
 
 
17
# This is a library file used by the Perl version of mysql-test-run,
 
18
# and is part of the translation of the Bourne shell script with the
 
19
# same name.
 
20
 
 
21
use File::Basename;
 
22
use IO::File();
 
23
use strict;
 
24
 
 
25
use My::Config;
 
26
 
 
27
sub collect_test_cases ($);
 
28
sub collect_one_suite ($);
 
29
sub collect_one_test_case ($$$$$$$$$);
 
30
 
 
31
sub mtr_options_from_test_file($$);
 
32
 
 
33
my $do_test;
 
34
my $skip_test;
 
35
 
 
36
sub init_pattern {
 
37
  my ($from, $what)= @_;
 
38
  if ( $from =~ /^[a-z0-9]$/ ) {
 
39
    # Does not contain any regex, make the pattern match
 
40
    # beginning of string
 
41
    $from= "^$from";
 
42
  }
 
43
  # Check that pattern is a valid regex
 
44
  eval { "" =~/$from/; 1 } or
 
45
    mtr_error("Invalid regex '$from' passed to $what\nPerl says: $@");
 
46
  return $from;
 
47
}
 
48
 
 
49
 
 
50
 
 
51
##############################################################################
 
52
#
 
53
#  Collect information about test cases we are to run
 
54
#
 
55
##############################################################################
 
56
 
 
57
sub collect_test_cases ($) {
 
58
  $do_test= init_pattern($::opt_do_test, "--do-test");
 
59
  $skip_test= init_pattern($::opt_skip_test, "--skip-test");
 
60
 
 
61
  my $suites= shift; # Semicolon separated list of test suites
 
62
  my $cases = [];    # Array of hash
 
63
 
 
64
  foreach my $suite (split(",", $suites))
 
65
  {
 
66
    push(@$cases, collect_one_suite($suite));
 
67
  }
 
68
 
 
69
 
 
70
  if ( @::opt_cases )
 
71
  {
 
72
    # Check that the tests specified was found
 
73
    # in at least one suite
 
74
    foreach my $test_name_spec ( @::opt_cases )
 
75
    {
 
76
      my $found= 0;
 
77
      my ($sname, $tname, $extension)= split_testname($test_name_spec);
 
78
      foreach my $test ( @$cases )
 
79
      {
 
80
        # test->{name} is always in suite.name format
 
81
        if ( $test->{name} =~ /.*\.$tname/ )
 
82
        {
 
83
          $found= 1;
 
84
        }
 
85
      }
 
86
      if ( not $found )
 
87
      {
 
88
        mtr_error("Could not find $tname in any suite");
 
89
      }
 
90
    }
 
91
  }
 
92
 
 
93
  if ( $::opt_reorder )
 
94
  {
 
95
    # Reorder the test cases in an order that will make them faster to run
 
96
    my %sort_criteria;
 
97
 
 
98
    # Make a mapping of test name to a string that represents how that test
 
99
    # should be sorted among the other tests.  Put the most important criterion
 
100
    # first, then a sub-criterion, then sub-sub-criterion, et c.
 
101
    foreach my $tinfo (@$cases)
 
102
    {
 
103
      my @criteria = ();
 
104
 
 
105
      # Look for tests that muct be in run in a defined order
 
106
      # that is defined by test having the same name except for
 
107
      # the ending digit
 
108
 
 
109
      # Put variables into hash
 
110
      my $test_name= $tinfo->{'name'};
 
111
      my $depend_on_test_name;
 
112
      if ( $test_name =~ /^([\D]+)([0-9]{1})$/ )
 
113
      {
 
114
        my $base_name= $1;
 
115
        my $idx= $2;
 
116
        mtr_verbose("$test_name =>  $base_name idx=$idx");
 
117
        if ( $idx > 1 )
 
118
        {
 
119
          $idx-= 1;
 
120
          $base_name= "$base_name$idx";
 
121
          mtr_verbose("New basename $base_name");
 
122
        }
 
123
 
 
124
        foreach my $tinfo2 (@$cases)
 
125
        {
 
126
          if ( $tinfo2->{'name'} eq $base_name )
 
127
          {
 
128
            mtr_verbose("found dependent test $tinfo2->{'name'}");
 
129
            $depend_on_test_name=$base_name;
 
130
          }
 
131
        }
 
132
      }
 
133
 
 
134
      if ( defined $depend_on_test_name )
 
135
      {
 
136
        mtr_verbose("Giving $test_name same critera as $depend_on_test_name");
 
137
        $sort_criteria{$test_name} = $sort_criteria{$depend_on_test_name};
 
138
      }
 
139
      else
 
140
      {
 
141
        #
 
142
        # Append the criteria for sorting, in order of importance.
 
143
        #
 
144
        # Group test with equal options together.
 
145
        # Ending with "~" makes empty sort later than filled
 
146
        push(@criteria, join("!", sort @{$tinfo->{'master_opt'}}) . "~");
 
147
 
 
148
        $sort_criteria{$test_name} = join(" ", @criteria);
 
149
      }
 
150
    }
 
151
 
 
152
    @$cases = sort {
 
153
      $sort_criteria{$a->{'name'}} . $a->{'name'} cmp
 
154
        $sort_criteria{$b->{'name'}} . $b->{'name'}; } @$cases;
 
155
 
 
156
    if ( $::opt_script_debug )
 
157
    {
 
158
      # For debugging the sort-order
 
159
      foreach my $tinfo (@$cases)
 
160
      {
 
161
        print("$sort_criteria{$tinfo->{'name'}} -> \t$tinfo->{'name'}\n");
 
162
      }
 
163
    }
 
164
  }
 
165
 
 
166
  return $cases;
 
167
 
 
168
}
 
169
 
 
170
# Valid extensions and their corresonding component id
 
171
my %exts = ( 'test' => 'mysqld',
 
172
             'imtest' => 'im'
 
173
           );
 
174
 
 
175
 
 
176
# Returns (suitename, testname, extension)
 
177
sub split_testname {
 
178
  my ($test_name)= @_;
 
179
 
 
180
  # Get rid of directory part and split name on .'s
 
181
  my @parts= split(/\./, basename($test_name));
 
182
 
 
183
  if (@parts == 1){
 
184
    # Only testname given, ex: alias
 
185
    return (undef , $parts[0], undef);
 
186
  } elsif (@parts == 2) {
 
187
    # Either testname.test or suite.testname given
 
188
    # Ex. main.alias or alias.test
 
189
 
 
190
    if (defined $exts{$parts[1]})
 
191
    {
 
192
      return (undef , $parts[0], $parts[1]);
 
193
    }
 
194
    else
 
195
    {
 
196
      return ($parts[0], $parts[1], undef);
 
197
    }
 
198
 
 
199
  } elsif (@parts == 3) {
 
200
    # Fully specified suitename.testname.test
 
201
    # ex main.alias.test
 
202
    return ( $parts[0], $parts[1], $parts[2]);
 
203
  }
 
204
 
 
205
  mtr_error("Illegal format of test name: $test_name");
 
206
}
 
207
 
 
208
 
 
209
sub collect_one_suite($)
 
210
{
 
211
  my $suite= shift;  # Test suite name
 
212
  my @cases;  # Array of hash
 
213
 
 
214
  mtr_verbose("Collecting: $suite");
 
215
 
 
216
  my $suitedir= "$::glob_mysql_test_dir"; # Default
 
217
  if ( $suite ne "main" )
 
218
  {
 
219
    $suitedir= mtr_path_exists("$suitedir/suite/$suite",
 
220
                               "$suitedir/$suite");
 
221
    mtr_verbose("suitedir: $suitedir");
 
222
  }
 
223
 
 
224
  my $testdir= "$suitedir/t";
 
225
  my $resdir=  "$suitedir/r";
 
226
 
 
227
  # ----------------------------------------------------------------------
 
228
  # Build a hash of disabled testcases for this suite
 
229
  # ----------------------------------------------------------------------
 
230
  my %disabled;
 
231
  if ( open(DISABLED, "$testdir/disabled.def" ) )
 
232
  {
 
233
    while ( <DISABLED> )
 
234
      {
 
235
        chomp;
 
236
        if ( /^\s*(\S+)\s*:\s*(.*?)\s*$/ )
 
237
          {
 
238
            $disabled{$1}= $2;
 
239
          }
 
240
      }
 
241
    close DISABLED;
 
242
  }
 
243
 
 
244
  # Read suite.opt file
 
245
  my $suite_opt_file=  "$testdir/suite.opt";
 
246
  my $suite_opts= [];
 
247
  if ( -f $suite_opt_file )
 
248
  {
 
249
    $suite_opts= mtr_get_opts_from_file($suite_opt_file);
 
250
  }
 
251
 
 
252
  if ( @::opt_cases )
 
253
  {
 
254
    # Collect in specified order
 
255
    foreach my $test_name_spec ( @::opt_cases )
 
256
    {
 
257
      my ($sname, $tname, $extension)= split_testname($test_name_spec);
 
258
 
 
259
      # The test name parts have now been defined
 
260
      #print "  suite_name: $sname\n";
 
261
      #print "  tname:      $tname\n";
 
262
      #print "  extension:  $extension\n";
 
263
 
 
264
      # Check cirrect suite if suitename is defined
 
265
      next if (defined $sname and $suite ne $sname);
 
266
 
 
267
      my $component_id;
 
268
      if ( defined $extension )
 
269
      {
 
270
        my $full_name= "$testdir/$tname.$extension";
 
271
        # Extension was specified, check if the test exists
 
272
        if ( ! -f $full_name)
 
273
        {
 
274
          # This is only an error if suite was specified, otherwise it
 
275
          # could exist in another suite
 
276
          mtr_error("Test '$full_name' was not found in suite '$sname'")
 
277
            if $sname;
 
278
 
 
279
          next;
 
280
        }
 
281
        $component_id= $exts{$extension};
 
282
      }
 
283
      else
 
284
      {
 
285
        # No extension was specified
 
286
        my ($ext, $component);
 
287
        while (($ext, $component)= each %exts) {
 
288
          my $full_name= "$testdir/$tname.$ext";
 
289
 
 
290
          if ( ! -f $full_name ) {
 
291
            next;
 
292
          }
 
293
          $component_id= $component;
 
294
          $extension= $ext;
 
295
        }
 
296
        # Test not found here, could exist in other suite
 
297
        next unless $component_id;
 
298
      }
 
299
 
 
300
      collect_one_test_case($testdir,$resdir,$suite,$tname,
 
301
                            "$tname.$extension",\@cases,\%disabled,
 
302
                            $component_id,$suite_opts);
 
303
    }
 
304
  }
 
305
  else
 
306
  {
 
307
    opendir(TESTDIR, $testdir) or mtr_error("Can't open dir \"$testdir\": $!");
 
308
 
 
309
    foreach my $elem ( sort readdir(TESTDIR) )
 
310
    {
 
311
      my $component_id= undef;
 
312
      my $tname= undef;
 
313
 
 
314
      if ($tname= mtr_match_extension($elem, 'test'))
 
315
      {
 
316
        $component_id = 'mysqld';
 
317
      }
 
318
      elsif ($tname= mtr_match_extension($elem, 'imtest'))
 
319
      {
 
320
        $component_id = 'im';
 
321
      }
 
322
      else
 
323
      {
 
324
        next;
 
325
      }
 
326
 
 
327
      # Skip tests that does not match the --do-test= filter
 
328
      next if ($do_test and not $tname =~ /$do_test/o);
 
329
 
 
330
      collect_one_test_case($testdir,$resdir,$suite,$tname,
 
331
                            $elem,\@cases,\%disabled,$component_id,
 
332
                            $suite_opts);
 
333
    }
 
334
    closedir TESTDIR;
 
335
  }
 
336
 
 
337
 
 
338
  #  Return empty list if no testcases found
 
339
  return if (@cases == 0);
 
340
 
 
341
  # ----------------------------------------------------------------------
 
342
  # Read combinations for this suite and build testcases x combinations
 
343
  # if any combinations exists
 
344
  # ----------------------------------------------------------------------
 
345
  if ( ! $::opt_skip_combination )
 
346
  {
 
347
    my @combinations;
 
348
    my $combination_file= "$suitedir/combinations";
 
349
    #print "combination_file: $combination_file\n";
 
350
    if (@::opt_combinations)
 
351
    {
 
352
      # take the combination from command-line
 
353
      mtr_verbose("Take the combination from command line");
 
354
      foreach my $combination (@::opt_combinations) {
 
355
        my $comb= {};
 
356
        $comb->{name}= $combination;
 
357
        push(@{$comb->{comb_opt}}, $combination);
 
358
        push(@combinations, $comb);
 
359
      }
 
360
    }
 
361
    elsif (-f $combination_file )
 
362
    {
 
363
      # Read combinations file in my.cnf format
 
364
      mtr_verbose("Read combinations file");
 
365
      my $config= My::Config->new($combination_file);
 
366
 
 
367
      foreach my $group ($config->groups()) {
 
368
        my $comb= {};
 
369
        $comb->{name}= $group->name();
 
370
        foreach my $option ( $group->options() ) {
 
371
          push(@{$comb->{comb_opt}}, $option->name()."=".$option->value());
 
372
        }
 
373
        push(@combinations, $comb);
 
374
      }
 
375
    }
 
376
 
 
377
    if (@combinations)
 
378
    {
 
379
      print " - adding combinations\n";
 
380
      #print_testcases(@cases);
 
381
 
 
382
      my @new_cases;
 
383
      foreach my $comb (@combinations)
 
384
      {
 
385
        foreach my $test (@cases)
 
386
        {
 
387
          #print $test->{name}, " ", $comb, "\n";
 
388
          my $new_test= {};
 
389
 
 
390
          while (my ($key, $value) = each(%$test)) {
 
391
            if (ref $value eq "ARRAY") {
 
392
              push(@{$new_test->{$key}}, @$value);
 
393
            } else {
 
394
              $new_test->{$key}= $value;
 
395
            }
 
396
          }
 
397
 
 
398
          # Append the combination options to master_opt and slave_opt
 
399
          push(@{$new_test->{master_opt}}, @{$comb->{comb_opt}});
 
400
          push(@{$new_test->{slave_opt}}, @{$comb->{comb_opt}});
 
401
 
 
402
          # Add combination name shrt name
 
403
          $new_test->{combination}= $comb->{name};
 
404
 
 
405
          # Add the new test to new test cases list
 
406
          push(@new_cases, $new_test);
 
407
        }
 
408
      }
 
409
      #print_testcases(@new_cases);
 
410
      @cases= @new_cases;
 
411
      #print_testcases(@cases);
 
412
    }
 
413
  }
 
414
 
 
415
  optimize_cases(\@cases);
 
416
  #print_testcases(@cases);
 
417
 
 
418
  return @cases;
 
419
}
 
420
 
 
421
 
 
422
#
 
423
# Loop through all test cases
 
424
# - optimize which test to run by skipping unnecessary ones
 
425
# - update settings if necessary
 
426
#
 
427
sub optimize_cases {
 
428
  my ($cases)= @_;
 
429
 
 
430
  foreach my $tinfo ( @$cases )
 
431
  {
 
432
    # Skip processing if already marked as skipped
 
433
    next if $tinfo->{skip};
 
434
 
 
435
    # Replication test needs an adjustment of binlog format
 
436
    if (mtr_match_prefix($tinfo->{'name'}, "rpl"))
 
437
    {
 
438
 
 
439
      # =======================================================
 
440
      # Get binlog-format used by this test from master_opt
 
441
      # =======================================================
 
442
      my $test_binlog_format;
 
443
      foreach my $opt ( @{$tinfo->{master_opt}} ) {
 
444
        $test_binlog_format= $test_binlog_format ||
 
445
          mtr_match_prefix($opt, "--binlog-format=");
 
446
      }
 
447
      # print $tinfo->{name}." uses ".$test_binlog_format."\n";
 
448
 
 
449
      # =======================================================
 
450
      # If a special binlog format was selected with
 
451
      # --mysqld=--binlog-format=x, skip all test with different
 
452
      # binlog-format
 
453
      # =======================================================
 
454
      if (defined $::used_binlog_format and
 
455
          $test_binlog_format and
 
456
          $::used_binlog_format ne $test_binlog_format)
 
457
      {
 
458
        $tinfo->{'skip'}= 1;
 
459
        $tinfo->{'comment'}= "Requires --binlog-format='$test_binlog_format'";
 
460
        next;
 
461
      }
 
462
 
 
463
      # =======================================================
 
464
      # Check that testcase supports the designated binlog-format
 
465
      # =======================================================
 
466
      if ($test_binlog_format and defined $tinfo->{'sup_binlog_formats'} )
 
467
      {
 
468
        my $supported=
 
469
          grep { $_ eq $test_binlog_format } @{$tinfo->{'sup_binlog_formats'}};
 
470
        if ( !$supported )
 
471
        {
 
472
          $tinfo->{'skip'}= 1;
 
473
          $tinfo->{'comment'}=
 
474
            "Doesn't support --binlog-format='$test_binlog_format'";
 
475
          next;
 
476
        }
 
477
      }
 
478
 
 
479
      # =======================================================
 
480
      # Use dynamic switching of binlog-format if mtr started
 
481
      # w/o --mysqld=--binlog-format=xxx and combinations.
 
482
      # =======================================================
 
483
      if (!defined $tinfo->{'combination'} and
 
484
          !defined $::used_binlog_format)
 
485
      {
 
486
        $test_binlog_format= $tinfo->{'sup_binlog_formats'}->[0];
 
487
      }
 
488
 
 
489
      # Save binlog format for dynamic switching
 
490
      $tinfo->{binlog_format}= $test_binlog_format;
 
491
    }
 
492
  }
 
493
}
 
494
 
 
495
 
 
496
##############################################################################
 
497
#
 
498
#  Collect information about a single test case
 
499
#
 
500
##############################################################################
 
501
 
 
502
 
 
503
sub collect_one_test_case($$$$$$$$$) {
 
504
  my $testdir= shift;
 
505
  my $resdir=  shift;
 
506
  my $suite=   shift;
 
507
  my $tname=   shift;
 
508
  my $elem=    shift;
 
509
  my $cases=   shift;
 
510
  my $disabled=shift;
 
511
  my $component_id= shift;
 
512
  my $suite_opts= shift;
 
513
 
 
514
  my $path= "$testdir/$elem";
 
515
 
 
516
  # ----------------------------------------------------------------------
 
517
  # Skip some tests silently
 
518
  # ----------------------------------------------------------------------
 
519
 
 
520
  if ( $::opt_start_from and $tname lt $::opt_start_from )
 
521
  {
 
522
    return;
 
523
  }
 
524
 
 
525
 
 
526
  my $tinfo= {};
 
527
  $tinfo->{'name'}= basename($suite) . ".$tname";
 
528
  if ( -f "$resdir/$::opt_engine/$tname.result")
 
529
  {
 
530
    $tinfo->{'result_file'}= "$resdir/$::opt_engine/$tname.result";
 
531
  }
 
532
  else
 
533
  {
 
534
    $tinfo->{'result_file'}= "$resdir/$tname.result";
 
535
  }
 
536
  $tinfo->{'component_id'} = $component_id;
 
537
  push(@$cases, $tinfo);
 
538
 
 
539
  # ----------------------------------------------------------------------
 
540
  # Skip some tests but include in list, just mark them to skip
 
541
  # ----------------------------------------------------------------------
 
542
 
 
543
  if ( $skip_test and $tname =~ /$skip_test/o )
 
544
  {
 
545
    $tinfo->{'skip'}= 1;
 
546
    return;
 
547
  }
 
548
 
 
549
  # ----------------------------------------------------------------------
 
550
  # Collect information about test case
 
551
  # ----------------------------------------------------------------------
 
552
 
 
553
  $tinfo->{'path'}= $path;
 
554
  $tinfo->{'timezone'}= "GMT-3"; # for UNIX_TIMESTAMP tests to work
 
555
 
 
556
  $tinfo->{'slave_num'}= 0; # Default, no slave
 
557
  $tinfo->{'master_num'}= 1; # Default, 1 master
 
558
  if ( defined mtr_match_prefix($tname,"rpl") )
 
559
  {
 
560
    if ( $::opt_skip_rpl )
 
561
    {
 
562
      $tinfo->{'skip'}= 1;
 
563
      $tinfo->{'comment'}= "No replication tests(--skip-rpl)";
 
564
      return;
 
565
    }
 
566
 
 
567
    $tinfo->{'slave_num'}= 1; # Default for rpl* tests, use one slave
 
568
 
 
569
  }
 
570
 
 
571
  if ( defined mtr_match_prefix($tname,"federated") )
 
572
  {
 
573
    # Default, federated uses the first slave as it's federated database
 
574
    $tinfo->{'slave_num'}= 1;
 
575
  }
 
576
 
 
577
  my $master_opt_file= "$testdir/$tname-master.opt";
 
578
  my $slave_opt_file=  "$testdir/$tname-slave.opt";
 
579
  my $slave_mi_file=   "$testdir/$tname.slave-mi";
 
580
  my $master_sh=       "$testdir/$tname-master.sh";
 
581
  my $slave_sh=        "$testdir/$tname-slave.sh";
 
582
  my $disabled_file=   "$testdir/$tname.disabled";
 
583
  my $im_opt_file=     "$testdir/$tname-im.opt";
 
584
 
 
585
  $tinfo->{'master_opt'}= [];
 
586
  $tinfo->{'slave_opt'}=  [];
 
587
  $tinfo->{'slave_mi'}=   [];
 
588
 
 
589
 
 
590
  # Add suite opts
 
591
  foreach my $opt ( @$suite_opts )
 
592
  {
 
593
    mtr_verbose($opt);
 
594
    push(@{$tinfo->{'master_opt'}}, $opt);
 
595
    push(@{$tinfo->{'slave_opt'}}, $opt);
 
596
  }
 
597
 
 
598
  # Add master opts
 
599
  if ( -f $master_opt_file )
 
600
  {
 
601
 
 
602
    my $master_opt= mtr_get_opts_from_file($master_opt_file);
 
603
 
 
604
    foreach my $opt ( @$master_opt )
 
605
    {
 
606
      my $value;
 
607
 
 
608
      # The opt file is used both to send special options to the mysqld
 
609
      # as well as pass special test case specific options to this
 
610
      # script
 
611
 
 
612
      $value= mtr_match_prefix($opt, "--timezone=");
 
613
      if ( defined $value )
 
614
      {
 
615
        $tinfo->{'timezone'}= $value;
 
616
        next;
 
617
      }
 
618
 
 
619
      $value= mtr_match_prefix($opt, "--slave-num=");
 
620
      if ( defined $value )
 
621
      {
 
622
        $tinfo->{'slave_num'}= $value;
 
623
        next;
 
624
      }
 
625
 
 
626
      $value= mtr_match_prefix($opt, "--result-file=");
 
627
      if ( defined $value )
 
628
      {
 
629
        # Specifies the file mysqltest should compare
 
630
        # output against
 
631
        if ( -f "r/$::opt_engine/$value.result")
 
632
        {
 
633
          $tinfo->{'result_file'}= "r/$::opt_engine/$value.result";
 
634
        }
 
635
        else
 
636
        {
 
637
          $tinfo->{'result_file'}= "r/$value.result";
 
638
        }
 
639
 
 
640
        next;
 
641
      }
 
642
 
 
643
      # If we set default time zone, remove the one we have
 
644
      $value= mtr_match_prefix($opt, "--default-time-zone=");
 
645
      if ( defined $value )
 
646
      {
 
647
        # Set timezone for this test case to something different
 
648
        $tinfo->{'timezone'}= "GMT-8";
 
649
        # Fallthrough, add the --default-time-zone option
 
650
      }
 
651
 
 
652
      # The --restart option forces a restart even if no special
 
653
      # option is set. If the options are the same as next testcase
 
654
      # there is no need to restart after the testcase
 
655
      # has completed
 
656
      if ( $opt eq "--force-restart" )
 
657
      {
 
658
        $tinfo->{'force_restart'}= 1;
 
659
        next;
 
660
      }
 
661
 
 
662
      # Ok, this was a real option, add it
 
663
      push(@{$tinfo->{'master_opt'}}, $opt);
 
664
    }
 
665
  }
 
666
 
 
667
  # Add slave opts
 
668
  if ( -f $slave_opt_file )
 
669
  {
 
670
    my $slave_opt= mtr_get_opts_from_file($slave_opt_file);
 
671
 
 
672
    foreach my $opt ( @$slave_opt )
 
673
    {
 
674
      # If we set default time zone, remove the one we have
 
675
      my $value= mtr_match_prefix($opt, "--default-time-zone=");
 
676
      $tinfo->{'slave_opt'}= [] if defined $value;
 
677
    }
 
678
    push(@{$tinfo->{'slave_opt'}}, @$slave_opt);
 
679
  }
 
680
 
 
681
  if ( -f $slave_mi_file )
 
682
  {
 
683
    $tinfo->{'slave_mi'}= mtr_get_opts_from_file($slave_mi_file);
 
684
  }
 
685
 
 
686
  if ( -f $master_sh )
 
687
  {
 
688
    if ( $::glob_win32_perl )
 
689
    {
 
690
      $tinfo->{'skip'}= 1;
 
691
      $tinfo->{'comment'}= "No tests with sh scripts on Windows";
 
692
      return;
 
693
    }
 
694
    else
 
695
    {
 
696
      $tinfo->{'master_sh'}= $master_sh;
 
697
    }
 
698
  }
 
699
 
 
700
  if ( -f $slave_sh )
 
701
  {
 
702
    if ( $::glob_win32_perl )
 
703
    {
 
704
      $tinfo->{'skip'}= 1;
 
705
      $tinfo->{'comment'}= "No tests with sh scripts on Windows";
 
706
      return;
 
707
    }
 
708
    else
 
709
    {
 
710
      $tinfo->{'slave_sh'}= $slave_sh;
 
711
    }
 
712
  }
 
713
 
 
714
  if ( -f $im_opt_file )
 
715
  {
 
716
    $tinfo->{'im_opts'} = mtr_get_opts_from_file($im_opt_file);
 
717
  }
 
718
  else
 
719
  {
 
720
    $tinfo->{'im_opts'} = [];
 
721
  }
 
722
 
 
723
  # FIXME why this late?
 
724
  my $marked_as_disabled= 0;
 
725
  if ( $disabled->{$tname} )
 
726
  {
 
727
    $marked_as_disabled= 1;
 
728
    $tinfo->{'comment'}= $disabled->{$tname};
 
729
  }
 
730
 
 
731
  if ( -f $disabled_file )
 
732
  {
 
733
    $marked_as_disabled= 1;
 
734
    $tinfo->{'comment'}= mtr_fromfile($disabled_file);
 
735
  }
 
736
 
 
737
  # If test was marked as disabled, either opt_enable_disabled is off and then
 
738
  # we skip this test, or it is on and then we run this test but warn
 
739
 
 
740
  if ( $marked_as_disabled )
 
741
  {
 
742
    if ( $::opt_enable_disabled )
 
743
    {
 
744
      $tinfo->{'dont_skip_though_disabled'}= 1;
 
745
    }
 
746
    else
 
747
    {
 
748
      $tinfo->{'skip'}= 1;
 
749
      $tinfo->{'disable'}= 1;   # Sub type of 'skip'
 
750
      return;
 
751
    }
 
752
  }
 
753
 
 
754
  if ( $component_id eq 'im' )
 
755
  {
 
756
    if ( $::glob_use_embedded_server )
 
757
    {
 
758
      $tinfo->{'skip'}= 1;
 
759
      $tinfo->{'comment'}= "No IM with embedded server";
 
760
      return;
 
761
    }
 
762
    elsif ( $::opt_ps_protocol )
 
763
    {
 
764
      $tinfo->{'skip'}= 1;
 
765
      $tinfo->{'comment'}= "No IM with --ps-protocol";
 
766
      return;
 
767
    }
 
768
    elsif ( $::opt_skip_im )
 
769
    {
 
770
      $tinfo->{'skip'}= 1;
 
771
      $tinfo->{'comment'}= "No IM tests(--skip-im)";
 
772
      return;
 
773
    }
 
774
  }
 
775
  else
 
776
  {
 
777
    mtr_options_from_test_file($tinfo,"$testdir/${tname}.test");
 
778
 
 
779
    if ( defined $::used_default_engine )
 
780
    {
 
781
      # Different default engine is used
 
782
      # tag test to require that engine
 
783
      $tinfo->{'ndb_test'}= 1
 
784
        if ( $::used_default_engine =~ /^ndb/i );
 
785
 
 
786
      $tinfo->{'innodb_test'}= 1
 
787
        if ( $::used_default_engine =~ /^innodb/i );
 
788
    }
 
789
 
 
790
    if ( $tinfo->{'ndb_extra'} and ! $::opt_ndb_extra_test )
 
791
    {
 
792
      $tinfo->{'skip'}= 1;
 
793
      $tinfo->{'comment'}= "Test need 'ndb_extra' option";
 
794
      return;
 
795
    }
 
796
 
 
797
    if ( $tinfo->{'require_manager'} )
 
798
    {
 
799
      $tinfo->{'skip'}= 1;
 
800
      $tinfo->{'comment'}= "Test need the _old_ manager(to be removed)";
 
801
      return;
 
802
    }
 
803
 
 
804
    if ( $tinfo->{'need_debug'} && ! $::debug_compiled_binaries )
 
805
    {
 
806
      $tinfo->{'skip'}= 1;
 
807
      $tinfo->{'comment'}= "Test need debug binaries";
 
808
      return;
 
809
    }
 
810
  }
 
811
}
 
812
 
 
813
 
 
814
# List of tags in the .test files that if found should set
 
815
# the specified value in "tinfo"
 
816
our @tags=
 
817
(
 
818
 ["include/have_innodb.inc", "innodb_test", 1],
 
819
 ["include/have_binlog_format_row.inc", "sup_binlog_formats", ["row"]],
 
820
 ["include/have_log_bin.inc", "need_binlog", 1],
 
821
 ["include/have_binlog_format_statement.inc",
 
822
  "sup_binlog_formats", ["statement"]],
 
823
 ["include/have_binlog_format_mixed.inc", "sup_binlog_formats", ["mixed"]],
 
824
 ["include/have_binlog_format_mixed_or_row.inc",
 
825
  "sup_binlog_formats", ["mixed","row"]],
 
826
 ["include/have_binlog_format_mixed_or_statement.inc",
 
827
  "sup_binlog_formats", ["mixed","statement"]],
 
828
 ["include/have_binlog_format_row_or_statement.inc",
 
829
  "sup_binlog_formats", ["row","statement"]],
 
830
 ["include/have_debug.inc", "need_debug", 1],
 
831
 ["require_manager", "require_manager", 1],
 
832
);
 
833
 
 
834
sub mtr_options_from_test_file($$) {
 
835
  my $tinfo= shift;
 
836
  my $file= shift;
 
837
  #mtr_verbose("$file");
 
838
  my $F= IO::File->new($file) or mtr_error("can't open file \"$file\": $!");
 
839
 
 
840
  while ( my $line= <$F> )
 
841
  {
 
842
 
 
843
    # Skip line if it start's with #
 
844
    next if ( $line =~ /^#/ );
 
845
 
 
846
    # Match this line against tag in "tags" array
 
847
    foreach my $tag (@tags)
 
848
    {
 
849
      if ( index($line, $tag->[0]) >= 0 )
 
850
      {
 
851
          # Tag matched, assign value to "tinfo"
 
852
        $tinfo->{"$tag->[1]"}= $tag->[2];
 
853
      }
 
854
    }
 
855
 
 
856
    # If test sources another file, open it as well
 
857
    if ( $line =~ /^\-\-([[:space:]]*)source(.*)$/ or
 
858
         $line =~ /^([[:space:]]*)source(.*);$/ )
 
859
    {
 
860
      my $value= $2;
 
861
      $value =~ s/^\s+//;  # Remove leading space
 
862
      $value =~ s/[[:space:]]+$//;  # Remove ending space
 
863
 
 
864
      my $sourced_file= "$::glob_mysql_test_dir/$value";
 
865
      if ( -f $sourced_file )
 
866
      {
 
867
        # Only source the file if it exists, we may get
 
868
        # false positives in the regexes above if someone
 
869
        # writes "source nnnn;" in a test case(such as mysqltest.test)
 
870
        mtr_options_from_test_file($tinfo, $sourced_file);
 
871
      }
 
872
    }
 
873
  }
 
874
}
 
875
 
 
876
 
 
877
sub print_testcases {
 
878
  my (@cases)= @_;
 
879
 
 
880
  print "=" x 60, "\n";
 
881
  foreach my $test (@cases){
 
882
    print "[", $test->{name}, "]", "\n";
 
883
    while ((my ($key, $value)) = each(%$test)) {
 
884
      print " ", $key, "=";
 
885
      if (ref $value eq "ARRAY") {
 
886
        print join(", ", @$value);
 
887
      } else {
 
888
        print $value;
 
889
      }
 
890
      print "\n";
 
891
    }
 
892
    print "\n";
 
893
  }
 
894
  print "=" x 60, "\n";
 
895
}
 
896
 
 
897
 
 
898
1;