WL#3949 Test should set binlog format dnamically

- Reorganize collect a little to make it easier to apply optimizations
  and settings to collected test cases.
- Add suite/rpl/combination file
- Rename include/set_binlog_format_x.inc to .sql since thay are run by "mysql"
 

mysql-test/lib/My/Config.pm

+# -*- cperl -*-
+
+package My::Config::Option;
+
+use strict;
+use warnings;
+
+
+sub new {
+  my ($class, $option_name, $option_value)= @_;
+  my $self= bless { name => $option_name,
+		    value => $option_value
+		  }, $class;
+  return $self;
+}
+
+
+sub name {
+  my ($self)= @_;
+  return $self->{name};
+}
+
+
+sub value {
+  my ($self)= @_;
+  return $self->{value};
+}
+
+
+package My::Config::Group;
+
+use strict;
+use warnings;
+
+
+sub new {
+  my ($class, $group_name)= @_;
+  my $self= bless { name => $group_name,
+		    options => [],
+		    options_by_name => {},
+		  }, $class;
+  return $self;
+}
+
+
+sub insert {
+  my ($self, $option_name, $value, $if_not_exist)= @_;
+  my $option= $self->option($option_name);
+  if (defined($option) and !$if_not_exist) {
+    $option->{value}= $value;
+  }
+  else {
+    my $option= My::Config::Option->new($option_name, $value);
+    # Insert option in list
+    push(@{$self->{options}}, $option);
+    # Insert option in hash
+    $self->{options_by_name}->{$option_name}= $option;
+  }
+  return $option;
+}
+
+sub remove {
+  my ($self, $option_name)= @_;
+
+  # Check that option exists
+  my $option= $self->option($option_name);
+
+  return undef unless defined $option;
+
+  # Remove from the hash
+  delete($self->{options_by_name}->{$option_name}) or die;
+
+  # Remove from the array
+  @{$self->{options}}= grep { $_->name ne $option_name } @{$self->{options}};
+
+  return $option;
+}
+
+
+sub options {
+  my ($self)= @_;
+  return @{$self->{options}};
+}
+
+
+sub name {
+  my ($self)= @_;
+  return $self->{name};
+}
+
+
+#
+# Return a specific option in the group
+#
+sub option {
+  my ($self, $option_name)= @_;
+
+  return $self->{options_by_name}->{$option_name};
+}
+
+
+#
+# Return a specific value for an option in the group
+#
+sub value {
+  my ($self, $option_name)= @_;
+  my $option= $self->option($option_name);
+
+  die "No option named '$option_name' in this group"
+    if ! defined($option);
+
+  return $option->value();
+}
+
+
+package My::Config;
+
+use strict;
+use warnings;
+use IO::File;
+use File::Basename;
+
+#
+# Constructor for My::Config
+# - represents a my.cnf config file
+#
+# Array of arrays
+#
+sub new {
+  my ($class, $path)= @_;
+  my $group_name= undef;
+
+  my $self= bless { groups => [] }, $class;
+  my $F= IO::File->new($path, "<")
+    or die "Could not open '$path': $!";
+
+  while (  my $line= <$F> ) {
+    chomp($line);
+
+    # [group]
+    if ( $line =~ /\[(.*)\]/ ) {
+      # New group found
+      $group_name= $1;
+      #print "group: $group_name\n";
+
+      $self->insert($group_name, undef, undef);
+    }
+
+    # Magic #! comments
+    elsif ( $line =~ /^#\!/) {
+      my $magic= $line;
+      die "Found magic comment '$magic' outside of group"
+	unless $group_name;
+
+      #print "$magic\n";
+      $self->insert($group_name, $magic, undef);
+    }
+
+    # Comments
+    elsif ( $line =~ /^#/ || $line =~ /^;/) {
+      # Skip comment
+      next;
+    }
+
+    # Empty lines
+    elsif ( $line =~ /^$/ ) {
+      # Skip empty lines
+      next;
+    }
+
+    # !include <filename>
+    elsif ( $line =~ /^\!include\s*(.*?)\s*$/ ) {
+      my $include_file_name= dirname($path)."/".$1;
+      # Check that the file exists
+      die "The include file '$include_file_name' does not exist"
+	unless -f $include_file_name;
+
+      $self->append(My::Config->new($include_file_name));
+    }
+
+    # <option>
+    elsif ( $line =~ /^([\@\w-]+)\s*$/ ) {
+      my $option= $1;
+
+      die "Found option '$option' outside of group"
+	unless $group_name;
+
+      #print "$option\n";
+      $self->insert($group_name, $option, undef);
+    }
+
+    # <option>=<value>
+    elsif ( $line =~ /^([\@\w-]+)\s*=\s*(.*?)\s*$/ ) {
+      my $option= $1;
+      my $value= $2;
+
+      die "Found option '$option=$value' outside of group"
+	unless $group_name;
+
+      #print "$option=$value\n";
+      $self->insert($group_name, $option, $value);
+    } else {
+      die "Unexpected line '$line' found in '$path'";
+    }
+
+  }
+  undef $F;			# Close the file
+
+  return $self;
+}
+
+#
+# Insert a new group if it does not already exist
+# and add option if defined
+#
+sub insert {
+  my ($self, $group_name, $option, $value, $if_not_exist)= @_;
+  my $group;
+
+  # Create empty array for the group if it doesn't exist
+  if ( !$self->group_exists($group_name) ) {
+    $group= $self->_group_insert($group_name);
+  }
+  else {
+    $group= $self->group($group_name);
+  }
+
+  if ( defined $option ) {
+    #print "option: $option, value: $value\n";
+
+    # Add the option to the group
+    $group->insert($option, $value, $if_not_exist);
+  }
+}
+
+#
+# Remove a option, given group and option name
+#
+sub remove {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  $group->remove($option_name) or
+    die "option '$option_name' does not exist";
+}
+
+
+
+#
+# Check if group with given name exists in config
+#
+sub group_exists {
+  my ($self, $group_name)= @_;
+
+  foreach my $group ($self->groups()) {
+    return 1 if $group->{name} eq $group_name;
+  }
+  return 0;
+}
+
+
+#
+# Insert a new group into config
+#
+sub _group_insert {
+  my ($self, $group_name)= @_;
+  caller eq __PACKAGE__ or die;
+
+  # Check that group does not already exist
+  die "Group already exists" if $self->group_exists($group_name);
+
+  my $group= My::Config::Group->new($group_name);
+  push(@{$self->{groups}}, $group);
+  return $group;
+}
+
+
+#
+# Append a configuration to current config
+#
+sub append {
+  my ($self, $from)= @_;
+
+  foreach my $group ($from->groups()) {
+    foreach my $option ($group->options()) {
+      $self->insert($group->name(), $option->name(), $option->value());
+    }
+
+  }
+}
+
+
+#
+# Return a list with all the groups in config
+#
+sub groups {
+  my ($self)= @_;
+  return ( @{$self->{groups}} );
+}
+
+
+#
+# Return a list of all the groups in config
+# starting with the given string
+#
+sub like {
+  my ($self, $prefix)= @_;
+  return ( grep ( $_->{name} =~ /^$prefix/, $self->groups()) );
+}
+
+
+#
+# Return the first group in config
+# starting with the given string
+#
+sub first_like {
+  my ($self, $prefix)= @_;
+  return ($self->like($prefix))[0];
+}
+
+
+#
+# Return a specific group in the config
+#
+sub group {
+  my ($self, $group_name)= @_;
+
+  foreach my $group ( $self->groups() ) {
+    return $group if $group->{name} eq $group_name;
+  }
+  return undef;
+}
+
+
+#
+# Return a list of all options in a specific group in the config
+#
+sub options_in_group {
+  my ($self, $group_name)= @_;
+
+  my $group= $self->group($group_name);
+  return () unless defined $group;
+  return $group->options();
+}
+
+
+#
+# Return a value given group and option name
+#
+sub value {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  my $option= $group->option($option_name);
+  die "option '$option_name' does not exist"
+    unless defined($option);
+
+  return $option->value();
+}
+
+
+#
+# Check if an option exists
+#
+sub exists {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  my $option= $group->option($option_name);
+  return defined($option);
+}
+
+
+# Overload "to string"-operator with 'stringify'
+use overload
+    '""' => \&stringify;
+
+#
+# Return the config as a string in my.cnf file format
+#
+sub stringify {
+  my ($self)= @_;
+  my $res;
+
+  foreach my $group ($self->groups()) {
+    $res .= "[$group->{name}]\n";
+
+    foreach my $option ($group->options()) {
+      $res .= $option->name();
+      my $value= $option->value();
+      if (defined $value) {
+	$res .= "=$value";
+      }
+      $res .= "\n";
+    }
+    $res .= "\n";
+  }
+  return $res;
+}
+
+
+#
+# Save the config to named file
+#
+sub save {
+    my ($self, $path)= @_;
+    my $F= IO::File->new($path, ">")
+	or die "Could not open '$path': $!";
+    print $F $self;
+    undef $F; # Close the file
+}
+
+1;

