From 8ec8da0491ad89604700b3e29a227966f6d84ba1 Mon Sep 17 00:00:00 2001
From: Perl Tidy <perltidy@bugzilla.org>
Date: Wed, 5 Dec 2018 15:38:52 -0500
Subject: no bug - reformat all the code using the new perltidy rules

---
 xt/lib/Bugzilla/Test/Search/FieldTest.pm | 806 ++++++++++++++++---------------
 1 file changed, 413 insertions(+), 393 deletions(-)

(limited to 'xt/lib/Bugzilla/Test/Search/FieldTest.pm')

diff --git a/xt/lib/Bugzilla/Test/Search/FieldTest.pm b/xt/lib/Bugzilla/Test/Search/FieldTest.pm
index 832c578cc..fc7b107c3 100644
--- a/xt/lib/Bugzilla/Test/Search/FieldTest.pm
+++ b/xt/lib/Bugzilla/Test/Search/FieldTest.pm
@@ -40,10 +40,12 @@ use Test::Exception;
 ###############
 
 sub new {
-    my ($class, $operator_test, $field, $test) = @_;
-    return bless { operator_test => $operator_test,
-                   field_object => $field,
-                   raw_test     => $test }, $class;
+  my ($class, $operator_test, $field, $test) = @_;
+  return bless {
+    operator_test => $operator_test,
+    field_object  => $field,
+    raw_test      => $test
+  }, $class;
 }
 
 #############
@@ -54,144 +56,156 @@ sub num_tests { return TESTS_PER_RUN }
 
 # The Bugzilla::Test::Search::OperatorTest that this is a child of.
 sub operator_test { return $_[0]->{operator_test} }
+
 # The Bugzilla::Field being tested.
 sub field_object { return $_[0]->{field_object} }
+
 # The name of the field being tested, which we need much more often
 # than we need the object.
 sub field {
-    my ($self) = @_;
-    $self->{field_name} ||= $self->field_object->name;
-    return $self->{field_name};
+  my ($self) = @_;
+  $self->{field_name} ||= $self->field_object->name;
+  return $self->{field_name};
 }
+
 # The Bugzilla::Test::Search object that this is a child of.
 sub search_test { return $_[0]->operator_test->search_test }
+
 # The operator being tested
 sub operator { return $_[0]->operator_test->operator }
+
 # The bugs currently being tested by Bugzilla::Test::Search.
 sub bugs { return $_[0]->search_test->bugs }
+
 sub bug {
-    my $self = shift;
-    return $self->search_test->bug(@_);
+  my $self = shift;
+  return $self->search_test->bug(@_);
 }
+
 sub number {
-    my ($self, $id) = @_;
-    foreach my $number (1..NUM_BUGS) {
-        return $number if $self->search_test->bug($number)->id == $id;
-    }
-    return 0;
+  my ($self, $id) = @_;
+  foreach my $number (1 .. NUM_BUGS) {
+    return $number if $self->search_test->bug($number)->id == $id;
+  }
+  return 0;
 }
 
 # The name displayed for this test by Test::More. Used in test descriptions.
 sub name {
-    my ($self) = @_;
-    my $field = $self->field;
-    my $operator = $self->operator;
-    my $value = $self->main_value;
+  my ($self)   = @_;
+  my $field    = $self->field;
+  my $operator = $self->operator;
+  my $value    = $self->main_value;
 
-    my $name = "$field-$operator-$value";
-    if (my $extra_name = $self->test->{extra_name}) {
-        $name .= "-$extra_name";
-    }
-    return $name;
+  my $name = "$field-$operator-$value";
+  if (my $extra_name = $self->test->{extra_name}) {
+    $name .= "-$extra_name";
+  }
+  return $name;
 }
 
 # The appropriate value from the TESTS constant for this test, taking
 # into account overrides.
 sub test {
-    my $self = shift;
-    return $self->{test} if $self->{test};
+  my $self = shift;
+  return $self->{test} if $self->{test};
 
-    my %test = %{ $self->{raw_test} };
+  my %test = %{$self->{raw_test}};
 
-    # We have field name overrides...
-    my $override = $test{override}->{$self->field};
-    # And also field type overrides.
-    if (!$override) {
-        $override = $test{override}->{$self->field_object->type} || {};
-    }
+  # We have field name overrides...
+  my $override = $test{override}->{$self->field};
 
-    foreach my $key (%$override) {
-        $test{$key} = $override->{$key};
-    }
+  # And also field type overrides.
+  if (!$override) {
+    $override = $test{override}->{$self->field_object->type} || {};
+  }
 
-    $self->{test} = \%test;
-    return $self->{test};
+  foreach my $key (%$override) {
+    $test{$key} = $override->{$key};
+  }
+
+  $self->{test} = \%test;
+  return $self->{test};
 }
 
 # All the values for all the bugs for this field.
 sub _field_values {
-    my ($self) = @_;
-    return $self->{field_values} if $self->{field_values};
+  my ($self) = @_;
+  return $self->{field_values} if $self->{field_values};
 
-    my %field_values;
-    foreach my $number (1..NUM_BUGS) {
-        $field_values{$number} = $self->_field_values_for_bug($number);
-    }
-    $self->{field_values} = \%field_values;
-    return $self->{field_values};
+  my %field_values;
+  foreach my $number (1 .. NUM_BUGS) {
+    $field_values{$number} = $self->_field_values_for_bug($number);
+  }
+  $self->{field_values} = \%field_values;
+  return $self->{field_values};
 }
