BirdCreateModelTest::testUpdateEggsByReplaceElements() - Code Metrics - bingo-soft/xml - Measure and Improve Code Quality continuously with Scrutinizer

testUpdateEggsByReplaceElements() A
last analyzed 2022-08-02 11:14 UTC

↳ Parent: BirdCreateModelTest

Complexity

Conditions	4
Paths	4

Size

Total Lines	16
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	12
c	0
b	0
f	0
nc	4
nop	0
dl	0
loc	16
rs	9.8666

<?php

namespace Tests\TestModel\Instance;

use Xml\Impl\Util\StringUtil;
use Xml\ModelInstanceInterface;
use Xml\Impl\Parser\AbstractModelParser;
use Tests\TestModel\{
    Gender,
    TestModelConstants,
    TestModelParser
};
use Tests\TestModel\TestModelTest;

class BirdCreateModelTest extends TestModelTest
{
    protected $tweety;
    protected $hedwig;
    protected $timmy;
    protected $egg1;
    protected $egg2;
    protected $egg3;

    protected function setUp(): void
    {
        $this->modelParser = new TestModelParser();
        $this->modelInstance = $this->modelParser->getEmptyModel();

        $animals = $this->modelInstance->newInstance(Animals::class);
        $this->modelInstance->setDocumentElement($animals);

        // add a tns namespace prefix for QName testing
        $animals->getDomElement()->registerNamespace("tns", TestModelConstants::MODEL_NAMESPACE);

        $this->tweety = $this->createBird($this->modelInstance, "tweety", Gender::FEMALE);
        $this->hedwig = $this->createBird($this->modelInstance, "hedwig", Gender::FEMALE);
        $this->timmy = $this->createBird($this->modelInstance, "timmy", Gender::FEMALE);
        $this->egg1 = $this->createEgg($this->modelInstance, "egg1");
        $this->egg1->setMother($this->tweety);
        $this->egg1->addGuardian($this->hedwig);
        $this->egg1->addGuardian($this->timmy);

        $this->egg2 = $this->createEgg($this->modelInstance, "egg2");
        $this->egg2->setMother($this->tweety);
        $this->egg2->addGuardian($this->hedwig);
        $this->egg2->addGuardian($this->timmy);

        $this->egg3 = $this->createEgg($this->modelInstance, "egg3");
        $this->egg3->addGuardian($this->timmy);

        $this->tweety->setSpouse($this->hedwig);
        $this->tweety->addEgg($this->egg1);
        $this->tweety->addEgg($this->egg2);
        $this->tweety->addEgg($this->egg3);

        $this->hedwig->addGuardedEgg($this->egg1);
        $this->hedwig->addGuardedEgg($this->egg2);

        $guardEgg = $this->modelInstance->newInstance(GuardEgg::class);
        $guardEgg->setTextContent($this->egg1->getId() . " " . $this->egg2->getId());
        $this->timmy->addGuardedEggRef($guardEgg);
        $this->timmy->addGuardedEgg($this->egg3);
    }

    public function testAddEggsByHelper(): void
    {
        $this->assertCount(3, $this->tweety->getEggs());
        $eggs = [$this->egg1, $this->egg2, $this->egg3];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }

        $egg4 = $this->createEgg($this->modelInstance, "egg4");
        $this->tweety->addEgg($egg4);
        $egg5 = $this->createEgg($this->modelInstance, "egg5");
        $this->tweety->addEgg($egg5);

        $this->assertCount(5, $this->tweety->getEggs());