mysql-test/lib/mtr_cases.pl

@@ -22,8 +22,11 @@ use File::Basename;
 use IO::File();
 use strict;
 
+use lib "lib/";
+use My::Config;
+
 sub collect_test_cases ($);
-sub collect_one_suite ($$);
+sub collect_one_suite ($);
 sub collect_one_test_case ($$$$$$$$$);
 
 sub mtr_options_from_test_file($$);
@@ -63,7 +66,7 @@ sub collect_test_cases ($) {
 
   foreach my $suite (split(",", $suites))
   {
-    collect_one_suite($suite, $cases);
+    push(@$cases, collect_one_suite($suite));
   }
 
 
@@ -207,16 +210,13 @@ sub split_testname {
 }
 
 
-sub collect_one_suite($$)
+sub collect_one_suite($)
 {
   my $suite= shift;  # Test suite name
-  my $cases= shift;  # List of test cases
+  my @cases;  # Array of hash
 
   mtr_verbose("Collecting: $suite");
 
-  my $combination_file=  "combinations";
-  my $combinations = [];
-
   my $suitedir= "$::glob_mysql_test_dir"; # Default
   if ( $suite ne "main" )
   {
@@ -224,36 +224,10 @@ sub collect_one_suite($$)
 			       "$suitedir/$suite");
     mtr_verbose("suitedir: $suitedir");
   }
-  my $combination_file= "$suitedir/$combination_file";
 
   my $testdir= "$suitedir/t";
   my $resdir=  "$suitedir/r";
 
-  if (!defined $::opt_record and !defined $::opt_skip_combination)
-  {
-    if (!@::opt_combination) 
-    {
-      # Read combinations file
-      if ( open(COMB,$combination_file) )
-      {
-        while (<COMB>)
-        {
-          chomp;
-          s/\ +/ /g;
-          push (@$combinations, $_) unless ($_ eq '');
-        }
-        close COMB;
-      }
-    }
-    else
-    {
-      # take the combination from command-line
-      @$combinations = @::opt_combination;
-    }
-  }
-  # Remember last element position
-  my $begin_index = $#{@$cases} + 1;
-
   # ----------------------------------------------------------------------
   # Build a hash of disabled testcases for this suite
   # ----------------------------------------------------------------------
@@ -328,7 +302,7 @@ sub collect_one_suite($$)
       }
 
       collect_one_test_case($testdir,$resdir,$suite,$tname,
-                            "$tname.$extension",$cases,\%disabled,
+                            "$tname.$extension",\@cases,\%disabled,
 			    $component_id,$suite_opts);
     }
   }
