catch known-broken tests as it's supposed to.
r=mkanat, a=mkanat (module owner)
return $self->{value_translation_cache}->{$test_name};
}
+# When doing AND/OR tests, the value for transformed_value_was_equal
+# (see Bugzilla::Test::Search::FieldTest) won't be recalculated
+# if we pull our values from the value_translation_cache. So we need
+# to also cache the values for transformed_value_was_equal.
+sub was_equal_cache {
+ my ($self, $field_test, $number, $value) = @_;
+ return if !$self->option('long');
+ my $test_name = $field_test->name;
+ if (@_ == 4) {
+ $self->{tvwe_cache}->{$test_name}->{$number} = $value;
+ }
+ return $self->{tvwe_cache}->{$test_name}->{$number};
+}
+
#############
# Main Test #
#############
return all { $_->bug_is_contained($number) } $self->field_tests;
}
-########################
-# SKIP & TODO Messages #
-########################
-
-sub _join_skip { () }
-sub _join_broken_constant { {} }
+sub _bug_will_actually_be_contained {
+ my ($self, $number) = @_;
+ return all { $_->will_actually_contain_bug($number) } $self->field_tests;
+}
##############################
# Bugzilla::Search arguments #
return \%params;
}
-1;
\ No newline at end of file
+1;
KNOWN_BROKEN
NUM_BUGS
NUM_SEARCH_TESTS
- OR_BROKEN
SKIP_FIELDS
SPECIAL_PARAM_TESTS
SUBSTR_NO_FIELD_ADD
CHANGED_VALUE_BROKEN,
# All fields should have a way to search for "changing
# from a blank value" probably.
- blocked => { contains => [3,4,5] },
- dependson => { contains => [2,4,5] },
+ blocked => { contains => [3,4,5], no_criteria => 1 },
+ dependson => { contains => [2,4,5], no_criteria => 1 },
work_time => { contains => [1] },
- FIELD_TYPE_BUG_ID, { contains => [5] },
+ FIELD_TYPE_BUG_ID, { contains => [5], no_criteria => 1 },
},
# changeto doesn't find remaining_time changes (possibly due to us not
# tracking that data properly).
{ value => '/*STAR_COMMENT_TEST' }
);
-# This overrides KNOWN_BROKEN for OR configurations.
-# It indicates that these combinations are broken in some way that they
-# aren't broken when alone, because they don't return what they logically
-# should when put into an OR.
-use constant OR_BROKEN => {
- # Multi-value fields search on individual values, so "equals" OR "notequals"
- # returns nothing, when it should instead logically return everything.
- 'blocked-equals' => {
- 'blocked-notequals' => { contains => [1,2,3,4,5] },
- },
- 'dependson-equals' => {
- 'dependson-notequals' => { contains => [1,2,3,4,5] },
- },
- 'bug_group-equals' => {
- 'bug_group-notequals' => { contains => [1,2,3,4,5] },
- },
- 'cc-equals' => {
- 'cc-notequals' => { contains => [1,2,3,4,5] },
- },
- 'commenter-equals' => {
- 'commenter-notequals' => { contains => [1,2,3,4,5] },
- 'longdesc-notequals' => { contains => [2,3,4,5] },
- 'longdescs.isprivate-notequals' => { contains => [2,3,4,5] },
- 'work_time-notequals' => { contains => [2,3,4,5] },
- },
- 'commenter-notequals' => {
- 'commenter-equals' => { contains => [1,2,3,4,5] },
- 'longdesc-equals' => { contains => [1] },
- 'longdescs.isprivate-equals' => { contains => [1] },
- 'work_time-equals' => { contains => [1] },
- },
-};
-
#################
# Special Tests #
#################
sub field_object { die "unimplemented" }
sub main_value { die "unimplenmented" }
sub test_value { die "unimplemented" }
+# Custom tests don't use transforms.
+sub transformed_value_was_equal { 0 }
sub debug_value {
my ($self) = @_;
my $string = '';
# result was equal to its first value.
sub transformed_value_was_equal {
my ($self, $number, $value) = @_;
- if (defined $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};
}
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;
+
+ # 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);
+
+ return 0;
+}
+
# Returns a string if creating a Bugzilla::Search object throws an error,
# with this field/operator/value combination.
sub search_known_broken {
use base qw(Bugzilla::Test::Search::FieldTest);
use Bugzilla::Test::Search::Constants;
-use List::MoreUtils qw(any uniq);
+use List::MoreUtils qw(all any uniq);
use constant type => 'OR';
# SKIP & TODO Messages #
########################
-sub _join_skip { () }
-sub _join_broken_constant { OR_BROKEN }
-
sub field_not_yet_implemented {
my ($self) = @_;
- foreach my $test ($self->field_tests) {
- if (grep { $_ eq $test->field } $self->_join_skip) {
- return $test->field . " is not yet supported in OR tests";
- }
- }
return $self->_join_messages('field_not_yet_implemented');
}
sub invalid_field_operator_combination {
sub _bug_will_actually_be_contained {
my ($self, $number) = @_;
- my @results;
+
foreach my $test ($self->field_tests) {
- if ($test->bug_is_contained($number)
- and !$test->contains_known_broken($number))
- {
- return 1;
- }
- elsif (!$test->bug_is_contained($number)
- and $test->contains_known_broken($number)) {
- return 1;
- }
+ # Some tests are broken in such a way that they actually
+ # generate no criteria in the SQL. In this case, the only way
+ # the test contains the bug is if *another* test contains it.
+ next if $test->_known_broken->{no_criteria};
+ return 1 if $test->will_actually_contain_bug($number);
}
return 0;
}
sub contains_known_broken {
my ($self, $number) = @_;
- my $join_broken = $self->_join_known_broken;
- if (my $contains = $join_broken->{contains}) {
- my $contains_is_broken = grep { $_ == $number } @$contains;
- if ($contains_is_broken) {
- my $name = $self->name;
- return "$name contains $number is broken";
- }
- return undef;
- }
-
- return $self->_join_contains_known_broken($number);
-}
-
-sub _join_contains_known_broken {
- my ($self, $number) = @_;
-
if ( ( $self->bug_is_contained($number)
and !$self->_bug_will_actually_be_contained($number) )
or ( !$self->bug_is_contained($number)
and $self->_bug_will_actually_be_contained($number) ) )
{
- my @messages = map { $_->contains_known_broken($number) } $self->field_tests;
+ my @messages = map { $_->contains_known_broken($number) }
+ $self->field_tests;
@messages = grep { $_ } @messages;
+ # Sometimes, with things that break because of no_criteria, there won't
+ # be anything in @messages even though we need to print out a message.
+ if (!@messages) {
+ my @no_criteria = grep { $_->_known_broken->{no_criteria} }
+ $self->field_tests;
+ @messages = map { "No criteria generated by " . $_->name }
+ @no_criteria;
+ }
+ die "broken test with no message" if !@messages;
return join(' AND ', @messages);
}
return undef;
}
-sub _join_known_broken {
- my ($self) = @_;
- my $or_broken = $self->_join_broken_constant;
- foreach my $test ($self->field_tests) {
- @or_broken_for = map { $_->join_broken($or_broken) } $self->field_tests;
- @or_broken_for = grep { defined $_ } @or_broken_for;
- last if !@or_broken_for;
- $or_broken = $or_broken_for[0];
- }
- return $or_broken;
-}
-
##############################
# Bugzilla::Search arguments #
##############################
return \%params;
}
-1;
\ No newline at end of file
+1;
projects / thirdparty / bugzilla.git / commitdiff