        $eggs = [$this->egg1, $this->egg2, $this->egg3, $egg4, $egg5];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateEggsByIdByHelper(): void
    {
        $this->egg1->setId("new-" . $this->egg1->getId());
        $this->egg2->setId("new-" . $this->egg2->getId());

        $this->assertCount(3, $this->tweety->getEggs());
        $eggs = [$this->egg1, $this->egg2, $this->egg3];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateEggsByIdByAttributeName(): void
    {
        $this->egg1->setAttributeValue("id", "new-" . $this->egg1->getId(), true);
        $this->egg2->setAttributeValue("id", "new-" . $this->egg2->getId(), true);

        $this->assertCount(3, $this->tweety->getEggs());
        $eggs = [$this->egg1, $this->egg2, $this->egg3];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateEggsByReplaceElements(): void
    {
        $egg4 = $this->createEgg($this->modelInstance, "egg4");
        $egg5 = $this->createEgg($this->modelInstance, "egg5");
        $this->egg1->replaceWithElement($egg4);
        $this->egg2->replaceWithElement($egg5);
        $this->assertCount(3, $this->tweety->getEggs());
        $eggs = [$this->egg3, $egg4, $egg5];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateEggsByRemoveElement(): void
    {
        $this->tweety->removeEgg($this->egg1);
        $this->assertCount(2, $this->tweety->getEggs());
        $eggs = [$this->egg2, $this->egg3];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->tweety->getEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testClearEggs(): void
    {
        $this->tweety->clearEggs();
        $this->assertEmpty($this->tweety->getEggs());
    }

    public function testSetSpouseRefByHelper(): void
    {
        $this->tweety->setSpouse($this->timmy);
        $this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
    }

    public function testUpdateSpouseByIdHelper(): void
    {
        $this->hedwig->setId("new-" . $this->hedwig->getId());
        $this->assertTrue($this->tweety->getSpouse()->equals($this->hedwig));
    }

    public function testUpdateSpouseByIdByAttributeName(): void
    {
        $this->hedwig->setAttributeValue("id", "new-" . $this->hedwig->getId(), true);
        $this->assertTrue($this->tweety->getSpouse()->equals($this->hedwig));
    }

    public function testUpdateSpouseByReplaceElement(): void
    {
        $this->hedwig->replaceWithElement($this->timmy);
        $this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
    }

    public function testUpdateSpouseByRemoveElement(): void
    {
        $animals = $this->modelInstance->getDocumentElement();
        $animals->removeAnimal($this->hedwig);
        $this->assertNull($this->tweety->getSpouse());
    }

    public function testClearSpouse(): void
    {
        $this->tweety->removeSpouse();
        $this->assertNull($this->tweety->getSpouse());
    }

    public function testSetSpouseRefsByHelper(): void
    {
        $spouseRef = $this->modelInstance->newInstance(SpouseRef::class);
        $spouseRef->setTextContent($this->timmy->getId());
        $this->tweety->getSpouseRef()->replaceWithElement($spouseRef);
        $this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
    }

    public function testSpouseRefsByTextContent(): void
    {
        $spouseRef = $this->tweety->getSpouseRef();
        $this->assertEquals($spouseRef->getTextContent(), $this->hedwig->getId());
    }

    public function testUpdateSpouseRefsByTextContent(): void
    {
        $spouseRef = $this->tweety->getSpouseRef();
        $spouseRef->setTextContent($this->timmy->getId());
        $this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
    }

    public function testUpdateSpouseRefsByTextContentWithNamespace(): void
    {
        $spouseRef = $this->tweety->getSpouseRef();
        $spouseRef->setTextContent("tns:" . $this->timmy->getId());
        $this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
    }

    public function testGetMother(): void
    {
        $mother = $this->egg1->getMother();
        $this->assertTrue($mother->equals($this->tweety));

        $mother = $this->egg2->getMother();
        $this->assertTrue($mother->equals($this->tweety));
    }

    public function testSetMotherRefByHelper(): void
    {
        $this->egg1->setMother($this->timmy);
        $this->assertTrue($this->egg1->getMother()->equals($this->timmy));
    }

    public function testUpdateMotherByIdHelper(): void
    {
        $this->tweety->setId("new-" . $this->tweety->getId());
        $this->assertTrue($this->egg1->getMother()->equals($this->tweety));
    }

    public function testUpdateMotherByIdByAttributeName(): void
    {
        $this->tweety->setAttributeValue("id", "new-" . $this->tweety->getId(), true);
        $this->assertTrue($this->egg1->getMother()->equals($this->tweety));
    }

    public function testUpdateMotherByReplaceElement(): void
    {
        $this->tweety->replaceWithElement($this->timmy);
        $this->assertTrue($this->egg1->getMother()->equals($this->timmy));
    }

    public function testUpdateMotherByRemoveElement(): void
    {
        $this->egg1->setMother($this->hedwig);
        $animals = $this->modelInstance->getDocumentElement();
        $animals->removeAnimal($this->hedwig);
        $this->assertNull($this->egg1->getMother());
    }

    public function testClearMother(): void
    {
        $this->egg1->removeMother();
        $this->assertNull($this->egg1->getMother());
    }

    public function testSetMotherRefsByHelper(): void
    {
        $mother = $this->modelInstance->newInstance(Mother::class);
        $mother->setHref("#" . $this->timmy->getId());
        $this->egg1->getMotherRef()->replaceWithElement($mother);
        $this->assertTrue($this->egg1->getMother()->equals($this->timmy));
    }

    public function testMotherRefsByTextContent(): void
    {
        $mother = $this->egg1->getMotherRef();
        $this->assertEquals("#" . $this->tweety->getId(), $mother->getHref());
    }

    public function testUpdateMotherRefsByTextContent(): void
    {
        $mother = $this->egg1->getMotherRef();
        $mother->setHref("#" . $this->timmy->getId());
        $this->assertTrue($this->egg1->getMother()->equals($this->timmy));
    }

    public function testGetGuards(): void
    {
        $guards = $this->egg1->getGuardians();
        $this->assertCount(2, $guards);
        $birds = [$this->hedwig, $this->timmy];
        foreach ($birds as $bird) {
            $exists = false;
            foreach ($guards as $guard) {
                if ($bird->equals($guard)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }

        $guards = $this->egg2->getGuardians();
        $this->assertCount(2, $guards);
        $birds = [$this->hedwig, $this->timmy];
        foreach ($birds as $bird) {
            $exists = false;
            foreach ($guards as $guard) {
                if ($bird->equals($guard)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testAddGuardianRefsByHelper(): void
    {
        $this->assertCount(2, $this->egg1->getGuardianRefs());

        $tweetyGuardian = $this->modelInstance->newInstance(Guardian::class);
        $tweetyGuardian->setHref("#" . $this->tweety->getId());
        $this->egg1->addGuardianRef($tweetyGuardian);

        $this->assertCount(3, $this->egg1->getGuardianRefs());
        $exists = false;
        foreach ($this->egg1->getGuardianRefs() as $ref) {
            if ($ref->equals($tweetyGuardian)) {
                $exists = true;
            }
        }
        $this->assertTrue($exists);
    }

    public function testGuardianRefsByTextContent(): void
    {
        $guardianRefs = $this->egg1->getGuardianRefs();
        $hrefs = [];
        foreach ($guardianRefs as $guardianRef) {
            $href = $guardianRef->getHref();
            $this->assertFalse(empty($href));
            $hrefs[] = $href;
        }
        $this->assertFalse(empty($hrefs));
        $this->assertContains("#" . $this->hedwig->getId(), $hrefs);
        $this->assertContains("#" . $this->timmy->getId(), $hrefs);
    }

    public function testUpdateGuardianRefsByTextContent(): void
    {
        $guardianRefs = $this->egg1->getGuardianRefs();

        $guardianRefs[0]->setHref("#" . $this->tweety->getId());

        $birds = [$this->tweety, $this->timmy];
        foreach ($birds as $bird) {
            $exists = false;
            foreach ($this->egg1->getGuardians() as $guard) {
                if ($bird->equals($guard)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateGuardianRefsByRemoveElements(): void
    {
        $guardianRefs = $this->egg1->getGuardianRefs();
        $this->egg1->removeGuardianRef($guardianRefs[1]);
        $this->assertCount(1, $this->egg1->getGuardians());
    }

    public function testClearGuardianRefs(): void
    {
        $this->egg1->clearGuardianRefs();
        $this->assertEmpty($this->egg1->getGuardianRefs());

        // should not affect animals collection
        $animals = $this->modelInstance->getDocumentElement();
        $this->assertCount(3, $animals->getAnimals());
    }

    public function testGetGuardedEggs(): void
    {
        $guardedEggs = $this->hedwig->getGuardedEggs();
        $this->assertCount(2, $guardedEggs);
        $eggs = [$this->egg1, $this->egg2];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($guardedEggs as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testAddGuardedEggRefsByHelper(): void
    {
        $this->assertCount(2, $this->hedwig->getGuardedEggRefs());

        $egg3GuardedEgg = $this->modelInstance->newInstance(GuardEgg::class);
        $egg3GuardedEgg->setTextContent($this->egg3->getId());
        $this->hedwig->addGuardedEggRef($egg3GuardedEgg);

        $this->assertCount(3, $this->hedwig->getGuardedEggRefs());

        $exists = false;
        foreach ($this->hedwig->getGuardedEggRefs() as $ref) {
            if ($ref->equals($egg3GuardedEgg)) {
                $exists = true;
            }
        }
        $this->assertTrue($exists);
    }

    public function testGuardedEggRefsByTextContent(): void
    {
        $guardianRefs = $this->timmy->getGuardedEggRefs();
        $textContents = [];
        foreach ($guardianRefs as $guardianRef) {
            $textContent = $guardianRef->getTextContent();
            $this->assertFalse(empty($textContent));
            $textContents = array_merge($textContents, StringUtil::splitListBySeparator($textContent, " "));
        }
        $this->assertCount(3, $textContents);
        $this->assertContains($this->egg1->getId(), $textContents);
        $this->assertContains($this->egg2->getId(), $textContents);
        $this->assertContains($this->egg3->getId(), $textContents);
    }

    public function testUpdateGuardedEggRefsByTextContent(): void
    {
        $guardianRefs = $this->hedwig->getGuardedEggRefs();

        $guardianRefs[0]->setTextContent($this->egg1->getId() . " " . $this->egg3->getId());

        $this->assertCount(3, $this->hedwig->getGuardedEggs());

        $eggs = [$this->egg1, $this->egg2, $this->egg3];
        foreach ($eggs as $egg) {
            $exists = false;
            foreach ($this->hedwig->getGuardedEggs() as $egg2) {
                if ($egg2->equals($egg)) {
                    $exists = true;
                }
            }
            $this->assertTrue($exists);
        }
    }

    public function testUpdateGuardedEggRefsByRemoveElements(): void
    {
        $guardianRefs = $this->timmy->getGuardedEggRefs();
        $this->timmy->removeGuardedEggRef($guardianRefs[0]);

        $this->assertCount(1, $this->timmy->getGuardedEggs());
        $exists = false;
        foreach ($this->timmy->getGuardedEggs() as $egg) {
            if ($egg->equals($this->egg3)) {
                $exists = true;
            }
        }
        $this->assertTrue($exists);
    }

    public function testClearGuardedEggRefs(): void
    {
        $this->timmy->clearGuardedEggRefs();
        $this->assertEmpty($this->timmy->getGuardedEggRefs());

        // should not affect animals collection
        $animals = $this->modelInstance->getDocumentElement();
        $this->assertCount(3, $animals->getAnimals());
    }
}


1			<?php
2
3			namespace Tests\TestModel\Instance;
4
5			use Xml\Impl\Util\StringUtil;
6			use Xml\ModelInstanceInterface;
7			use Xml\Impl\Parser\AbstractModelParser;
8			use Tests\TestModel\{
9			Gender,
10			TestModelConstants,
11			TestModelParser
12			};
13			use Tests\TestModel\TestModelTest;
14
15			class BirdCreateModelTest extends TestModelTest
16			{
17			protected $tweety;
18			protected $hedwig;
19			protected $timmy;
20			protected $egg1;
21			protected $egg2;
22			protected $egg3;
23
24			protected function setUp(): void
25			{
26			$this->modelParser = new TestModelParser();
27			$this->modelInstance = $this->modelParser->getEmptyModel();
28
29			$animals = $this->modelInstance->newInstance(Animals::class);
30			$this->modelInstance->setDocumentElement($animals);
31
32			// add a tns namespace prefix for QName testing
33			$animals->getDomElement()->registerNamespace("tns", TestModelConstants::MODEL_NAMESPACE);
34
35			$this->tweety = $this->createBird($this->modelInstance, "tweety", Gender::FEMALE);
36			$this->hedwig = $this->createBird($this->modelInstance, "hedwig", Gender::FEMALE);
37			$this->timmy = $this->createBird($this->modelInstance, "timmy", Gender::FEMALE);
38			$this->egg1 = $this->createEgg($this->modelInstance, "egg1");
39			$this->egg1->setMother($this->tweety);
40			$this->egg1->addGuardian($this->hedwig);
41			$this->egg1->addGuardian($this->timmy);
42
43			$this->egg2 = $this->createEgg($this->modelInstance, "egg2");
44			$this->egg2->setMother($this->tweety);
45			$this->egg2->addGuardian($this->hedwig);
46			$this->egg2->addGuardian($this->timmy);
47
48			$this->egg3 = $this->createEgg($this->modelInstance, "egg3");
49			$this->egg3->addGuardian($this->timmy);
50
51			$this->tweety->setSpouse($this->hedwig);
52			$this->tweety->addEgg($this->egg1);
53			$this->tweety->addEgg($this->egg2);
54			$this->tweety->addEgg($this->egg3);
55
56			$this->hedwig->addGuardedEgg($this->egg1);
57			$this->hedwig->addGuardedEgg($this->egg2);
58
59			$guardEgg = $this->modelInstance->newInstance(GuardEgg::class);
60			$guardEgg->setTextContent($this->egg1->getId() . " " . $this->egg2->getId());
61			$this->timmy->addGuardedEggRef($guardEgg);
62			$this->timmy->addGuardedEgg($this->egg3);
63			}
64
65			public function testAddEggsByHelper(): void
66			{
67			$this->assertCount(3, $this->tweety->getEggs());
68			$eggs = [$this->egg1, $this->egg2, $this->egg3];
69			foreach ($eggs as $egg) {
70			$exists = false;
71			foreach ($this->tweety->getEggs() as $egg2) {
72			if ($egg2->equals($egg)) {
73			$exists = true;
74			}
75			}
76			$this->assertTrue($exists);
77			}
78
79			$egg4 = $this->createEgg($this->modelInstance, "egg4");
80			$this->tweety->addEgg($egg4);
81			$egg5 = $this->createEgg($this->modelInstance, "egg5");
82			$this->tweety->addEgg($egg5);
83
84			$this->assertCount(5, $this->tweety->getEggs());
85
86			$eggs = [$this->egg1, $this->egg2, $this->egg3, $egg4, $egg5];
87			foreach ($eggs as $egg) {
88			$exists = false;
89			foreach ($this->tweety->getEggs() as $egg2) {
90			if ($egg2->equals($egg)) {
91			$exists = true;
92			}
93			}
94			$this->assertTrue($exists);
95			}
96			}
97
98			public function testUpdateEggsByIdByHelper(): void
99			{
100			$this->egg1->setId("new-" . $this->egg1->getId());
101			$this->egg2->setId("new-" . $this->egg2->getId());
102
103			$this->assertCount(3, $this->tweety->getEggs());
104			$eggs = [$this->egg1, $this->egg2, $this->egg3];
105			foreach ($eggs as $egg) {
106			$exists = false;
107			foreach ($this->tweety->getEggs() as $egg2) {
108			if ($egg2->equals($egg)) {
109			$exists = true;
110			}
111			}
112			$this->assertTrue($exists);
113			}
114			}
115
116			public function testUpdateEggsByIdByAttributeName(): void
117			{
118			$this->egg1->setAttributeValue("id", "new-" . $this->egg1->getId(), true);
119			$this->egg2->setAttributeValue("id", "new-" . $this->egg2->getId(), true);
120
121			$this->assertCount(3, $this->tweety->getEggs());
122			$eggs = [$this->egg1, $this->egg2, $this->egg3];
123			foreach ($eggs as $egg) {
124			$exists = false;
125			foreach ($this->tweety->getEggs() as $egg2) {
126			if ($egg2->equals($egg)) {
127			$exists = true;
128			}
129			}
130			$this->assertTrue($exists);
131			}
132			}
133
134			public function testUpdateEggsByReplaceElements(): void
135			{
136			$egg4 = $this->createEgg($this->modelInstance, "egg4");
137			$egg5 = $this->createEgg($this->modelInstance, "egg5");
138			$this->egg1->replaceWithElement($egg4);
139			$this->egg2->replaceWithElement($egg5);
140			$this->assertCount(3, $this->tweety->getEggs());
141			$eggs = [$this->egg3, $egg4, $egg5];
142			foreach ($eggs as $egg) {
143			$exists = false;
144			foreach ($this->tweety->getEggs() as $egg2) {
145			if ($egg2->equals($egg)) {
146			$exists = true;
147			}
148			}
149			$this->assertTrue($exists);
150			}
151			}
152
153			public function testUpdateEggsByRemoveElement(): void
154			{
155			$this->tweety->removeEgg($this->egg1);
156			$this->assertCount(2, $this->tweety->getEggs());
157			$eggs = [$this->egg2, $this->egg3];
158			foreach ($eggs as $egg) {
159			$exists = false;
160			foreach ($this->tweety->getEggs() as $egg2) {
161			if ($egg2->equals($egg)) {
162			$exists = true;
163			}
164			}
165			$this->assertTrue($exists);
166			}
167			}
168
169			public function testClearEggs(): void
170			{
171			$this->tweety->clearEggs();
172			$this->assertEmpty($this->tweety->getEggs());
173			}
174
175			public function testSetSpouseRefByHelper(): void
176			{
177			$this->tweety->setSpouse($this->timmy);
178			$this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
179			}
180
181			public function testUpdateSpouseByIdHelper(): void
182			{
183			$this->hedwig->setId("new-" . $this->hedwig->getId());
184			$this->assertTrue($this->tweety->getSpouse()->equals($this->hedwig));
185			}
186
187			public function testUpdateSpouseByIdByAttributeName(): void
188			{
189			$this->hedwig->setAttributeValue("id", "new-" . $this->hedwig->getId(), true);
190			$this->assertTrue($this->tweety->getSpouse()->equals($this->hedwig));
191			}
192
193			public function testUpdateSpouseByReplaceElement(): void
194			{
195			$this->hedwig->replaceWithElement($this->timmy);
196			$this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
197			}
198
199			public function testUpdateSpouseByRemoveElement(): void
200			{
201			$animals = $this->modelInstance->getDocumentElement();
202			$animals->removeAnimal($this->hedwig);
203			$this->assertNull($this->tweety->getSpouse());
204			}
205
206			public function testClearSpouse(): void
207			{
208			$this->tweety->removeSpouse();
209			$this->assertNull($this->tweety->getSpouse());
210			}
211
212			public function testSetSpouseRefsByHelper(): void
213			{
214			$spouseRef = $this->modelInstance->newInstance(SpouseRef::class);
215			$spouseRef->setTextContent($this->timmy->getId());
216			$this->tweety->getSpouseRef()->replaceWithElement($spouseRef);
217			$this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
218			}
219
220			public function testSpouseRefsByTextContent(): void
221			{
222			$spouseRef = $this->tweety->getSpouseRef();
223			$this->assertEquals($spouseRef->getTextContent(), $this->hedwig->getId());
224			}
225
226			public function testUpdateSpouseRefsByTextContent(): void
227			{
228			$spouseRef = $this->tweety->getSpouseRef();
229			$spouseRef->setTextContent($this->timmy->getId());
230			$this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
231			}
232
233			public function testUpdateSpouseRefsByTextContentWithNamespace(): void
234			{
235			$spouseRef = $this->tweety->getSpouseRef();
236			$spouseRef->setTextContent("tns:" . $this->timmy->getId());
237			$this->assertTrue($this->tweety->getSpouse()->equals($this->timmy));
238			}
239
240			public function testGetMother(): void
241			{
242			$mother = $this->egg1->getMother();
243			$this->assertTrue($mother->equals($this->tweety));
244
245			$mother = $this->egg2->getMother();
246			$this->assertTrue($mother->equals($this->tweety));
247			}
248
249			public function testSetMotherRefByHelper(): void
250			{
251			$this->egg1->setMother($this->timmy);
252			$this->assertTrue($this->egg1->getMother()->equals($this->timmy));
253			}
254
255			public function testUpdateMotherByIdHelper(): void
256			{
257			$this->tweety->setId("new-" . $this->tweety->getId());
258			$this->assertTrue($this->egg1->getMother()->equals($this->tweety));
259			}
260
261			public function testUpdateMotherByIdByAttributeName(): void
262			{
263			$this->tweety->setAttributeValue("id", "new-" . $this->tweety->getId(), true);
264			$this->assertTrue($this->egg1->getMother()->equals($this->tweety));
265			}
266
267			public function testUpdateMotherByReplaceElement(): void
268			{
269			$this->tweety->replaceWithElement($this->timmy);
270			$this->assertTrue($this->egg1->getMother()->equals($this->timmy));
271			}
272
273			public function testUpdateMotherByRemoveElement(): void
274			{
275			$this->egg1->setMother($this->hedwig);
276			$animals = $this->modelInstance->getDocumentElement();
277			$animals->removeAnimal($this->hedwig);
278			$this->assertNull($this->egg1->getMother());
279			}
280
281			public function testClearMother(): void
282			{
283			$this->egg1->removeMother();
284			$this->assertNull($this->egg1->getMother());
285			}
286
287			public function testSetMotherRefsByHelper(): void
288			{
289			$mother = $this->modelInstance->newInstance(Mother::class);
290			$mother->setHref("#" . $this->timmy->getId());
291			$this->egg1->getMotherRef()->replaceWithElement($mother);
292			$this->assertTrue($this->egg1->getMother()->equals($this->timmy));
293			}
294
295			public function testMotherRefsByTextContent(): void
296			{
297			$mother = $this->egg1->getMotherRef();
298			$this->assertEquals("#" . $this->tweety->getId(), $mother->getHref());
299			}
300
301			public function testUpdateMotherRefsByTextContent(): void
302			{
303			$mother = $this->egg1->getMotherRef();
304			$mother->setHref("#" . $this->timmy->getId());
305			$this->assertTrue($this->egg1->getMother()->equals($this->timmy));
306			}
307
308			public function testGetGuards(): void
309			{
310			$guards = $this->egg1->getGuardians();
311			$this->assertCount(2, $guards);
312			$birds = [$this->hedwig, $this->timmy];
313			foreach ($birds as $bird) {
314			$exists = false;
315			foreach ($guards as $guard) {
316			if ($bird->equals($guard)) {
317			$exists = true;
318			}
319			}
320			$this->assertTrue($exists);
321			}
322
323			$guards = $this->egg2->getGuardians();
324			$this->assertCount(2, $guards);
325			$birds = [$this->hedwig, $this->timmy];
326			foreach ($birds as $bird) {
327			$exists = false;
328			foreach ($guards as $guard) {
329			if ($bird->equals($guard)) {
330			$exists = true;
331			}
332			}
333			$this->assertTrue($exists);
334			}
335			}
336
337			public function testAddGuardianRefsByHelper(): void
338			{
339			$this->assertCount(2, $this->egg1->getGuardianRefs());
340
341			$tweetyGuardian = $this->modelInstance->newInstance(Guardian::class);
342			$tweetyGuardian->setHref("#" . $this->tweety->getId());
343			$this->egg1->addGuardianRef($tweetyGuardian);
344
345			$this->assertCount(3, $this->egg1->getGuardianRefs());
346			$exists = false;
347			foreach ($this->egg1->getGuardianRefs() as $ref) {
348			if ($ref->equals($tweetyGuardian)) {
349			$exists = true;
350			}
351			}
352			$this->assertTrue($exists);
353			}
354
355			public function testGuardianRefsByTextContent(): void
356			{
357			$guardianRefs = $this->egg1->getGuardianRefs();
358			$hrefs = [];
359			foreach ($guardianRefs as $guardianRef) {
360			$href = $guardianRef->getHref();
361			$this->assertFalse(empty($href));
362			$hrefs[] = $href;
363			}
364			$this->assertFalse(empty($hrefs));
365			$this->assertContains("#" . $this->hedwig->getId(), $hrefs);
366			$this->assertContains("#" . $this->timmy->getId(), $hrefs);
367			}
368
369			public function testUpdateGuardianRefsByTextContent(): void
370			{
371			$guardianRefs = $this->egg1->getGuardianRefs();
372
373			$guardianRefs[0]->setHref("#" . $this->tweety->getId());
374
375			$birds = [$this->tweety, $this->timmy];
376			foreach ($birds as $bird) {
377			$exists = false;
378			foreach ($this->egg1->getGuardians() as $guard) {
379			if ($bird->equals($guard)) {
380			$exists = true;
381			}
382			}
383			$this->assertTrue($exists);
384			}
385			}
386
387			public function testUpdateGuardianRefsByRemoveElements(): void
388			{
389			$guardianRefs = $this->egg1->getGuardianRefs();
390			$this->egg1->removeGuardianRef($guardianRefs[1]);
391			$this->assertCount(1, $this->egg1->getGuardians());
392			}
393
394			public function testClearGuardianRefs(): void
395			{
396			$this->egg1->clearGuardianRefs();
397			$this->assertEmpty($this->egg1->getGuardianRefs());
398
399			// should not affect animals collection
400			$animals = $this->modelInstance->getDocumentElement();
401			$this->assertCount(3, $animals->getAnimals());
402			}
403
404			public function testGetGuardedEggs(): void
405			{
406			$guardedEggs = $this->hedwig->getGuardedEggs();
407			$this->assertCount(2, $guardedEggs);
408			$eggs = [$this->egg1, $this->egg2];
409			foreach ($eggs as $egg) {
410			$exists = false;
411			foreach ($guardedEggs as $egg2) {
412			if ($egg2->equals($egg)) {
413			$exists = true;
414			}
415			}
416			$this->assertTrue($exists);
417			}
418			}
419
420			public function testAddGuardedEggRefsByHelper(): void
421			{
422			$this->assertCount(2, $this->hedwig->getGuardedEggRefs());
423
424			$egg3GuardedEgg = $this->modelInstance->newInstance(GuardEgg::class);
425			$egg3GuardedEgg->setTextContent($this->egg3->getId());
426			$this->hedwig->addGuardedEggRef($egg3GuardedEgg);
427
428			$this->assertCount(3, $this->hedwig->getGuardedEggRefs());
429
430			$exists = false;
431			foreach ($this->hedwig->getGuardedEggRefs() as $ref) {
432			if ($ref->equals($egg3GuardedEgg)) {
433			$exists = true;
434			}
435			}
436			$this->assertTrue($exists);
437			}
438
439			public function testGuardedEggRefsByTextContent(): void
440			{
441			$guardianRefs = $this->timmy->getGuardedEggRefs();
442			$textContents = [];
443			foreach ($guardianRefs as $guardianRef) {
444			$textContent = $guardianRef->getTextContent();
445			$this->assertFalse(empty($textContent));
446			$textContents = array_merge($textContents, StringUtil::splitListBySeparator($textContent, " "));
447			}
448			$this->assertCount(3, $textContents);
449			$this->assertContains($this->egg1->getId(), $textContents);
450			$this->assertContains($this->egg2->getId(), $textContents);
451			$this->assertContains($this->egg3->getId(), $textContents);
452			}
453
454			public function testUpdateGuardedEggRefsByTextContent(): void
455			{
456			$guardianRefs = $this->hedwig->getGuardedEggRefs();
457
458			$guardianRefs[0]->setTextContent($this->egg1->getId() . " " . $this->egg3->getId());
459
460			$this->assertCount(3, $this->hedwig->getGuardedEggs());
461
462			$eggs = [$this->egg1, $this->egg2, $this->egg3];
463			foreach ($eggs as $egg) {
464			$exists = false;
465			foreach ($this->hedwig->getGuardedEggs() as $egg2) {
466			if ($egg2->equals($egg)) {
467			$exists = true;
468			}
469			}
470			$this->assertTrue($exists);
471			}
472			}
473
474			public function testUpdateGuardedEggRefsByRemoveElements(): void
475			{
476			$guardianRefs = $this->timmy->getGuardedEggRefs();
477			$this->timmy->removeGuardedEggRef($guardianRefs[0]);
478
479			$this->assertCount(1, $this->timmy->getGuardedEggs());
480			$exists = false;
481			foreach ($this->timmy->getGuardedEggs() as $egg) {
482			if ($egg->equals($this->egg3)) {
483			$exists = true;
484			}
485			}
486			$this->assertTrue($exists);
487			}
488
489			public function testClearGuardedEggRefs(): void
490			{
491			$this->timmy->clearGuardedEggRefs();
492			$this->assertEmpty($this->timmy->getGuardedEggRefs());
493
494			// should not affect animals collection
495			$animals = $this->modelInstance->getDocumentElement();
496			$this->assertCount(3, $animals->getAnimals());
497			}
498			}
499

bingo-soft / xml

testUpdateEggsByReplaceElements() A last analyzed 2022-08-02 11:14 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testUpdateEggsByReplaceElements() A
last analyzed 2022-08-02 11:14 UTC