public function testCompositesWithoutIntersection()
{
// (x > 999) or ((x > 7) and (x <= 42))
$comp1 = new ConditionComposite();
// (x > 999)
$comp1_1 = new ValueGreaterThan(999);
// ()
$comp1_2 = new ConditionComposite();
$comp1->addOR($comp1_1)->addOR($comp1_2);
// (x > 7)
$comp1_2_1 = new ValueGreaterThan(7);
// (x <= 42)
$comp1_2_2 = new ValueGreaterThan(42);
$comp1_2_2->negate();
$comp1_2->addAND($comp1_2_1)->addAND($comp1_2_2);
// (x > 100) and (x <= 999)
$comp2 = new ConditionComposite();
// (x > 100)
$comp2_1 = new ValueGreaterThan(100);
// (x <= 999)
$comp2_2 = new ValueGreaterThan(999);
$comp2_2->negate();
$comp2->addAND($comp2_1)->addAND($comp2_2);
$this->assertFalse($this->detector->intersectExists($comp1, $comp2));
}
/**
* Rows of given array 2D represents OR conditions while columns represents
* AND conditions.
*
* Array of Condition objects like this:
* <pre>
* [
* [A, B],
* [C, D]
* ]
* </pre>
*
* is composed into ConditionComposite like this:
*
* ((A AND B) OR (C AND D))
*
* @param array $decomposedComposite
*
* @return ConditionComposite
*/
public function compose(array $decomposedComposite)
{
$composite = new ConditionComposite();
foreach ($decomposedComposite as $decomposedRowData) {
$ANDChain = $this->getANDCompositeOfConditions($decomposedRowData);
$composite->addOR($ANDChain);
}
return $composite;
}
/**
* (A AND (B OR (C AND D AND (E OR F))))
*
* should be decomposed to:
*
* [
* [A, B],
* [A, C, D, E]
* [A, C, D, F]
* ]
*
*/
public function testComplexStructureWithManyLevels()
{
//leaves
$A = new FakeCondition("A");
$B = new FakeCondition("B");
$C = new FakeCondition("C");
$D = new FakeCondition("D");
$E = new FakeCondition("E");
$F = new FakeCondition("F");
//E OR F
$comp1 = new ConditionComposite();
$comp1->addOR($E)->addOR($F);
//C AND D AND (E OR F)
$comp2 = new ConditionComposite();
$comp2->addAND($C)->addAND($D)->addAND($comp1);
//B OR (C AND D AND (E OR F))
$comp3 = new ConditionComposite();
$comp3->addOR($B)->addOR($comp2);
//A AND (B OR (C AND D AND (E OR F)))
$composite = new ConditionComposite();
$composite->addAND($A)->addAND($comp3);
$expected = [[$A, $B], [$A, $C, $D, $E], [$A, $C, $D, $F]];
$decompositionResult = $this->decomposer->decompose($composite);
$this->assertTrue($this->decomposedStructuresAreIdentical($expected, $decompositionResult));
}
public function testComparingDifferentComposites()
{
// (x > 7) and (!(x > 42) or (x > 99))
$comp1 = new ConditionComposite();
// (x > 7)
$comp1_1 = new ValueGreaterThan(7);
// ()
$comp1_2 = new ConditionComposite();
// !(x > 42)
$comp1_2_1 = new ValueGreaterThan(42);
$comp1_2_1->negate();
// (x > 99)
$comp1_2_2 = new ValueGreaterThan(99);
//(!(x > 42) or (x > 99))
$comp1_2->addOR($comp1_2_1)->addOR($comp1_2_2);
//// (x > 7) and (!(x > 42) or (x > 99))
$comp1->addAND($comp1_1)->addAND($comp1_2);
// (!(x > 42) and (x > 7)) or ((x > 7) and !(x > 99))
$comp2 = new ConditionComposite();
// ()
$comp2_1 = new ConditionComposite();
// ()
$comp2_2 = new ConditionComposite();
$comp2->addOR($comp2_1)->addOR($comp2_2);
// !(x > 42)
$comp2_1_1 = new ValueGreaterThan(42);
$comp2_1_1->negate();
// (x > 7)
$comp2_1_2 = new ValueGreaterThan(7);
// !(x > 42) and (x > 7))
$comp2_1->addAND($comp2_1_1)->addAND($comp2_1_2);
// (x > 7)
$comp2_2_1 = new ValueGreaterThan(7);
// (x > 99)
$comp2_2_2 = new ValueGreaterThan(99);
$comp2_2_2->negate();
// ((x > 7) and (x > 99))
$comp2_2->addAND($comp2_2_1)->addAND($comp2_2_2);
$this->assertFalse($this->cmp->equal($comp1, $comp2));
}
