芝麻web文件管理V1.00

编辑当前文件:/home/mgatv524/public_html/avenida/views/XML_Util.zip

PK������{eqY�f��������examples/example2.phpnu��[�����������<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * Examples (file #2)
 *
 * several examples for the methods of XML_Util
 * 
 * PHP versions 4 and 5
 *
 * LICENSE:
 *
 * Copyright (c) 2003-2008 Stephan Schmidt <schst@php.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * * The name of the author may not be used to endorse or promote products
 * derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category XML
 * @package XML_Util
 * @subpackage Examples
 * @author Stephan Schmidt <schst@php.net>
 * @copyright 2003-2008 Stephan Schmidt <schst@php.net>
 * @license http://opensource.org/licenses/bsd-license New BSD License
 * @version CVS: $Id$
 * @link http://pear.php.net/package/XML_Util
 */

/**
     * set error level
     */
    error_reporting(E_ALL);

require_once 'XML/Util.php';

/**
 * creating a start element
 */
 print 'creating a start element: ';
 print htmlentities(XML_Util::createStartElement('myNs:myTag', 
 array('foo' => 'bar'), 'http://www.w3c.org/myNs#'));
 print "\n \n";

/**
 * creating a start element
 */
 print 'creating a start element: ';
 print htmlentities(XML_Util::createStartElement('myTag', 
 array(), 'http://www.w3c.org/myNs#'));
 print "\n \n";

/**
 * creating a start element
 */
 print 'creating a start element: ';
 print '<pre>';
 print htmlentities(XML_Util::createStartElement('myTag', 
 array('foo' => 'bar', 'argh' => 'tomato'), 
 'http://www.w3c.org/myNs#', true));
 print '</pre>';
 print "\n \n";

/**
 * creating an end element
 */
 print 'creating an end element: ';
 print htmlentities(XML_Util::createEndElement('myNs:myTag'));
 print "\n \n";

/**
 * creating a CData section
 */
 print 'creating a CData section: ';
 print htmlentities(XML_Util::createCDataSection('I am content.'));
 print "\n \n";

/**
 * creating a comment
 */
 print 'creating a comment: ';
 print htmlentities(XML_Util::createComment('I am a comment.'));
 print "\n \n";

/**
     * creating an XML tag with multiline mode
     */
    $tag = array(
        'qname'        => 'foo:bar',
        'namespaceUri' => 'http://foo.com',
        'attributes'   => array('key' => 'value', 'argh' => 'fruit&vegetable'),
        'content'      => 'I\'m inside the tag & contain dangerous chars'
    );

print 'creating a tag with qualified name and namespaceUri: ';
 print '<pre>';
 print htmlentities(XML_Util::createTagFromArray($tag, 
 XML_UTIL_REPLACE_ENTITIES, true));
 print '</pre>';
 print "\n \n";

/**
 * create an attribute string without replacing the entities
 */
 $atts = array('series' => 'Starsky & Hutch', 'channel' => 'ABC');
 print 'creating a attribute string, '
 . 'entities in values already had been replaced: ';
 print htmlentities(XML_Util::attributesToString($atts, 
 true, false, false, false, XML_UTIL_ENTITIES_NONE));
 print "\n \n";

/**
 * using the array-syntax for attributesToString()
 */
 $atts = array('series' => 'Starsky & Hutch', 'channel' => 'ABC');
 print 'using the array-syntax for attributesToString() ';
 print htmlentities(XML_Util::attributesToString($atts, 
 array('entities' => XML_UTIL_ENTITIES_NONE)));
 print "\n \n";

?>
PK������{eqY5k��#���#����examples/example.phpnu��[�����������<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * Examples (file #1)
 *
 * several examples for the methods of XML_Util
 * 
 * PHP versions 4 and 5
 *
 * LICENSE:
 *
 * Copyright (c) 2003-2008 Stephan Schmidt <schst@php.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * * The name of the author may not be used to endorse or promote products
 * derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category XML
 * @package XML_Util
 * @subpackage Examples
 * @author Stephan Schmidt <schst@php.net>
 * @copyright 2003-2008 Stephan Schmidt <schst@php.net>
 * @license http://opensource.org/licenses/bsd-license New BSD License
 * @version CVS: $Id$
 * @link http://pear.php.net/package/XML_Util
 */

/**
     * set error level
     */
    error_reporting(E_ALL);

require_once 'XML/Util.php';
 
 /**
 * replacing XML entities
 */
 print 'replace XML entities: ';
 print XML_Util::replaceEntities('This string contains < & >.');
 print "\n \n";

/**
 * reversing XML entities
 */
 print 'replace XML entities: ';
 print XML_Util::reverseEntities('This string contains < & >.');
 print "\n \n";

/**
 * building XML declaration
 */
 print 'building XML declaration: ';
 print htmlspecialchars(XML_Util::getXMLDeclaration());
 print "\n \n";

print 'building XML declaration with additional attributes: ';
 print htmlspecialchars(XML_Util::getXMLDeclaration('1.0', 'UTF-8', true));
 print "\n \n";

/**
 * building document type declaration
 */
 print 'building DocType declaration: ';
 print htmlspecialchars(XML_Util::getDocTypeDeclaration('package', 
 'http://pear.php.net/dtd/package-1.0'));
 print "\n \n";

print 'building DocType declaration with public ID (does not exist): ';
 print htmlspecialchars(XML_Util::getDocTypeDeclaration('package', 
 array('uri' => 'http://pear.php.net/dtd/package-1.0', 
 'id' => '-//PHP//PEAR/DTD PACKAGE 0.1')));
 print "\n \n";

print 'building DocType declaration with internal DTD: ';
 print '<pre>';
 print htmlspecialchars(XML_Util::getDocTypeDeclaration('package', 
 'http://pear.php.net/dtd/package-1.0', 
 '<!ELEMENT additionalInfo (#PCDATA)>'));
 print '</pre>';
 print "\n \n";

/**
     * creating an attribute string
     */
    $att = array(
        'foo'  => 'bar',
        'argh' => 'tomato'
    );

print 'converting array to string: ';
 print XML_Util::attributesToString($att);
 print "\n \n";

/**
     * creating an attribute string with linebreaks
     */
    $att = array(
        'foo'  => 'bar',
        'argh' => 'tomato'
    );

print 'converting array to string (including line breaks): ';
 print '<pre>';
 print XML_Util::attributesToString($att, true, true);
 print '</pre>';
 print "\n \n";

/**
 * splitting a qualified tag name
 */
 print 'splitting qualified tag name: ';
 print '<pre>';
 print_r(XML_Util::splitQualifiedName('xslt:stylesheet'));
 print '</pre>';
 print "\n \n";

/**
 * splitting a qualified tag name (no namespace)
 */
 print 'splitting qualified tag name (no namespace): ';
 print '<pre>';
 print_r(XML_Util::splitQualifiedName('foo'));
 print '</pre>';
 print "\n \n";

/**
 * splitting a qualified tag name (no namespace, but default namespace specified)
 */
 print 'splitting qualified tag name '
 . '(no namespace, but default namespace specified): ';
 print '<pre>';
 print_r(XML_Util::splitQualifiedName('foo', 'bar'));
 print '</pre>';
 print "\n \n";

/**
 * verifying XML names
 */
 print 'verifying \'My private tag\': ';
 print '<pre>';
 print_r(XML_Util::isValidname('My Private Tag'));
 print '</pre>';
 print "\n \n";
 
 print 'verifying \'-MyTag\': ';
 print '<pre>';
 print_r(XML_Util::isValidname('-MyTag'));
 print '</pre>';
 print "\n \n";

/**
     * creating an XML tag
     */
    $tag = array(
        'namespace'  => 'foo',
        'localPart'  => 'bar',
        'attributes' => array('key' => 'value', 'argh' => 'fruit&vegetable'),
        'content'    => 'I\'m inside the tag'
    );

print 'creating a tag with namespace and local part: ';
 print htmlentities(XML_Util::createTagFromArray($tag));
 print "\n \n";

/**
     * creating an XML tag
     */
    $tag = array(
        'qname'        => 'foo:bar',
        'namespaceUri' => 'http://foo.com',
        'attributes'   => array('key' => 'value', 'argh' => 'fruit&vegetable'),
        'content'      => 'I\'m inside the tag'
    );

print 'creating a tag with qualified name and namespaceUri: ';
 print htmlentities(XML_Util::createTagFromArray($tag));
 print "\n \n";

/**
     * creating an XML tag
     */
    $tag = array(
        'qname'        => 'bar',
        'namespaceUri' => 'http://foo.com',
        'attributes'   => array('key' => 'value', 'argh' => 'fruit&vegetable')
    );

print 'creating an empty tag without namespace but namespace Uri: ';
 print htmlentities(XML_Util::createTagFromArray($tag));
 print "\n \n";

/**
     * creating an XML tag with more namespaces
     */
    $tag = array(
        'namespace'   => 'foo',
        'localPart'   => 'bar',
        'attributes'  => array('key' => 'value', 'argh' => 'fruit&vegetable'),
        'content'     => 'I\'m inside the tag',
        'namespaces'  => array(
            'bar'  => 'http://bar.com',
            'pear' => 'http://pear.php.net',
        )
    );

print 'creating an XML tag with more namespaces: ';
 print htmlentities(XML_Util::createTagFromArray($tag));
 print "\n \n";

/**
     * creating an XML tag with a CData Section
     */
    $tag = array(
        'qname'      => 'foo',
        'attributes' => array('key' => 'value', 'argh' => 'fruit&vegetable'),
        'content'    => 'I\'m inside the tag'
    );

print 'creating a tag with CData section: ';
 print htmlentities(XML_Util::createTagFromArray($tag, XML_UTIL_CDATA_SECTION));
 print "\n \n";

/**
 * creating an XML tag with a CData Section
 */
 $tag = array(
 'qname' => 'foo',
 'attributes' => array('key' => 'value', 'argh' => 't�t�'),
 'content' => 
 'Also XHTML-tags can be created '
 . 'and HTML entities can be replaced � � � � <>.'
 );

print 'creating a tag with HTML entities: ';
 print htmlentities(XML_Util::createTagFromArray($tag, XML_UTIL_ENTITIES_HTML));
 print "\n \n";

/**
 * creating an XML tag with createTag
 */
 print 'creating a tag with createTag: ';
 print htmlentities(XML_Util::createTag('myNs:myTag', 
 array('foo' => 'bar'), 
 'This is inside the tag', 
 'http://www.w3c.org/myNs#'));
 print "\n \n";

/**
 * trying to create an XML tag with an array as content
 */
 $tag = array(
 'qname' => 'bar',
 'content' => array('foo' => 'bar')
 );
 print 'trying to create an XML tag with an array as content: ';
 print '<pre>';
 print_r(XML_Util::createTagFromArray($tag));
 print '</pre>';
 print "\n \n";
 
 /**
 * trying to create an XML tag without a name
 */
 $tag = array(
 'attributes' => array('foo' => 'bar'),
 );
 print 'trying to create an XML tag without a name: ';
 print '<pre>';
 print_r(XML_Util::createTagFromArray($tag));
 print '</pre>';
 print "\n \n";
?>
PK�������eqYیu�����������tests/ApiVersionTests.phpnu��[�����������<?php

class ApiVersionTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::apiVersion()
 */
 public function testApiVersion()
 {
 $this->assertEquals('1.4', XML_Util::apiVersion());
 }
}PK�������eqY~�$[e��e����tests/CreateEndElementTests.phpnu��[�����������<?php

class CreateEndElementTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createEndElement()
 */
 public function testCreateEndElementBasicUsage()
 {
 $original = "myTag";
 $expected = "</myTag>";
 $this->assertEquals($expected, XML_Util::createEndElement($original));
 }

/**
 * @covers XML_Util::createEndElement()
 */
 public function testCreateEndElementWithNamespacedTag()
 {
 $original = "myNs:myTag";
 $expected = "</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createEndElement($original));
 }
}
PK�������eqYDf:������ ��tests/GetXmlDeclarationTests.phpnu��[�����������<?php

class GetXMLDeclarationTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::getXMLDeclaration()
 */
 public function testGetXMLDeclarationUsingVersion()
 {
 $version = "1.0";
 $expected = "<?xml version=\"1.0\"?>";
 $this->assertEquals($expected, XML_Util::getXMLDeclaration($version));
 }

/**
 * @covers XML_Util::getXMLDeclaration()
 */
 public function testGetXMLDeclarationUsingVersionAndEncodingAndStandalone()
 {
 $version = "1.0";
 $encoding = "UTF-8";
 $standalone = true;
 $expected = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
 $this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
 }

/**
 * @covers XML_Util::getXMLDeclaration()
 */
 public function testGetXMLDeclarationUsingVersionAndStandalone()
 {
 $version = "1.0";
 $encoding = null;
 $standalone = true;
 $expected = "<?xml version=\"1.0\" standalone=\"yes\"?>";
 $this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
 }
}
PK�������eqY���T��T����tests/CreateCommentTests.phpnu��[�����������<?php

class CreateCommentTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createComment()
 */
 public function testCreateCommentBasicUsage()
 {
 $original = "I am comment.";
 $expected = "";
 $this->assertEquals($expected, XML_Util::createComment($original));
 }
}
PK�������eqY��G������tests/Bug21177Tests.phpnu��[�����������<?php

/**
 * Bug #21177 "XML_Util::collapseEmptyTags() can return NULL"
 *
 * PREG returns NULL when it encounters an error.
 * In this case, it was encountering PREG_BACKTRACK_LIMIT_ERROR.
 *
 * @link https://pear.php.net/bugs/bug.php?id=21177
 */
class Bug21177Tests extends AbstractUnitTests
{
 public function getTestCandidate()
 {
 $expected = '<id_mytest_yesorno />';

return array(
 array('<idmytestyesorno></idmytestyesorno>', '<idmytestyesorno />'),
 array('<idmytestyesorno />', '<idmytestyesorno />'),

array('<id_mytest_yesorno></id_mytest_yesorno>', '<id_mytest_yesorno />'),
 array('<id_mytest_yesorno />', '<id_mytest_yesorno />'),
 );
 }

/**
 * @dataProvider getTestCandidate()
 */
 public function testCollapseEmptyTagsForBug21177($original, $expected)
 {
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($original, XML_UTIL_COLLAPSE_ALL), "Failed bugcheck.");
 }
}
PK�������eqYYq���������tests/Bug21184Tests.phpnu��[�����������<?php

/**
 * Bug #21184
 *
 * PREG returns NULL when it encounters an error.
 * In this case, it was encountering PREG_BACKTRACK_LIMIT_ERROR.
 *
 * @link https://pear.php.net/bugs/bug.php?id=21177
 */
class Bug21184 extends AbstractUnitTests
{
 public function testBug21184()
 {
 $xml = '<XML_Serializer_Tag>one</XML_Serializer_Tag>';
 $this->assertEquals($xml, XML_Util::collapseEmptyTags($xml, XML_UTIL_COLLAPSE_ALL));
 }
}
PK�������eqY|�\5���� ��tests/CollapseEmptyTagsTests.phpnu��[�����������<?php

class CollapseEmptyTagsTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsBasicUsage()
 {
 $emptyTag = "<foo></foo>";
 $expected = "<foo />";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsBasicUsageAlongsideNonemptyTag()
 {
 $emptyTag = "<foo></foo>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<foo /><bar>baz</bar>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseAll()
 {
 $emptyTag = "<foo></foo>";
 $expected = "<foo />";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_ALL));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseAll()
 {
 $emptyTag = "<foo></foo>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<foo /><bar>baz</bar>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_ALL));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagAlongsideEmptyTagWithCollapseAll()
 {
 $emptyTag = "<foo></foo>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<foo /><bar>baz</bar><foo />";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyPrefixedTagAlongsideNonemptyTagAlongsideEmptyPrefixedTagWithCollapseAll()
 {
 $emptyTag = "<foo:foo2></foo:foo2>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<foo:foo2 /><bar>baz</bar><foo:foo2 />";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyNsPrefixedTagAlongsideNonemptyTagAlongsideEmptyNsPrefixedTagWithCollapseAll()
 {
 $emptyTag = "<http://foo.com:foo2></http://foo.com:foo2>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<http://foo.com:foo2 /><bar>baz</bar><http://foo.com:foo2 />";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseXhtml()
 {
 $emptyTag = "<foo></foo>";
 $expected = "<foo></foo>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseXhtml()
 {
 $emptyTag = "<foo></foo>";
 $otherTag = "<bar>baz</bar>";
 $xhtmlTag = " ";
 $expected = "<foo></foo> <bar>baz</bar>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $xhtmlTag . $otherTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseNone()
 {
 $emptyTag = "<foo></foo>";
 $expected = "<foo></foo>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_NONE));
 }

/**
 * @covers XML_Util::collapseEmptyTags()
 */
 public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseNone()
 {
 $emptyTag = "<foo></foo>";
 $otherTag = "<bar>baz</bar>";
 $expected = "<foo></foo><bar>baz</bar>";
 $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_NONE));
 }
}
PK�������eqY��G��G��!��tests/SplitQualifiedNameTests.phpnu��[�����������<?php

class SplitQualifiedNameTests extends AbstractUnitTests
{
    /**
     * @covers XML_Util::splitQualifiedName()
     */
    public function testSplitQualifiedNameWithoutNamespace()
    {
        $original = "xslt:stylesheet";
        $expected = array(
            'namespace' => 'xslt',
            'localPart' => 'stylesheet',
        );
        $this->assertEquals($expected, XML_Util::splitQualifiedName($original));
    }

/**
 * @covers XML_Util::splitQualifiedName()
 */
 public function testSplitQualifiedNameWithNamespace()
 {
 $original = "stylesheet";
 $namespace = "myNs";
 $expected = array(
 'namespace' => 'myNs',
 'localPart' => 'stylesheet',
 );
 $this->assertEquals($expected, XML_Util::splitQualifiedName($original, $namespace));
 }
}
PK�������eqYz��t��������tests/ReverseEntitiesTests.phpnu��[�����������<?php

class ReverseEntitiesTests extends AbstractUnitTests
{
 protected function getSimpleData()
 {
 return 'This string contains < & >.';
 }

protected function getUtf8Data()
 {
 return 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê';
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleData()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData()));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), 'INVALID_OPTION'));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesXml()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML), $encoding);
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML), $encoding);
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequired()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesHtml()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
 }

/**
 * @covers XML_Util::reverseEntities()
 */
 public function testReverseEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
 }
}
PK�������eqYܬ$�������$��tests/GetDocTypeDeclarationTests.phpnu��[�����������<?php

class GetDocTypeDeclarationTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::getDocTypeDeclaration()
 */
 public function testGetDocTypeDeclarationUsingRoot()
 {
 $expected = "<!DOCTYPE rootTag>";
 $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag"));
 }

/**
 * @covers XML_Util::getDocTypeDeclaration()
 */
 public function testGetDocTypeDeclarationUsingRootAndStringUri()
 {
 $expected = "<!DOCTYPE rootTag SYSTEM \"myDocType.dtd\">";
 $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", "myDocType.dtd"));
 }

/**
 * @covers XML_Util::getDocTypeDeclaration()
 */
 public function testGetDocTypeDeclarationUsingRootAndArrayUri()
 {
 $uri = array(
 'uri' => 'http://pear.php.net/dtd/package-1.0',
 'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
 );
 $expected = "<!DOCTYPE rootTag PUBLIC \"-//PHP//PEAR/DTD PACKAGE 0.1\" \"http://pear.php.net/dtd/package-1.0\">";
 $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri));
 }

/**
 * @covers XML_Util::getDocTypeDeclaration()
 */
 public function testGetDocTypeDeclarationUsingRootAndArrayUriAndInternalDtd()
 {
 $uri = array(
 'uri' => 'http://pear.php.net/dtd/package-1.0',
 'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
 );
 $dtdEntry = '<!ELEMENT additionalInfo (#PCDATA)>';
 $expected =
<<< EOF
<!DOCTYPE rootTag PUBLIC "-//PHP//PEAR/DTD PACKAGE 0.1" "http://pear.php.net/dtd/package-1.0" [
<!ELEMENT additionalInfo (#PCDATA)>
]>
EOF;
 $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri, $dtdEntry));
 }
}
PK�������eqY��۩��������tests/Bug18343Tests.phpnu��[�����������<?php

/**
 * Bug #18343 "Entities in file names decoded during packaging"
 *
 * No matter what flags are given to createTagFromArray(),
 * an attribute must *always* be at least ENTITIES_XML encoded.
 *
 * @link https://pear.php.net/bugs/bug.php?id=18343
 */
class Bug18343Tests extends AbstractUnitTests
{
    private $tagArray = array(
        "qname"      => "install",
        "attributes" => array(
            "as"    => "Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
            "name"  => "test/Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
        )
    );

public function getFlagsToTest()
    {
        new XML_Util(); // for constants to be declared

return array(
            array('no flag', null),
            array('false', false),
            array('ENTITIES_NONE', XML_UTIL_ENTITIES_NONE),
            array('ENTITIES_XML', XML_UTIL_ENTITIES_XML),
            array('ENTITIES_XML_REQUIRED', XML_UTIL_ENTITIES_XML_REQUIRED),
            array('ENTITIES_HTML', XML_UTIL_ENTITIES_HTML),
            array('REPLACE_ENTITIES', XML_UTIL_REPLACE_ENTITIES),
        );
    }

/**
 * @dataProvider getFlagsToTest()
 */
 public function testCreateTagFromArrayForBug18343($key, $flag)
 {
 // all flags for the candidate input should return the same result
 $expected =
<<< EOF
<install as="Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek" name="test/Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek" />
EOF;
 $this->assertEquals($expected, XML_Util::createTagFromArray($this->tagArray, $flag), "Failed bugcheck for $key.");
 }
}
PK�������eqY>�M���������tests/Bug4950Tests.phpnu��[�����������<?php

/**
 * Bug #4950 "Incorrect CDATA serializing"
 *
 * Content that looks like CDATA end characters and tags
 * should still be recognized solely as content text.
 *
 * @link https://pear.php.net/bugs/bug.php?id=4950
 */
class Bug4950Tests extends AbstractUnitTests
{
 public function testCreateTagForBug4950()
 {
 $qname = "test";
 $attributes = array();
 $content = "Content ]]></test> here!";
 $namespaceUrl = null;
 $expected = "<test><![CDATA[Content ]]]]><![CDATA[></test> here!]]></test>";
 $result = XML_Util::createTag($qname, $attributes, $content, $namespaceUrl, XML_UTIL_CDATA_SECTION);
 $this->assertEquals($expected, $result, "Failed bugcheck.");
 }
}
PK�������eqY�rv���������tests/RaiseErrorTests.phpnu��[�����������<?php

class RaiseErrorTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::raiseError()
 */
 public function testRaiseError()
 {
 $code = 12345;
 $message = "I am an error";
 $error = XML_Util::raiseError($message, $code);
 $this->assertInstanceOf('PEAR_Error', $error);
 $this->assertEquals($message, $error->getMessage());
 $this->assertEquals($code, $error->getCode());
 }
}
PK�������eqY�C���������tests/ReplaceEntitiesTests.phpnu��[�����������<?php

class ReplaceEntitiesTests extends AbstractUnitTests
{
 protected function getSimpleData()
 {
 return 'This string contains < & >.';
 }

protected function getUtf8Data()
 {
 return 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê';
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleData()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData()));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), 'INVALID_OPTION'));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesXml()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML, $encoding));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML, $encoding));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequired()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesHtml()
 {
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This string contains < & >.";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
 }