@@ -358,97 +332,154 @@ sub collect_one_suite($$)
       next if ($do_test and not $tname =~ /$do_test/o);
 
       collect_one_test_case($testdir,$resdir,$suite,$tname,
-                            $elem,$cases,\%disabled,$component_id,
+                            $elem,\@cases,\%disabled,$component_id,
 			    $suite_opts);
     }
     closedir TESTDIR;
   }
 
+
+  #  Return empty list if no testcases found
+  return if (@cases == 0);
+
   # ----------------------------------------------------------------------
-  # Proccess combinations only if new tests were added
+  # Read combinations for this suite and build testcases x combinations
+  # if any combinations exists
   # ----------------------------------------------------------------------
-  if ($combinations && $begin_index <= $#{@$cases}) 
+  if ( ! $::opt_skip_combination )
   {
-    my $prepared = {};
-    my $end_index = $#{@$cases};
-    my $is_copy;
-    # Keep original master/slave options
-    my @orig_opts;
-    for (my $idx = $begin_index; $idx <= $end_index; $idx++) 
+    my @combinations;
+    my $combination_file= "$suitedir/combinations";
+    print "combination_file: $combination_file\n";
+    if (@::opt_combinations)
     {
-      foreach my $param (('master_opt','slave_opt','slave_mi')) 
-      {
-        @{$orig_opts[$idx]{$param}} = @{$cases->[$idx]->{$param}};        
+      # take the combination from command-line
+      mtr_verbose("Take the combination from command line");
+      foreach my $combination (@::opt_combinations) {
+	my $comb= {};
+	$comb->{name}= $combination;
+	push(@{$comb->{comb_opt}}, $combination);
+	push(@combinations, $comb);
       }
     }
-    my $comb_index = 1;
-    # Copy original test cases 
-    foreach my $comb_set (@$combinations)
+    elsif (-f $combination_file )
     {
-      for (my $idx = $begin_index; $idx <= $end_index; $idx++) 
+      # Read combinations file in my.cnf format
+      mtr_verbose("Read combinations file");
+      my $config= My::Config->new($combination_file);
+
+      foreach my $group ($config->groups()) {
+	my $comb= {};
+	$comb->{name}= $group->name();
+        foreach my $option ( $group->options() ) {
+	  push(@{$comb->{comb_opt}}, $option->name()."=".$option->value());
+	}
+	push(@combinations, $comb);
+      }
+    }
+
+    if (@combinations)
     {
-        my $test = $cases->[$idx];
-        my $copied_test = {};
-        foreach my $param (keys %{$test}) 
+      print " - adding combinations\n";
+      #print_testcases(@cases);
+
+      my @new_cases;
+      foreach my $comb (@combinations)
       {
-          # Scalar. Copy as is.
-          $copied_test->{$param} = $test->{$param};
-          # Array. Copy reference instead itself
-          if ($param =~ /(master_opt|slave_opt|slave_mi)/) 
+	foreach my $test (@cases)
 	{
-            my $new_arr = [];
-            @$new_arr = @{$orig_opts[$idx]{$param}};
-            $copied_test->{$param} = $new_arr;
+	  #print $test->{name}, " ", $comb, "\n";
+	  my $new_test= {};
+
+	  while (my ($key, $value) = each(%$test)) {
+	    if (ref $value eq "ARRAY") {
+	      push(@{$new_test->{$key}}, @$value);
+	    } else {
+	      $new_test->{$key}= $value;
 	    }
-          elsif ($param =~ /combinations/) 
-          {
-            $copied_test->{$param} = '';
 	  }
+
+	  # Append the combination options to master_opt and slave_opt
+	  push(@{$new_test->{master_opt}}, @{$comb->{comb_opt}});
+	  push(@{$new_test->{slave_opt}}, @{$comb->{comb_opt}});
+
+	  # Add combination name shrt name
+	  $new_test->{combination}= $comb->{name};
+
+	  # Add the new test to new test cases list
+	  push(@new_cases, $new_test);
 	}
-        if ($is_copy) 
-        {
-          push(@$cases, $copied_test);
-          $test = $cases->[$#{@$cases}];
       }
-        foreach my $comb_opt (split(/ /,$comb_set)) 
-        {
-          push(@{$test->{'master_opt'}},$comb_opt);
-          push(@{$test->{'slave_opt'}},$comb_opt);
-          # Enable rpl if added option is --binlog-format and test case supports that
-          if ($comb_opt =~ /^--binlog-format=.+$/) 
-          {
-            my @opt_pairs = split(/=/, $comb_opt);
-            if (defined $::used_binlog_format) 
-            {
-              if ($test->{'binlog_format'} ne $::used_binlog_format) 
-              {
-                $test->{'skip'} = 1;
-                $test->{'comment'} = "Requiring binlog format ".join(' or ', @{$test->{'sup_binlog_formats'}});
+      #print_testcases(@new_cases);
+      @cases= @new_cases;
+      #print_testcases(@cases);
     }
   }
-            else
+
+  optimize_cases(\@cases);
+  #print_testcases(@cases);
+
+  return @cases;
+}
+
+
+#
+# Loop through all test cases
+# - optimize which test to run by skipping unnecessary ones
+# - update settings if necessary
+#
+sub optimize_cases {
+  my ($cases)= @_;
+
+  foreach my $tinfo ( @$cases )
   {
-              foreach my $binlog_format (@{$test->{'sup_binlog_formats'}}) 
+    # Replication test needs an adjustment of binlog format
+    if (mtr_match_prefix($tinfo->{'name'}, "rpl"))
     {
-                $test->{'binlog_format'}= $binlog_format if ($binlog_format eq $opt_pairs[1]);
+
+      # =======================================================
+      # Get binlog-format used by this test from master_opt
+      # =======================================================
+      my $test_binlog_format;
+      foreach my $opt ( @{$tinfo->{master_opt}} ) {
+	$test_binlog_format= $test_binlog_format ||
+	  mtr_match_prefix($opt, "--binlog-format=");
       }
-              if (defined $prepared->{$test->{'name'}.'|'.$test->{'binlog_format'}} and $test->{'skip'} ne 1 )
+      # print $tinfo->{name}." uses ".$test_binlog_format."\n";
+
+      # =======================================================
+      # If a special binlog format was selected with
+      # --mysqld=--binlog-format=x, skip all test with different
+      # binlog-format
+      # =======================================================
+      if (defined $::used_binlog_format and
+	  $::used_binlog_format ne $test_binlog_format)
       {
-                $test->{'skip'} = 1;
-                $test->{'comment'} = "Test for binlog format '$test->{'binlog_format'}' already executed";
-              }
-            }
+	$tinfo->{'skip'}= 1;
+	$tinfo->{'comment'}= "Requires --binlog-format='$test_binlog_format'";
+	next;
       }
+
+      # =======================================================
+      # Check that testcase supports the designated binlog-format
+      # =======================================================
+      if ($test_binlog_format and defined $tinfo->{'sup_binlog_formats'} )
+      {
+	my $supported=
+	  grep { $_ eq $test_binlog_format } @{$tinfo->{'sup_binlog_formats'}};
+	if ( !$supported )
+	{
+	  $tinfo->{'skip'}= 1;
+	  $tinfo->{'comment'}=
+	    "Doesn't support --binlog-format='$test_binlog_format'";
+	  next;
 	}
-        $prepared->{$test->{'name'}.'|'.$test->{'binlog_format'}}= 1;
-        $test->{'combination'} = $comb_set;
       }
-      $is_copy = 1;
-      $comb_index++;
+
+      # Save binlog format for dynamic switching
+      $tinfo->{binlog_format}= $test_binlog_format;
     }
   }
-
-  return $cases;
 }
 
 
@@ -752,43 +783,6 @@ sub collect_one_test_case($$$$$$$$$) {
       return;
     }
 
-    # Replication test needs an adjustment of binlog format
-    if ($tinfo->{'name'} =~ /^rpl/) 
-    {
-      # Set default binlog format priority
-      if ($tinfo->{'name'} =~ /^rpl/ and !defined $tinfo->{'sup_binlog_formats'}) 
-      {
-        if ($::mysql_version_id >= 50100) 
-        {          
-          $tinfo->{'sup_binlog_formats'} = ["mixed", "row", "statement"];          
-        }
-        else
-        {
-          $tinfo->{'sup_binlog_formats'} = ["statement", "row"];
-        }
-      }
-      # Check that a test supports binlog format defined via --binlog-format
-      if (defined $::used_binlog_format)
-      {
-        # Try to find a supported binlog formats
-        foreach my $binlog_format (@{$tinfo->{'sup_binlog_formats'}}) 
-        {
-           $tinfo->{'binlog_format'}= $binlog_format unless ($binlog_format ne $::used_binlog_format);
-        }
-        # Skip a test because 
-        if (!defined $tinfo->{'binlog_format'}) 
-        {
-          $tinfo->{'skip'}= 1;
-          $tinfo->{'comment'}= "Requiring binlog format ".join(' or ', @{$tinfo->{'sup_binlog_formats'}});
-          return;
-        }
-      }
-      else
-      {
-        $tinfo->{'binlog_format'}= $tinfo->{'sup_binlog_formats'}->[0];
-      }
-    }
- 
     if ( $tinfo->{'need_debug'} && ! $::debug_compiled_binaries )
     {
       $tinfo->{'skip'}= 1;
@@ -870,11 +864,15 @@ our @tags=
  ["include/have_innodb.inc", "innodb_test", 1],
  ["include/have_binlog_format_row.inc", "sup_binlog_formats", ["row"]],
  ["include/have_log_bin.inc", "need_binlog", 1],
- ["include/have_binlog_format_statement.inc", "sup_binlog_formats", ["statement"]],
+ ["include/have_binlog_format_statement.inc",
+  "sup_binlog_formats", ["statement"]],
  ["include/have_binlog_format_mixed.inc", "sup_binlog_formats", ["mixed"]],
- ["include/have_binlog_format_mixed_or_row.inc", "sup_binlog_formats", ["mixed","row"]],
- ["include/have_binlog_format_mixed_or_statement.inc", "sup_binlog_formats", ["mixed","statement"]],
- ["include/have_binlog_format_row_or_statement.inc", "sup_binlog_formats", ["row","statement"]],
+ ["include/have_binlog_format_mixed_or_row.inc",
+  "sup_binlog_formats", ["mixed","row"]],
+ ["include/have_binlog_format_mixed_or_statement.inc",
+  "sup_binlog_formats", ["mixed","statement"]],
+ ["include/have_binlog_format_row_or_statement.inc",
+  "sup_binlog_formats", ["row","statement"]],
  ["include/big_test.inc", "big_test", 1],
  ["include/have_debug.inc", "need_debug", 1],
  ["include/have_ndb.inc", "ndb_test", 1],
@@ -922,8 +920,29 @@ sub mtr_options_from_test_file($$) {
 	mtr_options_from_test_file($tinfo, $sourced_file);
       }
     }
+  }
+}
 
+
+sub print_testcases {
+  my (@cases)= @_;
+
+  print "=" x 60, "\n";
+  foreach my $test (@cases){
+    print "[", $test->{name}, "]", "\n";
+    while ((my ($key, $value)) = each(%$test)) {
+      print " ", $key, "=";
+      if (ref $value eq "ARRAY") {
+	print join(", ", @$value);
+      } else {
+	print $value;
+      }
+      print "\n";
     }
+    print "\n";
+  }
+  print "=" x 60, "\n";
 }
 
+
 1;

mysql-test/lib/mtr_report.pl

@@ -50,9 +50,13 @@ my $tot_real_time= 0;
 
 sub mtr_report_test_name ($) {
   my $tinfo= shift;
+  my $tname= $tinfo->{name};
 
-  _mtr_log("$tinfo->{name}");
-  printf "%-30s ", $tinfo->{'name'};
+  $tname.= " '$tinfo->{combination}'"
+    if defined $tinfo->{combination};
+
+  _mtr_log($tname);
+  printf "%-30s ", $tname;
 }
 
 sub mtr_report_test_skipped ($) {

mysql-test/mysql-test-run.pl

@@ -164,7 +164,7 @@ our $opt_bench= 0;
 our $opt_small_bench= 0;
 our $opt_big_test= 0;
 
-our @opt_combination;
+our @opt_combinations;
 our $opt_skip_combination;
 
 our @opt_extra_mysqld_opt;
@@ -532,7 +532,7 @@ sub command_line_setup () {
              'skip-im'                  => \$opt_skip_im,
              'skip-test=s'              => \$opt_skip_test,
              'big-test'                 => \$opt_big_test,
-             'combination=s'            => \@opt_combination,
+             'combination=s'            => \@opt_combinations,
              'skip-combination'         => \$opt_skip_combination,
 
              # Specify ports
@@ -928,6 +928,10 @@ sub command_line_setup () {
     mtr_error("Will not run in record mode without a specific test case");
   }
 
+  if ( $opt_record )
+  {
+    $opt_skip_combination = 1;
+  }
 
   # --------------------------------------------------------------------------
   # ps protcol flag
@@ -3330,23 +3334,25 @@ sub do_before_run_mysqltest($)
       # if script decided to run mysqltest cluster _is_ installed ok
       $ENV{'NDB_STATUS_OK'} = "YES";
     }
-    if (defined $tinfo->{"binlog_format"} and  $mysql_version_id > 50100 ) 
-    {
-      foreach my $server ((@$master,@$slave)) 
+    if (defined $tinfo->{binlog_format} and  $mysql_version_id > 50100 )
     {
-        if ($server->{'pid'})
+      # Dynamically switch binlog format of
+      # master, slave is always restarted
+      foreach my $server ( @$master )
       {
+        next unless ($server->{'pid'});
 
 	mtr_init_args(\$args);
-
 	mtr_add_arg($args, "--no-defaults");
-  
 	mtr_add_arg($args, "--user=root");
 	mtr_add_arg($args, "--port=$server->{'port'}");
 	mtr_add_arg($args, "--socket=$server->{'path_sock'}");
 
-          mtr_run($exe_mysql, $args, "include/set_binlog_format_".$tinfo->{"binlog_format"}.".inc", "", "", "");
-
+	my $sql= "include/set_binlog_format_".$tinfo->{binlog_format}.".sql";
+	mtr_verbose("Setting binlog format:", $tinfo->{binlog_format});
+	if (mtr_run($exe_mysql, $args, $sql, "", "", "") != 0)
+	{
+	  mtr_error("Failed to switch binlog format");
 	}
       }
     }

mysql-test/suite/rpl/combinations

+[row]
+--binlog-format=row
+
+[stmt]
+--binlog-format=statement
+
+[mix]
+--binlog-format=mixed