Fix broken min/max calculations on groupRef child elements

Author: veewee

src/Documentation/StandardDocumentationReader.php

@@ -31,6 +31,6 @@ public function get(\DOMElement $node): string
         }
         $doc = preg_replace('/[\t ]+/', ' ', $doc);
 
-        return trim($doc);
+        return mb_trim($doc);
     }
 }

src/Schema/Element/GroupRef.php

@@ -58,12 +58,17 @@ public function getElements(): array
              * @var Element|ElementRef|ElementSingle|GroupRef $clonedElement
              */
             $clonedElement = clone $element;
-            if (0 < $this->getMax() || -1 === $this->getMax()) {
-                $clonedElement->setMax($this->getMax());
+
+            $groupMax = $this->getMax();
+            if (1 !== $groupMax) {
+                $elementMax = $clonedElement->getMax();
+                $clonedElement->setMax((-1 === $groupMax || -1 === $elementMax) ? -1 : $groupMax * $elementMax);
             }
 
-            if (1 < $this->getMin() && 1 === $clonedElement->getMin()) {
-                $clonedElement->setMin($this->getMin());
+            $groupMin = $this->getMin();
+            if (1 !== $groupMin) {
+                $elementMin = $clonedElement->getMin();
+                $clonedElement->setMin($groupMin * $elementMin);
             }
 
             $elements[$k] = $clonedElement;

src/SchemaReader.php

@@ -110,7 +110,7 @@ private function extractErrorMessage(): \Exception
         $errors = [];
 
         foreach (libxml_get_errors() as $error) {
-            $errors[] = sprintf("Error[%s] code %s: %s in '%s' at position %s:%s", $error->level, $error->code, trim($error->message), $error->file, $error->line, $error->column);
+            $errors[] = sprintf("Error[%s] code %s: %s in '%s' at position %s:%s", $error->level, $error->code, mb_trim($error->message), $error->file, $error->line, $error->column);
         }
         $e = new \Exception(implode('; ', $errors));
         libxml_use_internal_errors(false);
@@ -1244,7 +1244,7 @@ private function loadImport(
 
     private function createOrUseSchemaForNs(Schema $schema, string $namespace): Schema
     {
-        if ('' !== trim($namespace)) {
+        if ('' !== mb_trim($namespace)) {
             $newSchema = new Schema();
             $newSchema->addSchema($this->getGlobalSchema());
             $schema->addSchema($newSchema);

src/Utils/UrlUtils.php

@@ -8,7 +8,7 @@ class UrlUtils
 {
     public static function resolveRelativeUrl(string $base, string $rel): string
     {
-        if ('' === trim($rel)) {
+        if ('' === mb_trim($rel)) {
             return $base;
         }
 

tests/ElementsTest.php

@@ -63,7 +63,7 @@ public function testBase(): void
     /**
      * @dataProvider getGroupCounts
      */
-    public function testGroupOccurrences($item, $min, $max): void
+    public function testGroupOccurrences($groupItem, array $groupMinMax, array $elementsMinMax): void
     {
         $schema = $this->reader->readString(
             '
@@ -86,7 +86,10 @@ public function testGroupOccurrences($item, $min, $max): void
 
                 <xs:group name="myGroup">
                     <xs:sequence>
-                        <xs:element name="groupEl1" type="xs:string" />
+                        <xs:element name="nullable" type="xs:string" minOccurs="0" />
+                        <xs:element name="list" type="xs:string" minOccurs="0" maxOccurs="unbounded" />
+                        <xs:element name="scoped" type="xs:string" minOccurs="3" maxOccurs="5" />
+                        <xs:element name="single" type="xs:string" minOccurs="1" maxOccurs="1"/>
                     </xs:sequence>
                 </xs:group>
             </xs:schema>');
@@ -97,39 +100,69 @@ public function testGroupOccurrences($item, $min, $max): void
         $myGroup = $schema->findGroup('myGroup', 'http://www.example.com');
         self::assertInstanceOf(Group::class, $myGroup);
 
-        $myGroupRef = $myType->getElements()[$item];
+        $myGroupRef = $myType->getElements()[$groupItem];
         self::assertInstanceOf(GroupRef::class, $myGroupRef);
 
         $wrappedEls = $myGroupRef->getElements();
-        if (-1 === $max || $max > 0) {
-            self::assertEquals($max, $wrappedEls[0]->getMax());
-        } else {
-            self::assertEquals(1, $wrappedEls[0]->getMax());
-        }
-
-        if ($min > 1) {
-            self::assertEquals($max, $wrappedEls[0]->getMin());
-        } else {
-            self::assertEquals(1, $wrappedEls[0]->getMin());
+        foreach ($wrappedEls as $elementIndex => $element) {
+            [$elementMin, $elementMax] = $elementsMinMax[$elementIndex];
+            self::assertEquals($elementMin, $element->getMin(), 'Failed asserting on element index ' . $elementIndex);
+            self::assertEquals($elementMax, $element->getMax(), 'Failed asserting on element index ' . $elementIndex);
         }
 
         self::assertEquals('myGroup', $myGroupRef->getName());
 
-        self::assertEquals($min, $myGroupRef->getMin());
-        self::assertEquals($max, $myGroupRef->getMax());
+        [$groupMin, $groupMax] = $groupMinMax;
+        self::assertEquals($groupMin, $myGroupRef->getMin());
+        self::assertEquals($groupMax, $myGroupRef->getMax());
     }
 
     public function getGroupCounts(): array
     {
         return [
             // item, min, max
-            [0, 1, 1],
-            [1, 2, 2], // if the min = 2, max must be at least 2
-            [2, 1, 1],
-            [3, 1, -1],
-            [4, 1, 1],
-            [5, 2, 2],
-            [6, 1, -1],
+            [0, [1, 1], [
+                [0, 1],
+                [0, -1],
+                [3, 5],
+                [1, 1],
+            ]],
+            [1, [2, 2], [
+                [0, 2],
+                [0, -1],
+                [6, 10],
+                [2, 2],
+            ]],
+            [2, [1, 1], [
+                [0, 1],
+                [0, -1],
+                [3, 5],
+                [1, 1],
+            ]],
+            [3, [1, -1], [
+                [0, -1],
+                [0, -1],
+                [3, -1],
+                [1, -1],
+            ]],
+            [4, [1, 1], [
+                [0, 1],
+                [0, -1],
+                [3, 5],
+                [1, 1],
+            ]],
+            [5, [2, 2], [
+                [0, 2],
+                [0, -1],
+                [6, 10],
+                [2, 2],
+            ]],
+            [6, [1, -1], [
+                [0, -1],
+                [0, -1],
+                [3, -1],
+                [1, -1],
+            ]],
         ];
     }
 
@@ -154,7 +187,7 @@ public function testNotQualifiedTargetQualifiedElement(): void
         self::assertFalse($schema->getElementsQualification());
 
         /**
-         * @var $element ElementSingle
+         * @var ElementSingle $element
          */
         $element = $myType->getElements()[0];
         self::assertFalse($element->isQualified());