mirror of
https://github.com/Icinga/icingaweb2.git
synced 2025-11-03 20:54:27 +01:00
497 lines
22 KiB
PHP
497 lines
22 KiB
PHP
<?php
|
|
/* Icinga Web 2 | (c) 2015 Icinga Development Team | GPLv2+ */
|
|
|
|
namespace Tests\Icinga\Module\Setup;
|
|
|
|
use Icinga\Test\BaseTestCase;
|
|
use Icinga\Module\Setup\Requirement;
|
|
use Icinga\Module\Setup\RequirementSet;
|
|
|
|
class TrueRequirement extends Requirement
|
|
{
|
|
protected function evaluate()
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
class FalseRequirement extends Requirement
|
|
{
|
|
protected function evaluate()
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class RequirementSetTest extends BaseTestCase
|
|
{
|
|
public function testFlatMandatoryRequirementsOfTypeAnd()
|
|
{
|
|
$emptySet = new RequirementSet();
|
|
$this->assertFalse($emptySet->fulfilled(), 'A empty mandatory set of type and is fulfilled');
|
|
|
|
$singleTrueSet = new RequirementSet();
|
|
$singleTrueSet->add(new TrueRequirement());
|
|
$this->assertTrue(
|
|
$singleTrueSet->fulfilled(),
|
|
'A mandatory set of type and with a single TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$singleFalseSet = new RequirementSet();
|
|
$singleFalseSet->add(new FalseRequirement());
|
|
$this->assertFalse(
|
|
$singleFalseSet->fulfilled(),
|
|
'A mandatory set of type and with a single FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$mixedSet = new RequirementSet();
|
|
$mixedSet->add(new TrueRequirement());
|
|
$mixedSet->add(new FalseRequirement());
|
|
$this->assertFalse(
|
|
$mixedSet->fulfilled(),
|
|
'A mandatory set of type and with one True- and one FalseRequirement is fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testFlatOptionalRequirementsOfTypeAnd()
|
|
{
|
|
$emptySet = new RequirementSet(true);
|
|
$this->assertTrue($emptySet->fulfilled(), 'A empty optional set of type and is not fulfilled');
|
|
|
|
$singleTrueSet = new RequirementSet(true);
|
|
$singleTrueSet->add(new TrueRequirement());
|
|
$this->assertTrue(
|
|
$singleTrueSet->fulfilled(),
|
|
'A optional set of type and with a single TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$singleFalseSet = new RequirementSet(true);
|
|
$singleFalseSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$singleFalseSet->fulfilled(),
|
|
'A optional set of type and with a single FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$mixedSet = new RequirementSet(true);
|
|
$mixedSet->add(new TrueRequirement());
|
|
$mixedSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$mixedSet->fulfilled(),
|
|
'A optional set of type and with one True- and one FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testFlatMixedRequirementsOfTypeAnd()
|
|
{
|
|
$mandatoryOptionalTrueSet = new RequirementSet();
|
|
$mandatoryOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$mandatoryOptionalTrueSet->add(new FalseRequirement());
|
|
$this->assertFalse(
|
|
$mandatoryOptionalTrueSet->fulfilled(),
|
|
'A mandatory set of type and with one optional True- and one mandatory FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$mandatoryOptionalFalseSet = new RequirementSet();
|
|
$mandatoryOptionalFalseSet->add(new TrueRequirement());
|
|
$mandatoryOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$this->assertTrue(
|
|
$mandatoryOptionalFalseSet->fulfilled(),
|
|
'A mandatory set of type and with one mandatory True- and one optional FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalTrueSet = new RequirementSet(true);
|
|
$optionalOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$optionalOptionalTrueSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$optionalOptionalTrueSet->fulfilled(),
|
|
'A optional set of type and with one optional True- and one mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalFalseSet = new RequirementSet(true);
|
|
$optionalOptionalFalseSet->add(new TrueRequirement());
|
|
$optionalOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$this->assertTrue(
|
|
$optionalOptionalFalseSet->fulfilled(),
|
|
'A optional set of type and with one mandatory True- and one optional FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testFlatMandatoryRequirementsOfTypeOr()
|
|
{
|
|
$emptySet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$this->assertFalse($emptySet->fulfilled(), 'A empty mandatory set of type or is fulfilled');
|
|
|
|
$singleTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$singleTrueSet->add(new TrueRequirement());
|
|
$this->assertTrue(
|
|
$singleTrueSet->fulfilled(),
|
|
'A mandatory set of type or with a single TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$singleFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$singleFalseSet->add(new FalseRequirement());
|
|
$this->assertFalse(
|
|
$singleFalseSet->fulfilled(),
|
|
'A mandatory set of type or with a single FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$mixedSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mixedSet->add(new TrueRequirement());
|
|
$mixedSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$mixedSet->fulfilled(),
|
|
'A mandatory set of type or with one True- and one FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testFlatOptionalRequirementsOfTypeOr()
|
|
{
|
|
$emptySet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$this->assertTrue($emptySet->fulfilled(), 'A empty optional set of type or is not fulfilled');
|
|
|
|
$singleTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$singleTrueSet->add(new TrueRequirement());
|
|
$this->assertTrue(
|
|
$singleTrueSet->fulfilled(),
|
|
'A optional set of type or with a single TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$singleFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$singleFalseSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$singleFalseSet->fulfilled(),
|
|
'A optional set of type or with a single FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$mixedSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$mixedSet->add(new TrueRequirement());
|
|
$mixedSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$mixedSet->fulfilled(),
|
|
'A optional set of type or with one True- and one FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testFlatMixedRequirementsOfTypeOr()
|
|
{
|
|
$mandatoryOptionalTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$mandatoryOptionalTrueSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$mandatoryOptionalTrueSet->fulfilled(),
|
|
'A mandatory set of type or with one optional True- and one mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$mandatoryOptionalFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryOptionalFalseSet->add(new TrueRequirement());
|
|
$mandatoryOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$this->assertTrue(
|
|
$mandatoryOptionalFalseSet->fulfilled(),
|
|
'A mandatory set of type or with one mandatory True- and one optional FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$optionalOptionalTrueSet->add(new FalseRequirement());
|
|
$this->assertTrue(
|
|
$optionalOptionalTrueSet->fulfilled(),
|
|
'A optional set of type or with one optional True- and one mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalFalseSet->add(new TrueRequirement());
|
|
$optionalOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$this->assertTrue(
|
|
$optionalOptionalFalseSet->fulfilled(),
|
|
'A optional set of type or with one mandatory True- and one optional FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedMandatoryRequirementsOfTypeAnd()
|
|
{
|
|
$trueSet = new RequirementSet();
|
|
$trueSet->add(new TrueRequirement());
|
|
$falseSet = new RequirementSet();
|
|
$falseSet->add(new FalseRequirement());
|
|
|
|
$nestedTrueSet = new RequirementSet();
|
|
$nestedTrueSet->merge($trueSet);
|
|
$this->assertTrue(
|
|
$nestedTrueSet->fulfilled(),
|
|
'A nested mandatory set of type and with one mandatory TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedFalseSet = new RequirementSet();
|
|
$nestedFalseSet->merge($falseSet);
|
|
$this->assertFalse(
|
|
$nestedFalseSet->fulfilled(),
|
|
'A nested mandatory set of type and with one mandatory FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$nestedMixedSet = new RequirementSet();
|
|
$nestedMixedSet->merge($trueSet);
|
|
$nestedMixedSet->merge($falseSet);
|
|
$this->assertFalse(
|
|
$nestedMixedSet->fulfilled(),
|
|
'Two nested mandatory sets of type and with one mandatory True- and'
|
|
. ' one mandatory FalseRequirement respectively are fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedOptionalRequirementsOfTypeAnd()
|
|
{
|
|
$trueSet = new RequirementSet(true);
|
|
$trueSet->add(new TrueRequirement());
|
|
$falseSet = new RequirementSet(true);
|
|
$falseSet->add(new FalseRequirement());
|
|
|
|
$nestedTrueSet = new RequirementSet(true);
|
|
$nestedTrueSet->merge($trueSet);
|
|
$this->assertTrue(
|
|
$nestedTrueSet->fulfilled(),
|
|
'A nested optional set of type and with one mandatory TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedFalseSet = new RequirementSet(true);
|
|
$nestedFalseSet->merge($falseSet);
|
|
$this->assertTrue(
|
|
$nestedFalseSet->fulfilled(),
|
|
'A nested optional set of type and with one mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedMixedSet = new RequirementSet(true);
|
|
$nestedMixedSet->merge($trueSet);
|
|
$nestedMixedSet->merge($falseSet);
|
|
$this->assertTrue(
|
|
$nestedMixedSet->fulfilled(),
|
|
'Two nested optional sets of type and with one mandatory True- and'
|
|
. ' one mandatory FalseRequirement respectively are not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedMixedRequirementsOfTypeAnd()
|
|
{
|
|
$mandatoryMandatoryTrueSet = new RequirementSet();
|
|
$mandatoryMandatoryTrueSet->add(new TrueRequirement());
|
|
$mandatoryOptionalTrueSet = new RequirementSet();
|
|
$mandatoryOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$mandatoryMandatoryFalseSet = new RequirementSet();
|
|
$mandatoryMandatoryFalseSet->add(new FalseRequirement());
|
|
$mandatoryOptionalFalseSet = new RequirementSet();
|
|
$mandatoryOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$optionalMandatoryTrueSet = new RequirementSet(true);
|
|
$optionalMandatoryTrueSet->add(new TrueRequirement());
|
|
$optionalOptionalTrueSet = new RequirementSet(true);
|
|
$optionalOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$optionalMandatoryFalseSet = new RequirementSet(true);
|
|
$optionalMandatoryFalseSet->add(new FalseRequirement());
|
|
$optionalOptionalFalseSet = new RequirementSet(true);
|
|
$optionalOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
|
|
$mandatoryMandatoryOptionalTrueSet = new RequirementSet();
|
|
$mandatoryMandatoryOptionalTrueSet->merge($mandatoryOptionalTrueSet);
|
|
$mandatoryMandatoryOptionalTrueSet->merge($mandatoryMandatoryFalseSet);
|
|
$this->assertFalse(
|
|
$mandatoryMandatoryOptionalTrueSet->fulfilled(),
|
|
'A mandatory set of type and with two nested mandatory sets of type and where one has a optional'
|
|
. ' TrueRequirement and the other one has a mandatory FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$mandatoryMandatoryOptionalFalseSet = new RequirementSet();
|
|
$mandatoryMandatoryOptionalFalseSet->merge($mandatoryOptionalFalseSet);
|
|
$mandatoryMandatoryOptionalFalseSet->merge($mandatoryMandatoryTrueSet);
|
|
$this->assertTrue(
|
|
$mandatoryMandatoryOptionalFalseSet->fulfilled(),
|
|
'A mandatory set of type and with two nested mandatory sets of type and where one has a mandatory'
|
|
. ' TrueRequirement and the other one has a optional FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalOptionalTrueSet = new RequirementSet(true);
|
|
$optionalOptionalOptionalTrueSet->merge($optionalOptionalTrueSet);
|
|
$optionalOptionalOptionalTrueSet->merge($optionalMandatoryFalseSet);
|
|
$this->assertTrue(
|
|
$optionalOptionalOptionalTrueSet->fulfilled(),
|
|
'A optional set of type and with two nested optional sets of type and where one has a optional'
|
|
. ' TrueRequirement and the other one has a mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$optionalOptionalOptionalFalseSet = new RequirementSet(true);
|
|
$optionalOptionalOptionalFalseSet->merge($optionalOptionalFalseSet);
|
|
$optionalOptionalOptionalFalseSet->merge($optionalMandatoryTrueSet);
|
|
$this->assertTrue(
|
|
$optionalOptionalOptionalFalseSet->fulfilled(),
|
|
'A optional set of type and with two nested optional sets of type and where one has a mandatory'
|
|
. ' TrueRequirement and the other one has a optional FalseRequirement is not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedMandatoryRequirementsOfTypeOr()
|
|
{
|
|
$trueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$trueSet->add(new TrueRequirement());
|
|
$falseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$falseSet->add(new FalseRequirement());
|
|
|
|
$nestedTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$nestedTrueSet->merge($trueSet);
|
|
$this->assertTrue(
|
|
$nestedTrueSet->fulfilled(),
|
|
'A nested mandatory set of type or with one mandatory TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$nestedFalseSet->merge($falseSet);
|
|
$this->assertFalse(
|
|
$nestedFalseSet->fulfilled(),
|
|
'A nested mandatory set of type or with one mandatory FalseRequirement is fulfilled'
|
|
);
|
|
|
|
$nestedMixedSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$nestedMixedSet->merge($trueSet);
|
|
$nestedMixedSet->merge($falseSet);
|
|
$this->assertTrue(
|
|
$nestedMixedSet->fulfilled(),
|
|
'Two nested mandatory sets of type or with one mandatory True- and'
|
|
. ' one mandatory FalseRequirement respectively are not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedOptionalRequirementsOfTypeOr()
|
|
{
|
|
$trueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$trueSet->add(new TrueRequirement());
|
|
$falseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$falseSet->add(new FalseRequirement());
|
|
|
|
$nestedTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$nestedTrueSet->merge($trueSet);
|
|
$this->assertTrue(
|
|
$nestedTrueSet->fulfilled(),
|
|
'A nested optional set of type or with one mandatory TrueRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$nestedFalseSet->merge($falseSet);
|
|
$this->assertTrue(
|
|
$nestedFalseSet->fulfilled(),
|
|
'A nested optional set of type or with one mandatory FalseRequirement is not fulfilled'
|
|
);
|
|
|
|
$nestedMixedSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$nestedMixedSet->merge($trueSet);
|
|
$nestedMixedSet->merge($falseSet);
|
|
$this->assertTrue(
|
|
$nestedMixedSet->fulfilled(),
|
|
'Two nested optional sets of type or with one mandatory True- and'
|
|
. ' one mandatory FalseRequirement respectively are not fulfilled'
|
|
);
|
|
}
|
|
|
|
public function testNestedMixedRequirementsOfTypeOr()
|
|
{
|
|
$mandatoryMandatoryTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryMandatoryTrueSet->add(new TrueRequirement());
|
|
$mandatoryOptionalTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$mandatoryMandatoryFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryMandatoryFalseSet->add(new FalseRequirement());
|
|
$mandatoryOptionalFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
$optionalMandatoryTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalMandatoryTrueSet->add(new TrueRequirement());
|
|
$optionalOptionalTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalTrueSet->add(new TrueRequirement(array('optional' => true)));
|
|
$optionalMandatoryFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalMandatoryFalseSet->add(new FalseRequirement());
|
|
$optionalOptionalFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalFalseSet->add(new FalseRequirement(array('optional' => true)));
|
|
|
|
$mandatoryMandatoryOptionalTrueSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryMandatoryOptionalTrueSet->merge($mandatoryOptionalTrueSet);
|
|
$mandatoryMandatoryOptionalTrueSet->merge($mandatoryMandatoryFalseSet);
|
|
$this->assertTrue($mandatoryMandatoryOptionalTrueSet->fulfilled());
|
|
|
|
$mandatoryMandatoryOptionalFalseSet = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$mandatoryMandatoryOptionalFalseSet->merge($mandatoryOptionalFalseSet);
|
|
$mandatoryMandatoryOptionalFalseSet->merge($mandatoryMandatoryTrueSet);
|
|
$this->assertTrue($mandatoryMandatoryOptionalFalseSet->fulfilled());
|
|
|
|
$optionalOptionalOptionalTrueSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalOptionalTrueSet->merge($optionalOptionalTrueSet);
|
|
$optionalOptionalOptionalTrueSet->merge($optionalMandatoryFalseSet);
|
|
$this->assertTrue($optionalOptionalOptionalTrueSet->fulfilled());
|
|
|
|
$optionalOptionalOptionalFalseSet = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$optionalOptionalOptionalFalseSet->merge($optionalOptionalFalseSet);
|
|
$optionalOptionalOptionalFalseSet->merge($optionalMandatoryTrueSet);
|
|
$this->assertTrue($optionalOptionalOptionalFalseSet->fulfilled());
|
|
}
|
|
|
|
public function testNestedMandatoryRequirementsOfDifferentTypes()
|
|
{
|
|
$true = new TrueRequirement();
|
|
$false = new FalseRequirement();
|
|
|
|
$level1And = new RequirementSet();
|
|
$level2FirstOr = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level2SecondOr = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level1And->merge($level2FirstOr)->merge($level2SecondOr);
|
|
$level3FirstAnd = new RequirementSet();
|
|
$level3SecondAnd = new RequirementSet();
|
|
$level2FirstOr->merge($level3FirstAnd)->merge($level3SecondAnd);
|
|
$level2SecondOr->merge($level3FirstAnd)->merge($level3SecondAnd);
|
|
$level3FirstAnd->add($true)->add($true);
|
|
$level3SecondAnd->add($false)->add($true);
|
|
$this->assertTrue($level1And->fulfilled());
|
|
|
|
$level1Or = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level2FirstAnd = new RequirementSet();
|
|
$level2SecondAnd = new RequirementSet();
|
|
$level1Or->merge($level2FirstAnd)->merge($level2SecondAnd);
|
|
$level3FirstOr = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level3SecondOr = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level2FirstAnd->merge($level3FirstOr)->merge($level3SecondOr);
|
|
$level2SecondAnd->merge($level3FirstOr)->merge($level3SecondOr);
|
|
$level3FirstOr->add($false);
|
|
$level3SecondOr->add($true);
|
|
$this->assertFalse($level1Or->fulfilled());
|
|
}
|
|
|
|
public function testNestedOptionalRequirementsOfDifferentTypes()
|
|
{
|
|
$true = new TrueRequirement();
|
|
$false = new FalseRequirement();
|
|
|
|
$level1And = new RequirementSet();
|
|
$level2FirstAnd = new RequirementSet(true);
|
|
$level2SecondAnd = new RequirementSet(true);
|
|
$level1And->merge($level2FirstAnd)->merge($level2SecondAnd);
|
|
$level3FirstOr = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$level3SecondOr = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$level2FirstAnd->merge($level3FirstOr)->merge($level3SecondOr);
|
|
$level2SecondAnd->merge($level3FirstOr)->merge($level3SecondOr);
|
|
$level3FirstOr->add($false);
|
|
$level3SecondOr->add($false);
|
|
$this->assertFalse($level1And->fulfilled());
|
|
$this->assertTrue($level2FirstAnd->fulfilled());
|
|
$this->assertTrue($level2SecondAnd->fulfilled());
|
|
|
|
$level1Or = new RequirementSet(false, RequirementSet::MODE_OR);
|
|
$level2FirstOr = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$level2SecondOr = new RequirementSet(true, RequirementSet::MODE_OR);
|
|
$level1Or->merge($level2FirstOr)->merge($level2SecondOr);
|
|
$level3FirstAnd = new RequirementSet(true);
|
|
$level3SecondAnd = new RequirementSet(true);
|
|
$level2FirstOr->merge($level3FirstAnd)->merge($level3SecondAnd);
|
|
$level2SecondOr->merge($level3FirstAnd)->merge($level3SecondAnd);
|
|
$level3FirstAnd->add($true)->add($true);
|
|
$level3SecondAnd->add($false)->add($true);
|
|
$this->assertTrue($level1Or->fulfilled());
|
|
}
|
|
|
|
public function testNestedMixedRequirementsOfDifferentTypes()
|
|
{
|
|
$this->markTestIncomplete();
|
|
}
|
|
}
|