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)); }
/** * Takes an array of Condition objects and returns a ConditionComposite * containing all given conditions as AND nodes. * * @param \lukaszmakuch\LmCondition\Condition[] $ANDConditions * @return ConditionComposite */ protected function getANDCompositeOfConditions(array $ANDConditions) { $composite = new ConditionComposite(); foreach ($ANDConditions as $condition) { $composite->addAND($condition); } return $composite; }
/** * Checks whether intersection exsits among all AND conditions within * these composites. * * @param ConditionComposite $ANDComposite1 * @param ConditionComposite $ANDComposite2 * * @throws ImpossibleToLookForIntersection * @return boolean if intersection exist among all AND conditions * withing these composites */ protected function intersectionExistsBetween(ConditionComposite $ANDComposite1, ConditionComposite $ANDComposite2) { $setOfANDConditions1 = $ANDComposite1->getANDConditions(); $setOfANDConditions2 = $ANDComposite2->getANDConditions(); foreach ($setOfANDConditions1 as $ANDCondition1) { foreach ($setOfANDConditions2 as $ANDCondition2) { if (false === $this->leafIntersectDetector->intersectExists($ANDCondition1, $ANDCondition2)) { return false; } } } return true; }
protected function decomposeRow(ConditionComposite $c) { if (false === empty($c->getORConditions())) { throw new InvalidArgumentException("in this test there should be no OR conditions"); } $result = []; foreach ($c->getANDConditions() as $c) { if ($c instanceof ConditionComposite) { throw new InvalidArgumentException("in this test there should be no composite"); } $result[] = $c; } return $result; }
/** * Compares composites that contain only AND conditions (that are not composites). * * @param ConditionComposite $comp1 * @param ConditionComposite $comp2 * * @throws IncomparableConditions when it's not possible to compare leaves * @return boolean */ protected function ANDCompositesAreEqual(ConditionComposite $comp1, ConditionComposite $comp2) { return ArrayComparator::arraysHoldEqualElements($comp1->getANDConditions(), $comp2->getANDConditions(), function (Condition $c1, Condition $c2) { return $this->leafEqualityComparator->equal($c1, $c2); }); }
/** * Gets all OR conditions of a composite and processes them through decompose(Condition). * * @param ConditionComposite $c * * @return array */ protected function decomposeORConditionsOf(ConditionComposite $c) { return array_reduce($c->getORConditions(), function (array $decomposed, Condition $c) { return array_merge($decomposed, $this->decompose($c)); }, []); }
/** * (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)); }