<?php declare(strict_types=1);
 /**
  * Part of Windwalker project Test files.  @codingStandardsIgnoreStart
  *
  * @copyright  Copyright (C) 2019 SMS Taiwan, Inc.
  * @license    GNU General Public License version 2 or later; see LICENSE
  */
 
 namespace Windwalker\Structure\Test;
 
 use Windwalker\Structure\Structure;
 use Windwalker\Structure\StructureHelper;
 use Windwalker\Structure\Test\Stubs\StubDumpable;
 
 /**
  * Test class of StructureHelper
  *
  * @since 2.1
  */
 class StructureHelperTest extends \PHPUnit\Framework\TestCase
 {
     /**
      * Sets up the fixture, for example, opens a network connection.
      * This method is called before a test is executed.
      *
      * @return void
      */
     protected function setUp(): void
     {
     }
 
     /**
      * Tears down the fixture, for example, closes a network connection.
      * This method is called after a test is executed.
      *
      * @return void
      */
     protected function tearDown(): void
     {
     }
 
     /**
      * Method to test isAssociativeArray().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::isAssociativeArray
      */
     public function testIsAssociativeArray()
     {
         $this->assertFalse(StructureHelper::isAssociativeArray(['a', 'b']));
 
         $this->assertTrue(StructureHelper::isAssociativeArray([1, 2, 'a' => 'b', 'c', 'd']));
     }
 
     /**
      * Method to test toObject().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::toObject
      */
     public function testToObject()
     {
         $data = StructureHelper::toObject(['foo' => 'bar']);
 
         $this->assertIsObject($data);
 
         $this->assertEquals('bar', $data->foo);
 
         $data = StructureHelper::toObject(['foo' => 'bar'], 'ArrayObject');
 
         $this->assertInstanceOf('ArrayObject', $data);
 
         $data = StructureHelper::toObject(['foo' => ['bar' => 'baz']]);
 
         $this->assertEquals('baz', $data->foo->bar);
     }
 
     /**
      * Method to test getByPath().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::getByPath
      */
     public function testGetByPath()
     {
         $data = [
             'flower' => 'sakura',
             'olive' => 'peace',
             'pos1' => [
                 'sunflower' => 'love',
             ],
             'pos2' => [
                 'cornflower' => 'elegant',
             ],
             'array' => [
                 'A',
                 'B',
                 'C',
             ],
         ];
 
         $this->assertEquals('sakura', StructureHelper::getByPath($data, 'flower'));
         $this->assertEquals('love', StructureHelper::getByPath($data, 'pos1.sunflower'));
         $this->assertEquals('love', StructureHelper::getByPath($data, 'pos1/sunflower', '/'));
         $this->assertEquals($data['array'], StructureHelper::getByPath($data, 'array'));
         $this->assertNull(StructureHelper::getByPath($data, 'not.exists'));
     }
 
     /**
      * Method to test getByPath().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::getByPath
      */
     public function testGetByPathWithObject()
     {
         $data = [
             'flower' => 'sakura',
             'olive' => 'peace',
             'pos1' => (object) [
                 'sunflower' => 'love',
             ],
             'pos2' => new Structure(
                 [
                     'cornflower' => 'elegant',
                 ]
             ),
             'array' => [
                 'A',
                 'B',
                 'C',
             ],
         ];
 
         $this->assertEquals('sakura', StructureHelper::getByPath($data, 'flower'));
         $this->assertEquals('love', StructureHelper::getByPath($data, 'pos1.sunflower'));
         $this->assertEquals('elegant', StructureHelper::getByPath($data, 'pos2.cornflower'));
         $this->assertEquals(null, StructureHelper::getByPath($data, 'pos2.data'));
     }
 
     /**
      * Method to test setByPath().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::setByPath
      */
     public function testSetByPath()
     {
         $data = [];
 
         // One level
         $return = StructureHelper::setByPath($data, 'flower', 'sakura');
 
         $this->assertEquals('sakura', $data['flower']);
         $this->assertTrue($return);
 
         // Multi-level
         StructureHelper::setByPath($data, 'foo.bar', 'test');
 
         $this->assertEquals('test', $data['foo']['bar']);
 
         // Separator
         StructureHelper::setByPath($data, 'foo/bar', 'play', '/');
 
         $this->assertEquals('play', $data['foo']['bar']);
 
         // False
         $return = StructureHelper::setByPath($data, '', 'goo');
 
         $this->assertFalse($return);
 
         // Fix path
         StructureHelper::setByPath($data, 'double..separators', 'value');
 
         $this->assertEquals('value', $data['double']['separators']);
     }
 
     /**
      * testRemoveByPath
      *
      * @return  void
      */
     public function testRemoveByPath()
     {
         $data = [
             'foo' => [
                 'bar' => '123',
             ],
         ];
 
         StructureHelper::removeByPath($data, 'foo.bar');
 
         $this->assertFalse(array_key_exists('bar', $data['foo']));
 
         $data = [
             'foo' => [
                 'bar' => '123',
             ],
         ];
 
         StructureHelper::removeByPath($data, 'foo');
 
         $this->assertFalse(array_key_exists('foo', $data));
 
         $data = [
             'foo' => [
                 'bar' => '123',
             ],
         ];
 
         StructureHelper::removeByPath($data, 'foo.yoo');
 
         $this->assertEquals('123', $data['foo']['bar']);
     }
 
     /**
      * Method to test getPathNodes().
      *
      * @return void
      *
      * @covers \Windwalker\Structure\StructureHelper::getPathNodes
      */
     public function testGetPathNodes()
     {
         $this->assertEquals(['a', 'b', 'c'], StructureHelper::getPathNodes('a..b.c'));
         $this->assertEquals(['a', 'b', 'c'], StructureHelper::getPathNodes('a//b/c', '/'));
     }
 
     /**
      * testFlatten
      *
      * @return  void
      *
      * @covers  \Windwalker\Structure\StructureHelper::flatten
      * @since   2.0
      */
     public function testFlatten()
     {
         $array = [
             'flower' => 'sakura',
             'olive' => 'peace',
             'pos1' => [
                 'sunflower' => 'love',
             ],
             'pos2' => [
                 'cornflower' => 'elegant',
             ],
         ];
 
         $flatted = StructureHelper::flatten($array);
 
         $this->assertEquals($flatted['pos1.sunflower'], 'love');
 
         $flatted = StructureHelper::flatten($array, '/');
 
         $this->assertEquals($flatted['pos1/sunflower'], 'love');
     }
 
     /**
      * Data provider for object inputs
      *
      * @return  array
      *
      * @since   2.0
      */
     public function seedTestToArray()
     {
         return [
             'string' => [
                 'foo',
                 false,
                 ['foo'],
             ],
             'array' => [
                 ['foo'],
                 false,
                 ['foo'],
             ],
             'array_recursive' => [
                 [
                     'foo' => [
                         (object) ['bar' => 'bar'],
                         (object) ['baz' => 'baz'],
                     ],
                 ],
                 true,
                 [
                     'foo' => [
                         ['bar' => 'bar'],
                         ['baz' => 'baz'],
                     ],
                 ],
             ],
             'iterator' => [
                 ['foo' => new \ArrayIterator(['bar' => 'baz'])],
                 true,
                 ['foo' => ['bar' => 'baz']],
             ],
         ];
     }
 
     /**
      * testToArray
      *
      * @param $input
      * @param $recursive
      * @param $expect
      *
      * @return  void
      *
      * @dataProvider  seedTestToArray
      * @covers        \Windwalker\Utilities\ArrayHelper::toArray
      */
     public function testToArray($input, $recursive, $expect)
     {
         $this->assertEquals($expect, StructureHelper::toArray($input, $recursive));
     }
 
     public function testDumpObjectValue()
     {
         $data = new StubDumpable(new StubDumpable());
 
         $dumped = StructureHelper::dumpObjectValues($data);
 
         $this->assertEquals('foo', $dumped['foo']);
         $this->assertEquals('bar', $dumped['bar']);
         $this->assertNull($dumped['data']['self']);
         $this->assertEquals(StructureHelper::dumpObjectValues(new StubDumpable()), $dumped['data']['new']);
         $this->assertEquals(['sakura', 'rose'], $dumped['data']['flower']);
         $this->assertEquals(['wind' => 'walker'], $dumped['iterator']);
     }
 }