+
 # The values for this field for the numbered bug.
 sub bug_values {
-    my ($self, $number) = @_;
-    return @{ $self->_field_values->{$number} };
+  my ($self, $number) = @_;
+  return @{$self->_field_values->{$number}};
 }
 
 # The untranslated, non-overriden value--used in the name of the test
 # and other places.
 sub main_value { return $_[0]->{raw_test}->{value} }
+
 # The untranslated test value, taking into account overrides.
-sub test_value { return $_[0]->test->{value} };
+sub test_value { return $_[0]->test->{value} }
+
 # The value translated appropriately for passing to Bugzilla::Search.
 sub translated_value {
-    my $self = shift;
-    if (!exists $self->{translated_value}) {
-        my $value = $self->search_test->value_translation_cache($self);
-        if (!defined $value) {
-            $value = $self->_translate_value();
-            $self->search_test->value_translation_cache($self, $value);
-        }
-        $self->{translated_value} = $value;
+  my $self = shift;
+  if (!exists $self->{translated_value}) {
+    my $value = $self->search_test->value_translation_cache($self);
+    if (!defined $value) {
+      $value = $self->_translate_value();
+      $self->search_test->value_translation_cache($self, $value);
     }
-    return $self->{translated_value};
+    $self->{translated_value} = $value;
+  }
+  return $self->{translated_value};
 }
+
 # Used in failure diagnostic messages.
 sub debug_fail {
-    my ($self, $number, $results, $sql) = @_;
-    my @expected = @{ $self->test->{contains} };
-    my @results = sort
-                  map { $self->number($_) }
-                  map { $_->[0] }
-                  @$results;
-    return
-        "   Value: '" . $self->translated_value . "'\n" .
-        "Expected: [" . join(',', @expected) . "]\n" .
-        " Results: [" . join(',', @results) . "]\n" .
-        trim($sql) . "\n";
+  my ($self, $number, $results, $sql) = @_;
+  my @expected = @{$self->test->{contains}};
+  my @results = sort map { $self->number($_) } map { $_->[0] } @$results;
+  return
+      "   Value: '"
+    . $self->translated_value . "'\n"
+    . "Expected: ["
+    . join(',', @expected) . "]\n"
+    . " Results: ["
+    . join(',', @results) . "]\n"
+    . trim($sql) . "\n";
 }
 
 # True for a bug if we ran the "transform" function on it and the
 # result was equal to its first value.
 sub transformed_value_was_equal {
-    my ($self, $number, $value) = @_;
-    if (@_ > 2) {
-        $self->{transformed_value_was_equal}->{$number} = $value;
-        $self->search_test->was_equal_cache($self, $number, $value);
-    }
-    my $cached = $self->search_test->was_equal_cache($self, $number);
-    return $cached if defined $cached;
-    return $self->{transformed_value_was_equal}->{$number};
+  my ($self, $number, $value) = @_;
+  if (@_ > 2) {
+    $self->{transformed_value_was_equal}->{$number} = $value;
+    $self->search_test->was_equal_cache($self, $number, $value);
+  }
+  my $cached = $self->search_test->was_equal_cache($self, $number);
+  return $cached if defined $cached;
+  return $self->{transformed_value_was_equal}->{$number};
 }
 
 # True if this test is supposed to contain the numbered bug.
 sub bug_is_contained {
-    my ($self, $number) = @_;
-    my $contains = $self->test->{contains};
-    if ($self->transformed_value_was_equal($number)
-        and !$self->test->{override}->{$self->field}->{contains})
-    {
-        $contains = $self->test->{if_equal}->{contains};
-    }
-    return grep($_ == $number, @$contains) ? 1 : 0;
+  my ($self, $number) = @_;
+  my $contains = $self->test->{contains};
+  if ($self->transformed_value_was_equal($number)
+    and !$self->test->{override}->{$self->field}->{contains})
+  {
+    $contains = $self->test->{if_equal}->{contains};
+  }
+  return grep($_ == $number, @$contains) ? 1 : 0;
 }
 
 ###################################################
@@ -200,112 +214,114 @@ sub bug_is_contained {
 
 # The tests we know are broken for this operator/field combination.
 sub _known_broken {
-    my ($self, $constant, $skip_pg_check) = @_;
-
-    $constant ||= KNOWN_BROKEN;
-    my $field = $self->field;
-    my $type = $self->field_object->type;
-    my $operator = $self->operator;
-    my $value = $self->main_value;
-    my $value_name = "$operator-$value";
-    if (my $extra_name = $self->test->{extra_name}) {
-        $value_name .= "-$extra_name";
-    }
-
-    my $value_broken = $constant->{$value_name}->{$field};
-    $value_broken ||= $constant->{$value_name}->{$type};
-    return $value_broken if $value_broken;
-    my $operator_broken = $constant->{$operator}->{$field};
-    $operator_broken ||= $constant->{$operator}->{$type};
-    return $operator_broken if $operator_broken;
-    return {};
+  my ($self, $constant, $skip_pg_check) = @_;
+
+  $constant ||= KNOWN_BROKEN;
+  my $field      = $self->field;
+  my $type       = $self->field_object->type;
+  my $operator   = $self->operator;
+  my $value      = $self->main_value;
+  my $value_name = "$operator-$value";
+  if (my $extra_name = $self->test->{extra_name}) {
+    $value_name .= "-$extra_name";
+  }
+
+  my $value_broken = $constant->{$value_name}->{$field};
+  $value_broken ||= $constant->{$value_name}->{$type};
+  return $value_broken if $value_broken;
+  my $operator_broken = $constant->{$operator}->{$field};
+  $operator_broken ||= $constant->{$operator}->{$type};
+  return $operator_broken if $operator_broken;
+  return {};
 }
 
 # True if the "contains" search for the numbered bug is broken.
 # That is, either the result is supposed to contain it and doesn't,
 # or the result is not supposed to contain it and does.
 sub contains_known_broken {
-    my ($self, $number) = @_;
-    my $field = $self->field;
-    my $operator = $self->operator;
+  my ($self, $number) = @_;
+  my $field    = $self->field;
+  my $operator = $self->operator;
 
-    my $contains_broken = $self->_known_broken->{contains} || [];
-    if (grep($_ == $number, @$contains_broken)) {
-        return "$field $operator contains $number is known to be broken";
-    }
-    return undef;
+  my $contains_broken = $self->_known_broken->{contains} || [];
+  if (grep($_ == $number, @$contains_broken)) {
+    return "$field $operator contains $number is known to be broken";
+  }
+  return undef;
 }
 
 # Used by subclasses. Checks both bug_is_contained and contains_known_broken
 # to tell you whether or not the bug will *actually* be found by the test.
 sub will_actually_contain_bug {
-    my ($self, $number) = @_;
-    my $is_contained = $self->bug_is_contained($number) ? 1 : 0;
-    my $is_broken = $self->contains_known_broken($number) ? 1 : 0;
+  my ($self, $number) = @_;
+  my $is_contained = $self->bug_is_contained($number)      ? 1 : 0;
+  my $is_broken    = $self->contains_known_broken($number) ? 1 : 0;
 
-    # If the test is supposed to contain the bug and *isn't* broken,
-    # then the test will contain the bug.
-    return 1 if ($is_contained and !$is_broken);
-    # If this test is *not* supposed to contain the bug, but that test is
-    # broken, then this test *will* contain the bug.
-    return 1 if (!$is_contained and $is_broken);
+  # If the test is supposed to contain the bug and *isn't* broken,
+  # then the test will contain the bug.
+  return 1 if ($is_contained and !$is_broken);
 
-    return 0;
+  # If this test is *not* supposed to contain the bug, but that test is
+  # broken, then this test *will* contain the bug.
+  return 1 if (!$is_contained and $is_broken);
+
+  return 0;
 }
 
 # Returns a string if creating a Bugzilla::Search object throws an error,
 # with this field/operator/value combination.
 sub search_known_broken {
-    my ($self) = @_;
-    my $field = $self->field;
-    my $operator = $self->operator;
-    if ($self->_known_broken->{search}) {
-        return "Bugzilla::Search for $field $operator is known to be broken";
-    }
-    return undef;
+  my ($self)   = @_;
+  my $field    = $self->field;
+  my $operator = $self->operator;
+  if ($self->_known_broken->{search}) {
+    return "Bugzilla::Search for $field $operator is known to be broken";
+  }
+  return undef;
 }
 
 # Returns a string if we haven't yet implemented the tests for this field,
 # but we plan to in the future.
 sub field_not_yet_implemented {
-    my ($self) = @_;
-    my $skip_this_field = grep { $_ eq $self->field } SKIP_FIELDS;
-    if ($skip_this_field) {
-        my $field = $self->field;
-        return "$field testing not yet implemented";
-    }
-    return undef;
+  my ($self) = @_;
+  my $skip_this_field = grep { $_ eq $self->field } SKIP_FIELDS;
+  if ($skip_this_field) {
+    my $field = $self->field;
+    return "$field testing not yet implemented";
+  }
+  return undef;
 }
 
 # Returns a message if this field/operator combination can't ever be run.
 # At no time in the future will this field/operator combination ever work.
 sub invalid_field_operator_combination {
-    my ($self) = @_;
-    my $field = $self->field;
-    my $operator = $self->operator;
+  my ($self)   = @_;
+  my $field    = $self->field;
+  my $operator = $self->operator;
 
-    if ($field eq 'content' && $operator !~ /matches/) {
-        return "content field does not support $operator";
-    }
-    elsif ($operator =~ /matches/ && $field ne 'content') {
-        return "matches operator does not support fields other than content";
-    }
-    return undef;
+  if ($field eq 'content' && $operator !~ /matches/) {
+    return "content field does not support $operator";
+  }
+  elsif ($operator =~ /matches/ && $field ne 'content') {
+    return "matches operator does not support fields other than content";
+  }
+  return undef;
 }
 
 # True if this field is broken in an OR combination.
 sub join_broken {
-    my ($self, $or_broken_map) = @_;
-    my $or_broken = $or_broken_map->{$self->field . '-' . $self->operator};
-    if (!$or_broken) {
-        # See if this is a comment field, and in that case, if there's
-        # a generic entry for all comment fields.
-        my $is_comment_field = COMMENT_FIELDS->{$self->field};
-        if ($is_comment_field) {
-            $or_broken = $or_broken_map->{'longdescs.-' . $self->operator};
-        }
+  my ($self, $or_broken_map) = @_;
+  my $or_broken = $or_broken_map->{$self->field . '-' . $self->operator};
+  if (!$or_broken) {
+
+    # See if this is a comment field, and in that case, if there's
+    # a generic entry for all comment fields.
+    my $is_comment_field = COMMENT_FIELDS->{$self->field};
+    if ($is_comment_field) {
+      $or_broken = $or_broken_map->{'longdescs.-' . $self->operator};
     }
-    return $or_broken;
+  }
+  return $or_broken;
 }
 
 #########################################
@@ -314,28 +330,28 @@ sub join_broken {
 
 # The data that will get passed to Bugzilla::Search as its arguments.
 sub search_params {
-    my ($self) = @_;
-    return $self->{search_params} if $self->{search_params};
+  my ($self) = @_;
+  return $self->{search_params} if $self->{search_params};
 
-    my %params = (
-        "field0-0-0" => $self->field,
-        "type0-0-0"  => $self->operator,
-        "value0-0-0"  => $self->translated_value,
-    );
+  my %params = (
+    "field0-0-0" => $self->field,
+    "type0-0-0"  => $self->operator,
+    "value0-0-0" => $self->translated_value,
+  );
 
-    $self->{search_params} = \%params;
-    return $self->{search_params};
+  $self->{search_params} = \%params;
+  return $self->{search_params};
 }
 
 sub search_columns {
-    my ($self) = @_;
-    my $field = $self->field;
-    my @search_fields = qw(bug_id);
-    if ($self->field_object->buglist) {
-        my $col_name = COLUMN_TRANSLATION->{$field} || $field;
-        push(@search_fields, $col_name);
-    }
-    return \@search_fields;
+  my ($self)        = @_;
+  my $field         = $self->field;
+  my @search_fields = qw(bug_id);
+  if ($self->field_object->buglist) {
+    my $col_name = COLUMN_TRANSLATION->{$field} || $field;
+    push(@search_fields, $col_name);
+  }
+  return \@search_fields;
 }
 
 
@@ -344,103 +360,107 @@ sub search_columns {
 ################
 
 sub _field_values_for_bug {
-    my ($self, $number) = @_;
-    my $field = $self->field;
-
-    my @values;
-
-    if ($field =~ /^attach.+\.(.+)$/ ) {
-        my $attach_field = $1;
-        $attach_field = ATTACHMENT_FIELDS->{$attach_field} || $attach_field;
-        @values = $self->_values_for($number, 'attachments', $attach_field);
-    }
-    elsif (my $flag_field = FLAG_FIELDS->{$field}) {
-        @values = $self->_values_for($number, 'flags', $flag_field);
-    }
-    elsif (my $translation = COMMENT_FIELDS->{$field}) {
-        @values = $self->_values_for($number, 'comments', $translation);
-        # We want the last value to come first, so that single-value
-        # searches use the last comment.
-        @values = reverse @values;
-    }
-    elsif ($field eq 'longdescs.count') {
-        @values = scalar(@{ $self->bug($number)->comments });
-    }
-    elsif ($field eq 'work_time') {
-        @values = $self->_values_for($number, 'actual_time');
-    }
-    elsif ($field eq 'bug_group') {
-        @values = $self->_values_for($number, 'groups_in', 'name');
-    }
-    elsif ($field eq 'keywords') {
-        @values = $self->_values_for($number, 'keyword_objects', 'name');
-    }
-    elsif ($field eq 'content') {
-        @values = $self->_values_for($number, 'short_desc');
-    }
-    elsif ($field eq 'see_also') {
-        @values = $self->_values_for($number, 'see_also', 'name');
-    }
-    elsif ($field eq 'tag') {
-        @values = $self->_values_for($number, 'tags');
-    }
-    # Bugzilla::Bug truncates creation_ts, but we need the full value
-    # from the database. This has no special value for changedfrom,
-    # because it never changes.
-    elsif ($field eq 'creation_ts') {
-        my $bug = $self->bug($number);
-        my $creation_ts = Bugzilla->dbh->selectrow_array(
-            'SELECT creation_ts FROM bugs WHERE bug_id = ?',
-            undef, $bug->id);
-        @values = ($creation_ts);
-    }
-    else {
-        @values = $self->_values_for($number, $field);
-    }
-
-    # We convert user objects to their login name, here, all in one
-    # block for simplicity.
-    if (grep { $_ eq $field } USER_FIELDS) {
-        # requestees.login_name is empty for most bugs (but checking
-        # blessed(undef) handles that.
-        # Values that come from %original_values aren't User objects.
-        @values = map { blessed($_) ? $_->login : $_ } @values;
-        @values = grep { defined $_ } @values;
-    }
-
-    return \@values;
+  my ($self, $number) = @_;
+  my $field = $self->field;
+
+  my @values;
+
+  if ($field =~ /^attach.+\.(.+)$/) {
+    my $attach_field = $1;
+    $attach_field = ATTACHMENT_FIELDS->{$attach_field} || $attach_field;
+    @values = $self->_values_for($number, 'attachments', $attach_field);
+  }
+  elsif (my $flag_field = FLAG_FIELDS->{$field}) {
+    @values = $self->_values_for($number, 'flags', $flag_field);
+  }
+  elsif (my $translation = COMMENT_FIELDS->{$field}) {
+    @values = $self->_values_for($number, 'comments', $translation);
+
+    # We want the last value to come first, so that single-value
+    # searches use the last comment.
+    @values = reverse @values;
+  }
+  elsif ($field eq 'longdescs.count') {
+    @values = scalar(@{$self->bug($number)->comments});
+  }
+  elsif ($field eq 'work_time') {
+    @values = $self->_values_for($number, 'actual_time');
+  }
+  elsif ($field eq 'bug_group') {
+    @values = $self->_values_for($number, 'groups_in', 'name');
+  }
+  elsif ($field eq 'keywords') {
+    @values = $self->_values_for($number, 'keyword_objects', 'name');
+  }
+  elsif ($field eq 'content') {
+    @values = $self->_values_for($number, 'short_desc');
+  }
+  elsif ($field eq 'see_also') {
+    @values = $self->_values_for($number, 'see_also', 'name');
+  }
+  elsif ($field eq 'tag') {
+    @values = $self->_values_for($number, 'tags');
+  }
+
+  # Bugzilla::Bug truncates creation_ts, but we need the full value
+  # from the database. This has no special value for changedfrom,
+  # because it never changes.
+  elsif ($field eq 'creation_ts') {
+    my $bug = $self->bug($number);
+    my $creation_ts
+      = Bugzilla->dbh->selectrow_array(
+      'SELECT creation_ts FROM bugs WHERE bug_id = ?',
+      undef, $bug->id);
+    @values = ($creation_ts);
+  }
+  else {
+    @values = $self->_values_for($number, $field);
+  }
+
+  # We convert user objects to their login name, here, all in one
+  # block for simplicity.
+  if (grep { $_ eq $field } USER_FIELDS) {
+
+    # requestees.login_name is empty for most bugs (but checking
+    # blessed(undef) handles that.
+    # Values that come from %original_values aren't User objects.
+    @values = map { blessed($_) ? $_->login : $_ } @values;
+    @values = grep { defined $_ } @values;
+  }
+
+  return \@values;
 }
 
 sub _values_for {
-    my ($self, $number, $bug_field, $item_field) = @_;
+  my ($self, $number, $bug_field, $item_field) = @_;
 
-    my $item;
-    if ($self->operator eq 'changedfrom') {
-        $item = $self->search_test->bug_create_value($number, $bug_field);
-    }
-    else {
-        my $bug = $self->bug($number);
-        $item = $bug->$bug_field;
-    }
+  my $item;
+  if ($self->operator eq 'changedfrom') {
+    $item = $self->search_test->bug_create_value($number, $bug_field);
+  }
+  else {
+    my $bug = $self->bug($number);
+    $item = $bug->$bug_field;
+  }
 
-    if ($item_field) {
-        if ($bug_field eq 'flags' and $item_field eq 'name') {
-            return (map { $_->name . $_->status } @$item);
-        }
-        return (map { $self->_get_item($_, $item_field) } @$item);
+  if ($item_field) {
+    if ($bug_field eq 'flags' and $item_field eq 'name') {
+      return (map { $_->name . $_->status } @$item);
     }
+    return (map { $self->_get_item($_, $item_field) } @$item);
+  }
 
-    return @$item if ref($item) eq 'ARRAY';
-    return $item if defined $item;
-    return ();
+  return @$item if ref($item) eq 'ARRAY';
+  return $item  if defined $item;
+  return ();
 }
 
 sub _get_item {
-    my ($self, $from, $field) = @_;
-    if (blessed($from)) {
-        return $from->$field;
-    }
-    return $from->{$field};
+  my ($self, $from, $field) = @_;
+  if (blessed($from)) {
+    return $from->$field;
+  }
+  return $from->{$field};
 }
 
 #####################
@@ -453,83 +473,85 @@ sub _get_item {
 # and then we insert it as required into the "value" from TESTS. (For example,
 # <1> becomes the value for the field from bug 1.)
 sub _translate_value {
-    my $self = shift;
-    my $value = $self->test_value;
-    foreach my $number (1..NUM_BUGS) {
-        $value = $self->_translate_value_for_bug($number, $value);
-    }
-    # Sanity check to make sure that none of the <> stuff was left in.
-    if ($value =~ /<\d/) {
-        die $self->name . ": value untranslated: $value\n";
-    }
-    return $value;
+  my $self  = shift;
+  my $value = $self->test_value;
+  foreach my $number (1 .. NUM_BUGS) {
+    $value = $self->_translate_value_for_bug($number, $value);
+  }
+
+  # Sanity check to make sure that none of the <> stuff was left in.
+  if ($value =~ /<\d/) {
+    die $self->name . ": value untranslated: $value\n";
+  }
+  return $value;
 }
 
 sub _translate_value_for_bug {
-    my ($self, $number, $value) = @_;
-
-    my $bug = $self->bug($number);
-
-    my $bug_id = $bug->id;
-    $value =~ s/<$number-id>/$bug_id/g;
-    my $bug_delta = $bug->delta_ts;
-    $value =~ s/<$number-delta>/$bug_delta/g;
-    my $reporter = $bug->reporter->login;
-    $value =~ s/<$number-reporter>/$reporter/g;
-    if ($value =~ /<$number-bug_group>/) {
-        my @bug_groups = map { $_->name } @{ $bug->groups_in };
-        @bug_groups = grep { $_ =~ /^\d+-group-/ } @bug_groups;
-        my $group = $bug_groups[0];
-        $value =~ s/<$number-bug_group>/$group/g;
-    }
-
-    my @bug_values = $self->bug_values($number);
-    return $value if !@bug_values;
-
-    if ($self->operator =~ /substr/) {
-        @bug_values = map { $self->_substr_value($_) } @bug_values;
-    }
-
-    my $string_value = $bug_values[0];
-    if ($self->operator =~ /word/) {
-        $string_value = join(' ', @bug_values);
-    }
-    if (my $func = $self->test->{transform}) {
-        my $transformed = $func->(@bug_values);
-        my $is_equal = $transformed eq $bug_values[0] ? 1 : 0;
-        $self->transformed_value_was_equal($number, $is_equal);
-        $string_value = $transformed;
-    }
-
-    if ($self->test->{escape}) {
-        $string_value = quotemeta($string_value);
-    }
-    $value =~ s/<$number>/$string_value/g;
-
-    return $value;
+  my ($self, $number, $value) = @_;
+
+  my $bug = $self->bug($number);
+
+  my $bug_id = $bug->id;
+  $value =~ s/<$number-id>/$bug_id/g;
+  my $bug_delta = $bug->delta_ts;
+  $value =~ s/<$number-delta>/$bug_delta/g;
+  my $reporter = $bug->reporter->login;
+  $value =~ s/<$number-reporter>/$reporter/g;
+  if ($value =~ /<$number-bug_group>/) {
+    my @bug_groups = map { $_->name } @{$bug->groups_in};
+    @bug_groups = grep { $_ =~ /^\d+-group-/ } @bug_groups;
+    my $group = $bug_groups[0];
+    $value =~ s/<$number-bug_group>/$group/g;
+  }
+
+  my @bug_values = $self->bug_values($number);
+  return $value if !@bug_values;
+
+  if ($self->operator =~ /substr/) {
+    @bug_values = map { $self->_substr_value($_) } @bug_values;
+  }
+
+  my $string_value = $bug_values[0];
+  if ($self->operator =~ /word/) {
+    $string_value = join(' ', @bug_values);
+  }
+  if (my $func = $self->test->{transform}) {
+    my $transformed = $func->(@bug_values);
+    my $is_equal = $transformed eq $bug_values[0] ? 1 : 0;
+    $self->transformed_value_was_equal($number, $is_equal);
+    $string_value = $transformed;
+  }
+
+  if ($self->test->{escape}) {
+    $string_value = quotemeta($string_value);
+  }
+  $value =~ s/<$number>/$string_value/g;
+
+  return $value;
 }
 
 sub _substr_value {
-    my ($self, $value) = @_;
-    my $field = $self->field;
-    my $type  = $self->field_object->type;
-    my $substr_size = SUBSTR_SIZE;
-    if (exists FIELD_SUBSTR_SIZE->{$field}) {
-        $substr_size = FIELD_SUBSTR_SIZE->{$field};
-    }
-    elsif (exists FIELD_SUBSTR_SIZE->{$type}) {
-        $substr_size = FIELD_SUBSTR_SIZE->{$type};
-    }
-    if ($substr_size > 0) {
-        # The field name is included in every field value, and if it's
-        # long, it might take up the whole substring, and we don't want that.
-        if (!grep { $_ eq $field or $_ eq $type } SUBSTR_NO_FIELD_ADD) {
-            $substr_size += length($field);
-        }
-        my $string = substr($value, 0, $substr_size);
-        return $string;
-    }
-    return substr($value, $substr_size);
+  my ($self, $value) = @_;
+  my $field       = $self->field;
+  my $type        = $self->field_object->type;
+  my $substr_size = SUBSTR_SIZE;
+  if (exists FIELD_SUBSTR_SIZE->{$field}) {
+    $substr_size = FIELD_SUBSTR_SIZE->{$field};
+  }
+  elsif (exists FIELD_SUBSTR_SIZE->{$type}) {
+    $substr_size = FIELD_SUBSTR_SIZE->{$type};
+  }
+  if ($substr_size > 0) {
+
+    # The field name is included in every field value, and if it's
+    # long, it might take up the whole substring, and we don't want that.
+    if (!grep { $_ eq $field or $_ eq $type } SUBSTR_NO_FIELD_ADD) {
+      $substr_size += length($field);
+    }
+    my $string = substr($value, 0, $substr_size);
+    return $string;
+  }
+  return substr($value, $substr_size);
 }
 
 #####################
@@ -537,95 +559,93 @@ sub _substr_value {
 #####################
 
 sub run {
-    my ($self) = @_;
+  my ($self) = @_;
 
-    my $invalid_combination = $self->invalid_field_operator_combination;
-    my $field_not_implemented = $self->field_not_yet_implemented;
+  my $invalid_combination   = $self->invalid_field_operator_combination;
+  my $field_not_implemented = $self->field_not_yet_implemented;
 
-    SKIP: {
-        skip($invalid_combination, $self->num_tests) if $invalid_combination;
-        TODO: {
-            todo_skip ($field_not_implemented, $self->num_tests) if $field_not_implemented;
-            $self->do_tests();
-        }
+SKIP: {
+    skip($invalid_combination, $self->num_tests) if $invalid_combination;
+  TODO: {
+      todo_skip($field_not_implemented, $self->num_tests) if $field_not_implemented;
+      $self->do_tests();
     }
+  }
 }
 
 sub do_tests {
-    my ($self) = @_;
-    my $name = $self->name;
+  my ($self) = @_;
+  my $name = $self->name;
 
-    my $search_broken = $self->search_known_broken;
+  my $search_broken = $self->search_known_broken;
 
-    my $search = $self->_test_search_object_creation();
+  my $search = $self->_test_search_object_creation();
 
-    my $sql;
-    TODO: {
-        local $TODO = $search_broken if $search_broken;
-        lives_ok { $sql = $search->_sql } "$name: generate SQL";
-    }
+  my $sql;
+TODO: {
+    local $TODO = $search_broken if $search_broken;
+    lives_ok { $sql = $search->_sql } "$name: generate SQL";
+  }
 
-    my $results;
-    SKIP: {
-        skip "Can't run SQL without any SQL", 1 if !defined $sql;
-        $results = $self->_test_sql($search);
-    }
+  my $results;
+SKIP: {
+    skip "Can't run SQL without any SQL", 1 if !defined $sql;
+    $results = $self->_test_sql($search);
+  }
 
-    $self->_test_content($results, $sql);
+  $self->_test_content($results, $sql);
 }
 
 sub _test_search_object_creation {
-    my ($self) = @_;
-    my $name = $self->name;
-    my @args = (fields => $self->search_columns, params => $self->search_params);
-    my $search;
-    lives_ok { $search = new Bugzilla::Search(@args) }
-             "$name: create search object";
-    return $search;
+  my ($self) = @_;
+  my $name = $self->name;
+  my @args = (fields => $self->search_columns, params => $self->search_params);
+  my $search;
+  lives_ok { $search = new Bugzilla::Search(@args) }
+  "$name: create search object";
+  return $search;
 }
 
 sub _test_sql {
-    my ($self, $search) = @_;
-    my $name = $self->name;
-    my $results;
-    lives_ok { $results = $search->data } "$name: Run SQL Query"
-        or diag($search->_sql);
-    return $results;
+  my ($self, $search) = @_;
+  my $name = $self->name;
+  my $results;
+  lives_ok { $results = $search->data } "$name: Run SQL Query"
+    or diag($search->_sql);
+  return $results;
 }
 
 sub _test_content {
-    my ($self, $results, $sql) = @_;
+  my ($self, $results, $sql) = @_;
 
-    SKIP: {
-        skip "Without results we can't test them", NUM_BUGS if !$results;
-        foreach my $number (1..NUM_BUGS) {
-            $self->_test_content_for_bug($number, $results, $sql);
-        }
+SKIP: {
+    skip "Without results we can't test them", NUM_BUGS if !$results;
+    foreach my $number (1 .. NUM_BUGS) {
+      $self->_test_content_for_bug($number, $results, $sql);
     }
+  }
 }
 
 sub _test_content_for_bug {
-    my ($self, $number, $results, $sql) = @_;
-    my $name = $self->name;
-
-    my $contains_known_broken = $self->contains_known_broken($number);
-
-    my %result_ids = map { $_->[0] => 1 } @$results;
-    my $bug_id = $self->bug($number)->id;
-
-    TODO: {
-        local $TODO = $contains_known_broken if $contains_known_broken;
-        if ($self->bug_is_contained($number)) {
-            ok($result_ids{$bug_id},
-               "$name: contains bug $number ($bug_id)")
-                or diag $self->debug_fail($number, $results, $sql);
-        }
-        else {
-            ok(!$result_ids{$bug_id},
-               "$name: does not contain bug $number ($bug_id)")
-                or diag $self->debug_fail($number, $results, $sql);
-        }
+  my ($self, $number, $results, $sql) = @_;
+  my $name = $self->name;
+
+  my $contains_known_broken = $self->contains_known_broken($number);
+
+  my %result_ids = map { $_->[0] => 1 } @$results;
+  my $bug_id = $self->bug($number)->id;
+
+TODO: {
+    local $TODO = $contains_known_broken if $contains_known_broken;
+    if ($self->bug_is_contained($number)) {
+      ok($result_ids{$bug_id}, "$name: contains bug $number ($bug_id)")
+        or diag $self->debug_fail($number, $results, $sql);
+    }
+    else {
+      ok(!$result_ids{$bug_id}, "$name: does not contain bug $number ($bug_id)")
+        or diag $self->debug_fail($number, $results, $sql);
     }
+  }
 }
 
 1;
-- 
cgit v1.2.3-24-g4f1b