/**
 * @covers XML_Util::replaceEntities()
 */
 public function testReplaceEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
 {
 $encoding = "UTF-8";
 $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
 $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
 }
}
PK�������eqY4e��j��j��!��tests/CreateCDataSectionTests.phpnu��[�����������<?php

class CreateCDataSectionTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createCDataSection()
 */
 public function testCreateCDataSectionBasicUsage()
 {
 $original = "I am content.";
 $expected ="<![CDATA[I am content.]]>";
 $this->assertEquals($expected, XML_Util::createCDataSection($original));
 }
}
PK�������eqYe�>��4���4��!��tests/CreateTagFromArrayTests.phpnu��[�����������<?php

class CreateTagFromArrayTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQname()
 {
 $original = array(
 "qname" => "foo:bar",
 );
 $expected = "<foo:bar />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespace()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 );
 $expected = "<foo:bar xmlns:foo=\"http://foo.com\" />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributes()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 );
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\" xmlns:foo=\"http://foo.com\" />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContent()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\" xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndAttributesAndContent()
 {
 $original = array(
 "qname" => "foo:bar",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndContent()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "content" => "I'm inside the tag",
 );
 $expected = "<foo:bar xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithEntitiesNone()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\" xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_ENTITIES_NONE));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntities()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\" xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineFalse()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = false;
 $expected = "<foo:bar argh=\"fruit&vegetable\" key=\"value\" xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrue()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = true;
 $expected =
<<< EOF
<foo:bar argh="fruit&vegetable"
 key="value"
 xmlns:foo="http://foo.com">I'm inside the tag</foo:bar>
EOF;
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndent()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = true;
 $indent = " ";
 $expected =
<<< EOF
<foo:bar argh="fruit&vegetable"
 key="value"
 xmlns:foo="http://foo.com">I'm inside the tag</foo:bar>
EOF;
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $expected = "<foo:bar argh=\"fruit&vegetable\"^ key=\"value\"^ xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = true;
 $expected = "<foo:bar argh=\"fruit&vegetable\"^ key=\"value\"^ xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
 {
 $original = array(
 "qname" => "foo:bar",
 "namespaceUri" => "http://foo.com",
 "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
 "content" => "I'm inside the tag",
 );
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = false;
 $expected = "<foo:bar key=\"value\"^ argh=\"fruit&vegetable\"^ xmlns:foo=\"http://foo.com\">I'm inside the tag</foo:bar>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
 }

/**
     * @covers XML_Util::createTagFromArray()
     */
    public function testCreateTagFromArrayWithInvalidArray()
    {
        $badArray = array(
            "foo" => "bar",
        );
        $expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
        $this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
    }

/**
     * @covers XML_Util::createTagFromArray()
     */
    public function testCreateTagFromArrayWithNamespaceAndAttributesAndContentButWithoutQname()
    {
        $original = array(
            "namespaceUri" => "http://foo.com",
            "attributes"   => array( "key" => "value", "argh" => "fruit&vegetable" ),
            "content"      => "I'm inside the tag",
        );
        $expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
        $this->assertEquals($expectedError, XML_Util::createTagFromArray($original));
    }

/**
     * @covers XML_Util::createTagFromArray()
     */
    public function testCreateTagFromArrayWithNonScalarContent()
    {
        $badArray = array(
            'content' => array('foo', 'bar'),
        );
        $expectedError = "Supplied non-scalar value as tag content";
        $this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
    }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithArrayOfNamespaces()
 {
 $original = array(
 'qname' => 'foo:bar',
 'namespaces' => array('ns1' => 'uri1', 'ns2' => 'uri2'),
 );
 $expected = "<foo:bar xmlns:ns1=\"uri1\" xmlns:ns2=\"uri2\" />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameDerivedFromNamespaceUriAndLocalPart()
 {
 $original = array(
 'namespaceUri' => 'http://bar.org',
 'localPart' => 'foo'
 );
 $expected = "<foo xmlns=\"http://bar.org\" />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameDerivedFromNamespaceAndLocalPart()
 {
 $original = array(
 'namespace' => 'http://foo.org',
 'localPart' => 'bar'
 );
 $expected = "<http://foo.org:bar />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithQnameDerivedFromLocalPart()
 {
 $original = array(
 'namespace' => '',
 'localPart' => 'bar'
 );
 $expected = "<bar />";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original));
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayWithImplicitlyEmptyContentAndCollapseNoneDoesNotCollapseTag()
 {
 $original = array('qname' => 'tag1');
 $expected = "<tag1></tag1>";
 $actual = XML_Util::createTagFromArray(
 $original,
 XML_UTIL_REPLACE_ENTITIES, // default $replaceEntities
 false, // default $multiline
 '_auto', // default $indent
 "\n", // default $linebreak
 true, // default $sortAttributes
 XML_UTIL_COLLAPSE_NONE
 );
 $this->assertEquals($expected, $actual);
 }

/**
 * @covers XML_Util::createTagFromArray()
 */
 public function testCreateTagFromArrayForCdataWithExplicitlyEmptyContentDoesNotCollapseTag()
 {
 $original = array('qname' => 'tag1', 'content' => '');
 $expected = "<tag1><![CDATA[]]></tag1>";
 $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_CDATA_SECTION));
 }
}
PK�������eqY�YR�"��"��!��tests/CreateStartElementTests.phpnu��[�����������<?php

class CreateStartElementTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagOnly()
 {
 $original = "myNs:myTag";
 $expected = "<myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createStartElement($original));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributes()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $expected = "<myNs:myTag foo=\"bar\">";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithEmptyAttributes()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = "";
 $expected = "<myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespace()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\" xmlns:myNs=\"http://www.w3c.org/myNs#\">";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithEmptyAttributesAndNonUriNamespace()
 {
 $originalTag = "myTag";
 $originalAttributes = "";
 $originalNamespace = "foo";
 $expected = "<myTag xmlns=\"foo\">";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultiline()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected =
<<< EOF
<myNs:myTag foo="bar"
 xmlns:myNs="http://www.w3c.org/myNs#">
EOF;
 $multiline = true;
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndent()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected =
<<< EOF
<myNs:myTag foo="bar"
 xmlns:myNs="http://www.w3c.org/myNs#">
EOF;
 $multiline = true;
 $indent = " ";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreak()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsTrue()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar", "boo" => "baz");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag boo=\"baz\"^ foo=\"bar\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = true;
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
 }

/**
 * @covers XML_Util::createStartElement()
 */
 public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsFalse()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar", "boo" => "baz");
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\"^ boo=\"baz\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = false;
 $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
 }
}
PK�������eqY���!��������tests/AbstractUnitTests.phpnu��[�����������<?php

/*
 * Allow for PHPUnit 4.* while XML_Util is still usable on PHP 5.4
 */
if (!class_exists('PHPUnit_Framework_TestCase')) {
    class PHPUnit_Framework_TestCase extends \PHPUnit\Framework\TestCase {}
}

abstract class AbstractUnitTests extends \PHPUnit_Framework_TestCase
{
 public function setUp()
 {
 // ensure the class is defined, and thus its constants are declared
 new XML_Util();
 }
}
PK�������eqY�m4�*��*����tests/CreateTagTests.phpnu��[�����������<?php

class CreateTagTests extends AbstractUnitTests
{
 /**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributes()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $expected = "<myNs:myTag foo=\"bar\" />";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContent()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag";
 $expected = "<myNs:myTag foo=\"bar\">This is inside the tag</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespace()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\" xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithCDataSection()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\" xmlns:myNs=\"http://www.w3c.org/myNs#\"><![CDATA[This is inside the tag and has < & @ > in it]]></myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_CDATA_SECTION));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntities()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $expected = "<myNs:myTag foo=\"bar\" xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag and has < & @ > in it</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineFalse()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = false;
 $expected = "<myNs:myTag foo=\"bar\" xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag and has < & @ > in it</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrue()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = true;
 $expected =
<<< EOF
<myNs:myTag foo="bar"
 xmlns:myNs="http://www.w3c.org/myNs#">This is inside the tag and has < & @ > in it</myNs:myTag>
EOF;
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndent()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = true;
 $indent = " ";
 $expected =
<<< EOF
<myNs:myTag foo="bar"
 xmlns:myNs="http://www.w3c.org/myNs#">This is inside the tag and has < & @ > in it</myNs:myTag>
EOF;

$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
    }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $expected = "<myNs:myTag foo=\"bar\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag and has < & @ > in it</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar", "boo" => "baz");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = true;
 $expected = "<myNs:myTag boo=\"baz\"^ foo=\"bar\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag and has < & @ > in it</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
 }

/**
 * @covers XML_Util::createTag()
 */
 public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
 {
 $originalTag = "myNs:myTag";
 $originalAttributes = array("foo" => "bar", "boo" => "baz");
 $originalContent = "This is inside the tag and has < & @ > in it";
 $originalNamespace = "http://www.w3c.org/myNs#";
 $multiline = true;
 $indent = " ";
 $linebreak = "^";
 $sortAttributes = false;
 $expected = "<myNs:myTag foo=\"bar\"^ boo=\"baz\"^ xmlns:myNs=\"http://www.w3c.org/myNs#\">This is inside the tag and has < & @ > in it</myNs:myTag>";
 $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
 }
}
PK�������eqY�Gs���������tests/Bug5392Tests.phpnu��[�����������<?php

/**
 * Bug #5392 "encoding of ISO-8859-1 is the only supported encoding"
 *
 * Original characters of the given encoding that are "replaced"
 * should then "reverse" back to perfectly match the original.
 *
 * @link https://pear.php.net/bugs/bug.php?id=5392
 */
class Bug5392Tests extends AbstractUnitTests
{
 public function testReplaceEntitiesForBug5392()
 {
 $original = 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê';
 $replacedResult = XML_Util::replaceEntities($original, XML_UTIL_ENTITIES_HTML, "UTF-8");
 $reversedResult = XML_Util::reverseEntities($replacedResult, XML_UTIL_ENTITIES_HTML, "UTF-8");
 $this->assertEquals($original, $reversedResult, "Failed bugcheck.");
 }
}
PK�������eqYZ�t�����!��tests/AttributesToStringTests.phpnu��[�����������<?php

class AttributesToStringTests extends AbstractUnitTests
{
    /**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringBasicUsage()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " boo=\"baz\" foo=\"bar\"";
        $this->assertEquals($expected, XML_Util::attributesToString($original));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithExplicitSortTrue()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " boo=\"baz\" foo=\"bar\"";
        $sort = true;
        $this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithExplicitSortFalse()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " foo=\"bar\" boo=\"baz\"";
        $sort = false;
        $this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithMultilineFalse()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " boo=\"baz\" foo=\"bar\"";
        $sort = true;
        $multiline = false;
        $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
    }

/**
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithMultilineTrue()
 {
 $original = array('foo' => 'bar','boo' => 'baz',);
 $expected =
<<< EOF
 boo="baz"
 foo="bar"
EOF;
 $sort = true;
 $multiline = true;
 $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
 }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithExplicitIndent()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " boo=\"baz\"\n        foo=\"bar\"";
        $sort = true;
        $multiline = true;
        $indent = '        '; // 8 spaces
        $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $indent));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithExplicitLinebreak()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $expected = " boo=\"baz\"\n^foo=\"bar\"";
        $sort = true;
        $multiline = true;
        $linebreak = '^'; // some dummy character
        $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithOptionsThatIncludesSort()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $options = array(
            'multiline' => true,
            'indent'    => '----',
            'linebreak' => "^",
            'entities'  => XML_UTIL_ENTITIES_XML,
            'sort'      => true,
        );

$expected = " boo=\"baz\"\n----foo=\"bar\"";
        $this->assertEquals($expected, XML_Util::attributesToString($original, $options));
    }

/**
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithOptionsThatExcludesSort()
    {
        $original = array('foo' => 'bar','boo' => 'baz',);
        $options = array(
            'multiline' => true,
            'indent'    => '----',
            'linebreak' => "^",
            'entities'  => XML_UTIL_ENTITIES_XML,
        );

$expected = " boo=\"baz\"\n----foo=\"bar\"";
        $this->assertEquals($expected, XML_Util::attributesToString($original, $options));
    }

/**
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithEntitiesNone()
 {
 $original = array("foo" => "b@&r", "boo" => "b><z");
 $expected = " boo=\"b><z\" foo=\"b@&r\"";
 $sort = true;
 $multiline = false;
 $linebreak = ' ';
 $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_NONE));
 }

/**
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithEntitiesXml()
 {
 $original = array("foo" => "b@&r", "boo" => "b><z");
 $expected = " boo=\"b><z\" foo=\"b@&r\"";
 $sort = true;
 $multiline = false;
 $linebreak = ' ';
 $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML));
 }

/**
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithEntitiesXmlRequired()
 {
 $original = array("foo" => "b@&r", "boo" => "b><z");
 $expected = " boo=\"b><z\" foo=\"b@&r\"";
 $sort = true;
 $multiline = false;
 $linebreak = ' ';
 $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML_REQUIRED));
 }

/**
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithEntitiesHtml()
 {
 $original = array("foo" => "b@&r", "boo" => "b><z");
 $expected = " boo=\"b><z\" foo=\"b@&r\"";
 $sort = true;
 $multiline = false;
 $linebreak = ' ';
 $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_HTML));
 }

/**
     * Tag attributes should not be treated as CDATA,
     * so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
     *
     * @covers XML_Util::attributesToString()
     */
    public function testAttributesToStringWithCDataSectionForSingleAttribute()
    {
        $original = array('foo' => 'bar'); // need exactly one attribute here
        $options = array(
            'sort'      => true,   // doesn't matter for this testcase
            'multiline' => false,  // doesn't matter for this testcase
            'indent'    => null,   // doesn't matter for this testcase
            'linebreak' => null,   // doesn't matter for this testcase
            'entities'  => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
        );
        $expected = " foo=\"bar\"";
        $this->assertEquals($expected, XML_Util::attributesToString($original, $options));
    }

/**
 * Tag attributes should not be treated as CDATA,
 * so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
 *
 * @covers XML_Util::attributesToString()
 */
 public function testAttributesToStringWithCDataSectionForMultipleAttributesAndMultilineFalse()
 {
 $original = array('foo' => 'bar', 'boo' => 'baz'); // need more than one attribute here
 $options = array(
 'sort' => true, // doesn't matter for this testcase
 'multiline' => false, // DOES matter for this testcase, must be false
 'indent' => null, // doesn't matter for this testcase
 'linebreak' => null, // doesn't matter for this testcase
 'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
 );
 $expected = " boo=\"baz\" foo=\"bar\"";
 $this->assertEquals($expected, XML_Util::attributesToString($original, $options));
 }
}
PK�������eqYݑh���������tests/IsValidNameTests.phpnu��[�����������<?php

class IsValidNameTests extends AbstractUnitTests
{
    /**
     * @covers XML_Util::isValidName()
     */
    public function testIsValidNameForTagNameThatIsValid()
    {
        $tagName = "alpha-x_y_z.123";
        $result = XML_Util::isValidName($tagName);
        $this->assertTrue($result);
    }

/**
     * @covers XML_Util::isValidName()
     */
    public function testIsValidNameForTagNameWithInvalidCharacter()
    {
        $tagName = "invalidTag?";
        $result = XML_Util::isValidName($tagName);
        $this->assertInstanceOf('PEAR_Error', $result);
        $expectedError = "XML names may only contain alphanumeric chars, period, hyphen, colon and underscores";
        $this->assertEquals($expectedError, $result->getMessage());
    }

/**
     * @covers XML_Util::isValidName()
     */
    public function testIsValidNameForTagNameWithInvalidStartingCharacter()
    {
        $tagName = "1234five";
        $result = XML_Util::isValidName($tagName);
        $this->assertInstanceOf('PEAR_Error', $result);
        $expectedError = "XML names may only start with letter or underscore";
        $this->assertEquals($expectedError, $result->getMessage());
    }

/**
     * @covers XML_Util::isValidName()
     */
    public function testIsValidNameForInt()
    {
        $tagName = 1;
        $result = XML_Util::isValidName($tagName);
        $this->assertInstanceOf('PEAR_Error', $result);
        $expectedError = "XML names may only start with letter or underscore";
        $this->assertEquals($expectedError, $result->getMessage());
    }

/**
 * @covers XML_Util::isValidName()
 */
 public function testIsValidNameForEmptyString()
 {
 $tagName = '';
 $result = XML_Util::isValidName($tagName);
 $this->assertInstanceOf('PEAR_Error', $result);
 $expectedError = "XML names may only start with letter or underscore";
 $this->assertEquals($expectedError, $result->getMessage());
 }
}
PK��������{eqY�f����������������������examples/example2.phpnu��[�����������PK��������{eqY5k��#���#��������������0��examples/example.phpnu��[�����������PK���������eqYیu���������������������<7��tests/ApiVersionTests.phpnu��[�����������PK���������eqY~�$[e��e��������������b8��tests/CreateEndElementTests.phpnu��[�����������PK���������eqYDf:������ ������������;��tests/GetXmlDeclarationTests.phpnu��[�����������PK���������eqY���T��T���������������?��tests/CreateCommentTests.phpnu��[�����������PK���������eqY��G�����������������A��tests/Bug21177Tests.phpnu��[�����������PK���������eqYYq��������������������E��tests/Bug21184Tests.phpnu��[�����������PK���������eqY|�\5���� �������������H��tests/CollapseEmptyTagsTests.phpnu��[�����������PK���������eqY��G��G��!������������QY��tests/SplitQualifiedNameTests.phpnu��[�����������PK���������eqYz��t�������������������\��tests/ReverseEntitiesTests.phpnu��[�����������PK���������eqYܬ$�������$������������
n��tests/GetDocTypeDeclarationTests.phpnu��[�����������PK���������eqY��۩������������������Tu��tests/Bug18343Tests.phpnu��[�����������PK���������eqY>�M�������������������i|��tests/Bug4950Tests.phpnu��[�����������PK���������eqY�rv����������������������tests/RaiseErrorTests.phpnu��[�����������PK���������eqY�C�����������������������tests/ReplaceEntitiesTests.phpnu��[�����������PK���������eqY4e��j��j��!����������������tests/CreateCDataSectionTests.phpnu��[�����������PK���������eqYe�>��4���4��!������������{���tests/CreateTagFromArrayTests.phpnu��[�����������PK���������eqY�YR�"��"��!����������������tests/CreateStartElementTests.phpnu��[�����������PK���������eqY���!����������������������tests/AbstractUnitTests.phpnu��[�����������PK���������eqY�m4�*��*������������������tests/CreateTagTests.phpnu��[�����������PK���������eqY�Gs�������������������X��tests/Bug5392Tests.phpnu��[�����������PK���������eqYZ�t�����!��������������tests/AttributesToStringTests.phpnu��[�����������PK���������eqYݑh�������������������"�tests/IsValidNameTests.phpnu��[�����������PK���������
*���