/**
  * Check this resource type instance has bag property associated with it
  * Note: This is an internal method used by library. Devs don't use this.
  *
  * @param array(mixed) &$arrayToDetectLoopInComplexType array for detecting loop.
  *
  * @return boolean true if resource type instance has bag property else false
  */
 public function hasBagProperty(&$arrayToDetectLoopInComplexType)
 {
     // Note: Calling this method will initialize _bagProperties
     // and _hasBagProperty flag to a boolean value
     // from null depending on the current state of
     // _propertiesDeclaredOnThisType array, so method
     // should be called only after adding all properties
     if (is_null($this->_hasBagProperty)) {
         if ($this->_baseType != null && $this->_baseType->hasBagProperty($arrayToDetectLoopInComplexType)) {
             $this->_hasBagProperty = true;
         } else {
             foreach ($this->_propertiesDeclaredOnThisType as $resourceProperty) {
                 $hasBagInComplex = false;
                 if ($resourceProperty->isKindOf(ResourcePropertyKind::COMPLEX_TYPE)) {
                     //We can say current ResouceType ("this")
                     //is contains a bag property if:
                     //1. It contain a property of kind bag.
                     //2. It contains a normal complex property
                     //with a sub property of kind bag.
                     //The second case can be further expanded, i.e.
                     //if the normal complex property
                     //has a normal complex sub property with a
                     //sub property of kind bag.
                     //So for complex type we recursively call this
                     //function to check for bag.
                     //Shown below how looping can happen in complex type:
                     //Customer ResourceType (id1)
                     //{
                     //  ....
                     //  Address: Address ResourceType (id2)
                     //  {
                     //    .....
                     //    AltAddress: Address ResourceType (id2)
                     //    {
                     //      ...
                     //    }
                     //  }
                     //}
                     //
                     //Here the resource type of Customer::Address and
                     //Customer::Address::AltAddress
                     //are same, this is a loop, we need to detect
                     //this and avoid infinite recursive loop.
                     //
                     $count = count($arrayToDetectLoopInComplexType);
                     $foundLoop = false;
                     for ($i = 0; $i < $count; $i++) {
                         if ($arrayToDetectLoopInComplexType[$i] === $resourceProperty->getResourceType()) {
                             $foundLoop = true;
                             break;
                         }
                     }
                     if (!$foundLoop) {
                         $arrayToDetectLoopInComplexType[$count] = $resourceProperty->getResourceType();
                         $hasBagInComplex = $resourceProperty->getResourceType()->hasBagProperty($arrayToDetectLoopInComplexType);
                         unset($arrayToDetectLoopInComplexType[$count]);
                     }
                 }
                 if ($resourceProperty->isKindOf(ResourcePropertyKind::BAG) || $hasBagInComplex) {
                     $this->_hasBagProperty = true;
                     break;
                 }
             }
         }
     }
     return $this->_hasBagProperty;
 }
 /**
  * test ResourceType class
  */
 public function testResourceType()
 {
     try {
         $exceptionThrown = false;
         try {
             ResourceType::getPrimitiveResourceType(TypeCode::VOID);
         } catch (\InvalidArgumentException $exception) {
             $exceptionThrown = true;
             $this->assertStringEndsWith('is not a valid EdmPrimitiveType Enum value', $exception->getMessage());
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'EdmPrimitiveType\' has not been raised');
         }
         $int16ResType = new ResourceType(new Int16(), ResourceTypeKind::PRIMITIVE, 'Int16', 'Edm');
         $exceptionThrown = false;
         try {
             $int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', $int16ResType);
         } catch (\InvalidArgumentException $exception) {
             $this->AssertEquals('Primitive type cannot have base type', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'basetype\' has not been raised');
         }
         $exceptionThrown = false;
         try {
             $int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', null, true);
         } catch (\InvalidArgumentException $exception) {
             $this->AssertEquals('Primitive type cannot be abstract', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'abstract\' has not been raised');
         }
         $exceptionThrown = false;
         try {
             $int32ResType = new ResourceType(null, ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm');
         } catch (\InvalidArgumentException $exception) {
             $this->assertStringEndsWith('should be an \'IType\' implementor instance', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'IType\' has not been raised');
         }
         $exceptionThrown = false;
         try {
             $customerResType = new ResourceType(null, ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
         } catch (\InvalidArgumentException $exception) {
             $this->assertStringEndsWith('argument should be an \'ReflectionClass\' instance', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'ReflectionClass\' has not been raised');
         }
         $customerResType = new ResourceType(new ReflectionClass('Customer2'), ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
         $this->AssertEquals($customerResType->getName(), 'Customer');
         $this->AssertEquals($customerResType->getFullName(), 'Northwind.Customer');
         $this->assertTrue($customerResType->getInstanceType() instanceof \ReflectionClass);
         $this->AssertEquals($customerResType->getNamespace(), 'Northwind');
         $this->AssertEquals($customerResType->getResourceTypeKind(), ResourceTypeKind::ENTITY);
         $this->AssertEquals($customerResType->isMediaLinkEntry(), false);
         $exceptionThrown = false;
         try {
             $customerResType->validateType();
         } catch (InvalidOperationException $exception) {
             $this->assertStringEndsWith('Please make sure the key properties are defined for this entity type', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidOperationException for \'No key defined\' has not been raised');
         }
         $exceptionThrown = false;
         try {
             $int32ResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
             $primitiveResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
             $testProperty = new ResourceProperty('test', null, ResourcePropertyKind::PRIMITIVE, $primitiveResourceType);
             $int32ResourceType->addProperty($testProperty);
         } catch (InvalidOperationException $exception) {
             $this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'Primitive\'', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidOperationException for \'property on primitive\' has not been raised');
         }
         $stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
         $customerIDPrimProperty = new ResourceProperty('CustomerID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType);
         $customerNamePrimProperty = new ResourceProperty('CustomerName', null, ResourcePropertyKind::PRIMITIVE, $stringResourceType);
         $intResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
         $ratingPrimProperty = new ResourceProperty('Rating', null, ResourcePropertyKind::PRIMITIVE, $intResourceType);
         $addressResType = new ResourceType(new ReflectionClass('Address2'), ResourceTypeKind::COMPLEX, 'Address', 'Northwind');
         $exceptionThrown = false;
         try {
             $booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
             $isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $booleanResourceType);
             $addressResType->addProperty($isPrimaryPrimProperty);
         } catch (InvalidOperationException $exception) {
             $this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'EntityType\'', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidOperationException for \'Key on non-entity\' has not been raised');
         }
         $booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
         $isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE, $booleanResourceType);
         $addressResType->addProperty($isPrimaryPrimProperty);
         $exceptionThrown = false;
         try {
             $addressResType->addProperty($isPrimaryPrimProperty);
         } catch (InvalidOperationException $exception) {
             $this->assertStringStartsWith('Property with same name \'IsPrimary\' already exists in type \'Address\'', $exception->getMessage());
             $exceptionThrown = true;
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidArgumentException for \'Property duplication\' has not been raised');
         }
         $exceptionThrown = false;
         try {
             $addressResType->setMediaLinkEntry(true);
         } catch (InvalidOperationException $exception) {
             $exceptionThrown = true;
             $this->assertStringStartsWith('Cannot apply the HasStreamAttribute', $exception->getMessage());
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidOperationException for \'MLE on non-entity\' has not been raised');
         }
         $customerAdrComplexType = new ResourceProperty('Address', null, ResourcePropertyKind::COMPLEX_TYPE, $addressResType);
         $customerResType->addProperty($customerIDPrimProperty);
         $customerResType->addProperty($customerNamePrimProperty);
         $customerResType->addProperty($ratingPrimProperty);
         $customerResType->addProperty($customerAdrComplexType);
         $customerResType->validateType();
         $customerProperties = $customerResType->getPropertiesDeclaredOnThisType();
         $this->AssertEquals(count($customerProperties), 4);
         $customerAllProperties = $customerResType->getAllProperties();
         $this->AssertEquals(count($customerProperties), count($customerAllProperties));
         $keys = array('CustomerID', 'CustomerName', 'Rating', 'Address');
         $i = 0;
         foreach ($customerAllProperties as $key => $customerProperty) {
             $this->AssertEquals($key, $keys[$i++]);
         }
         $entityKeys = array('CustomerID');
         $customerKeyProperties = $customerResType->getKeyProperties();
         $i = 0;
         foreach ($customerKeyProperties as $key => $customerKeyProperty) {
             $this->AssertEquals($key, $entityKeys[$i++]);
         }
         $this->AssertEquals(count($customerResType->getETagProperties()), 0);
         $this->AssertEquals($customerResType->tryResolvePropertyTypeByName('PropNotExists'), null);
         $property = $customerResType->tryResolvePropertyTypeByName('CustomerName');
         $this->AssertNotEquals($property, null);
         $this->AssertEquals($property->getName(), 'CustomerName');
         $employeeResType = new ResourceType(new ReflectionClass('Employee2'), ResourceTypeKind::ENTITY, 'Employee', 'Northwind');
         $stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
         $employeeResType->addProperty(new ResourceProperty('EmployeeID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType));
         $employeeResType->addProperty(new ResourceProperty('Emails', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::BAG, $stringResourceType));
         $employeeResType->setMediaLinkEntry(true);
         $employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
         $exceptionThrown = false;
         try {
             $employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
         } catch (InvalidOperationException $exception) {
             $exceptionThrown = true;
             $this->assertStringStartsWith('Named stream with the name \'ThumNail_64X64\' already exists in type \'Employee\'', $exception->getMessage());
         }
         if (!$exceptionThrown) {
             $this->fail('An expected InvalidOperationException for \'named stream duplication\' has not been raised');
         }
         $this->AssertEquals($employeeResType->hasNamedStream(), true);
         $b = array();
         $this->AssertEquals($employeeResType->hasBagProperty($b), true);
         $namedStreams = $employeeResType->getAllNamedStreams();
         $this->AssertEquals(count($namedStreams), 1);
         $this->AssertTrue(array_key_exists('ThumNail_64X64', $namedStreams));
         $name = $employeeResType->tryResolveNamedStreamByName('ThumNail_64X64')->getName();
         $this->AssertEquals($name, 'ThumNail_64X64');
     } catch (\Exception $exception) {
         $this->fail('An unexpected Exception has been raised' . $exception->getMessage());
     }
 }