Mse a jour / réinstallation des Bundles vendors (et ajout du bundle FOSUsers)

app/logs/dev.log

@@ -2613,3 +2613,39 @@
 [2011-09-07 18:23:33] doctrine.DEBUG: CREATE TABLE element (id INT NOT NULL, element_type_id VARCHAR(12) DEFAULT NULL, url VARCHAR(1024) NOT NULL, name VARCHAR(128) NOT NULL, date_added TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY(id)) ([]) [] []
 [2011-09-07 18:23:34] doctrine.DEBUG: CREATE INDEX IDX_41405E3932A7CCC7 ON element (element_type_id) ([]) [] []
 [2011-09-07 18:23:34] doctrine.DEBUG: ALTER TABLE element ADD CONSTRAINT FK_41405E3932A7CCC7 FOREIGN KEY (element_type_id) REFERENCES element_type(id) NOT DEFERRABLE INITIALLY IMMEDIATE ([]) [] []
+[2011-09-08 08:53:00] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\RouterListener::onEarlyKernelRequest". [] []
+[2011-09-08 08:53:00] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\SessionListener::onKernelRequest". [] []
+[2011-09-08 08:53:00] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Component\Security\Http\Firewall::onKernelRequest". [] []
+[2011-09-08 08:53:00] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\RouterListener::onKernelRequest". [] []
+[2011-09-08 08:53:07] request.INFO: Matched route "index" (parameters: "_controller": "Muzich\IndexBundle\Controller\IndexController::indexAction", "_route": "index") [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\AsseticBundle\EventListener\RequestListener::onKernelRequest". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "Symfony\Bundle\FrameworkBundle\DataCollector\RequestDataCollector::onKernelController". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\ControllerListener::onKernelController". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\ParamConverterListener::onKernelController". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\TemplateListener::onKernelController". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "Acme\DemoBundle\ControllerListener::onKernelController". [] []
+[2011-09-08 08:53:07] event.DEBUG: Notified event "kernel.controller" to listener "JMS\SecurityExtraBundle\Controller\ControllerListener::onCoreController". [] []
+[2011-09-08 08:53:08] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Component\HttpKernel\EventListener\ResponseListener::onKernelResponse". [] []
+[2011-09-08 08:53:08] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bundle\SecurityBundle\EventListener\ResponseListener::onKernelResponse". [] []
+[2011-09-08 08:53:08] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bridge\Monolog\Handler\FirePHPHandler::onKernelResponse". [] []
+[2011-09-08 08:53:08] event.DEBUG: Notified event "kernel.response" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\CacheListener::onKernelResponse". [] []
+[2011-09-08 08:53:08] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Component\HttpKernel\EventListener\ProfilerListener::onKernelResponse". [] []
+[2011-09-08 08:53:10] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bundle\WebProfilerBundle\EventListener\WebDebugToolbarListener::onKernelResponse". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\RouterListener::onEarlyKernelRequest". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\SessionListener::onKernelRequest". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Component\Security\Http\Firewall::onKernelRequest". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\FrameworkBundle\EventListener\RouterListener::onKernelRequest". [] []
+[2011-09-08 08:53:12] request.INFO: Matched route "_wdt" (parameters: "_controller": "Symfony\Bundle\WebProfilerBundle\Controller\ProfilerController::toolbarAction", "token": "4e68746492229", "_route": "_wdt") [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.request" to listener "Symfony\Bundle\AsseticBundle\EventListener\RequestListener::onKernelRequest". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "Symfony\Bundle\FrameworkBundle\DataCollector\RequestDataCollector::onKernelController". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\ControllerListener::onKernelController". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\ParamConverterListener::onKernelController". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\TemplateListener::onKernelController". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "Acme\DemoBundle\ControllerListener::onKernelController". [] []
+[2011-09-08 08:53:12] event.DEBUG: Notified event "kernel.controller" to listener "JMS\SecurityExtraBundle\Controller\ControllerListener::onCoreController". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Component\HttpKernel\EventListener\ResponseListener::onKernelResponse". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bundle\SecurityBundle\EventListener\ResponseListener::onKernelResponse". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bridge\Monolog\Handler\FirePHPHandler::onKernelResponse". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Sensio\Bundle\FrameworkExtraBundle\EventListener\CacheListener::onKernelResponse". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Component\HttpKernel\EventListener\ProfilerListener::onKernelResponse". [] []
+[2011-09-08 08:53:13] event.DEBUG: Notified event "kernel.response" to listener "Symfony\Bundle\WebProfilerBundle\EventListener\WebDebugToolbarListener::onKernelResponse". [] []

deps

@@ -57,3 +57,7 @@
     git=http://github.com/symfony/AsseticBundle.git
     target=/bundles/Symfony/Bundle/AsseticBundle
     version=v1.0.0
+
+[FOSUserBundle]
+    git=git://github.com/FriendsOfSymfony/FOSUserBundle.git
+    target=bundles/FOS/UserBundle

deps~

@@ -0,0 +1,59 @@
+[symfony]
+    git=http://github.com/symfony/symfony.git
+    version=v2.0.1
+
+[twig]
+    git=http://github.com/fabpot/Twig.git
+    version=v1.1.2
+
+[monolog]
+    git=http://github.com/Seldaek/monolog.git
+    version=1.0.1
+
+[doctrine-common]
+    git=http://github.com/doctrine/common.git
+    version=2.1.1
+
+[doctrine-dbal]
+    git=http://github.com/doctrine/dbal.git
+    version=2.1.1
+
+[doctrine]
+    git=http://github.com/doctrine/doctrine2.git
+    version=2.1.1
+
+[swiftmailer]
+    git=http://github.com/swiftmailer/swiftmailer.git
+    version=v4.1.1
+
+[assetic]
+    git=http://github.com/kriswallsmith/assetic.git
+    version=v1.0.1
+
+[twig-extensions]
+    git=http://github.com/fabpot/Twig-extensions.git
+
+[metadata]
+    git=http://github.com/schmittjoh/metadata.git
+    version=1.0.0
+
+[SensioFrameworkExtraBundle]
+    git=http://github.com/sensio/SensioFrameworkExtraBundle.git
+    target=/bundles/Sensio/Bundle/FrameworkExtraBundle
+
+[JMSSecurityExtraBundle]
+    git=http://github.com/schmittjoh/JMSSecurityExtraBundle.git
+    target=/bundles/JMS/SecurityExtraBundle
+
+[SensioDistributionBundle]
+    git=http://github.com/sensio/SensioDistributionBundle.git
+    target=/bundles/Sensio/Bundle/DistributionBundle
+
+[SensioGeneratorBundle]
+    git=http://github.com/sensio/SensioGeneratorBundle.git
+    target=/bundles/Sensio/Bundle/GeneratorBundle
+
+[AsseticBundle]
+    git=http://github.com/symfony/AsseticBundle.git
+    target=/bundles/Symfony/Bundle/AsseticBundle
+    version=v1.0.0

vendor/assetic/.gitignore

@@ -0,0 +1 @@
+phpunit.xml

vendor/bundles/FOS/UserBundle

@@ -0,0 +1 @@
+Subproject commit ce316132d0701fd96cac7df3b1998be0d4986ac7

vendor/bundles/Sensio/Bundle/DistributionBundle/TODO.txt

@@ -1,22 +0,0 @@
-* Create a command that can be run when a project code has been updated on
-  the production servers:
-
-    ./build_bootstrap.php (à inclure dans cache:clear)
-    cache:clear --env=prod --without-debug
-    assets:install --env=prod web/
-    assetic:dump --env=prod web/
-
-    On ne pourrait la mettre que dans Symfony SE sauf si on la configure
-    quelque part:
-
-    ./app/console project:prepare
-    ./app/console project:update --env=prod
-
-* faire une commande upgrade pour Symfony SE (mettre à jour le build_bootstrap pour la RC1 -> performance win)
-
-* add a command that installs a list pre-defined bundles
-  this list is hosted somewhere under symfony.com, retrieved, cached
-  and propose a one-click install (via Git or download?)
-
-* Add a CLI to send feedback to the Symfony server -> the resulting anonymous
-  database is free to access for everyone?

vendor/bundles/Symfony/Bundle/AsseticBundle/.gitignore

@@ -0,0 +1 @@
+phpunit.xml

vendor/doctrine-common/.gitignore

@@ -0,0 +1,5 @@
+build.properties
+build/
+logs/
+reports/
+dist/

vendor/doctrine-common/build.properties.dev

@@ -0,0 +1,14 @@
+version=2.0.0BETA2
+stability=beta
+build.dir=build
+dist.dir=dist
+report.dir=reports
+log.archive.dir=logs
+svn.path=/usr/bin/svn
+test.phpunit_configuration_file=
+test.phpunit_generate_coverage=0
+test.pmd_reports=0
+test.pdepend_exec=
+test.phpmd_exec=
+project.pirum_dir=
+project.download_dir=

vendor/doctrine-common/build.xml

@@ -0,0 +1,160 @@
+<?xml version="1.0"?>
+
+<!--
+    Doctrine 2 build file.
+-->
+
+<project name="Doctrine2" default="build" basedir=".">
+    <taskdef classname="phing.tasks.ext.d51PearPkg2Task" name="d51pearpkg2" />
+
+    <property file="build.properties" />
+    
+    <!-- 
+        Fileset for artifacts shared across all distributed packages.
+    -->
+    <fileset id="shared-artifacts" dir=".">
+        <include name="LICENSE"/>
+        <include name="COPYRIGHT"/>
+        <include name="CHANGELOG"/>
+    </fileset>
+
+    <!-- 
+        Fileset for the sources of the Doctrine Common package.
+    -->
+    <fileset id="common-sources" dir="./lib">
+        <include name="Doctrine/Common/**"/>
+    </fileset>
+
+    <!--
+        Clean the directory for the next build.
+    -->
+    <target name="clean">
+        <available file="./build.properties" property="build_properties_exist" value="true"/>
+        <fail unless="build_properties_exist" message="The build.properties file is missing." />
+
+        <delete dir="${build.dir}" includeemptydirs="true" />
+        <delete dir="${dist.dir}" includeemptydirs="true" />
+        <delete dir="${report.dir}" includeemptydirs="true" />
+    </target>
+
+    <!--
+        Prepare the new build directories after cleaning
+    -->
+    <target name="prepare" depends="clean">
+        <echo msg="Creating build directory: ${build.dir}" />
+        <mkdir dir="${build.dir}" />
+        <echo msg="Creating distribution directory: ${dist.dir}" />
+        <mkdir dir="${dist.dir}" />
+        <echo msg="Creating report directory: ${report.dir}" />
+        <mkdir dir="${report.dir}" />
+        <mkdir dir="${build.dir}/logs"/>
+        <mkdir dir="${report.dir}/tests"/>
+    </target>
+
+    <!--
+        Builds Common package, preparing it for distribution.
+    -->
+    <target name="build-common">
+        <copy todir="${build.dir}/common">
+            <fileset refid="shared-artifacts"/>
+        </copy>
+        <copy todir="${build.dir}/common">
+            <fileset refid="common-sources"/>
+        </copy>
+    </target>
+
+    <target name="build" depends="prepare,build-common"/>
+    
+    <!-- 
+        Runs the full test suite.
+    -->
+    <target name="test" depends="prepare">
+        <if><equals arg1="${test.phpunit_generate_coverage}" arg2="1" />
+            <then>
+                <property name="test.phpunit_coverage_file" value="${build.dir}/logs/clover.xml" />
+            </then>
+            <else>
+                <property name="test.phpunit_coverage_file" value="false" />
+            </else>
+        </if>
+
+        <nativephpunit
+            testfile="./tests/Doctrine/Tests/AllTests.php" junitlogfile="${build.dir}/logs/testsuites.xml"
+            testdirectory="./tests"  coverageclover="${test.phpunit_coverage_file}" configuration="${test.phpunit_configuration_file}"
+        />
+        <phpunitreport infile="${build.dir}/logs/testsuites.xml" format="frames" todir="${report.dir}/tests" />
+
+        <tstamp/>
+        <copy file="${build.dir}/logs/testsuites.xml" tofile="${log.archive.dir}/latest/log.xml" overwrite="true"/>
+
+        <if><equals arg1="${test.pmd_reports}" arg2="1" />
+            <then>
+                <exec command="${test.pdepend_exec} --jdepend-xml=${build.dir}/logs/jdepend.xml ./lib/Doctrine" />
+                <exec command="${test.phpmd_exec} ./lib/Doctrine xml codesize --reportfile ${build.dir}/logs/phpmd.xml" />
+
+                <copy file="${build.dir}/logs/jdepend.xml" tofile="${log.archive.dir}/latest/jdepend.xml" overwrite="true"/>
+                <copy file="${build.dir}/logs/phpmd.xml" tofile="${log.archive.dir}/latest/phpmd.xml" overwrite="true"/>
+            </then>
+        </if>
+    </target>
+
+    <!-- 
+        Builds distributable PEAR packages.
+    -->
+    <target name="build-packages" depends="build">
+        <d51pearpkg2 baseinstalldir="/" dir="${build.dir}/common">
+           <name>DoctrineCommon</name>
+           <summary>Doctrine Common PHP Extensions</summary>
+           <channel>pear.doctrine-project.org</channel>
+           <description>The Doctrine Common package contains shared code between the other packages.</description>
+           <lead user="jwage" name="Jonathan H. Wage" email="jonwage@gmail.com" />
+           <lead user="guilhermeblanco" name="Guilherme Blanco" email="guilhermeblanco@gmail.com" />
+           <lead user="romanb" name="Roman Borschel" email="roman@code-factory.org" />
+           <lead user="beberlei" name="Benjamin Eberlei" email="kontakt@beberlei.de" />
+           <license>LGPL</license>
+           <version release="${version}" api="${version}" />
+           <stability release="${stability}" api="${stability}" />
+           <notes>-</notes>
+           <dependencies>
+               <php minimum_version="5.3.0" />
+               <pear minimum_version="1.6.0" recommended_version="1.6.1" />
+           </dependencies>
+        </d51pearpkg2>
+        <exec command="pear package" dir="${build.dir}/common" passthru="true" />
+        <exec command="mv DoctrineCommon-${version}.tgz ../../dist" dir="${build.dir}/common" passthru="true" />
+        <tar destfile="dist/DoctrineCommon-${version}-full.tar.gz" compression="gzip" basedir="${build.dir}">
+            <fileset dir="${build.dir}">
+                <include name="**/**" />
+                <exclude name="logs/" />
+            </fileset>
+        </tar>
+    </target>
+
+    <target name="git-tag">
+        <exec command="grep '${version}-DEV' ${project.basedir}/lib/Doctrine/Common/Version.php" checkreturn="true"/>
+        <exec command="sed 's/${version}-DEV/${version}/' ${project.basedir}/lib/Doctrine/Common/Version.php > ${project.basedir}/lib/Doctrine/Common/Version2.php" passthru="true" />
+        <exec command="mv ${project.basedir}/lib/Doctrine/Common/Version2.php ${project.basedir}/lib/Doctrine/Common/Version.php" passthru="true" />
+        <exec command="git commit -a -m 'Release ${version}'" />
+        <exec command="git tag -m 'Tag ${version}' -a ${version}" passthru="true" />
+    </target>
+
+    <target name="pirum-release">
+        <exec command="sudo pirum add ${project.pirum_dir} ${project.basedir}/dist/DoctrineCommon-${version}.tgz" dir="."  passthru="true" />
+        <exec command="sudo pirum build ${project.pirum_dir}" passthru="true" />
+    </target>
+
+    <target name="distribute-download">
+        <copy file="dist/DoctrineCommon-${version}-full.tar.gz" todir="${project.download_dir}" />
+    </target>
+
+    <target name="update-dev-version">
+        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/Common/Version.php" checkreturn="true"/>
+        <propertyprompt propertyName="next_version" defaultValue="${version}" promptText="Enter next version string (without -DEV)" />
+        <exec command="sed 's/${version}/${next_version}-DEV/' ${project.basedir}/lib/Doctrine/Common/Version.php > ${project.basedir}/lib/Doctrine/Common/Version2.php" passthru="true" />
+        <exec command="mv ${project.basedir}/lib/Doctrine/Common/Version2.php ${project.basedir}/lib/Doctrine/Common/Version.php" passthru="true" />
+        <exec command="git add ${project.basedir}/lib/Doctrine/Common/Version.php" passthru="true" />
+        <exec command="git commit -m 'Bump Dev Version to ${next_version}'" passthru="true" />
+    </target>
+
+    <target name="release" depends="git-tag,build-packages,distribute-download,pirum-release,update-dev-version" />
+</project>

vendor/doctrine-common/tests/.gitignore

@@ -0,0 +1,3 @@
+Doctrine/Tests/Proxies/
+Doctrine/Tests/ORM/Proxy/generated/
+Doctrine/Tests/ORM/Tools/Export/export

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php

@@ -0,0 +1,378 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DoctrineReader;
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\Annotation\IgnorePhpDoc;
+use ReflectionClass, Doctrine\Common\Annotations\AnnotationReader;
+
+use Doctrine\Tests\Common\Annotations\DummyAnnotation;
+use Doctrine\Tests\Common\Annotations\Name;
+use Doctrine\Tests\Common\Annotations\DummyId;
+use Doctrine\Tests\Common\Annotations\DummyJoinTable;
+use Doctrine\Tests\Common\Annotations\DummyJoinColumn;
+use Doctrine\Tests\Common\Annotations\DummyColumn;
+use Doctrine\Tests\Common\Annotations\DummyGeneratedValue;
+
+require_once __DIR__ . '/TopLevelAnnotation.php';
+
+abstract class AbstractReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testAnnotations()
+    {
+        $reader = $this->getReader();
+
+        $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\DummyClass');
+        $this->assertEquals(1, count($reader->getClassAnnotations($class)));
+        $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyAnnotation', $annot = $reader->getClassAnnotation($class, $annotName));
+        $this->assertEquals("hello", $annot->dummyValue);
+
+        $field1Prop = $class->getProperty('field1');
+        $propAnnots = $reader->getPropertyAnnotations($field1Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertInstanceOf($annotName, $annot = $reader->getPropertyAnnotation($field1Prop, $annotName));
+        $this->assertEquals("fieldHello", $annot->dummyValue);
+
+        $getField1Method = $class->getMethod('getField1');
+        $methodAnnots = $reader->getMethodAnnotations($getField1Method);
+        $this->assertEquals(1, count($methodAnnots));
+        $this->assertInstanceOf($annotName, $annot = $reader->getMethodAnnotation($getField1Method, $annotName));
+        $this->assertEquals(array(1, 2, "three"), $annot->value);
+
+        $field2Prop = $class->getProperty('field2');
+        $propAnnots = $reader->getPropertyAnnotations($field2Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyJoinTable', $joinTableAnnot = $reader->getPropertyAnnotation($field2Prop, $annotName));
+        $this->assertEquals(1, count($joinTableAnnot->joinColumns));
+        $this->assertEquals(1, count($joinTableAnnot->inverseJoinColumns));
+        $this->assertTrue($joinTableAnnot->joinColumns[0] instanceof DummyJoinColumn);
+        $this->assertTrue($joinTableAnnot->inverseJoinColumns[0] instanceof DummyJoinColumn);
+        $this->assertEquals('col1', $joinTableAnnot->joinColumns[0]->name);
+        $this->assertEquals('col2', $joinTableAnnot->joinColumns[0]->referencedColumnName);
+        $this->assertEquals('col3', $joinTableAnnot->inverseJoinColumns[0]->name);
+        $this->assertEquals('col4', $joinTableAnnot->inverseJoinColumns[0]->referencedColumnName);
+
+        $dummyAnnot = $reader->getMethodAnnotation($class->getMethod('getField1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('', $dummyAnnot->dummyValue);
+        $this->assertEquals(array(1, 2, 'three'), $dummyAnnot->value);
+
+        $dummyAnnot = $reader->getPropertyAnnotation($class->getProperty('field1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('fieldHello', $dummyAnnot->dummyValue);
+
+        $classAnnot = $reader->getClassAnnotation($class, 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('hello', $classAnnot->dummyValue);
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in class Doctrine\Tests\Common\Annotations\DummyClassSyntaxError.
+     */
+    public function testClassSyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\DummyClassSyntaxError'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in method Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError::foo().
+     */
+    public function testMethodSyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError', 'foo'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in property Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError::$foo.
+     */
+    public function testPropertySyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError', 'foo'));
+    }
+
+    /**
+     * @group regression
+     */
+    public function testMultipleAnnotationsOnSameLine()
+    {
+        $reader = $this->getReader();
+        $annots = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClass2', 'id'));
+        $this->assertEquals(3, count($annots));
+    }
+
+    public function testNonAnnotationProblem()
+    {
+        $reader = $this->getReader();
+
+        $this->assertNotNull($annot = $reader->getPropertyAnnotation(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassNonAnnotationProblem', 'foo'), $name = 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+        $this->assertType($name, $annot);
+    }
+
+    public function testImportWithConcreteAnnotation()
+    {
+        $reader = $this->getReader();
+        $property = new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestImportWithConcreteAnnotation', 'field');
+        $annotations = $reader->getPropertyAnnotations($property);
+        $this->assertEquals(1, count($annotations));
+        $this->assertNotNull($reader->getPropertyAnnotation($property, 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+    }
+
+    public function testImportWithInheritance()
+    {
+        $reader = $this->getReader();
+
+        $class = new TestParentClass();
+        $ref = new \ReflectionClass($class);
+
+        $childAnnotations = $reader->getPropertyAnnotations($ref->getProperty('child'));
+        $this->assertEquals(1, count($childAnnotations));
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Foo\Name', reset($childAnnotations));
+
+        $parentAnnotations = $reader->getPropertyAnnotations($ref->getProperty('parent'));
+        $this->assertEquals(1, count($parentAnnotations));
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Bar\Name', reset($parentAnnotations));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage The annotation "@NameFoo" in property Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass::$field was never imported.
+     */
+    public function testImportDetectsNotImportedAnnotation()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass', 'field'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage The annotation "@Foo\Bar\Name" in property Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass::$field was never imported.
+     */
+    public function testImportDetectsNonExistentAnnotation()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass', 'field'));
+    }
+
+    public function testTopLevelAnnotation()
+    {
+        $reader = $this->getReader();
+        $annotations = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestTopLevelAnnotationClass', 'field'));
+
+        $this->assertEquals(1, count($annotations));
+        $this->assertInstanceOf('\TopLevelAnnotation', reset($annotations));
+    }
+
+    public function testIgnoresAnnotationsNotPrefixedWithWhitespace()
+    {
+        $reader = $this->getReader();
+
+        $annotation = $reader->getClassAnnotation(new \ReflectionClass(new TestIgnoresNonAnnotationsClass()), 'Doctrine\Tests\Common\Annotations\Name');
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Name', $annotation);
+    }
+
+    abstract protected function getReader();
+}
+
+/**
+ * @parseAnnotation("var")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ */
+class TestParseAnnotationClass
+{
+    /**
+     * @var
+     */
+    private $field;
+}
+
+/**
+ * @Name
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class TestIgnoresNonAnnotationsClass
+{
+}
+
+class TestTopLevelAnnotationClass
+{
+    /**
+     * @\TopLevelAnnotation
+     */
+    private $field;
+}
+
+class TestNonExistentAnnotationClass
+{
+    /**
+     * @Foo\Bar\Name
+     */
+    private $field;
+}
+
+class TestAnnotationNotImportedClass
+{
+    /**
+     * @NameFoo
+     */
+    private $field;
+}
+
+class TestChildClass
+{
+    /**
+     * @\Doctrine\Tests\Common\Annotations\Foo\Name(name = "foo")
+     */
+    protected $child;
+}
+
+class TestParentClass extends TestChildClass
+{
+    /**
+     * @\Doctrine\Tests\Common\Annotations\Bar\Name(name = "bar")
+     */
+    private $parent;
+}
+
+class TestImportWithConcreteAnnotation
+{
+    /**
+     * @DummyAnnotation(dummyValue = "bar")
+     */
+    private $field;
+}
+
+/**
+ * A description of this class.
+ *
+ * Let's see if the parser recognizes that this @ is not really referring to an
+ * annotation. Also make sure that @var \ is not concated to "@var\is".
+ *
+ * @author robo
+ * @since 2.0
+ * @DummyAnnotation(dummyValue="hello")
+ */
+class DummyClass {
+    /**
+     * A nice property.
+     *
+     * @var mixed
+     * @DummyAnnotation(dummyValue="fieldHello")
+     */
+    private $field1;
+
+    /**
+     * @DummyJoinTable(name="join_table",
+     *      joinColumns={@DummyJoinColumn(name="col1", referencedColumnName="col2")},
+     *      inverseJoinColumns={
+     *          @DummyJoinColumn(name="col3", referencedColumnName="col4")
+     *      })
+     */
+    private $field2;
+
+    /**
+     * Gets the value of field1.
+     *
+     * @return mixed
+     * @DummyAnnotation({1,2,"three"})
+     */
+    public function getField1() {
+    }
+}
+
+/**
+ * @ignoreAnnotation("var")
+ */
+class DummyClass2 {
+    /**
+     * @DummyId @DummyColumn(type="integer") @DummyGeneratedValue
+     * @var integer
+     */
+    private $id;
+}
+
+class DummyId extends \Doctrine\Common\Annotations\Annotation {}
+class DummyColumn extends \Doctrine\Common\Annotations\Annotation {
+    public $type;
+}
+class DummyGeneratedValue extends \Doctrine\Common\Annotations\Annotation {}
+class DummyAnnotation extends \Doctrine\Common\Annotations\Annotation {
+    public $dummyValue;
+}
+class DummyJoinColumn extends \Doctrine\Common\Annotations\Annotation {
+    public $name;
+    public $referencedColumnName;
+}
+class DummyJoinTable extends \Doctrine\Common\Annotations\Annotation {
+    public $name;
+    public $joinColumns;
+    public $inverseJoinColumns;
+}
+
+/**
+ * @DummyAnnotation(@)
+ */
+class DummyClassSyntaxError
+{
+
+}
+
+class DummyClassMethodSyntaxError
+{
+    /**
+     * @DummyAnnotation(@)
+     */
+    public function foo()
+    {
+
+    }
+}
+
+class DummyClassPropertySyntaxError
+{
+    /**
+     * @DummyAnnotation(@)
+     */
+    public $foo;
+}
+
+/**
+ * @ignoreAnnotation({"since", "var"})
+ */
+class DummyClassNonAnnotationProblem
+{
+    /**
+     * @DummyAnnotation
+     *
+     * @var \Test
+     * @since 0.1
+     */
+    public $foo;
+}
+
+
+/**
+* @DummyAnnotation Foo bar <foobar@1domain.com>
+*/
+class DummyClassWithEmail
+{
+    
+}
+
+namespace Doctrine\Tests\Common\Annotations\Foo;
+
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+    public $name;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Bar;
+
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+    public $name;
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+
+class AnnotationReaderTest extends AbstractReaderTest
+{
+    protected function getReader()
+    {
+        return new AnnotationReader();
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Cache\ArrayCache;
+
+class CachedReaderTest extends AbstractReaderTest
+{
+    private $cache;
+
+    public function testIgnoresStaleCache()
+    {
+        $file = __DIR__.'/Fixtures/Controller.php';
+        touch($file);
+        $name = 'Doctrine\Tests\Common\Annotations\Fixtures\Controller';
+        $cacheKey = $name.'@[Annot]';
+
+        $cache = $this->getMock('Doctrine\Common\Cache\Cache');
+        $cache
+            ->expects($this->at(0))
+            ->method('fetch')
+            ->with($this->equalTo($cacheKey))
+            ->will($this->returnValue(array()))
+        ;
+        $cache
+            ->expects($this->at(1))
+            ->method('fetch')
+            ->with($this->equalTo('[C]'.$cacheKey))
+            ->will($this->returnValue(time() - 10))
+        ;
+        $cache
+            ->expects($this->at(2))
+            ->method('save')
+            ->with($this->equalTo($cacheKey))
+        ;
+        $cache
+            ->expects($this->at(3))
+            ->method('save')
+            ->with($this->equalTo('[C]'.$cacheKey))
+        ;
+
+        $reader = new CachedReader(new AnnotationReader(), $cache, true);
+        $this->assertEquals(array(
+            new Route(array('value' => '/someprefix')),
+        ), $reader->getClassAnnotations(new \ReflectionClass($name)));
+    }
+
+    protected function getReader()
+    {
+        $this->cache = new ArrayCache();
+        return new CachedReader(new AnnotationReader(), $this->cache);
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DocLexer;
+
+class DocLexerTest extends \PHPUnit_Framework_TestCase
+{
+    public function testMarkerAnnotation()
+    {
+        $lexer = new DocLexer;
+
+        $lexer->setInput("@Name");
+        $this->assertNull($lexer->token);
+        $this->assertNull($lexer->lookahead);
+
+        $this->assertTrue($lexer->moveNext());
+        $this->assertNull($lexer->token);
+        $this->assertEquals('@', $lexer->lookahead['value']);
+
+        $this->assertTrue($lexer->moveNext());
+        $this->assertEquals('@', $lexer->token['value']);
+        $this->assertEquals('Name', $lexer->lookahead['value']);
+
+        $this->assertFalse($lexer->moveNext());
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php

@@ -0,0 +1,389 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\Annotation\IgnorePhpDoc;
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\DocParser;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+
+class DocParserTest extends \PHPUnit_Framework_TestCase
+{
+    public function testNestedArraysWithNestedAnnotation()
+    {
+        $parser = $this->createTestParser();
+
+        // Nested arrays with nested annotations
+        $result = $parser->parse('@Name(foo={1,2, {"key"=@Name}})');
+        $annot = $result[0];
+
+        $this->assertTrue($annot instanceof Name);
+        $this->assertNull($annot->value);
+        $this->assertEquals(3, count($annot->foo));
+        $this->assertEquals(1, $annot->foo[0]);
+        $this->assertEquals(2, $annot->foo[1]);
+        $this->assertTrue(is_array($annot->foo[2]));
+
+        $nestedArray = $annot->foo[2];
+        $this->assertTrue(isset($nestedArray['key']));
+        $this->assertTrue($nestedArray['key'] instanceof Name);
+    }
+
+    public function testBasicAnnotations()
+    {
+        $parser = $this->createTestParser();
+
+        // Marker annotation
+        $result = $parser->parse("@Name");
+        $annot = $result[0];
+        $this->assertTrue($annot instanceof Name);
+        $this->assertNull($annot->value);
+        $this->assertNull($annot->foo);
+
+        // Associative arrays
+        $result = $parser->parse('@Name(foo={"key1" = "value1"})');
+        $annot = $result[0];
+        $this->assertNull($annot->value);
+        $this->assertTrue(is_array($annot->foo));
+        $this->assertTrue(isset($annot->foo['key1']));
+
+        // Numerical arrays
+        $result = $parser->parse('@Name({2="foo", 4="bar"})');
+        $annot = $result[0];
+        $this->assertTrue(is_array($annot->value));
+        $this->assertEquals('foo', $annot->value[2]);
+        $this->assertEquals('bar', $annot->value[4]);
+        $this->assertFalse(isset($annot->value[0]));
+        $this->assertFalse(isset($annot->value[1]));
+        $this->assertFalse(isset($annot->value[3]));
+
+        // Multiple values
+        $result = $parser->parse('@Name(@Name, @Name)');
+        $annot = $result[0];
+
+        $this->assertTrue($annot instanceof Name);
+        $this->assertTrue(is_array($annot->value));
+        $this->assertTrue($annot->value[0] instanceof Name);
+        $this->assertTrue($annot->value[1] instanceof Name);
+
+        // Multiple types as values
+        $result = $parser->parse('@Name(foo="Bar", @Name, {"key1"="value1", "key2"="value2"})');
+        $annot = $result[0];
+
+        $this->assertTrue($annot instanceof Name);
+        $this->assertTrue(is_array($annot->value));
+        $this->assertTrue($annot->value[0] instanceof Name);
+        $this->assertTrue(is_array($annot->value[1]));
+        $this->assertEquals('value1', $annot->value[1]['key1']);
+        $this->assertEquals('value2', $annot->value[1]['key2']);
+
+        // Complete docblock
+        $docblock = <<<DOCBLOCK
+/**
+ * Some nifty class.
+ *
+ * @author Mr.X
+ * @Name(foo="bar")
+ */
+DOCBLOCK;
+
+        $result = $parser->parse($docblock);
+        $this->assertEquals(1, count($result));
+        $annot = $result[0];
+        $this->assertTrue($annot instanceof Name);
+        $this->assertEquals("bar", $annot->foo);
+        $this->assertNull($annot->value);
+   }
+
+    public function testNamespacedAnnotations()
+    {
+        $parser = new DocParser;
+        $parser->setIgnoreNotImportedAnnotations(true);
+
+        $docblock = <<<DOCBLOCK
+/**
+ * Some nifty class.
+ *
+ * @package foo
+ * @subpackage bar
+ * @author Mr.X <mr@x.com>
+ * @Doctrine\Tests\Common\Annotations\Name(foo="bar")
+ * @ignore
+ */
+DOCBLOCK;
+
+        $result = $parser->parse($docblock);
+        $this->assertEquals(1, count($result));
+        $annot = $result[0];
+        $this->assertTrue($annot instanceof Name);
+        $this->assertEquals("bar", $annot->foo);
+    }
+
+    /**
+     * @group debug
+     */
+    public function testTypicalMethodDocBlock()
+    {
+        $parser = $this->createTestParser();
+
+        $docblock = <<<DOCBLOCK
+/**
+ * Some nifty method.
+ *
+ * @since 2.0
+ * @Doctrine\Tests\Common\Annotations\Name(foo="bar")
+ * @param string \$foo This is foo.
+ * @param mixed \$bar This is bar.
+ * @return string Foo and bar.
+ * @This is irrelevant
+ * @Marker
+ */
+DOCBLOCK;
+
+        $result = $parser->parse($docblock);
+        $this->assertEquals(2, count($result));
+        $this->assertTrue(isset($result[0]));
+        $this->assertTrue(isset($result[1]));
+        $annot = $result[0];
+        $this->assertTrue($annot instanceof Name);
+        $this->assertEquals("bar", $annot->foo);
+        $marker = $result[1];
+        $this->assertTrue($marker instanceof Marker);
+    }
+
+    /**
+     * @group DDC-575
+     */
+    public function testRegressionDDC575()
+    {
+        $parser = $this->createTestParser();
+
+        $docblock = <<<DOCBLOCK
+/**
+ * @Name
+ *
+ * Will trigger error.
+ */
+DOCBLOCK;
+
+        $result = $parser->parse($docblock);
+
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Name", $result[0]);
+
+        $docblock = <<<DOCBLOCK
+/**
+ * @Name
+ * @Marker
+ *
+ * Will trigger error.
+ */
+DOCBLOCK;
+
+        $result = $parser->parse($docblock);
+
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Name", $result[0]);
+    }
+
+    /**
+     * @group DDC-77
+     */
+    public function testAnnotationWithoutClassIsIgnoredWithoutWarning()
+    {
+        $parser = new DocParser();
+        $parser->setIgnoreNotImportedAnnotations(true);
+        $result = $parser->parse("@param");
+
+        $this->assertEquals(0, count($result));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected PlainValue, got ''' at position 10.
+     */
+    public function testAnnotationDontAcceptSingleQuotes()
+    {
+        $parser = $this->createTestParser();
+        $parser->parse("@Name(foo='bar')");
+    }
+
+    /**
+     * @group DCOM-41
+     */
+    public function testAnnotationDoesntThrowExceptionWhenAtSignIsNotFollowedByIdentifier()
+    {
+        $parser = new DocParser();
+        $result = $parser->parse("'@'");
+
+        $this->assertEquals(0, count($result));
+    }
+
+    /**
+     * @group DCOM-41
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     */
+    public function testAnnotationThrowsExceptionWhenAtSignIsNotFollowedByIdentifierInNestedAnnotation()
+    {
+        $parser = new DocParser();
+        $result = $parser->parse("@Doctrine\Tests\Common\Annotations\Name(@')");
+    }
+    
+    /**
+     * @group DCOM-56
+     */
+    public function testAutoloadAnnotation()
+    {
+        $this->assertFalse(class_exists('Doctrine\Tests\Common\Annotations\Fixture\Annotation\Autoload', false), 'Pre-condition: Doctrine\Tests\Common\Annotations\Fixture\Annotation\Autoload not allowed to be loaded.');
+        
+        $parser = new DocParser();
+        
+        AnnotationRegistry::registerAutoloadNamespace('Doctrine\Tests\Common\Annotations\Fixtures\Annotation', __DIR__ . '/../../../../');
+        
+        $parser->setImports(array(
+            'autoload' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Autoload',
+        ));
+        $annotations = $parser->parse('@Autoload');
+        
+        $this->assertEquals(1, count($annotations));
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Autoload', $annotations[0]);
+    }
+
+    public function createTestParser()
+    {
+        $parser = new DocParser();
+        $parser->setIgnoreNotImportedAnnotations(true);
+        $parser->setImports(array(
+            'name' => 'Doctrine\Tests\Common\Annotations\Name',
+            '__NAMESPACE__' => 'Doctrine\Tests\Common\Annotations',
+        ));
+
+        return $parser;
+    }
+
+    /**
+     * @group DDC-78
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected PlainValue, got ''' at position 10 in class \Doctrine\Tests\Common\Annotations\Name
+     */
+    public function testSyntaxErrorWithContextDescription()
+    {
+        $parser = $this->createTestParser();
+        $parser->parse("@Name(foo='bar')", "class \Doctrine\Tests\Common\Annotations\Name");
+    }
+
+    /**
+     * @group DDC-183
+     */
+    public function testSyntaxErrorWithUnknownCharacters()
+    {
+        $docblock = <<<DOCBLOCK
+/**
+ * @test at.
+ */
+class A {
+}
+DOCBLOCK;
+
+        //$lexer = new \Doctrine\Common\Annotations\Lexer();
+        //$lexer->setInput(trim($docblock, '/ *'));
+        //var_dump($lexer);
+
+        try {
+            $parser = $this->createTestParser();
+            $result = $parser->parse($docblock);
+        } catch (Exception $e) {
+            $this->fail($e->getMessage());
+        }
+    }
+
+    /**
+     * @group DCOM-14
+     */
+    public function testIgnorePHPDocThrowTag()
+    {
+        $docblock = <<<DOCBLOCK
+/**
+ * @throws \RuntimeException
+ */
+class A {
+}
+DOCBLOCK;
+
+        try {
+            $parser = $this->createTestParser();
+            $result = $parser->parse($docblock);
+        } catch (Exception $e) {
+            $this->fail($e->getMessage());
+        }
+    }
+
+    /**
+     * @group DCOM-38
+     */
+    public function testCastInt()
+    {
+        $parser = $this->createTestParser();
+
+        $result = $parser->parse("@Name(foo=1234)");
+        $annot = $result[0];
+        $this->assertInternalType('int', $annot->foo);
+    }
+
+    /**
+     * @group DCOM-38
+     */
+    public function testCastFloat()
+    {
+        $parser = $this->createTestParser();
+
+        $result = $parser->parse("@Name(foo=1234.345)");
+        $annot = $result[0];
+        $this->assertInternalType('float', $annot->foo);
+    }
+
+    public function testReservedKeywordsInAnnotations()
+    {
+        $parser = $this->createTestParser();
+
+        $result = $parser->parse('@Doctrine\Tests\Common\Annotations\True');
+        $this->assertTrue($result[0] instanceof True);
+        $result = $parser->parse('@Doctrine\Tests\Common\Annotations\False');
+        $this->assertTrue($result[0] instanceof False);
+        $result = $parser->parse('@Doctrine\Tests\Common\Annotations\Null');
+        $this->assertTrue($result[0] instanceof Null);
+
+        $result = $parser->parse('@True');
+        $this->assertTrue($result[0] instanceof True);
+        $result = $parser->parse('@False');
+        $this->assertTrue($result[0] instanceof False);
+        $result = $parser->parse('@Null');
+        $this->assertTrue($result[0] instanceof Null);
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Syntax Error] Expected Doctrine\Common\Annotations\DocLexer::T_IDENTIFIER or Doctrine\Common\Annotations\DocLexer::T_TRUE or Doctrine\Common\Annotations\DocLexer::T_FALSE or Doctrine\Common\Annotations\DocLexer::T_NULL, got '3.42' at position 5.
+     */
+    public function testInvalidIdentifierInAnnotation()
+    {
+        $parser = $this->createTestParser();
+
+        $result = $parser->parse('@Foo\3.42');
+    }
+}
+
+class Name extends \Doctrine\Common\Annotations\Annotation {
+    public $foo;
+}
+
+class Marker extends \Doctrine\Common\Annotations\Annotation {}
+
+class True extends \Doctrine\Common\Annotations\Annotation {}
+
+class False extends \Doctrine\Common\Annotations\Annotation {}
+
+class Null extends \Doctrine\Common\Annotations\Annotation {}
+
+namespace Doctrine\Tests\Common\Annotations\FooBar;
+
+class Name extends \Doctrine\Common\Annotations\Annotation {
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\FileCacheReader;
+
+class FileCacheReaderTest extends AbstractReaderTest
+{
+    private $cacheDir;
+    
+    protected function getReader()
+    {
+        $this->cacheDir = sys_get_temp_dir() . "/annotations_". uniqid();
+        @mkdir($this->cacheDir);
+        return new FileCacheReader(new AnnotationReader(), $this->cacheDir);
+    }
+    
+    public function tearDown()
+    {
+        foreach (glob($this->cacheDir.'/*.php') AS $file) {
+            unlink($file);
+        }
+        rmdir($this->cacheDir);
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ */
+class Autoload extends \Doctrine\Common\Annotations\Annotation
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+class Route extends \Doctrine\Common\Annotations\Annotation
+{
+    private $pattern;
+    private $name;
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+class Secure
+{
+    private $roles;
+
+    public function __construct(array $values)
+    {
+        if (is_string($values['value'])) {
+            $values['value'] = array($values['value']);
+        }
+
+        $this->roles = $values['value'];
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+class Template
+{
+    private $name;
+
+    public function __construct(array $values)
+    {
+        $this->name = isset($values['value']) ? $values['value'] : null;
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php

@@ -0,0 +1,300 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("/someprefix")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Controller
+{
+    /**
+     * @Route("/", name="_demo")
+     * @Template()
+     */
+    public function indexAction()
+    {
+        return array();
+    }
+
+    /**
+     * @Route("/hello/{name}", name="_demo_hello")
+     * @Template()
+     */
+    public function helloAction($name)
+    {
+        return array('name' => $name);
+    }
+
+    /**
+     * @Route("/contact", name="_demo_contact")
+     * @Template()
+     */
+    public function contactAction()
+    {
+        $form = ContactForm::create($this->get('form.context'), 'contact');
+
+        $form->bind($this->container->get('request'), $form);
+        if ($form->isValid()) {
+            $form->send($this->get('mailer'));
+
+            $this->get('session')->setFlash('notice', 'Message sent!');
+
+            return new RedirectResponse($this->generateUrl('_demo'));
+        }
+
+        return array('form' => $form);
+    }
+
+    /**
+     * Creates the ACL for the passed object identity
+     *
+     * @param ObjectIdentityInterface $oid
+     * @return void
+     */
+    private function createObjectIdentity(ObjectIdentityInterface $oid)
+    {
+        $classId = $this->createOrRetrieveClassId($oid->getType());
+
+        $this->connection->executeQuery($this->getInsertObjectIdentitySql($oid->getIdentifier(), $classId, true));
+    }
+
+    /**
+     * Returns the primary key for the passed class type.
+     *
+     * If the type does not yet exist in the database, it will be created.
+     *
+     * @param string $classType
+     * @return integer
+     */
+    private function createOrRetrieveClassId($classType)
+    {
+        if (false !== $id = $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn()) {
+            return $id;
+        }
+
+        $this->connection->executeQuery($this->getInsertClassSql($classType));
+
+        return $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn();
+    }
+
+    /**
+     * Returns the primary key for the passed security identity.
+     *
+     * If the security identity does not yet exist in the database, it will be
+     * created.
+     *
+     * @param SecurityIdentityInterface $sid
+     * @return integer
+     */
+    private function createOrRetrieveSecurityIdentityId(SecurityIdentityInterface $sid)
+    {
+        if (false !== $id = $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn()) {
+            return $id;
+        }
+
+        $this->connection->executeQuery($this->getInsertSecurityIdentitySql($sid));
+
+        return $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn();
+    }
+
+    /**
+     * Deletes all ACEs for the given object identity primary key.
+     *
+     * @param integer $oidPK
+     * @return void
+     */
+    private function deleteAccessControlEntries($oidPK)
+    {
+        $this->connection->executeQuery($this->getDeleteAccessControlEntriesSql($oidPK));
+    }
+
+    /**
+     * Deletes the object identity from the database.
+     *
+     * @param integer $pk
+     * @return void
+     */
+    private function deleteObjectIdentity($pk)
+    {
+        $this->connection->executeQuery($this->getDeleteObjectIdentitySql($pk));
+    }
+
+    /**
+     * Deletes all entries from the relations table from the database.
+     *
+     * @param integer $pk
+     * @return void
+     */
+    private function deleteObjectIdentityRelations($pk)
+    {
+        $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+    }
+
+    /**
+     * This regenerates the ancestor table which is used for fast read access.
+     *
+     * @param AclInterface $acl
+     * @return void
+     */
+    private function regenerateAncestorRelations(AclInterface $acl)
+    {
+        $pk = $acl->getId();
+        $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+        $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $pk));
+
+        $parentAcl = $acl->getParentAcl();
+        while (null !== $parentAcl) {
+            $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $parentAcl->getId()));
+
+            $parentAcl = $parentAcl->getParentAcl();
+        }
+    }
+
+    /**
+     * This processes changes on an ACE related property (classFieldAces, or objectFieldAces).
+     *
+     * @param string $name
+     * @param array $changes
+     * @return void
+     */
+    private function updateFieldAceProperty($name, array $changes)
+    {
+        $sids = new \SplObjectStorage();
+        $classIds = new \SplObjectStorage();
+        $currentIds = array();
+        foreach ($changes[1] as $field => $new) {
+            for ($i=0,$c=count($new); $i<$c; $i++) {
+                $ace = $new[$i];
+
+                if (null === $ace->getId()) {
+                    if ($sids->contains($ace->getSecurityIdentity())) {
+                        $sid = $sids->offsetGet($ace->getSecurityIdentity());
+                    } else {
+                        $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+                    }
+
+                    $oid = $ace->getAcl()->getObjectIdentity();
+                    if ($classIds->contains($oid)) {
+                        $classId = $classIds->offsetGet($oid);
+                    } else {
+                        $classId = $this->createOrRetrieveClassId($oid->getType());
+                    }
+
+                    $objectIdentityId = $name === 'classFieldAces' ? null : $ace->getAcl()->getId();
+
+                    $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, $field, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+                    $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, $field, $i))->fetchColumn();
+                    $this->loadedAces[$aceId] = $ace;
+
+                    $aceIdProperty = new \ReflectionProperty('Symfony\Component\Security\Acl\Domain\Entry', 'id');
+                    $aceIdProperty->setAccessible(true);
+                    $aceIdProperty->setValue($ace, intval($aceId));
+                } else {
+                    $currentIds[$ace->getId()] = true;
+                }
+            }
+        }
+
+        foreach ($changes[0] as $old) {
+            for ($i=0,$c=count($old); $i<$c; $i++) {
+                $ace = $old[$i];
+
+                if (!isset($currentIds[$ace->getId()])) {
+                    $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+                    unset($this->loadedAces[$ace->getId()]);
+                }
+            }
+        }
+    }
+
+    /**
+     * This processes changes on an ACE related property (classAces, or objectAces).
+     *
+     * @param string $name
+     * @param array $changes
+     * @return void
+     */
+    private function updateAceProperty($name, array $changes)
+    {
+        list($old, $new) = $changes;
+
+        $sids = new \SplObjectStorage();
+        $classIds = new \SplObjectStorage();
+        $currentIds = array();
+        for ($i=0,$c=count($new); $i<$c; $i++) {
+            $ace = $new[$i];
+
+            if (null === $ace->getId()) {
+                if ($sids->contains($ace->getSecurityIdentity())) {
+                    $sid = $sids->offsetGet($ace->getSecurityIdentity());
+                } else {
+                    $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+                }
+
+                $oid = $ace->getAcl()->getObjectIdentity();
+                if ($classIds->contains($oid)) {
+                    $classId = $classIds->offsetGet($oid);
+                } else {
+                    $classId = $this->createOrRetrieveClassId($oid->getType());
+                }
+
+                $objectIdentityId = $name === 'classAces' ? null : $ace->getAcl()->getId();
+
+                $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, null, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+                $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, null, $i))->fetchColumn();
+                $this->loadedAces[$aceId] = $ace;
+
+                $aceIdProperty = new \ReflectionProperty($ace, 'id');
+                $aceIdProperty->setAccessible(true);
+                $aceIdProperty->setValue($ace, intval($aceId));
+            } else {
+                $currentIds[$ace->getId()] = true;
+            }
+        }
+
+        for ($i=0,$c=count($old); $i<$c; $i++) {
+            $ace = $old[$i];
+
+            if (!isset($currentIds[$ace->getId()])) {
+                $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+                unset($this->loadedAces[$ace->getId()]);
+            }
+        }
+    }
+
+    /**
+     * Persists the changes which were made to ACEs to the database.
+     *
+     * @param \SplObjectStorage $aces
+     * @return void
+     */
+    private function updateAces(\SplObjectStorage $aces)
+    {
+        foreach ($aces as $ace) {
+            $propertyChanges = $aces->offsetGet($ace);
+            $sets = array();
+
+            if (isset($propertyChanges['mask'])) {
+                $sets[] = sprintf('mask = %d', $propertyChanges['mask'][1]);
+            }
+            if (isset($propertyChanges['strategy'])) {
+                $sets[] = sprintf('granting_strategy = %s', $this->connection->quote($propertyChanges['strategy']));
+            }
+            if (isset($propertyChanges['aceOrder'])) {
+                $sets[] = sprintf('ace_order = %d', $propertyChanges['aceOrder'][1]);
+            }
+            if (isset($propertyChanges['auditSuccess'])) {
+                $sets[] = sprintf('audit_success = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditSuccess'][1]));
+            }
+            if (isset($propertyChanges['auditFailure'])) {
+                $sets[] = sprintf('audit_failure = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditFailure'][1]));
+            }
+
+            $this->connection->executeQuery($this->getUpdateAccessControlEntrySql($ace->getId(), $sets));
+        }
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class AnotherClass { }
+class MultipleClassesInFile { }

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use
+    Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route,
+    Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure
+;
+
+class MultipleImportsInUseStatement {}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php

@@ -0,0 +1,10 @@
+<?php
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("foo")
+ * @Template
+ */
+class AnnotationsTestsFixturesNonNamespacedClass { }

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+interface TestInterface
+{
+    /**
+     * @Secure
+     */
+    function foo();
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\FileCacheReader;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\DocLexer;
+use Doctrine\Common\Annotations\DocParser;
+use Doctrine\Common\Annotations\AnnotationReader;
+
+require_once __DIR__ . '/Fixtures/Annotation/Route.php';
+require_once __DIR__ . '/Fixtures/Annotation/Template.php';
+require_once __DIR__ . '/Fixtures/Annotation/Secure.php';
+
+class PerformanceTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @group performance
+     */
+    public function testCachedReadPerformanceWithInMemory()
+    {
+        $reader = new CachedReader(new AnnotationReader(), new ArrayCache());
+        $method = $this->getMethod();
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $reader->getMethodAnnotations($method);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('cached reader (in-memory)', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testCachedReadPerformanceWithFileCache()
+    {
+        $method = $this->getMethod();
+
+        // prime cache
+        $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+        $reader->getMethodAnnotations($method);
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+            $reader->getMethodAnnotations($method);
+            clearstatcache();
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('cached reader (file)', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testReadPerformance()
+    {
+        $reader = new AnnotationReader();
+        $method = $this->getMethod();
+
+        $time = microtime(true);
+        for ($i=0,$c=150; $i<$c; $i++) {
+            $reader = new AnnotationReader();
+            $reader->getMethodAnnotations($method);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('reader', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testDocParsePerformance()
+    {
+        $imports = array(
+            'ignorephpdoc'     => 'Annotations\Annotation\IgnorePhpDoc',
+            'ignoreannotation' => 'Annotations\Annotation\IgnoreAnnotation',
+            'route'            => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+            'template'         => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template',
+            '__NAMESPACE__'    => 'Doctrine\Tests\Common\Annotations\Fixtures',
+        );
+        $ignored = array(
+            'access', 'author', 'copyright', 'deprecated', 'example', 'ignore',
+            'internal', 'link', 'see', 'since', 'tutorial', 'version', 'package',
+            'subpackage', 'name', 'global', 'param', 'return', 'staticvar',
+            'static', 'var', 'throws', 'inheritdoc',
+        );
+
+        $parser = new DocParser();
+        $method = $this->getMethod();
+        $methodComment = $method->getDocComment();
+        $classComment = $method->getDeclaringClass()->getDocComment();
+
+        $time = microtime(true);
+        for ($i=0,$c=200; $i<$c; $i++) {
+            $parser = new DocParser();
+            $parser->setImports($imports);
+            $parser->setIgnoredAnnotationNames($ignored);
+
+            $parser->parse($methodComment);
+            $parser->parse($classComment);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-parser', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testDocLexerPerformance()
+    {
+        $lexer = new DocLexer();
+        $method = $this->getMethod();
+        $methodComment = $method->getDocComment();
+        $classComment = $method->getDeclaringClass()->getDocComment();
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $lexer = new DocLexer();
+            $lexer->setInput($methodComment);
+            $lexer->setInput($classComment);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-lexer', $time, $c);
+    }
+
+    private function getMethod()
+    {
+        return new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\Controller', 'helloAction');
+    }
+
+    private function printResults($test, $time, $iterations)
+    {
+        if (0 == $iterations) {
+            throw new \InvalidArgumentException('$iterations cannot be zero.');
+        }
+
+        $title = $test." results:\n";
+        $iterationsText = sprintf("Iterations:         %d\n", $iterations);
+        $totalTime      = sprintf("Total Time:         %.3f s\n", $time);
+        $iterationTime  = sprintf("Time per iteration: %.3f ms\n", $time/$iterations * 1000);
+
+        $max = max(strlen($title), strlen($iterationTime)) - 1;
+
+        echo "\n".str_repeat('-', $max)."\n";
+        echo $title;
+        echo str_repeat('=', $max)."\n";
+        echo $iterationsText;
+        echo $totalTime;
+        echo $iterationTime;
+        echo str_repeat('-', $max)."\n";
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\PhpParser;
+
+require_once __DIR__.'/AnnotationReaderTest.php';
+require_once __DIR__.'/Fixtures/NonNamespacedClass.php';
+
+class PhpParserTest extends \PHPUnit_Framework_TestCase
+{
+    public function testParseClassWithMultipleClassesInFile()
+    {
+        $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\MultipleClassesInFile');
+        $parser = new PhpParser();
+
+        $this->assertEquals(array(
+            'route'  => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+            'secure' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWithMultipleImportsInUseStatement()
+    {
+        $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\MultipleImportsInUseStatement');
+        $parser = new PhpParser();
+
+        $this->assertEquals(array(
+            'route'  => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+            'secure' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWhenNotUserDefined()
+    {
+        $parser = new PhpParser();
+        $this->assertEquals(array(), $parser->parseClass(new \ReflectionClass('\stdClass')));
+    }
+
+    public function testParseClassWhenClassIsNotNamespaced()
+    {
+        $parser = new PhpParser();
+        $class = new \ReflectionClass('\AnnotationsTestsFixturesNonNamespacedClass');
+
+        $this->assertEquals(array(
+            'route'  => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+            'template' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWhenClassIsInterface()
+    {
+        $parser = new PhpParser();
+        $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\TestInterface');
+
+        $this->assertEquals(array(
+            'secure' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Regression/BCAnnotationReaderTest.php

@@ -0,0 +1,258 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Regression;
+
+use ReflectionClass;
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\IndexedReader;
+
+use Doctrine\Tests\Common\Annotations\DummyJoinTable;
+use Doctrine\Tests\Common\Annotations\DummyId;
+
+/**
+ * Important: This class needs a different namespace than Doctrine\Tests\Common\Annotations\
+ * to be able to really test the set default annotation namespace functionality.
+ */
+class BCAnnotationReaderTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    public function testAnnotations()
+    {
+        $reader = $this->createAnnotationReader();
+    
+        $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\DummyClass');
+        $classAnnots = $reader->getClassAnnotations($class);
+        
+        $annotName = 'Doctrine\Tests\Common\Annotations\DummyAnnotation';
+        $this->assertEquals(1, count($classAnnots));
+        $this->assertTrue($classAnnots[$annotName] instanceof \Doctrine\Tests\Common\Annotations\DummyAnnotation); // no use!
+        $this->assertEquals("hello", $classAnnots[$annotName]->dummyValue);
+        
+        $field1Prop = $class->getProperty('field1');
+        $propAnnots = $reader->getPropertyAnnotations($field1Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertTrue($propAnnots[$annotName] instanceof \Doctrine\Tests\Common\Annotations\DummyAnnotation); // no use!
+        $this->assertEquals("fieldHello", $propAnnots[$annotName]->dummyValue);
+        
+        $getField1Method = $class->getMethod('getField1');
+        $methodAnnots = $reader->getMethodAnnotations($getField1Method);
+        $this->assertEquals(1, count($methodAnnots));
+        $this->assertTrue($methodAnnots[$annotName] instanceof \Doctrine\Tests\Common\Annotations\DummyAnnotation); // no use!
+        $this->assertEquals(array(1, 2, "three"), $methodAnnots[$annotName]->value);
+        
+        $field2Prop = $class->getProperty('field2');
+        $propAnnots = $reader->getPropertyAnnotations($field2Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertTrue(isset($propAnnots['Doctrine\Tests\Common\Annotations\DummyJoinTable']));
+        $joinTableAnnot = $propAnnots['Doctrine\Tests\Common\Annotations\DummyJoinTable'];
+        $this->assertEquals(1, count($joinTableAnnot->joinColumns));
+        $this->assertEquals(1, count($joinTableAnnot->inverseJoinColumns));
+        $this->assertTrue($joinTableAnnot->joinColumns[0] instanceof \Doctrine\Tests\Common\Annotations\DummyJoinColumn); // no use!
+        $this->assertTrue($joinTableAnnot->inverseJoinColumns[0] instanceof \Doctrine\Tests\Common\Annotations\DummyJoinColumn); // no use!
+        $this->assertEquals('col1', $joinTableAnnot->joinColumns[0]->name);
+        $this->assertEquals('col2', $joinTableAnnot->joinColumns[0]->referencedColumnName);
+        $this->assertEquals('col3', $joinTableAnnot->inverseJoinColumns[0]->name);
+        $this->assertEquals('col4', $joinTableAnnot->inverseJoinColumns[0]->referencedColumnName);
+
+        $dummyAnnot = $reader->getMethodAnnotation($class->getMethod('getField1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('', $dummyAnnot->dummyValue);
+        $this->assertEquals(array(1, 2, 'three'), $dummyAnnot->value);
+
+        $dummyAnnot = $reader->getPropertyAnnotation($class->getProperty('field1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('fieldHello', $dummyAnnot->dummyValue);
+
+        $classAnnot = $reader->getClassAnnotation($class, 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('hello', $classAnnot->dummyValue);
+    }
+
+    /**
+     * @group regression
+     */
+    public function testMultipleAnnotationsOnSameLine()
+    {
+        $reader = $this->createAnnotationReader();
+        $class = new ReflectionClass('\Doctrine\Tests\Common\Annotations\Regression\DummyClass2');
+        $annotations = $reader->getPropertyAnnotations($class->getProperty('id'));
+        $this->assertEquals(3, count($annotations));
+    }
+
+    public function testCustomAnnotationCreationFunction()
+    {
+        $reader = $this->createAnnotationReader();
+        $reader->setAnnotationCreationFunction(function($name, $values) {
+            if ($name == 'Doctrine\Tests\Common\Annotations\DummyAnnotation') {
+                $a = new CustomDummyAnnotationClass;
+                $a->setDummyValue($values['dummyValue']);
+                return $a;
+            }
+        });
+
+        $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\DummyClass');
+        $classAnnots = $reader->getClassAnnotations($class);
+        $this->assertTrue(isset($classAnnots['Doctrine\Tests\Common\Annotations\Regression\CustomDummyAnnotationClass']));
+        $annot = $classAnnots['Doctrine\Tests\Common\Annotations\Regression\CustomDummyAnnotationClass'];
+        $this->assertEquals('hello', $annot->getDummyValue());
+    }
+
+    public function testNonAnnotationProblem()
+    {
+        $reader = $this->createAnnotationReader();
+
+        $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\DummyClassNonAnnotationProblem');
+        $annotations = $reader->getPropertyAnnotations($class->getProperty('foo'));
+        $this->assertArrayHasKey('Doctrine\Tests\Common\Annotations\DummyAnnotation', $annotations);
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\DummyAnnotation', $annotations['Doctrine\Tests\Common\Annotations\DummyAnnotation']);
+    }
+
+    /**
+     * @return AnnotationReader
+     */
+    public function createAnnotationReader()
+    {
+        $reader = new IndexedReader(new AnnotationReader(new \Doctrine\Common\Cache\ArrayCache));
+        $reader->setDefaultAnnotationNamespace('Doctrine\Tests\Common\Annotations\\');
+        $reader->setEnableParsePhpImports(false);
+        return $reader;
+    }
+    
+    public function testEmailAsAnnotation()
+    {
+        $reader = new AnnotationReader(new \Doctrine\Common\Cache\ArrayCache);
+        $reader->setDefaultAnnotationNamespace('Doctrine\Tests\Common\Annotations\\');
+        
+        $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\DummyClassWithEmail');
+        $classAnnots = $reader->getClassAnnotations($class);
+        
+        $this->assertEquals(1, count($classAnnots));
+    }
+    
+    public function testNamespaceAliasedAnnotations()
+    {
+        $reader = new IndexedReader(new AnnotationReader(new \Doctrine\Common\Cache\ArrayCache));
+        $reader->setAnnotationNamespaceAlias('Doctrine\Tests\Common\Annotations\\', 'alias');
+
+        $reflClass = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\AliasNamespace');
+        
+        $result = $reader->getPropertyAnnotations($reflClass->getProperty('bar'));
+        $this->assertEquals(1, count($result));
+        $annot = $result['Doctrine\Tests\Common\Annotations\Name'];
+        $this->assertTrue($annot instanceof \Doctrine\Tests\Common\Annotations\Name); // no use!
+        $this->assertEquals('bar', $annot->foo);
+    }
+
+    /**
+     * @group DCOM-4
+     */
+    public function testNamespaceAliasAnnotationWithSeparator()
+    {
+        $reader = new IndexedReader(new AnnotationReader(new \Doctrine\Common\Cache\ArrayCache));
+        $reader->setAnnotationNamespaceAlias('Doctrine\Tests\Common\\', 'alias');
+
+        $reflClass = new ReflectionClass('Doctrine\Tests\Common\Annotations\Regression\AliasNamespace');
+        
+        $result = $reader->getPropertyAnnotations($reflClass->getProperty('foo'));
+        $this->assertEquals(1, count($result));
+        $annot = $result['Doctrine\Tests\Common\Annotations\Name'];
+        $this->assertTrue($annot instanceof \Doctrine\Tests\Common\Annotations\Name); // no use!
+        $this->assertEquals('bar', $annot->foo);
+    }
+}
+
+class CustomDummyAnnotationClass {
+    private $dummyValue;
+
+    public function setDummyValue($value) {
+        $this->dummyValue = $value;
+    }
+
+    public function getDummyValue() {
+        return $this->dummyValue;
+    }
+}
+
+class AliasNamespace
+{
+
+    /**
+     * @alias:Name(foo="bar")
+     */
+    public $bar;
+    /**
+     * @alias:Annotations\Name(foo="bar")
+     */
+    public $foo;
+}
+
+/**
+ * A description of this class.
+ *
+ * Let's see if the parser recognizes that this @ is not really referring to an
+ * annotation. Also make sure that @var \ is not concated to "@var\is".
+ * 
+ * Copy of the class one namespace up to avoid matches against __NAMESPACE__
+ *
+ * @author robo
+ * @since 2.0
+ * @DummyAnnotation(dummyValue="hello")
+ */
+class DummyClass {
+    /**
+     * A nice property.
+     *
+     * @var mixed
+     * @DummyAnnotation(dummyValue="fieldHello")
+     */
+    private $field1;
+
+    /**
+     * @DummyJoinTable(name="join_table",
+     *      joinColumns={@DummyJoinColumn(name="col1", referencedColumnName="col2")},
+     *      inverseJoinColumns={
+     *          @DummyJoinColumn(name="col3", referencedColumnName="col4")
+     *      })
+     */
+    private $field2;
+
+    /**
+     * Gets the value of field1.
+     *
+     * @return mixed
+     * @DummyAnnotation({1,2,"three"})
+     */
+    public function getField1() {
+    }
+}
+
+
+/**
+ * @ignoreAnnotation("var")
+ */
+class DummyClass2 {
+    /**
+     * @DummyId @DummyColumn(type="integer") @DummyGeneratedValue
+     * @var integer
+     */
+    private $id;
+}
+
+/**
+ * @ignoreAnnotation({"since", "var"})
+ */
+class DummyClassNonAnnotationProblem
+{
+    /**
+     * @DummyAnnotation
+     *
+     * @var \Test
+     * @since 0.1
+     */
+    public $foo;
+}
+
+
+/**
+* @DummyAnnotation Foo bar <foobar@1domain.com>
+*/
+class DummyClassWithEmail
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Ticket;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Controller;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+
+/**
+ * @group
+ */
+class DCOM55Test extends \PHPUnit_Framework_TestCase
+{
+    public function testIssue()
+    {
+        AnnotationRegistry::registerAutoloadNamespace('Doctrine\Tests\Common\Annotations\Fixtures', __DIR__ . '/../../../../../');
+
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\Dummy');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $annots = $reader->getClassAnnotations($class);
+        
+        $this->assertEquals(0, count($annots));
+    }
+    
+    public function testAnnotation()
+    {
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Consumer');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $annots = $reader->getClassAnnotations($class);
+        
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf(__NAMESPACE__.'\\DCOM55Annotation', $annots[0]);
+    }
+    
+    public function testParseAnnotationDocblocks()
+    {
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Annotation');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $annots = $reader->getClassAnnotations($class);
+        
+        $this->assertEquals(0, count($annots));
+    }
+}
+
+/**
+ * @Controller
+ */
+class Dummy
+{
+    
+}
+
+/**
+ * @Annotation
+ */
+class DCOM55Annotation
+{
+    
+}
+
+/**
+ * @DCOM55Annotation
+ */
+class DCOM55Consumer
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php

@@ -0,0 +1,7 @@
+<?php
+
+use Doctrine\Common\Annotations\Annotation;
+
+class TopLevelAnnotation extends Annotation
+{
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ApcCache;
+
+class ApcCacheTest extends CacheTest
+{
+    public function setUp()
+    {
+        if ( ! extension_loaded('apc') || false === @apc_cache_info()) {
+            $this->markTestSkipped('The ' . __CLASS__ .' requires the use of APC');
+        }
+    }
+
+    protected function _getCacheDriver()
+    {
+        return new ApcCache();
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/ArrayCacheTest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ArrayCache;
+
+class ArrayCacheTest extends CacheTest
+{
+    protected function _getCacheDriver()
+    {
+        return new ArrayCache();
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/CacheTest.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+abstract class CacheTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    public function testBasics()
+    {
+        $cache = $this->_getCacheDriver();
+
+        // Test save
+        $cache->save('test_key', 'testing this out');
+
+        // Test contains to test that save() worked
+        $this->assertTrue($cache->contains('test_key'));
+
+        // Test fetch
+        $this->assertEquals('testing this out', $cache->fetch('test_key'));
+
+        // Test delete
+        $cache->save('test_key2', 'test2');
+        $cache->delete('test_key2');
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+
+    public function testDeleteAll()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->save('test_key1', '1');
+        $cache->save('test_key2', '2');
+        $cache->deleteAll();
+
+        $this->assertFalse($cache->contains('test_key1'));
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+
+    public function testDeleteByRegex()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->save('test_key1', '1');
+        $cache->save('test_key2', '2');
+        $cache->deleteByRegex('/test_key[0-9]/');
+
+        $this->assertFalse($cache->contains('test_key1'));
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+
+    public function testDeleteByPrefix()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->save('test_key1', '1');
+        $cache->save('test_key2', '2');
+        $cache->deleteByPrefix('test_key');
+
+        $this->assertFalse($cache->contains('test_key1'));
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+
+    public function testDeleteBySuffix()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->save('1test_key', '1');
+        $cache->save('2test_key', '2');
+        $cache->deleteBySuffix('test_key');
+
+        $this->assertFalse($cache->contains('1test_key'));
+        $this->assertFalse($cache->contains('2test_key'));
+    }
+
+    public function testDeleteByWildcard()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->save('test_key1', '1');
+        $cache->save('test_key2', '2');
+        $cache->delete('test_key*');
+
+        $this->assertFalse($cache->contains('test_key1'));
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+
+    public function testNamespace()
+    {
+        $cache = $this->_getCacheDriver();
+        $cache->setNamespace('test_');
+        $cache->save('key1', 'test');
+        $this->assertTrue($cache->contains('key1'));
+
+        $ids = $cache->getIds();
+        $this->assertTrue(in_array('test_key1', $ids));
+    }
+
+    abstract protected function _getCacheDriver();
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/MemcacheCacheTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\MemcacheCache;
+
+class MemcacheCacheTest extends CacheTest
+{
+    private $_memcache;
+
+    public function setUp()
+    {
+        if (extension_loaded('memcache')) {
+            $this->_memcache = new \Memcache;
+            $ok = @$this->_memcache->connect('localhost', 11211);
+            if (!$ok) {
+                $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+            }
+        } else {
+            $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+        }
+    }
+
+    protected function _getCacheDriver()
+    {
+        $driver = new MemcacheCache();
+        $driver->setMemcache($this->_memcache);
+        return $driver;
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/XcacheCacheTest.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\XcacheCache;
+
+class XcacheCacheTest extends CacheTest
+{
+    public function setUp()
+    {
+        if ( ! extension_loaded('xcache')) {
+            $this->markTestSkipped('The ' . __CLASS__ .' requires the use of xcache');
+        }
+    }
+
+    protected function _getCacheDriver()
+    {
+        return new XcacheCache();
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Cache/ZendDataCacheTest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ZendDataCache;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class ZendDataCacheTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    public function setUp()
+    {
+        if (!function_exists('zend_shm_cache_fetch') || (php_sapi_name() != 'apache2handler')) {
+            $this->markTestSkipped('The ' . __CLASS__ .' requires the use of Zend Data Cache which only works in apache2handler SAPI');
+        }
+    }
+
+    protected function _getCacheDriver()
+    {
+        return new ZendDataCache();
+    }
+    
+    public function testBasics()
+    {
+        $cache = $this->_getCacheDriver();
+
+        // Test save
+        $cache->save('test_key', 'testing this out');
+
+        // Test contains to test that save() worked
+        $this->assertTrue($cache->contains('test_key'));
+
+        // Test fetch
+        $this->assertEquals('testing this out', $cache->fetch('test_key'));
+
+        // Test delete
+        $cache->save('test_key2', 'test2');
+        $cache->delete('test_key2');
+        $this->assertFalse($cache->contains('test_key2'));
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/ClassLoaderTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Doctrine\Tests\Common;
+
+use Doctrine\Common\ClassLoader;
+
+class ClassLoaderTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    public function testClassLoader()
+    {
+        $classLoader = new ClassLoader('ClassLoaderTest');
+        $classLoader->setIncludePath(__DIR__);
+        $classLoader->setFileExtension('.class.php');
+        $classLoader->setNamespaceSeparator('_');
+
+        $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassA'));
+        $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassB'));
+        $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassC'));
+        $this->assertFalse($classLoader->canLoadClass('OtherClass'));
+        $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassA'), true);
+        $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassB'), true);
+        $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassC'), true);
+    }
+
+    public function testClassExists()
+    {
+        $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\ClassD'));
+        $badLoader = function($className) {
+            require __DIR__ . '/ClassLoaderTest/ClassD.php';
+            return true;
+        };
+        spl_autoload_register($badLoader);
+        $this->assertTrue(ClassLoader::classExists('ClassLoaderTest\ClassD'));
+        spl_autoload_unregister($badLoader);
+    }
+
+    public function testGetClassLoader()
+    {
+        $cl = new ClassLoader('ClassLoaderTest', __DIR__);
+        $cl->register();
+        $this->assertTrue(ClassLoader::getClassLoader('ClassLoaderTest\ClassD') instanceof \Doctrine\Common\ClassLoader);
+        $this->assertNull(ClassLoader::getClassLoader('This\Class\Does\Not\Exist'));
+        $cl->unregister();
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassA.class.php

@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassA
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassB.class.php

@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassB
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassC.class.php

@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassC
+{
+    
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassD.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace ClassLoaderTest;
+
+class ClassD {}

vendor/doctrine-common/tests/Doctrine/Tests/Common/Collections/CollectionTest.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace Doctrine\Tests\Common\Collections;
+
+use Doctrine\Tests;
+
+class CollectionTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    /**
+     * @var \Doctrine\Common\Collections\Collection
+     */
+    private $_coll;
+
+    protected function setUp()
+    {
+        $this->_coll = new \Doctrine\Common\Collections\ArrayCollection;
+    }
+
+    public function testIssetAndUnset()
+    {
+        $this->assertFalse(isset($this->_coll[0]));
+        $this->_coll->add('testing');
+        $this->assertTrue(isset($this->_coll[0]));
+        unset($this->_coll[0]);
+        $this->assertFalse(isset($this->_coll[0]));
+    }
+
+    public function testToString()
+    {
+        $this->_coll->add('testing');
+        $this->assertTrue(is_string((string) $this->_coll));
+    }
+
+    public function testRemovingNonExistentEntryReturnsNull()
+    {
+        $this->assertEquals(null, $this->_coll->remove('testing_does_not_exist'));
+    }
+
+    public function testExists()
+    {
+        $this->_coll->add("one");
+        $this->_coll->add("two");
+        $exists = $this->_coll->exists(function($k, $e) { return $e == "one"; });
+        $this->assertTrue($exists);
+        $exists = $this->_coll->exists(function($k, $e) { return $e == "other"; });
+        $this->assertFalse($exists);
+    }
+
+    public function testMap()
+    {
+        $this->_coll->add(1);
+        $this->_coll->add(2);
+        $res = $this->_coll->map(function($e) { return $e * 2; });
+        $this->assertEquals(array(2, 4), $res->toArray());
+    }
+
+    public function testFilter()
+    {
+        $this->_coll->add(1);
+        $this->_coll->add("foo");
+        $this->_coll->add(3);
+        $res = $this->_coll->filter(function($e) { return is_numeric($e); });
+        $this->assertEquals(array(0 => 1, 2 => 3), $res->toArray());
+    }
+
+    public function testFirstAndLast()
+    {
+        $this->_coll->add('one');
+        $this->_coll->add('two');
+
+        $this->assertEquals($this->_coll->first(), 'one');
+        $this->assertEquals($this->_coll->last(), 'two');
+    }
+
+    public function testArrayAccess()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+
+        $this->assertEquals($this->_coll[0], 'one');
+        $this->assertEquals($this->_coll[1], 'two');
+
+        unset($this->_coll[0]);
+        $this->assertEquals($this->_coll->count(), 1);
+    }
+
+    public function testContainsKey()
+    {
+        $this->_coll[5] = 'five';
+        $this->assertTrue($this->_coll->containsKey(5));
+    }
+
+    public function testContains()
+    {
+        $this->_coll[0] = 'test';
+        $this->assertTrue($this->_coll->contains('test'));
+    }
+
+    public function testSearch()
+    {
+        $this->_coll[0] = 'test';
+        $this->assertEquals(0, $this->_coll->indexOf('test'));
+    }
+
+    public function testGet()
+    {
+        $this->_coll[0] = 'test';
+        $this->assertEquals('test', $this->_coll->get(0));
+    }
+
+    public function testGetKeys()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->assertEquals(array(0, 1), $this->_coll->getKeys());
+    }
+
+    public function testGetValues()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->assertEquals(array('one', 'two'), $this->_coll->getValues());
+    }
+
+    public function testCount()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->assertEquals($this->_coll->count(), 2);
+        $this->assertEquals(count($this->_coll), 2);
+    }
+
+    public function testForAll()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->assertEquals($this->_coll->forAll(function($k, $e) { return is_string($e); }), true);
+        $this->assertEquals($this->_coll->forAll(function($k, $e) { return is_array($e); }), false);
+    }
+
+    public function testPartition()
+    {
+        $this->_coll[] = true;
+        $this->_coll[] = false;
+        $partition = $this->_coll->partition(function($k, $e) { return $e == true; });
+        $this->assertEquals($partition[0][0], true);
+        $this->assertEquals($partition[1][0], false);
+    }
+
+    public function testClear()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->_coll->clear();
+        $this->assertEquals($this->_coll->isEmpty(), true);
+    }
+
+    public function testRemove()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $el = $this->_coll->remove(0);
+
+        $this->assertEquals('one', $el);
+        $this->assertEquals($this->_coll->contains('one'), false);
+        $this->assertNull($this->_coll->remove(0));
+    }
+
+    public function testRemoveElement()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        
+        $this->assertTrue($this->_coll->removeElement('two'));
+        $this->assertFalse($this->_coll->contains('two'));
+        $this->assertFalse($this->_coll->removeElement('two'));
+    }
+
+    public function testSlice()
+    {
+        $this->_coll[] = 'one';
+        $this->_coll[] = 'two';
+        $this->_coll[] = 'three';
+
+        $slice = $this->_coll->slice(0, 1);
+        $this->assertInternalType('array', $slice);
+        $this->assertEquals(array('one'), $slice);
+
+        $slice = $this->_coll->slice(1);
+        $this->assertEquals(array(1 => 'two', 2 => 'three'), $slice);
+
+        $slice = $this->_coll->slice(1, 1);
+        $this->assertEquals(array(1 => 'two'), $slice);
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/Common/EventManagerTest.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Doctrine\Tests\Common;
+
+use Doctrine\Common\EventManager;
+use Doctrine\Common\EventArgs;
+
+class EventManagerTest extends \Doctrine\Tests\DoctrineTestCase
+{
+    /* Some pseudo events */
+    const preFoo = 'preFoo';
+    const postFoo = 'postFoo';
+    const preBar = 'preBar';
+    const postBar = 'postBar';
+
+    private $_preFooInvoked = false;
+    private $_postFooInvoked = false;
+
+    private $_eventManager;
+
+    protected function setUp()
+    {
+        $this->_eventManager = new EventManager;
+        $this->_preFooInvoked = false;
+        $this->_postFooInvoked = false;
+    }
+
+    public function testInitialState()
+    {
+        $this->assertEquals(array(), $this->_eventManager->getListeners());
+        $this->assertFalse($this->_eventManager->hasListeners(self::preFoo));
+        $this->assertFalse($this->_eventManager->hasListeners(self::postFoo));
+    }
+
+    public function testAddEventListener()
+    {
+        $this->_eventManager->addEventListener(array('preFoo', 'postFoo'), $this);
+        $this->assertTrue($this->_eventManager->hasListeners(self::preFoo));
+        $this->assertTrue($this->_eventManager->hasListeners(self::postFoo));
+        $this->assertEquals(1, count($this->_eventManager->getListeners(self::preFoo)));
+        $this->assertEquals(1, count($this->_eventManager->getListeners(self::postFoo)));
+        $this->assertEquals(2, count($this->_eventManager->getListeners()));
+    }
+
+    public function testDispatchEvent()
+    {
+        $this->_eventManager->addEventListener(array('preFoo', 'postFoo'), $this);
+        $this->_eventManager->dispatchEvent(self::preFoo);
+        $this->assertTrue($this->_preFooInvoked);
+        $this->assertFalse($this->_postFooInvoked);
+    }
+
+    public function testRemoveEventListener()
+    {
+        $this->_eventManager->addEventListener(array('preBar'), $this);
+        $this->assertTrue($this->_eventManager->hasListeners(self::preBar));
+        $this->_eventManager->removeEventListener(array('preBar'), $this);
+        $this->assertFalse($this->_eventManager->hasListeners(self::preBar));
+    }
+
+    public function testAddEventSubscriber()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->_eventManager->addEventSubscriber($eventSubscriber);
+        $this->assertTrue($this->_eventManager->hasListeners(self::preFoo));
+        $this->assertTrue($this->_eventManager->hasListeners(self::postFoo));
+    }
+
+    /* Listener methods */
+
+    public function preFoo(EventArgs $e)
+    {
+        $this->_preFooInvoked = true;
+    }
+
+    public function postFoo(EventArgs $e)
+    {
+        $this->_postFooInvoked = true;
+    }
+}
+
+class TestEventSubscriber implements \Doctrine\Common\EventSubscriber
+{
+    public function getSubscribedEvents()
+    {
+        return array('preFoo', 'postFoo');
+    }
+}

vendor/doctrine-common/tests/Doctrine/Tests/DoctrineTestCase.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests;
+
+/**
+ * Base testcase class for all Doctrine testcases.
+ */
+abstract class DoctrineTestCase extends \PHPUnit_Framework_TestCase
+{
+}

vendor/doctrine-common/tests/Doctrine/Tests/TestInit.php

@@ -0,0 +1,27 @@
+<?php
+/*
+ * This file bootstraps the test environment.
+ */
+namespace Doctrine\Tests;
+
+error_reporting(E_ALL | E_STRICT);
+
+// register silently failing autoloader
+spl_autoload_register(function($class)
+{
+    if (0 === strpos($class, 'Doctrine\Tests\\')) {
+        $path = __DIR__.'/../../'.strtr($class, '\\', '/').'.php';
+        if (file_exists($path) && is_readable($path)) {
+            require_once $path;
+
+            return true;
+        }
+    } else if (0 === strpos($class, 'Doctrine\Common\\')) {
+        $path = __DIR__.'/../../../lib/'.($class = strtr($class, '\\', '/')).'.php';
+        if (file_exists($path) && is_readable($path)) {
+            require_once $path;
+
+            return true;
+        }
+    }
+});

vendor/doctrine-common/tests/NativePhpunitTask.php

@@ -0,0 +1,246 @@
+<?php
+/**
+ * Native PHPUnit Task
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to kontakt@beberlei.de so I can send you a copy immediately.
+ */
+
+require_once 'PHPUnit/Autoload.php';
+
+/**
+ * A more flexible and powerful PHPUnit Task than the native Phing one.
+ *
+ * Plus forward compability for PHPUnit 3.5 and later is ensured by using the PHPUnit Test Runner instead of implementing one.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class NativePhpunitTask extends Task
+{
+    private $test;
+    private $testfile;
+    private $testdirectory;
+    private $configuration = null;
+    private $coverageClover = null;
+    private $junitlogfile = null;
+    private $haltonfailure = true;
+    private $haltonerror = true;
+
+    public function setTestdirectory($directory) {
+        $this->testdirectory = $directory;
+    }
+
+    public function setTest($test) {
+        $this->test = $test;
+    }
+
+    public function setTestfile($testfile) {
+        $this->testfile = $testfile;
+    }
+
+    public function setJunitlogfile($junitlogfile) {
+        if (strlen($junitlogfile) == 0) {
+            $junitlogfile = NULL;
+        }
+
+        $this->junitlogfile = $junitlogfile;
+    }
+
+    public function setConfiguration($configuration) {
+        if (strlen($configuration) == 0) {
+            $configuration = NULL;
+        }
+
+        $this->configuration = $configuration;
+    }
+
+    public function setCoverageClover($coverageClover) {
+        if (strlen($coverageClover) == 0) {
+            $coverageClover = NULL;
+        }
+
+        $this->coverageClover = $coverageClover;
+    }
+
+    public function setHaltonfailure($haltonfailures) {
+        $this->haltonfailure = $haltonfailures;
+    }
+
+    public function setHaltonerror($haltonerrors) {
+        $this->haltonerror = $haltonerrors;
+    }
+
+    public function init()
+    {
+        require_once "PHPUnit/Runner/Version.php";
+        $version = PHPUnit_Runner_Version::id();
+
+        if (version_compare($version, '3.4.0') < 0) {
+            throw new BuildException("NativePHPUnitTask requires PHPUnit version >= 3.2.0", $this->getLocation());
+        }
+
+        require_once 'PHPUnit/Util/Filter.php';
+
+        // point PHPUnit_MAIN_METHOD define to non-existing method
+        if (!defined('PHPUnit_MAIN_METHOD')) {
+            define('PHPUnit_MAIN_METHOD', 'PHPUnitTask::undefined');
+        }
+    }
+
+    public function main()
+    {
+        if (!is_dir(realpath($this->testdirectory))) {
+            throw new BuildException("NativePHPUnitTask requires a Test Directory path given, '".$this->testdirectory."' given.");
+        }
+        set_include_path(realpath($this->testdirectory) . PATH_SEPARATOR . get_include_path());
+
+        $printer = new NativePhpunitPrinter();
+
+        $arguments = array(
+            'configuration' => $this->configuration,
+            'coverageClover' => $this->coverageClover,
+            'junitLogfile' => $this->junitlogfile,
+            'printer' => $printer,
+        );
+
+        $runner = new PHPUnit_TextUI_TestRunner();
+        $suite = $runner->getTest($this->test, $this->testfile, true);
+
+        try {
+            $result = $runner->doRun($suite, $arguments);
+            /* @var $result PHPUnit_Framework_TestResult */
+
+            if ( ($this->haltonfailure && $result->failureCount() > 0) || ($this->haltonerror && $result->errorCount() > 0) ) {
+                throw new BuildException("PHPUnit: ".$result->failureCount()." Failures and ".$result->errorCount()." Errors, ".
+                    "last failure message: ".$printer->getMessages());
+            }
+
+            $this->log("PHPUnit Success: ".count($result->passed())." tests passed, no ".
+                "failures (".$result->skippedCount()." skipped, ".$result->notImplementedCount()." not implemented)");
+
+            // Hudson for example doesn't like the backslash in class names
+            if (file_exists($this->coverageClover)) {
+                $this->log("Generated Clover Coverage XML to: ".$this->coverageClover);
+                $content = file_get_contents($this->coverageClover);
+                $content = str_replace("\\", ".", $content);
+                file_put_contents($this->coverageClover, $content);
+                unset($content);
+            }
+
+        } catch(\Exception $e) {
+            throw new BuildException("NativePhpunitTask failed: ".$e->getMessage());
+        }
+    }
+}
+
+class NativePhpunitPrinter extends PHPUnit_Util_Printer implements PHPUnit_Framework_TestListener
+{
+    private $_messages = array();
+
+    public function write($buffer)
+    {
+        // do nothing
+    }
+
+    public function getMessages()
+    {
+        return $this->_messages;
+    }
+
+    /**
+     * An error occurred.
+     *
+     * @param  PHPUnit_Framework_Test $test
+     * @param  Exception              $e
+     * @param  float                  $time
+     */
+    public function addError(PHPUnit_Framework_Test $test, Exception $e, $time)
+    {
+        $this->_messages[] = "Test ERROR: ".$test->getName().": ".$e->getMessage();
+    }
+
+    /**
+     * A failure occurred.
+     *
+     * @param  PHPUnit_Framework_Test                 $test
+     * @param  PHPUnit_Framework_AssertionFailedError $e
+     * @param  float                                  $time
+     */
+    public function addFailure(PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
+    {
+        $this->_messages[] = "Test FAILED: ".$test->getName().": ".$e->getMessage();
+    }
+
+    /**
+     * Incomplete test.
+     *
+     * @param  PHPUnit_Framework_Test $test
+     * @param  Exception              $e
+     * @param  float                  $time
+     */
+    public function addIncompleteTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+    {
+
+    }
+
+    /**
+     * Skipped test.
+     *
+     * @param  PHPUnit_Framework_Test $test
+     * @param  Exception              $e
+     * @param  float                  $time
+     * @since  Method available since Release 3.0.0
+     */
+    public function addSkippedTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+    {
+
+    }
+
+    /**
+     * A test suite started.
+     *
+     * @param  PHPUnit_Framework_TestSuite $suite
+     * @since  Method available since Release 2.2.0
+     */
+    public function startTestSuite(PHPUnit_Framework_TestSuite $suite)
+    {
+
+    }
+
+    /**
+     * A test suite ended.
+     *
+     * @param  PHPUnit_Framework_TestSuite $suite
+     * @since  Method available since Release 2.2.0
+     */
+    public function endTestSuite(PHPUnit_Framework_TestSuite $suite)
+    {
+
+    }
+
+    /**
+     * A test started.
+     *
+     * @param  PHPUnit_Framework_Test $test
+     */
+    public function startTest(PHPUnit_Framework_Test $test)
+    {
+
+    }
+
+    /**
+     * A test ended.
+     *
+     * @param  PHPUnit_Framework_Test $test
+     * @param  float                  $time
+     */
+    public function endTest(PHPUnit_Framework_Test $test, $time)
+    {
+        
+    }
+}

vendor/doctrine-common/tests/README.markdown

@@ -0,0 +1,27 @@
+# Running the Doctrine 2 Testsuite
+
+## Running tests
+
+Execute PHPUnit in the root folder of your doctrine-common clone.
+
+    phpunit
+
+## Testing Lock-Support
+
+The Lock support in Doctrine 2 is tested using Gearman, which allows to run concurrent tasks in parallel.
+Install Gearman with PHP as follows:
+
+1. Go to http://www.gearman.org and download the latest Gearman Server
+2. Compile it and then call ldconfig
+3. Start it up "gearmand -vvvv"
+4. Install pecl/gearman by calling "gearman-beta"
+
+You can then go into tests/ and start up two workers:
+
+    php Doctrine/Tests/ORM/Functional/Locking/LockAgentWorker.php
+
+Then run the locking test-suite:
+
+    phpunit --configuration <myconfig.xml> Doctrine/Tests/ORM/Functional/Locking/GearmanLockTest.php
+
+This can run considerable time, because it is using sleep() to test for the timing ranges of locks.

vendor/doctrine-dbal/.gitignore

@@ -0,0 +1,7 @@
+build.properties
+build/
+logs/
+reports/
+dist/
+download/
+lib/Doctrine/Common/

vendor/doctrine-dbal/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "lib/vendor/doctrine-common"]
+	path = lib/vendor/doctrine-common
+	url = git://github.com/doctrine/common.git
+[submodule "lib/vendor/Symfony/Component/Console"]
+	path = lib/vendor/Symfony/Component/Console
+	url = git://github.com/symfony/Console.git

vendor/doctrine-dbal/bin/doctrine-dbal

@@ -0,0 +1,4 @@
+#!/usr/bin/env php
+<?php
+
+include('doctrine-dbal.php');

vendor/doctrine-dbal/bin/doctrine-dbal.php

@@ -0,0 +1,43 @@
+<?php
+
+require_once 'Doctrine/Common/ClassLoader.php';
+
+$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
+$classLoader->register();
+
+$classLoader = new \Doctrine\Common\ClassLoader('Symfony', 'Doctrine');
+$classLoader->register();
+
+$configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
+
+$helperSet = null;
+if (file_exists($configFile)) {
+    if ( ! is_readable($configFile)) {
+        trigger_error(
+            'Configuration file [' . $configFile . '] does not have read permission.', E_ERROR
+        );
+    }
+
+    require $configFile;
+    
+    foreach ($GLOBALS as $helperSetCandidate) {
+        if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
+            $helperSet = $helperSetCandidate;
+            break;
+        }
+    }
+}
+
+$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();
+
+$cli = new \Symfony\Component\Console\Application('Doctrine Command Line Interface', Doctrine\DBAL\Version::VERSION);
+$cli->setCatchExceptions(true);
+$cli->setHelperSet($helperSet);
+$cli->addCommands(array(
+    // DBAL Commands
+    new \Doctrine\DBAL\Tools\Console\Command\RunSqlCommand(),
+    new \Doctrine\DBAL\Tools\Console\Command\ImportCommand(),
+    new \Doctrine\DBAL\Tools\Console\Command\ReservedWordsCommand(),
+
+));
+$cli->run();

vendor/doctrine-dbal/bin/doctrine.php

@@ -0,0 +1,42 @@
+<?php
+
+require_once 'Doctrine/Common/ClassLoader.php';
+
+$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
+$classLoader->register();
+
+$classLoader = new \Doctrine\Common\ClassLoader('Symfony', 'Doctrine');
+$classLoader->register();
+
+$configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
+
+$helperSet = null;
+if (file_exists($configFile)) {
+    if ( ! is_readable($configFile)) {
+        trigger_error(
+            'Configuration file [' . $configFile . '] does not have read permission.', E_ERROR
+        );
+    }
+
+    require $configFile;
+    
+    foreach ($GLOBALS as $helperSetCandidate) {
+        if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
+            $helperSet = $helperSetCandidate;
+            break;
+        }
+    }
+}
+
+$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();
+
+$cli = new \Symfony\Component\Console\Application('Doctrine Command Line Interface', Doctrine\DBAL\Version::VERSION);
+$cli->setCatchExceptions(true);
+$cli->setHelperSet($helperSet);
+$cli->addCommands(array(
+    // DBAL Commands
+    new \Doctrine\DBAL\Tools\Console\Command\RunSqlCommand(),
+    new \Doctrine\DBAL\Tools\Console\Command\ImportCommand(),
+
+));
+$cli->run();

vendor/doctrine-dbal/build.properties.dev

@@ -0,0 +1,16 @@
+version_name=2.0.2
+stability=stable
+build.dir=build
+dist.dir=dist
+report.dir=reports
+project.pirum_dir=
+project.download_dir=
+log.archive.dir=logs
+svn.path=/usr/bin/svn
+test.phpunit_configuration_file=
+test.phpunit_generate_coverage=0
+test.pmd_reports=0
+test.pdepend_exec=
+test.phpmd_exec=
+dependencies.common=2.0.1
+dependencies.sfconsole=2.0.0

vendor/doctrine-dbal/build.xml

@@ -0,0 +1,203 @@
+<?xml version="1.0"?>
+
+<!--
+    Doctrine 2 build file.
+-->
+
+<project name="Doctrine DBAL" default="build" basedir=".">
+    <taskdef classname="phing.tasks.ext.d51PearPkg2Task" name="d51pearpkg2" />
+
+    <property file="build.properties" />
+
+    <!--
+        Fileset for artifacts shared across all distributed packages.
+    -->
+    <fileset id="shared-artifacts" dir=".">
+        <include name="LICENSE"/>
+    </fileset>
+
+    <!--
+        Fileset for command line scripts
+    -->
+    <fileset id="bin-scripts" dir="./bin">
+        <include name="doctrine-dbal"/>
+        <include name="doctrine-dbal.php"/>
+    </fileset>
+
+    <!--
+        Fileset for the sources of the Doctrine Common dependency.
+    -->
+    <fileset id="common-sources" dir="./lib/vendor/doctrine-common/lib">
+        <include name="Doctrine/Common/**"/>
+    </fileset>
+
+    <!--
+        Fileset for the sources of the Doctrine DBAL package.
+    -->
+    <fileset id="dbal-sources" dir="./lib">
+        <include name="Doctrine/DBAL/**"/>
+    </fileset>
+
+    <!--
+      Fileset for source of the Symfony YAML and Console components.
+    -->
+    <fileset id="symfony-sources" dir="./lib/vendor">
+        <include name="Symfony/Component**"/>
+    </fileset>
+
+    <!--
+        Clean the directory for the next build.
+    -->
+    <target name="clean">
+        <available file="./build.properties" property="build_properties_exist" value="true"/>
+        <fail unless="build_properties_exist" message="The build.properties file is missing." />
+
+        <delete dir="${build.dir}" includeemptydirs="true" />
+        <delete dir="${dist.dir}" includeemptydirs="true" />
+        <delete dir="${report.dir}" includeemptydirs="true" />
+    </target>
+
+    <!--
+        Prepare the new build directories after cleaning
+    -->
+    <target name="prepare" depends="clean">
+        <echo msg="Creating build directory: ${build.dir}" />
+        <mkdir dir="${build.dir}" />
+        <echo msg="Creating distribution directory: ${dist.dir}" />
+        <mkdir dir="${dist.dir}" />
+        <echo msg="Creating report directory: ${report.dir}" />
+        <mkdir dir="${report.dir}" />
+        <mkdir dir="${build.dir}/logs"/>
+        <mkdir dir="${report.dir}/tests"/>
+    </target>
+
+    <!--
+        Builds DBAL package, preparing it for distribution.
+    -->
+    <target name="build-dbal" depends="prepare">
+        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
+        <copy todir="${build.dir}/doctrine-dbal">
+            <fileset refid="shared-artifacts"/>
+        </copy>
+        <copy todir="${build.dir}/doctrine-dbal">
+            <fileset refid="common-sources"/>
+            <fileset refid="dbal-sources"/>
+        </copy>
+        <copy todir="${build.dir}/doctrine-dbal/Doctrine">
+            <fileset refid="symfony-sources"/>
+        </copy>
+        <copy todir="${build.dir}/doctrine-dbal/bin">
+            <fileset refid="bin-scripts"/>
+        </copy>
+        <exec command="sed 's/${version}-DEV/${version}/' ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version.php > ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version2.php" passthru="true" />
+        <exec command="mv ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version2.php ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version.php" passthru="true" />
+    </target>
+
+    <target name="build" depends="test,build-dbal"/>
+
+    <!--
+        Runs the full test suite.
+    -->
+    <target name="test" depends="prepare">
+        <if><equals arg1="${test.phpunit_generate_coverage}" arg2="1" />
+            <then>
+                <property name="test.phpunit_coverage_option" value="--coverage-clover ${build.dir}/logs/clover.xml" />
+            </then>
+            <else>
+                <property name="test.phpunit_coverage_option" value="" />
+            </else>
+        </if>
+
+        <if><equals arg1="${test.phpunit_configuration_file}" arg2="" />
+            <then>
+                <property name="test.phpunit_configuration_option" value="" />
+            </then>
+            <else>
+                <property name="test.phpunit_configuration_option" value="--configuration ${test.phpunit_configuration_file}" />
+            </else>
+        </if>
+
+        <exec command="phpunit ${test.phpunit_configuration_option} ${test.phpunit_coverage_option} --log-junit ../${build.dir}/logs/testsuites.xml Doctrine/Tests/AllTests.php" dir="./tests" />
+        <phpunitreport infile="${build.dir}/logs/testsuites.xml" format="frames" todir="${report.dir}/tests" />
+
+        <tstamp/>
+        <copy file="${build.dir}/logs/testsuites.xml" tofile="${log.archive.dir}/latest/log.xml" overwrite="true"/>
+
+        <if><equals arg1="${test.pmd_reports}" arg2="1" />
+            <then>
+                <exec command="${test.pdepend_exec} --jdepend-xml=${build.dir}/logs/jdepend.xml ./lib/Doctrine" />
+                <exec command="${test.phpmd_exec} ./lib/Doctrine xml codesize --reportfile ${build.dir}/logs/phpmd.xml" />
+
+                <copy file="${build.dir}/logs/jdepend.xml" tofile="${log.archive.dir}/latest/jdepend.xml" overwrite="true"/>
+                <copy file="${build.dir}/logs/phpmd.xml" tofile="${log.archive.dir}/latest/phpmd.xml" overwrite="true"/>
+            </then>
+        </if>
+    </target>
+
+    <!--
+        Builds distributable PEAR packages.
+    -->
+    <target name="build-packages" depends="build-dbal">
+        <d51pearpkg2 baseinstalldir="/" dir="${build.dir}/doctrine-dbal">
+           <name>DoctrineDBAL</name>
+           <summary>Doctrine Database Abstraction Layer</summary>
+           <channel>pear.doctrine-project.org</channel>
+           <description>The Doctrine DBAL package is the database abstraction layer used to power the ORM package.</description>
+           <lead user="jwage" name="Jonathan H. Wage" email="jonwage@gmail.com" />
+           <lead user="guilhermeblanco" name="Guilherme Blanco" email="guilhermeblanco@gmail.com" />
+           <lead user="romanb" name="Roman Borschel" email="roman@code-factory.org" />
+           <lead user="beberlei" name="Benjamin Eberlei" email="kontakt@beberlei.de" />
+           <license>LGPL</license>
+           <version release="${version}" api="${version}" />
+           <stability release="${stability}" api="${stability}" />
+           <notes>-</notes>
+           <dependencies>
+               <php minimum_version="5.3.2" />
+               <pear minimum_version="1.6.0" recommended_version="1.6.1" />
+               <package name="DoctrineCommon" channel="pear.doctrine-project.org" minimum_version="${dependencies.common}" />
+               <!-- Doctrine Symfony Console PEAR package is generated in ORM build.xml process -->
+               <package name="DoctrineSymfonyConsole" channel="pear.doctrine-project.org" minimum_version="${dependencies.sfconsole}" />
+           </dependencies>
+           <dirroles key="bin">script</dirroles>
+           <ignore>Doctrine/Common/</ignore>
+           <ignore>Doctrine/Symfony/</ignore>
+           <release>
+                <install as="doctrine-dbal" name="bin/doctrine-dbal" />
+                <install as="doctrine-dbal.php" name="bin/doctrine-dbal.php" />
+           </release>
+        </d51pearpkg2>
+        <exec command="pear package" dir="${build.dir}/doctrine-dbal" passthru="true" />
+        <exec command="mv DoctrineDBAL-${version}.tgz ../../dist" dir="${build.dir}/doctrine-dbal" passthru="true" />
+        <tar destfile="dist/DoctrineDBAL-${version}-full.tar.gz" compression="gzip" basedir="${build.dir}">
+            <fileset dir="${build.dir}">
+                <include name="**/**" />
+                <exclude name="logs/" />
+            </fileset>
+        </tar>
+    </target>
+
+    <target name="git-tag">
+        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
+        <exec command="git tag -a ${version}" passthru="true" />
+    </target>
+
+    <target name="pirum-release">
+        <exec command="sudo pirum add ${project.pirum_dir} ${project.basedir}/dist/DoctrineDBAL-${version}.tgz" dir="."  passthru="true" />
+        <exec command="sudo pirum build ${project.pirum_dir}" passthru="true" />
+    </target>
+
+    <target name="distribute-download">
+        <copy file="dist/DoctrineDBAL-${version}-full.tar.gz" todir="${project.download_dir}" />
+    </target>
+
+    <target name="update-dev-version">
+        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
+        <propertyprompt propertyName="next_version" defaultValue="${version}" promptText="Enter next version string (without -DEV)" />
+        <exec command="sed 's/${version}-DEV/${next_version}-DEV/' ${project.basedir}/lib/Doctrine/DBAL/Version.php > ${project.basedir}/lib/Doctrine/DBAL/Version2.php" passthru="true" />
+        <exec command="mv ${project.basedir}/lib/Doctrine/DBAL/Version2.php ${project.basedir}/lib/Doctrine/DBAL/Version.php" passthru="true" />
+        <exec command="git add ${project.basedir}/lib/Doctrine/DBAL/Version.php" passthru="true" />
+        <exec command="git commit -m 'Bump Dev Version to ${next_version}'" passthru="true" />
+    </target>
+
+    <target name="release" depends="git-tag,build-packages,distribute-download,pirum-release,update-dev-version" />
+</project>

vendor/doctrine-dbal/tests/.gitignore

@@ -0,0 +1,3 @@
+Doctrine/Tests/Proxies/
+Doctrine/Tests/ORM/Proxy/generated/
+Doctrine/Tests/ORM/Tools/Export/export

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/ConnectionTest.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace Doctrine\Tests\DBAL;
+
+require_once __DIR__ . '/../TestInit.php';
+
+use Doctrine\DBAL\Connection;
+use Doctrine\Common\EventManager;
+use Doctrine\DBAL\Configuration;
+use Doctrine\DBAL\Events;
+ 
+class ConnectionTest extends \Doctrine\Tests\DbalTestCase
+{
+    /**
+     * @var Doctrine\DBAL\Connection
+     */
+    protected $_conn = null;
+
+    public function setUp()
+    {
+        $params = array(
+            'driver' => 'pdo_mysql',
+            'host' => 'localhost',
+            'user' => 'root',
+            'password' => 'password',
+            'port' => '1234'
+        );
+        $this->_conn = \Doctrine\DBAL\DriverManager::getConnection($params);
+    }
+
+    public function testIsConnected()
+    {
+        $this->assertFalse($this->_conn->isConnected());
+    }
+
+    public function testNoTransactionActiveByDefault()
+    {
+        $this->assertFalse($this->_conn->isTransactionActive());
+    }
+
+    public function testCommitWithNoActiveTransaction_ThrowsException()
+    {
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException');
+        $this->_conn->commit();
+    }
+
+    public function testRollbackWithNoActiveTransaction_ThrowsException()
+    {
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException');
+        $this->_conn->rollback();
+    }
+
+    public function testSetRollbackOnlyNoActiveTransaction_ThrowsException()
+    {
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException');
+        $this->_conn->setRollbackOnly();
+    }
+
+    public function testIsRollbackOnlyNoActiveTransaction_ThrowsException()
+    {
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException');
+        $this->_conn->isRollbackOnly();
+    }
+
+    public function testGetConfiguration()
+    {
+        $config = $this->_conn->getConfiguration();
+
+        $this->assertInstanceOf('Doctrine\DBAL\Configuration', $config);
+    }
+
+    public function testGetHost()
+    {
+        $this->assertEquals('localhost', $this->_conn->getHost());
+    }
+
+    public function testGetPort()
+    {
+        $this->assertEquals('1234', $this->_conn->getPort());
+    }
+
+    public function testGetUsername()
+    {
+        $this->assertEquals('root', $this->_conn->getUsername());
+    }
+
+    public function testGetPassword()
+    {
+        $this->assertEquals('password', $this->_conn->getPassword());
+    }
+
+    public function testGetDriver()
+    {
+        $this->assertInstanceOf('Doctrine\DBAL\Driver\PDOMySql\Driver', $this->_conn->getDriver());
+    }
+
+    public function testGetEventManager()
+    {
+        $this->assertInstanceOf('Doctrine\Common\EventManager', $this->_conn->getEventManager());
+    }
+
+    public function testConnectDispatchEvent()
+    {
+        $listenerMock = $this->getMock('ConnectDispatchEventListener', array('postConnect'));
+        $listenerMock->expects($this->once())->method('postConnect');
+
+        $eventManager = new EventManager();
+        $eventManager->addEventListener(array(Events::postConnect), $listenerMock);
+
+        $driverMock = $this->getMock('Doctrine\DBAL\Driver');
+        $driverMock->expects(($this->at(0)))
+                   ->method('connect');
+        $platform = new Mocks\MockPlatform();
+
+        $conn = new Connection(array('platform' => $platform), $driverMock, new Configuration(), $eventManager);
+        $conn->connect();
+    }
+
+    /**
+     * Pretty dumb test, however we want to check that the EchoSQLLogger correctly implements the interface.
+     *
+     * @group DBAL-11
+     */
+    public function testEchoSQLLogger()
+    {
+        $logger = new \Doctrine\DBAL\Logging\EchoSQLLogger();
+        $this->_conn->getConfiguration()->setSQLLogger($logger);
+        $this->assertSame($logger, $this->_conn->getConfiguration()->getSQLLogger());
+    }
+
+    /**
+     * Pretty dumb test, however we want to check that the DebugStack correctly implements the interface.
+     *
+     * @group DBAL-11
+     */
+    public function testDebugSQLStack()
+    {
+        $logger = new \Doctrine\DBAL\Logging\DebugStack();
+        $this->_conn->getConfiguration()->setSQLLogger($logger);
+        $this->assertSame($logger, $this->_conn->getConfiguration()->getSQLLogger());
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/DriverManagerTest.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace Doctrine\Tests\DBAL;
+
+require_once __DIR__ . '/../TestInit.php';
+ 
+class DriverManagerTest extends \Doctrine\Tests\DbalTestCase
+{
+    /**
+     * @expectedException \Doctrine\DBAL\DBALException
+     */
+    public function testInvalidPdoInstance()
+    {
+        $options = array(
+            'pdo' => 'test'
+        );
+        $test = \Doctrine\DBAL\DriverManager::getConnection($options);
+    }
+
+    public function testValidPdoInstance()
+    {
+        $options = array(
+            'pdo' => new \PDO('sqlite::memory:')
+        );
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+        $this->assertEquals('sqlite', $conn->getDatabasePlatform()->getName());
+    }
+
+    /**
+     * @group DBAL-32
+     */
+    public function testPdoInstanceSetErrorMode()
+    {
+        $pdo = new \PDO('sqlite::memory:');
+        $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_SILENT);
+        $options = array(
+            'pdo' => $pdo
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+        $this->assertEquals(\PDO::ERRMODE_EXCEPTION, $pdo->getAttribute(\PDO::ATTR_ERRMODE));
+    }
+
+    /**
+     * @expectedException \Doctrine\DBAL\DBALException
+     */
+    public function testCheckParams()
+    {
+        $conn = \Doctrine\DBAL\DriverManager::getConnection(array());
+    }
+
+    /**
+     * @expectedException \Doctrine\DBAL\DBALException
+     */
+    public function testInvalidDriver()
+    {
+        $conn = \Doctrine\DBAL\DriverManager::getConnection(array('driver' => 'invalid_driver'));
+    }
+
+    public function testCustomPlatform()
+    {
+        $mockPlatform = new \Doctrine\Tests\DBAL\Mocks\MockPlatform();
+        $options = array(
+            'pdo' => new \PDO('sqlite::memory:'),
+            'platform' => $mockPlatform
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+        $this->assertSame($mockPlatform, $conn->getDatabasePlatform());
+    }
+
+    public function testCustomWrapper()
+    {
+        $wrapperClass = 'Doctrine\Tests\Mocks\ConnectionMock';
+
+        $options = array(
+            'pdo' => new \PDO('sqlite::memory:'),
+            'wrapperClass' => $wrapperClass,
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+        $this->assertInstanceOf($wrapperClass, $conn);
+    }
+
+    public function testInvalidWrapperClass()
+    {
+        $this->setExpectedException('\Doctrine\DBAL\DBALException');
+
+        $options = array(
+            'pdo' => new \PDO('sqlite::memory:'),
+            'wrapperClass' => 'stdClass',
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+    }
+
+    public function testInvalidDriverClass()
+    {
+        $this->setExpectedException('\Doctrine\DBAL\DBALException');
+
+        $options = array(
+            'driverClass' => 'stdClass'
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+    }
+
+    public function testValidDriverClass()
+    {
+        $options = array(
+            'driverClass' => 'Doctrine\DBAL\Driver\PDOMySql\Driver',
+        );
+
+        $conn = \Doctrine\DBAL\DriverManager::getConnection($options);
+        $this->assertInstanceOf('Doctrine\DBAL\Driver\PDOMySql\Driver', $conn->getDriver());
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Events/MysqlSessionInitTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Events;
+
+use Doctrine\Tests\DbalTestCase;
+use Doctrine\DBAL\Event\Listeners\MysqlSessionInit;
+use Doctrine\DBAL\Event\ConnectionEventArgs;
+use Doctrine\DBAL\Events;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class MysqlSessionInitTest extends DbalTestCase
+{
+    public function testPostConnect()
+    {
+        $connectionMock = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
+        $connectionMock->expects($this->once())
+                       ->method('executeUpdate')
+                       ->with($this->equalTo("SET NAMES foo COLLATE bar"));
+
+        $eventArgs = new ConnectionEventArgs($connectionMock);
+
+
+        $listener = new MysqlSessionInit('foo', 'bar');
+        $listener->postConnect($eventArgs);
+    }
+
+    public function testGetSubscribedEvents()
+    {
+        $listener = new MysqlSessionInit();
+        $this->assertEquals(array(Events::postConnect), $listener->getSubscribedEvents());
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Events/OracleSessionInitTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Events;
+
+use Doctrine\Tests\DbalTestCase;
+use Doctrine\DBAL\Event\Listeners\OracleSessionInit;
+use Doctrine\DBAL\Event\ConnectionEventArgs;
+use Doctrine\DBAL\Events;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class OracleSessionInitTest extends DbalTestCase
+{
+    public function testPostConnect()
+    {
+        $connectionMock = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
+        $connectionMock->expects($this->once())
+                       ->method('executeUpdate')
+                       ->with($this->isType('string'));
+
+        $eventArgs = new ConnectionEventArgs($connectionMock);
+
+
+        $listener = new OracleSessionInit();
+        $listener->postConnect($eventArgs);
+    }
+
+    public function testGetSubscribedEvents()
+    {
+        $listener = new OracleSessionInit();
+        $this->assertEquals(array(Events::postConnect), $listener->getSubscribedEvents());
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/ConnectionTest.php

@@ -0,0 +1,210 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\ConnectionException;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class ConnectionTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    public function setUp()
+    {
+        $this->resetSharedConn();
+        parent::setUp();
+    }
+
+    public function tearDown()
+    {
+        parent::tearDown();
+        $this->resetSharedConn();
+    }
+
+    public function testGetWrappedConnection()
+    {
+        $this->assertInstanceOf('Doctrine\DBAL\Driver\Connection', $this->_conn->getWrappedConnection());
+    }
+
+    public function testCommitWithRollbackOnlyThrowsException()
+    {
+        $this->_conn->beginTransaction();
+        $this->_conn->setRollbackOnly();
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException');
+        $this->_conn->commit();
+    }
+
+    public function testTransactionNestingBehavior()
+    {
+        try {
+            $this->_conn->beginTransaction();
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+            
+            try {
+                $this->_conn->beginTransaction();
+                $this->assertEquals(2, $this->_conn->getTransactionNestingLevel());
+                throw new \Exception;
+                $this->_conn->commit(); // never reached
+            } catch (\Exception $e) {
+                $this->_conn->rollback();
+                $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+                //no rethrow                
+            }
+            $this->assertTrue($this->_conn->isRollbackOnly());
+
+            $this->_conn->commit(); // should throw exception
+            $this->fail('Transaction commit after failed nested transaction should fail.');
+        } catch (ConnectionException $e) {
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+            $this->_conn->rollback();
+            $this->assertEquals(0, $this->_conn->getTransactionNestingLevel());
+        }
+    }
+
+    public function testTransactionNestingBehaviorWithSavepoints()
+    {
+        if (!$this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform to support savepoints.');
+        }
+
+        $this->_conn->setNestTransactionsWithSavepoints(true);
+        try {
+            $this->_conn->beginTransaction();
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+
+            try {
+                $this->_conn->beginTransaction();
+                $this->assertEquals(2, $this->_conn->getTransactionNestingLevel());
+                $this->_conn->beginTransaction();
+                $this->assertEquals(3, $this->_conn->getTransactionNestingLevel());
+                $this->_conn->commit();
+                $this->assertEquals(2, $this->_conn->getTransactionNestingLevel());
+                throw new \Exception;
+                $this->_conn->commit(); // never reached
+            } catch (\Exception $e) {
+                $this->_conn->rollback();
+                $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+                //no rethrow
+            }
+            $this->assertFalse($this->_conn->isRollbackOnly());
+            try {
+                $this->_conn->setNestTransactionsWithSavepoints(false);
+                $this->fail('Should not be able to disable savepoints in usage for nested transactions inside an open transaction.');
+            } catch (ConnectionException $e) {
+                $this->assertTrue($this->_conn->getNestTransactionsWithSavepoints());
+            }
+            $this->_conn->commit(); // should not throw exception
+        } catch (ConnectionException $e) {
+            $this->fail('Transaction commit after failed nested transaction should not fail when using savepoints.');
+            $this->_conn->rollback();
+        }
+    }
+
+    public function testTransactionNestingBehaviorCantBeChangedInActiveTransaction()
+    {
+        if (!$this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform to support savepoints.');
+        }
+
+        $this->_conn->beginTransaction();
+        try {
+            $this->_conn->setNestTransactionsWithSavepoints(true);
+            $this->fail('An exception should have been thrown by chaning the nesting transaction behavior within an transaction.');
+        } catch(ConnectionException $e) {
+            $this->_conn->rollBack();
+        }
+    }
+
+    public function testSetNestedTransactionsThroughSavepointsNotSupportedThrowsException()
+    {
+        if ($this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform not to support savepoints.');
+        }
+
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException', "Savepoints are not supported by this driver.");
+
+        $this->_conn->setNestTransactionsWithSavepoints(true);
+    }
+
+    public function testCreateSavepointsNotSupportedThrowsException()
+    {
+        if ($this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform not to support savepoints.');
+        }
+
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException', "Savepoints are not supported by this driver.");
+
+        $this->_conn->createSavepoint('foo');
+    }
+
+    public function testReleaseSavepointsNotSupportedThrowsException()
+    {
+        if ($this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform not to support savepoints.');
+        }
+
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException', "Savepoints are not supported by this driver.");
+
+        $this->_conn->releaseSavepoint('foo');
+    }
+
+    public function testRollbackSavepointsNotSupportedThrowsException()
+    {
+        if ($this->_conn->getDatabasePlatform()->supportsSavepoints()) {
+            $this->markTestSkipped('This test requires the platform not to support savepoints.');
+        }
+
+        $this->setExpectedException('Doctrine\DBAL\ConnectionException', "Savepoints are not supported by this driver.");
+
+        $this->_conn->rollbackSavepoint('foo');
+    }
+
+    public function testTransactionBehaviorWithRollback()
+    {
+        try {
+            $this->_conn->beginTransaction();
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+            
+            throw new \Exception;
+              
+            $this->_conn->commit(); // never reached
+        } catch (\Exception $e) {
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+            $this->_conn->rollback();
+            $this->assertEquals(0, $this->_conn->getTransactionNestingLevel());
+        }
+    }
+
+    public function testTransactionBehaviour()
+    {
+        try {
+            $this->_conn->beginTransaction();
+            $this->assertEquals(1, $this->_conn->getTransactionNestingLevel());
+            $this->_conn->commit();
+        } catch (\Exception $e) {
+            $this->_conn->rollback();
+            $this->assertEquals(0, $this->_conn->getTransactionNestingLevel());
+        }
+
+        $this->assertEquals(0, $this->_conn->getTransactionNestingLevel());
+    }
+
+    public function testTransactionalWithException()
+    {
+        try {
+            $this->_conn->transactional(function($conn) {
+                $conn->executeQuery($conn->getDatabasePlatform()->getDummySelectSQL());
+                throw new \RuntimeException("Ooops!");
+            });
+        } catch (\RuntimeException $expected) {
+            $this->assertEquals(0, $this->_conn->getTransactionNestingLevel());
+        }
+    }
+
+    public function testTransactional()
+    {
+        $this->_conn->transactional(function($conn) {
+            /* @var $conn Connection */
+            $conn->executeQuery($conn->getDatabasePlatform()->getDummySelectSQL());
+        });
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/DataAccessTest.php

@@ -0,0 +1,272 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Connection;
+use PDO;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class DataAccessTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    public function setUp()
+    {
+        parent::setUp();
+
+        try {
+            /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+            $table = new \Doctrine\DBAL\Schema\Table("fetch_table");
+            $table->addColumn('test_int', 'integer');
+            $table->addColumn('test_string', 'string');
+            $table->addColumn('test_datetime', 'datetime', array('notnull' => false));
+
+            $sm = $this->_conn->getSchemaManager();
+            $sm->createTable($table);
+
+            $this->_conn->insert('fetch_table', array('test_int' => 1, 'test_string' => 'foo', 'test_datetime' => '2010-01-01 10:10:10'));
+        } catch(\Exception $e) {
+            
+        }
+    }
+
+    public function testPrepareWithBindValue()
+    {
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+
+        $stmt->bindValue(1, 1);
+        $stmt->bindValue(2, 'foo');
+        $stmt->execute();
+
+        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
+        $row = array_change_key_case($row, \CASE_LOWER);
+        $this->assertEquals(array('test_int' => 1, 'test_string' => 'foo'), $row);
+    }
+
+    public function testPrepareWithBindParam()
+    {
+        $paramInt = 1;
+        $paramStr = 'foo';
+
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+
+        $stmt->bindParam(1, $paramInt);
+        $stmt->bindParam(2, $paramStr);
+        $stmt->execute();
+
+        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
+        $row = array_change_key_case($row, \CASE_LOWER);
+        $this->assertEquals(array('test_int' => 1, 'test_string' => 'foo'), $row);
+    }
+
+    public function testPrepareWithFetchAll()
+    {
+        $paramInt = 1;
+        $paramStr = 'foo';
+
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+
+        $stmt->bindParam(1, $paramInt);
+        $stmt->bindParam(2, $paramStr);
+        $stmt->execute();
+
+        $rows = $stmt->fetchAll(\PDO::FETCH_ASSOC);
+        $rows[0] = array_change_key_case($rows[0], \CASE_LOWER);
+        $this->assertEquals(array('test_int' => 1, 'test_string' => 'foo'), $rows[0]);
+    }
+
+    public function testPrepareWithFetchColumn()
+    {
+        $paramInt = 1;
+        $paramStr = 'foo';
+
+        $sql = "SELECT test_int FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+
+        $stmt->bindParam(1, $paramInt);
+        $stmt->bindParam(2, $paramStr);
+        $stmt->execute();
+
+        $column = $stmt->fetchColumn();
+        $this->assertEquals(1, $column);
+    }
+
+    public function testPrepareWithQuoted()
+    {
+        $table = 'fetch_table';
+        $paramInt = 1;
+        $paramStr = 'foo';
+
+        $sql = "SELECT test_int, test_string FROM " . $this->_conn->quoteIdentifier($table) . " ".
+               "WHERE test_int = " . $this->_conn->quote($paramInt) . " AND test_string = " . $this->_conn->quote($paramStr);
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+    }
+
+    public function testPrepareWithExecuteParams()
+    {
+        $paramInt = 1;
+        $paramStr = 'foo';
+
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $stmt = $this->_conn->prepare($sql);
+        $this->assertInstanceOf('Doctrine\DBAL\Statement', $stmt);
+        $stmt->execute(array($paramInt, $paramStr));
+
+        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
+        $row = array_change_key_case($row, \CASE_LOWER);
+        $this->assertEquals(array('test_int' => 1, 'test_string' => 'foo'), $row);
+    }
+
+    public function testFetchAll()
+    {
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $data = $this->_conn->fetchAll($sql, array(1, 'foo'));
+
+        $this->assertEquals(1, count($data));
+
+        $row = $data[0];
+        $this->assertEquals(2, count($row));
+
+        $row = array_change_key_case($row, \CASE_LOWER);
+        $this->assertEquals(1, $row['test_int']);
+        $this->assertEquals('foo', $row['test_string']);
+    }
+
+    public function testFetchRow()
+    {
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $row = $this->_conn->fetchAssoc($sql, array(1, 'foo'));
+
+        $row = array_change_key_case($row, \CASE_LOWER);
+        
+        $this->assertEquals(1, $row['test_int']);
+        $this->assertEquals('foo', $row['test_string']);
+    }
+
+    public function testFetchArray()
+    {
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $row = $this->_conn->fetchArray($sql, array(1, 'foo'));
+
+        $this->assertEquals(1, $row[0]);
+        $this->assertEquals('foo', $row[1]);
+    }
+
+    public function testFetchColumn()
+    {
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $testInt = $this->_conn->fetchColumn($sql, array(1, 'foo'), 0);
+
+        $this->assertEquals(1, $testInt);
+
+        $sql = "SELECT test_int, test_string FROM fetch_table WHERE test_int = ? AND test_string = ?";
+        $testString = $this->_conn->fetchColumn($sql, array(1, 'foo'), 1);
+
+        $this->assertEquals('foo', $testString);
+    }
+
+    /**
+     * @group DDC-697
+     */
+    public function testExecuteQueryBindDateTimeType()
+    {
+        $sql = 'SELECT count(*) AS c FROM fetch_table WHERE test_datetime = ?';
+        $stmt = $this->_conn->executeQuery($sql,
+            array(1 => new \DateTime('2010-01-01 10:10:10')),
+            array(1 => Type::DATETIME)
+        );
+
+        $this->assertEquals(1, $stmt->fetchColumn());
+    }
+
+    /**
+     * @group DDC-697
+     */
+    public function testExecuteUpdateBindDateTimeType()
+    {
+        $datetime = new \DateTime('2010-02-02 20:20:20');
+
+        $sql = 'INSERT INTO fetch_table (test_int, test_string, test_datetime) VALUES (?, ?, ?)';
+        $affectedRows = $this->_conn->executeUpdate($sql,
+            array(1 => 1,               2 => 'foo',             3 => $datetime),
+            array(1 => PDO::PARAM_INT,  2 => PDO::PARAM_STR,    3 => Type::DATETIME)
+        );
+
+        $this->assertEquals(1, $affectedRows);
+        $this->assertEquals(1, $this->_conn->executeQuery(
+            'SELECT count(*) AS c FROM fetch_table WHERE test_datetime = ?',
+            array(1 => $datetime),
+            array(1 => Type::DATETIME)
+        )->fetchColumn());
+    }
+
+    /**
+     * @group DDC-697
+     */
+    public function testPrepareQueryBindValueDateTimeType()
+    {
+        $sql = 'SELECT count(*) AS c FROM fetch_table WHERE test_datetime = ?';
+        $stmt = $this->_conn->prepare($sql);
+        $stmt->bindValue(1, new \DateTime('2010-01-01 10:10:10'), Type::DATETIME);
+        $stmt->execute();
+
+        $this->assertEquals(1, $stmt->fetchColumn());
+    }
+    
+    /**
+     * @group DBAL-78
+     */
+    public function testNativeArrayListSupport()
+    {
+        for ($i = 100; $i < 110; $i++) {
+            $this->_conn->insert('fetch_table', array('test_int' => $i, 'test_string' => 'foo' . $i, 'test_datetime' => '2010-01-01 10:10:10'));
+        }
+        
+        $stmt = $this->_conn->executeQuery('SELECT test_int FROM fetch_table WHERE test_int IN (?)',
+            array(array(100, 101, 102, 103, 104)), array(Connection::PARAM_INT_ARRAY));
+        
+        $data = $stmt->fetchAll(PDO::FETCH_NUM);
+        $this->assertEquals(5, count($data));
+        $this->assertEquals(array(array(100), array(101), array(102), array(103), array(104)), $data);
+        
+        $stmt = $this->_conn->executeQuery('SELECT test_int FROM fetch_table WHERE test_string IN (?)',
+            array(array('foo100', 'foo101', 'foo102', 'foo103', 'foo104')), array(Connection::PARAM_STR_ARRAY));
+        
+        $data = $stmt->fetchAll(PDO::FETCH_NUM);
+        $this->assertEquals(5, count($data));
+        $this->assertEquals(array(array(100), array(101), array(102), array(103), array(104)), $data);
+    }
+
+    /**
+     * @group DDC-1014
+     */
+    public function testDateArithmetics()
+    {
+        $p = $this->_conn->getDatabasePlatform();
+        $sql = 'SELECT ';
+        $sql .= $p->getDateDiffExpression('test_datetime', $p->getCurrentTimestampSQL()) .' AS diff, ';
+        $sql .= $p->getDateAddDaysExpression('test_datetime', 10) .' AS add_days, ';
+        $sql .= $p->getDateSubDaysExpression('test_datetime', 10) .' AS sub_days, ';
+        $sql .= $p->getDateAddMonthExpression('test_datetime', 2) .' AS add_month, ';
+        $sql .= $p->getDateSubMonthExpression('test_datetime', 2) .' AS sub_month ';
+        $sql .= 'FROM fetch_table';
+
+        $row = $this->_conn->fetchAssoc($sql);
+        $row = array_change_key_case($row, CASE_LOWER);
+
+        $diff = floor( (strtotime('2010-01-01')-time()) / 3600 / 24);
+        $this->assertEquals($diff, (int)$row['diff'], "Date difference should be approx. ".$diff." days.", 1);
+        $this->assertEquals('2010-01-11', date('Y-m-d', strtotime($row['add_days'])), "Adding date should end up on 2010-01-11");
+        $this->assertEquals('2009-12-22', date('Y-m-d', strtotime($row['sub_days'])), "Subtracting date should end up on 2009-12-22");
+        $this->assertEquals('2010-03-01', date('Y-m-d', strtotime($row['add_month'])), "Adding month should end up on 2010-03-01");
+        $this->assertEquals('2009-11-01', date('Y-m-d', strtotime($row['sub_month'])), "Adding month should end up on 2009-11-01");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/LoggingTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class LoggingTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    public function testLogExecuteQuery()
+    {
+        $sql = $this->_conn->getDatabasePlatform()->getDummySelectSQL();
+
+        $logMock = $this->getMock('Doctrine\DBAL\Logging\SQLLogger');
+        $logMock->expects($this->at(0))
+                ->method('startQuery')
+                ->with($this->equalTo($sql), $this->equalTo(array()), $this->equalTo(array()));
+        $logMock->expects($this->at(1))
+                ->method('stopQuery');
+        $this->_conn->getConfiguration()->setSQLLogger($logMock);
+        $this->_conn->executeQuery($sql, array());
+    }
+
+    public function testLogExecuteUpdate()
+    {
+        $this->markTestSkipped('Test breaks MySQL but works on all other platforms (Unbuffered Queries stuff).');
+
+        $sql = $this->_conn->getDatabasePlatform()->getDummySelectSQL();
+
+        $logMock = $this->getMock('Doctrine\DBAL\Logging\SQLLogger');
+        $logMock->expects($this->at(0))
+                ->method('startQuery')
+                ->with($this->equalTo($sql), $this->equalTo(array()), $this->equalTo(array()));
+        $logMock->expects($this->at(1))
+                ->method('stopQuery');
+        $this->_conn->getConfiguration()->setSQLLogger($logMock);
+        $this->_conn->executeUpdate($sql, array());
+    }
+
+    public function testLogPrepareExecute()
+    {
+        $sql = $this->_conn->getDatabasePlatform()->getDummySelectSQL();
+
+        $logMock = $this->getMock('Doctrine\DBAL\Logging\SQLLogger');
+        $logMock->expects($this->once())
+                ->method('startQuery')
+                ->with($this->equalTo($sql), $this->equalTo(array()));
+        $logMock->expects($this->at(1))
+                ->method('stopQuery');
+        $this->_conn->getConfiguration()->setSQLLogger($logMock);
+
+        $stmt = $this->_conn->prepare($sql);
+        $stmt->execute();
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/ModifyLimitQueryTest.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Connection;
+use PDO;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class ModifyLimitQueryTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    private static $tableCreated = false;
+    
+    public function setUp()
+    {
+        parent::setUp();
+
+        if (!self::$tableCreated) {
+            /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+            $table = new \Doctrine\DBAL\Schema\Table("modify_limit_table");
+            $table->addColumn('test_int', 'integer');
+            
+            $table2 = new \Doctrine\DBAL\Schema\Table("modify_limit_table2");
+            $table2->addColumn('test_int', 'integer');
+
+            $sm = $this->_conn->getSchemaManager();
+            $sm->createTable($table);
+            $sm->createTable($table2);
+            self::$tableCreated = true;
+        }
+        $this->_conn->exec($this->_conn->getDatabasePlatform()->getTruncateTableSQL('modify_limit_table'));
+        $this->_conn->exec($this->_conn->getDatabasePlatform()->getTruncateTableSQL('modify_limit_table2'));
+    }
+    
+    public function testModifyLimitQuerySimpleQuery()
+    {
+        $this->_conn->insert('modify_limit_table', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 2));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 3));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 4));
+        
+        $sql = "SELECT * FROM modify_limit_table";
+        
+        $this->assertLimitResult(array(1, 2, 3, 4), $sql, 10, 0);
+        $this->assertLimitResult(array(1, 2), $sql, 2, 0);
+        $this->assertLimitResult(array(3, 4), $sql, 2, 2);
+    }
+    
+    public function testModifyLimitQueryJoinQuery()
+    {
+        $this->_conn->insert('modify_limit_table', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 2));
+        
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 2));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 2));
+        
+        $sql = "SELECT modify_limit_table.test_int FROM modify_limit_table INNER JOIN modify_limit_table2 ON modify_limit_table.test_int = modify_limit_table2.test_int";
+        
+        $this->assertLimitResult(array(1, 1, 1, 2, 2), $sql, 10, 0);
+        $this->assertLimitResult(array(1, 1, 1), $sql, 3, 0);
+        $this->assertLimitResult(array(2, 2), $sql, 2, 3);
+    }
+    
+    public function testModifyLimitQueryOrderBy()
+    {
+        $this->_conn->insert('modify_limit_table', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 2));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 3));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 4));
+        
+        $sql = "SELECT * FROM modify_limit_table ORDER BY test_int DESC";
+        
+        $this->assertLimitResult(array(4, 3, 2, 1), $sql, 10, 0);
+        $this->assertLimitResult(array(4, 3), $sql, 2, 0);
+        $this->assertLimitResult(array(2, 1), $sql, 2, 2);
+    }
+    
+    public function testModifyLimitQueryGroupBy()
+    {
+        $this->_conn->insert('modify_limit_table', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table', array('test_int' => 2));
+        
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 1));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 2));
+        $this->_conn->insert('modify_limit_table2', array('test_int' => 2));
+        
+        $sql = "SELECT modify_limit_table.test_int FROM modify_limit_table " .
+               "INNER JOIN modify_limit_table2 ON modify_limit_table.test_int = modify_limit_table2.test_int ".
+               "GROUP BY modify_limit_table.test_int";
+        $this->assertLimitResult(array(1, 2), $sql, 10, 0);
+        $this->assertLimitResult(array(1), $sql, 1, 0);
+        $this->assertLimitResult(array(2), $sql, 1, 1);
+    }
+    
+    public function assertLimitResult($expectedResults, $sql, $limit, $offset)
+    {
+        $p = $this->_conn->getDatabasePlatform();
+        $data = array();
+        foreach ($this->_conn->fetchAll($p->modifyLimitQuery($sql, $limit, $offset)) AS $row) {
+            $data[] = current($row);
+        }
+        $this->assertEquals($expectedResults, $data);
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/PortabilityTest.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\DriverManager;
+use PDO;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+/**
+ * @group DBAL-56
+ */
+class PortabilityTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    static private $hasTable = false;
+    
+    private $portableConnection;
+    
+    public function tearDown()
+    {
+        if ($this->portableConnection) {
+            $this->portableConnection->close();
+        }
+    }
+    
+    private function getPortableConnection($portabilityMode = \Doctrine\DBAL\Portability\Connection::PORTABILITY_ALL, $case = \PDO::CASE_LOWER)
+    {
+        if (!$this->portableConnection) {
+            $params = $this->_conn->getParams();
+            $params['wrapperClass'] = 'Doctrine\DBAL\Portability\Connection';
+            $params['portability'] = $portabilityMode;
+            $params['fetch_case'] = $case;
+            $this->portableConnection = DriverManager::getConnection($params, $this->_conn->getConfiguration(), $this->_conn->getEventManager());
+
+            try {
+                /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+                $table = new \Doctrine\DBAL\Schema\Table("portability_table");
+                $table->addColumn('Test_Int', 'integer');
+                $table->addColumn('Test_String', 'string', array('fixed' => true, 'length' => 32));
+                $table->addColumn('Test_Null', 'string', array('notnull' => false));
+
+                $sm = $this->portableConnection->getSchemaManager();
+                $sm->createTable($table);
+
+                $this->portableConnection->insert('portability_table', array('Test_Int' => 1, 'Test_String' => 'foo', 'Test_Null' => ''));
+                $this->portableConnection->insert('portability_table', array('Test_Int' => 1, 'Test_String' => 'foo  ', 'Test_Null' => null));
+            } catch(\Exception $e) {
+                
+            }
+        }
+        
+        return $this->portableConnection;
+    }
+    
+    public function testFullFetchMode()
+    {
+        $rows = $this->getPortableConnection()->fetchAll('SELECT * FROM portability_table');
+        $this->assertFetchResultRows($rows);
+        
+        $stmt = $this->getPortableConnection()->query('SELECT * FROM portability_table');
+        while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
+            $this->assertFetchResultRow($row);
+        }
+        
+        $stmt = $this->getPortableConnection()->prepare('SELECT * FROM portability_table');
+        $stmt->execute();
+        
+        while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
+            $this->assertFetchResultRow($row);
+        }
+    }
+    
+    public function assertFetchResultRows($rows)
+    {
+        $this->assertEquals(2, count($rows));
+        foreach ($rows AS $row) {
+            $this->assertFetchResultRow($row);
+        }
+    }
+    
+    public function assertFetchResultRow($row)
+    {
+        $this->assertEquals(1, $row['test_int']);
+        $this->assertArrayHasKey('test_string', $row, "Case should be lowered.");
+        $this->assertEquals(3, strlen($row['test_string']), "test_string should be rtrimed to length of three for CHAR(32) column.");
+        $this->assertNull($row['test_null']);
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/Db2SchemaManagerTest.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+class Db2SchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/MsSqlSchemaManagerTest.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema;
+
+require_once __DIR__ . '/../../../TestInit.php';
+ 
+class MsSqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+    
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/MySqlSchemaManagerTest.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Schema;
+
+require_once __DIR__ . '/../../../TestInit.php';
+ 
+class MySqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+    public function testSwitchPrimaryKeyColumns()
+    {
+        $tableOld = new Table("switch_primary_key_columns");
+        $tableOld->addColumn('foo_id', 'integer');
+        $tableOld->addColumn('bar_id', 'integer');
+        $tableNew = clone $tableOld;
+
+        $this->_sm->createTable($tableOld);
+        $tableFetched = $this->_sm->listTableDetails("switch_primary_key_columns");
+        $tableNew = clone $tableFetched;
+        $tableNew->setPrimaryKey(array('bar_id', 'foo_id'));
+
+        $comparator = new \Doctrine\DBAL\Schema\Comparator;
+        $this->_sm->alterTable($comparator->diffTable($tableFetched, $tableNew));
+    }
+
+    public function testDiffTableBug()
+    {
+        $schema = new Schema();
+        $table = $schema->createTable('diffbug_routing_translations');
+        $table->addColumn('id', 'integer');
+        $table->addColumn('route', 'string');
+        $table->addColumn('locale', 'string');
+        $table->addColumn('attribute', 'string');
+        $table->addColumn('localized_value', 'string');
+        $table->addColumn('original_value', 'string');
+        $table->setPrimaryKey(array('id'));
+        $table->addUniqueIndex(array('route', 'locale', 'attribute'));
+        $table->addIndex(array('localized_value')); // this is much more selective than the unique index
+
+        $this->_sm->createTable($table);
+        $tableFetched = $this->_sm->listTableDetails("diffbug_routing_translations");
+        
+        $comparator = new \Doctrine\DBAL\Schema\Comparator;
+        $diff = $comparator->diffTable($tableFetched, $table);
+
+        $this->assertFalse($diff, "no changes expected.");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/OracleSchemaManagerTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema;
+
+require_once __DIR__ . '/../../../TestInit.php';
+ 
+class OracleSchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+    public function setUp()
+    {
+        parent::setUp();
+
+        if(!isset($GLOBALS['db_username'])) {
+            $this->markTestSkipped('Foo');
+        }
+
+        $username = $GLOBALS['db_username'];
+
+        $query = "GRANT ALL PRIVILEGES TO ".$username;
+
+        $conn = \Doctrine\Tests\TestUtil::getTempConnection();
+        $conn->executeUpdate($query);
+    }
+
+    public function testRenameTable()
+    {
+        $this->_sm->tryMethod('DropTable', 'list_tables_test');
+        $this->_sm->tryMethod('DropTable', 'list_tables_test_new_name');
+
+        $this->createTestTable('list_tables_test');
+        $this->_sm->renameTable('list_tables_test', 'list_tables_test_new_name');
+
+        $tables = $this->_sm->listTables();
+
+        $this->assertHasTable($tables, 'list_tables_test_new_name');
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/PostgreSqlSchemaManagerTest.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+require_once __DIR__ . '/../../../TestInit.php';
+ 
+class PostgreSqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+    /**
+     * @group DBAL-21
+     */
+    public function testSupportDomainTypeFallback()
+    {
+        $createDomainTypeSQL = "CREATE DOMAIN MyMoney AS DECIMAL(18,2)";
+        $this->_conn->exec($createDomainTypeSQL);
+
+        $createTableSQL = "CREATE TABLE domain_type_test (id INT PRIMARY KEY, value MyMoney)";
+        $this->_conn->exec($createTableSQL);
+
+        $table = $this->_conn->getSchemaManager()->listTableDetails('domain_type_test');
+        $this->assertInstanceOf('Doctrine\DBAL\Types\DecimalType', $table->getColumn('value')->getType());
+
+        Type::addType('MyMoney', 'Doctrine\Tests\DBAL\Functional\Schema\MoneyType');
+        $this->_conn->getDatabasePlatform()->registerDoctrineTypeMapping('MyMoney', 'MyMoney');
+
+        $table = $this->_conn->getSchemaManager()->listTableDetails('domain_type_test');
+        $this->assertInstanceOf('Doctrine\Tests\DBAL\Functional\Schema\MoneyType', $table->getColumn('value')->getType());
+    }
+
+    /**
+     * @group DBAL-37
+     */
+    public function testDetectsAutoIncrement()
+    {
+        $autoincTable = new \Doctrine\DBAL\Schema\Table('autoinc_table');
+        $column = $autoincTable->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+        $this->_sm->createTable($autoincTable);
+        $autoincTable = $this->_sm->listTableDetails('autoinc_table');
+
+        $this->assertTrue($autoincTable->getColumn('id')->getAutoincrement());
+    }
+
+    /**
+     * @group DBAL-37
+     */
+    public function testAlterTableAutoIncrementAdd()
+    {
+        $tableFrom = new \Doctrine\DBAL\Schema\Table('autoinc_table_add');
+        $column = $tableFrom->addColumn('id', 'integer');
+        $this->_sm->createTable($tableFrom);
+        $tableFrom = $this->_sm->listTableDetails('autoinc_table_add');
+        $this->assertFalse($tableFrom->getColumn('id')->getAutoincrement());
+
+        $tableTo = new \Doctrine\DBAL\Schema\Table('autoinc_table_add');
+        $column = $tableTo->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+
+        $c = new \Doctrine\DBAL\Schema\Comparator();
+        $diff = $c->diffTable($tableFrom, $tableTo);
+        $sql = $this->_conn->getDatabasePlatform()->getAlterTableSQL($diff);
+        $this->assertEquals(array(
+            "CREATE SEQUENCE autoinc_table_add_id_seq",
+            "SELECT setval('autoinc_table_add_id_seq', (SELECT MAX(id) FROM autoinc_table_add))",
+            "ALTER TABLE autoinc_table_add ALTER id SET DEFAULT nextval('autoinc_table_add_id_seq')",
+        ), $sql);
+
+        $this->_sm->alterTable($diff);
+        $tableFinal = $this->_sm->listTableDetails('autoinc_table_add');
+        $this->assertTrue($tableFinal->getColumn('id')->getAutoincrement());
+    }
+
+    /**
+     * @group DBAL-37
+     */
+    public function testAlterTableAutoIncrementDrop()
+    {
+        $tableFrom = new \Doctrine\DBAL\Schema\Table('autoinc_table_drop');
+        $column = $tableFrom->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+        $this->_sm->createTable($tableFrom);
+        $tableFrom = $this->_sm->listTableDetails('autoinc_table_drop');
+        $this->assertTrue($tableFrom->getColumn('id')->getAutoincrement());
+
+        $tableTo = new \Doctrine\DBAL\Schema\Table('autoinc_table_drop');
+        $column = $tableTo->addColumn('id', 'integer');
+
+        $c = new \Doctrine\DBAL\Schema\Comparator();
+        $diff = $c->diffTable($tableFrom, $tableTo);
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $diff, "There should be a difference and not false being returned from the table comparison");
+        $this->assertEquals(array("ALTER TABLE autoinc_table_drop ALTER id DROP DEFAULT"), $this->_conn->getDatabasePlatform()->getAlterTableSQL($diff));
+
+        $this->_sm->alterTable($diff);
+        $tableFinal = $this->_sm->listTableDetails('autoinc_table_drop');
+        $this->assertFalse($tableFinal->getColumn('id')->getAutoincrement());
+    }
+
+    /**
+     * @group DBAL-75
+     */
+    public function testTableWithSchema()
+    {
+        $this->_conn->exec('CREATE SCHEMA nested');
+
+        $nestedRelatedTable = new \Doctrine\DBAL\Schema\Table('nested.schemarelated');
+        $column = $nestedRelatedTable->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+        $nestedRelatedTable->setPrimaryKey(array('id'));
+
+        $nestedSchemaTable = new \Doctrine\DBAL\Schema\Table('nested.schematable');
+        $column = $nestedSchemaTable->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+        $nestedSchemaTable->setPrimaryKey(array('id'));
+        $nestedSchemaTable->addUnnamedForeignKeyConstraint($nestedRelatedTable, array('id'), array('id'));
+        
+        $this->_sm->createTable($nestedRelatedTable);
+        $this->_sm->createTable($nestedSchemaTable);
+
+        $tables = $this->_sm->listTableNames();
+        $this->assertContains('nested.schematable', $tables, "The table should be detected with its non-public schema.");
+
+        $nestedSchemaTable = $this->_sm->listTableDetails('nested.schematable');
+        $this->assertTrue($nestedSchemaTable->hasColumn('id'));
+        $this->assertEquals(array('id'), $nestedSchemaTable->getPrimaryKey()->getColumns());
+
+        $relatedFks = $nestedSchemaTable->getForeignKeys();
+        $this->assertEquals(1, count($relatedFks));
+        $relatedFk = array_pop($relatedFks);
+        $this->assertEquals("nested.schemarelated", $relatedFk->getForeignTableName());
+    }
+
+    /**
+     * @group DBAL-91
+     * @group DBAL-88
+     */
+    public function testReturnQuotedAssets()
+    {
+        $sql = 'create table dbal91_something ( id integer  CONSTRAINT id_something PRIMARY KEY NOT NULL  ,"table"   integer );';
+        $this->_conn->exec($sql);
+
+        $sql = 'ALTER TABLE dbal91_something ADD CONSTRAINT something_input FOREIGN KEY( "table" ) REFERENCES dbal91_something ON UPDATE CASCADE;';
+        $this->_conn->exec($sql);
+
+        $table = $this->_sm->listTableDetails('dbal91_something');
+
+        $this->assertEquals(
+            array(
+                "CREATE TABLE dbal91_something (id INT NOT NULL, table INT DEFAULT NULL, PRIMARY KEY(id))",
+                "CREATE INDEX IDX_A9401304ECA7352B ON dbal91_something (\"table\")",
+            ),
+            $this->_conn->getDatabasePlatform()->getCreateTableSQL($table)
+        );
+    }
+}
+
+class MoneyType extends Type
+{
+
+    public function getName()
+    {
+        return "MyMoney";
+    }
+
+    public function getSqlDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
+    {
+        return 'MyMoney';
+    }
+
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/SchemaManagerFunctionalTestCase.php

@@ -0,0 +1,525 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Types\Type,
+    Doctrine\DBAL\Schema\AbstractSchemaManager;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+class SchemaManagerFunctionalTestCase extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    /**
+     * @var \Doctrine\DBAL\Schema\AbstractSchemaManager
+     */
+    protected $_sm;
+
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $class = get_class($this);
+        $e = explode('\\', $class);
+        $testClass = end($e);
+        $dbms = strtolower(str_replace('SchemaManagerTest', null, $testClass));
+
+        if ($this->_conn->getDatabasePlatform()->getName() !== $dbms) {
+            $this->markTestSkipped('The ' . $testClass .' requires the use of ' . $dbms);
+        }
+
+        $this->_sm = $this->_conn->getSchemaManager();
+    }
+
+    public function testListSequences()
+    {
+        if(!$this->_conn->getDatabasePlatform()->supportsSequences()) {
+            $this->markTestSkipped($this->_conn->getDriver()->getName().' does not support sequences.');
+        }
+
+        $sequence = new \Doctrine\DBAL\Schema\Sequence('list_sequences_test_seq', 20, 10);
+        $this->_sm->createSequence($sequence);
+        
+        $sequences = $this->_sm->listSequences();
+        
+        $this->assertInternalType('array', $sequences, 'listSequences() should return an array.');
+
+        $foundSequence = null;
+        foreach($sequences AS $sequence) {
+            $this->assertInstanceOf('Doctrine\DBAL\Schema\Sequence', $sequence, 'Array elements of listSequences() should be Sequence instances.');
+            if(strtolower($sequence->getName()) == 'list_sequences_test_seq') {
+                $foundSequence = $sequence;
+            }
+        }
+
+        $this->assertNotNull($foundSequence, "Sequence with name 'list_sequences_test_seq' was not found.");
+        $this->assertEquals(20, $foundSequence->getAllocationSize(), "Allocation Size is expected to be 20.");
+        $this->assertEquals(10, $foundSequence->getInitialValue(), "Initial Value is expected to be 10.");
+    }
+
+    public function testListDatabases()
+    {
+        if (!$this->_sm->getDatabasePlatform()->supportsCreateDropDatabase()) {
+            $this->markTestSkipped('Cannot drop Database client side with this Driver.');
+        }
+
+        $this->_sm->dropAndCreateDatabase('test_create_database');
+        $databases = $this->_sm->listDatabases();
+
+        $databases = \array_map('strtolower', $databases);
+        
+        $this->assertEquals(true, \in_array('test_create_database', $databases));
+    }
+
+    public function testListTables()
+    {
+        $this->createTestTable('list_tables_test');
+        $tables = $this->_sm->listTables();
+
+        $this->assertInternalType('array', $tables);
+        $this->assertTrue(count($tables) > 0, "List Tables has to find at least one table named 'list_tables_test'.");
+
+        $foundTable = false;
+        foreach ($tables AS $table) {
+            $this->assertInstanceOf('Doctrine\DBAL\Schema\Table', $table);
+            if (strtolower($table->getName()) == 'list_tables_test') {
+                $foundTable = true;
+
+                $this->assertTrue($table->hasColumn('id'));
+                $this->assertTrue($table->hasColumn('test'));
+                $this->assertTrue($table->hasColumn('foreign_key_test'));
+            }
+        }
+
+        $this->assertTrue( $foundTable , "The 'list_tables_test' table has to be found.");
+    }
+
+    public function createListTableColumns()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('list_table_columns');
+        $table->addColumn('id', 'integer', array('notnull' => true));
+        $table->addColumn('test', 'string', array('length' => 255, 'notnull' => false));
+        $table->addColumn('foo', 'text', array('notnull' => true));
+        $table->addColumn('bar', 'decimal', array('precision' => 10, 'scale' => 4, 'notnull' => false));
+        $table->addColumn('baz1', 'datetime');
+        $table->addColumn('baz2', 'time');
+        $table->addColumn('baz3', 'date');
+
+        return $table;
+    }
+
+    public function testListTableColumns()
+    {
+        $table = $this->createListTableColumns();
+
+        $this->_sm->dropAndCreateTable($table);
+
+        $columns = $this->_sm->listTableColumns('list_table_columns');
+
+        $this->assertArrayHasKey('id', $columns);
+        $this->assertEquals('id',   strtolower($columns['id']->getname()));
+        $this->assertInstanceOf('Doctrine\DBAL\Types\IntegerType', $columns['id']->gettype());
+        $this->assertEquals(false,  $columns['id']->getunsigned());
+        $this->assertEquals(true,   $columns['id']->getnotnull());
+        $this->assertEquals(null,   $columns['id']->getdefault());
+        $this->assertInternalType('array',  $columns['id']->getPlatformOptions());
+
+        $this->assertArrayHasKey('test', $columns);
+        $this->assertEquals('test', strtolower($columns['test']->getname()));
+        $this->assertInstanceOf('Doctrine\DBAL\Types\StringType', $columns['test']->gettype());
+        $this->assertEquals(255,    $columns['test']->getlength());
+        $this->assertEquals(false,  $columns['test']->getfixed());
+        $this->assertEquals(false,  $columns['test']->getnotnull());
+        $this->assertEquals(null,   $columns['test']->getdefault());
+        $this->assertInternalType('array',  $columns['test']->getPlatformOptions());
+
+        $this->assertEquals('foo',  strtolower($columns['foo']->getname()));
+        $this->assertInstanceOf('Doctrine\DBAL\Types\TextType', $columns['foo']->gettype());
+        $this->assertEquals(false,  $columns['foo']->getunsigned());
+        $this->assertEquals(false,  $columns['foo']->getfixed());
+        $this->assertEquals(true,   $columns['foo']->getnotnull());
+        $this->assertEquals(null,   $columns['foo']->getdefault());
+        $this->assertInternalType('array',  $columns['foo']->getPlatformOptions());
+
+        $this->assertEquals('bar',  strtolower($columns['bar']->getname()));
+        $this->assertInstanceOf('Doctrine\DBAL\Types\DecimalType', $columns['bar']->gettype());
+        $this->assertEquals(null,   $columns['bar']->getlength());
+        $this->assertEquals(10,     $columns['bar']->getprecision());
+        $this->assertEquals(4,      $columns['bar']->getscale());
+        $this->assertEquals(false,  $columns['bar']->getunsigned());
+        $this->assertEquals(false,  $columns['bar']->getfixed());
+        $this->assertEquals(false,  $columns['bar']->getnotnull());
+        $this->assertEquals(null,   $columns['bar']->getdefault());
+        $this->assertInternalType('array',  $columns['bar']->getPlatformOptions());
+
+        $this->assertEquals('baz1', strtolower($columns['baz1']->getname()));
+        $this->assertInstanceOf('Doctrine\DBAL\Types\DateTimeType', $columns['baz1']->gettype());
+        $this->assertEquals(true,   $columns['baz1']->getnotnull());
+        $this->assertEquals(null,   $columns['baz1']->getdefault());
+        $this->assertInternalType('array',  $columns['baz1']->getPlatformOptions());
+
+        $this->assertEquals('baz2', strtolower($columns['baz2']->getname()));
+        $this->assertContains($columns['baz2']->gettype()->getName(), array('time', 'date', 'datetime'));
+        $this->assertEquals(true,   $columns['baz2']->getnotnull());
+        $this->assertEquals(null,   $columns['baz2']->getdefault());
+        $this->assertInternalType('array',  $columns['baz2']->getPlatformOptions());
+        
+        $this->assertEquals('baz3', strtolower($columns['baz3']->getname()));
+        $this->assertContains($columns['baz2']->gettype()->getName(), array('time', 'date', 'datetime'));
+        $this->assertEquals(true,   $columns['baz3']->getnotnull());
+        $this->assertEquals(null,   $columns['baz3']->getdefault());
+        $this->assertInternalType('array',  $columns['baz3']->getPlatformOptions());
+    }
+
+    public function testDiffListTableColumns()
+    {
+        if ($this->_sm->getDatabasePlatform()->getName() == 'oracle') {
+            $this->markTestSkipped('Does not work with Oracle, since it cannot detect DateTime, Date and Time differenecs (at the moment).');
+        }
+
+        $offlineTable = $this->createListTableColumns();
+        $onlineTable = $this->_sm->listTableDetails('list_table_columns');
+
+        $comparator = new \Doctrine\DBAL\Schema\Comparator();
+        $diff = $comparator->diffTable($offlineTable, $onlineTable);
+
+        $this->assertFalse($diff, "No differences should be detected with the offline vs online schema.");
+    }
+
+    public function testListTableIndexes()
+    {
+        $table = $this->getTestTable('list_table_indexes_test');
+        $table->addUniqueIndex(array('test'), 'test_index_name');
+        $table->addIndex(array('id', 'test'), 'test_composite_idx');
+
+        $this->_sm->createTable($table);
+
+        $tableIndexes = $this->_sm->listTableIndexes('list_table_indexes_test');
+
+        $this->assertEquals(3, count($tableIndexes));
+
+        $this->assertArrayHasKey('primary', $tableIndexes, 'listTableIndexes() has to return a "primary" array key.');
+        $this->assertEquals(array('id'), array_map('strtolower', $tableIndexes['primary']->getColumns()));
+        $this->assertTrue($tableIndexes['primary']->isUnique());
+        $this->assertTrue($tableIndexes['primary']->isPrimary());
+
+        $this->assertEquals('test_index_name', $tableIndexes['test_index_name']->getName());
+        $this->assertEquals(array('test'), array_map('strtolower', $tableIndexes['test_index_name']->getColumns()));
+        $this->assertTrue($tableIndexes['test_index_name']->isUnique());
+        $this->assertFalse($tableIndexes['test_index_name']->isPrimary());
+
+        $this->assertEquals('test_composite_idx', $tableIndexes['test_composite_idx']->getName());
+        $this->assertEquals(array('id', 'test'), array_map('strtolower', $tableIndexes['test_composite_idx']->getColumns()));
+        $this->assertFalse($tableIndexes['test_composite_idx']->isUnique());
+        $this->assertFalse($tableIndexes['test_composite_idx']->isPrimary());
+    }
+
+    public function testDropAndCreateIndex()
+    {
+        $table = $this->getTestTable('test_create_index');
+        $table->addUniqueIndex(array('test'), 'test');
+        $this->_sm->dropAndCreateTable($table);
+
+        $this->_sm->dropAndCreateIndex($table->getIndex('test'), $table);
+        $tableIndexes = $this->_sm->listTableIndexes('test_create_index');
+        $this->assertInternalType('array', $tableIndexes);
+
+        $this->assertEquals('test',        strtolower($tableIndexes['test']->getName()));
+        $this->assertEquals(array('test'), array_map('strtolower', $tableIndexes['test']->getColumns()));
+        $this->assertTrue($tableIndexes['test']->isUnique());
+        $this->assertFalse($tableIndexes['test']->isPrimary());
+    }
+
+    public function testCreateTableWithForeignKeys()
+    {
+        if(!$this->_sm->getDatabasePlatform()->supportsForeignKeyConstraints()) {
+            $this->markTestSkipped('Platform does not support foreign keys.');
+        }
+
+        $tableB = $this->getTestTable('test_foreign');
+
+        $this->_sm->dropAndCreateTable($tableB);
+
+        $tableA = $this->getTestTable('test_create_fk');
+        $tableA->addForeignKeyConstraint('test_foreign', array('foreign_key_test'), array('id'));
+
+        $this->_sm->dropAndCreateTable($tableA);
+
+        $fkTable = $this->_sm->listTableDetails('test_create_fk');
+        $fkConstraints = $fkTable->getForeignKeys();
+        $this->assertEquals(1, count($fkConstraints), "Table 'test_create_fk1' has to have one foreign key.");
+
+        $fkConstraint = current($fkConstraints);
+        $this->assertType('\Doctrine\DBAL\Schema\ForeignKeyConstraint', $fkConstraint);
+        $this->assertEquals('test_foreign',             strtolower($fkConstraint->getForeignTableName()));
+        $this->assertEquals(array('foreign_key_test'),  array_map('strtolower', $fkConstraint->getColumns()));
+        $this->assertEquals(array('id'),                array_map('strtolower', $fkConstraint->getForeignColumns()));
+
+        $this->assertTrue($fkTable->columnsAreIndexed($fkConstraint->getColumns()), "The columns of a foreign key constraint should always be indexed.");
+    }
+
+    public function testListForeignKeys()
+    {
+        if(!$this->_conn->getDatabasePlatform()->supportsForeignKeyConstraints()) {
+            $this->markTestSkipped('Does not support foreign key constraints.');
+        }
+
+        $this->createTestTable('test_create_fk1');
+        $this->createTestTable('test_create_fk2');
+
+        $foreignKey = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(
+            array('foreign_key_test'), 'test_create_fk2', array('id'), 'foreign_key_test_fk', array('onDelete' => 'CASCADE')
+        );
+
+        $this->_sm->createForeignKey($foreignKey, 'test_create_fk1');
+
+        $fkeys = $this->_sm->listTableForeignKeys('test_create_fk1');
+
+        $this->assertEquals(1, count($fkeys), "Table 'test_create_fk1' has to have one foreign key.");
+        
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\ForeignKeyConstraint', $fkeys[0]);
+        $this->assertEquals(array('foreign_key_test'),  array_map('strtolower', $fkeys[0]->getLocalColumns()));
+        $this->assertEquals(array('id'),                array_map('strtolower', $fkeys[0]->getForeignColumns()));
+        $this->assertEquals('test_create_fk2',          strtolower($fkeys[0]->getForeignTableName()));
+
+        if($fkeys[0]->hasOption('onDelete')) {
+            $this->assertEquals('CASCADE', $fkeys[0]->getOption('onDelete'));
+        }
+    }
+
+    protected function getCreateExampleViewSql()
+    {
+        $this->markTestSkipped('No Create Example View SQL was defined for this SchemaManager');
+    }
+
+    public function testCreateSchema()
+    {
+        $this->createTestTable('test_table');
+
+        $schema = $this->_sm->createSchema();
+
+        $this->assertTrue($schema->hasTable('test_table'));
+    }
+
+    public function testAlterTableScenario()
+    {
+        if(!$this->_sm->getDatabasePlatform()->supportsAlterTable()) {
+            $this->markTestSkipped('Alter Table is not supported by this platform.');
+        }
+
+        $this->createTestTable('alter_table');
+        $this->createTestTable('alter_table_foreign');
+
+        $table = $this->_sm->listTableDetails('alter_table');
+        $this->assertTrue($table->hasColumn('id'));
+        $this->assertTrue($table->hasColumn('test'));
+        $this->assertTrue($table->hasColumn('foreign_key_test'));
+        $this->assertEquals(0, count($table->getForeignKeys()));
+        $this->assertEquals(1, count($table->getIndexes()));
+
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff("alter_table");
+        $tableDiff->addedColumns['foo'] = new \Doctrine\DBAL\Schema\Column('foo', Type::getType('integer'));
+        $tableDiff->removedColumns['test'] = $table->getColumn('test');
+
+        $this->_sm->alterTable($tableDiff);
+
+        $table = $this->_sm->listTableDetails('alter_table');
+        $this->assertFalse($table->hasColumn('test'));
+        $this->assertTrue($table->hasColumn('foo'));
+
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff("alter_table");
+        $tableDiff->addedIndexes[] = new \Doctrine\DBAL\Schema\Index('foo_idx', array('foo'));
+
+        $this->_sm->alterTable($tableDiff);
+
+        $table = $this->_sm->listTableDetails('alter_table');
+        $this->assertEquals(2, count($table->getIndexes()));
+        $this->assertTrue($table->hasIndex('foo_idx'));
+        $this->assertEquals(array('foo'), array_map('strtolower', $table->getIndex('foo_idx')->getColumns()));
+        $this->assertFalse($table->getIndex('foo_idx')->isPrimary());
+        $this->assertFalse($table->getIndex('foo_idx')->isUnique());
+
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff("alter_table");
+        $tableDiff->changedIndexes[] = new \Doctrine\DBAL\Schema\Index('foo_idx', array('foo', 'foreign_key_test'));
+
+        $this->_sm->alterTable($tableDiff);
+
+        $table = $this->_sm->listTableDetails('alter_table');
+        $this->assertEquals(2, count($table->getIndexes()));
+        $this->assertTrue($table->hasIndex('foo_idx'));
+        $this->assertEquals(array('foo', 'foreign_key_test'), array_map('strtolower', $table->getIndex('foo_idx')->getColumns()));
+
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff("alter_table");
+        $tableDiff->removedIndexes[] = new \Doctrine\DBAL\Schema\Index('foo_idx', array('foo', 'foreign_key_test'));
+        $fk = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(array('foreign_key_test'), 'alter_table_foreign', array('id'));
+        $tableDiff->addedForeignKeys[] = $fk;
+
+        $this->_sm->alterTable($tableDiff);
+        $table = $this->_sm->listTableDetails('alter_table');
+
+        // dont check for index size here, some platforms automatically add indexes for foreign keys.
+        $this->assertFalse($table->hasIndex('foo_idx'));
+
+        $this->assertEquals(1, count($table->getForeignKeys()));
+        $fks = $table->getForeignKeys();
+        $foreignKey = current($fks);
+        $this->assertEquals('alter_table_foreign', strtolower($foreignKey->getForeignTableName()));
+        $this->assertEquals(array('foreign_key_test'), array_map('strtolower', $foreignKey->getColumns()));
+        $this->assertEquals(array('id'), array_map('strtolower', $foreignKey->getForeignColumns()));
+    }
+
+    public function testCreateAndListViews()
+    {
+        $this->createTestTable('view_test_table');
+
+        $name = "doctrine_test_view";
+        $sql = "SELECT * FROM view_test_table";
+
+        $view = new \Doctrine\DBAL\Schema\View($name, $sql);
+
+        $this->_sm->dropAndCreateView($view);
+
+        $views = $this->_sm->listViews();
+    }
+
+    public function testAutoincrementDetection()
+    {
+        if (!$this->_sm->getDatabasePlatform()->supportsIdentityColumns()) {
+            $this->markTestSkipped('This test is only supported on platforms that have autoincrement');
+        }
+
+        $table = new \Doctrine\DBAL\Schema\Table('test_autoincrement');
+        $table->setSchemaConfig($this->_sm->createSchemaConfig());
+        $table->addColumn('id', 'integer', array('autoincrement' => true));
+        $table->setPrimaryKey(array('id'));
+
+        $this->_sm->createTable($table);
+
+        $inferredTable = $this->_sm->listTableDetails('test_autoincrement');
+        $this->assertTrue($inferredTable->hasColumn('id'));
+        $this->assertTrue($inferredTable->getColumn('id')->getAutoincrement());
+    }
+    
+    /**
+     * @group DDC-887
+     */
+    public function testUpdateSchemaWithForeignKeyRenaming()
+    {
+        if (!$this->_sm->getDatabasePlatform()->supportsForeignKeyConstraints()) {
+            $this->markTestSkipped('This test is only supported on platforms that have foreign keys.');
+        }
+        
+        $table = new \Doctrine\DBAL\Schema\Table('test_fk_base');
+        $table->addColumn('id', 'integer');
+        $table->setPrimaryKey(array('id'));
+        
+        $tableFK = new \Doctrine\DBAL\Schema\Table('test_fk_rename');
+        $tableFK->setSchemaConfig($this->_sm->createSchemaConfig());
+        $tableFK->addColumn('id', 'integer');
+        $tableFK->addColumn('fk_id', 'integer');
+        $tableFK->setPrimaryKey(array('id'));
+        $tableFK->addIndex(array('fk_id'), 'fk_idx');
+        $tableFK->addForeignKeyConstraint('test_fk_base', array('fk_id'), array('id'));
+        
+        $this->_sm->createTable($table);
+        $this->_sm->createTable($tableFK);
+        
+        $tableFKNew = new \Doctrine\DBAL\Schema\Table('test_fk_rename');
+        $tableFKNew->setSchemaConfig($this->_sm->createSchemaConfig());
+        $tableFKNew->addColumn('id', 'integer');
+        $tableFKNew->addColumn('rename_fk_id', 'integer');
+        $tableFKNew->setPrimaryKey(array('id'));
+        $tableFKNew->addIndex(array('rename_fk_id'), 'fk_idx');
+        $tableFKNew->addForeignKeyConstraint('test_fk_base', array('rename_fk_id'), array('id'));
+        
+        $c = new \Doctrine\DBAL\Schema\Comparator();
+        $tableDiff = $c->diffTable($tableFK, $tableFKNew);
+        
+        $this->_sm->alterTable($tableDiff);
+    }
+
+    /**
+     * @group DBAL-42
+     */
+    public function testGetColumnComment()
+    {
+        if (!$this->_conn->getDatabasePlatform()->supportsInlineColumnComments() && !$this->_conn->getDatabasePlatform()->supportsCommentOnStatement()) {
+            $this->markTestSkipped('Database does not support column comments.');
+        }
+
+        $table = new \Doctrine\DBAL\Schema\Table('column_comment_test');
+        $table->addColumn('id', 'integer', array('comment' => 'This is a comment'));
+        $table->setPrimaryKey(array('id'));
+
+        $this->_sm->createTable($table);
+
+        $columns = $this->_sm->listTableColumns("column_comment_test");
+        $this->assertEquals(1, count($columns));
+        $this->assertEquals('This is a comment', $columns['id']->getComment());
+    }
+
+    /**
+     * @group DBAL-42
+     */
+    public function testAutomaticallyAppendCommentOnMarkedColumns()
+    {
+        if (!$this->_conn->getDatabasePlatform()->supportsInlineColumnComments() && !$this->_conn->getDatabasePlatform()->supportsCommentOnStatement()) {
+            $this->markTestSkipped('Database does not support column comments.');
+        }
+
+        $table = new \Doctrine\DBAL\Schema\Table('column_comment_test2');
+        $table->addColumn('id', 'integer', array('comment' => 'This is a comment'));
+        $table->addColumn('obj', 'object', array('comment' => 'This is a comment'));
+        $table->addColumn('arr', 'array', array('comment' => 'This is a comment'));
+        $table->setPrimaryKey(array('id'));
+
+        $this->_sm->createTable($table);
+
+        $columns = $this->_sm->listTableColumns("column_comment_test2");
+        $this->assertEquals(3, count($columns));
+        $this->assertEquals('This is a comment', $columns['id']->getComment());
+        $this->assertEquals('This is a comment', $columns['obj']->getComment(), "The Doctrine2 Typehint should be stripped from comment.");
+        $this->assertInstanceOf('Doctrine\DBAL\Types\ObjectType', $columns['obj']->getType(), "The Doctrine2 should be detected from comment hint.");
+        $this->assertEquals('This is a comment', $columns['arr']->getComment(), "The Doctrine2 Typehint should be stripped from comment.");
+        $this->assertInstanceOf('Doctrine\DBAL\Types\ArrayType', $columns['arr']->getType(), "The Doctrine2 should be detected from comment hint.");
+    }
+
+    /**
+     * @param string $name
+     * @param array $data
+     */
+    protected function createTestTable($name = 'test_table', $data = array())
+    {
+        $options = array();
+        if (isset($data['options'])) {
+            $options = $data['options'];
+        }
+
+        $table = $this->getTestTable($name, $options);
+
+        $this->_sm->dropAndCreateTable($table);
+    }
+
+    protected function getTestTable($name, $options=array())
+    {
+        $table = new \Doctrine\DBAL\Schema\Table($name, array(), array(), array(), false, $options);
+        $table->setSchemaConfig($this->_sm->createSchemaConfig());
+        $table->addColumn('id', 'integer', array('notnull' => true));
+        $table->setPrimaryKey(array('id'));
+        $table->addColumn('test', 'string', array('length' => 255));
+        $table->addColumn('foreign_key_test', 'integer');
+        return $table;
+    }
+
+    protected function assertHasTable($tables, $tableName)
+    {
+        $foundTable = false;
+        foreach ($tables AS $table) {
+            $this->assertInstanceOf('Doctrine\DBAL\Schema\Table', $table, 'No Table instance was found in tables array.');
+            if (strtolower($table->getName()) == 'list_tables_test_new_name') {
+                $foundTable = true;
+            }
+        }
+        $this->assertTrue($foundTable, "Could not find new table");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/Schema/SqliteSchemaManagerTest.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional\Schema;
+
+use Doctrine\DBAL\Schema;
+
+require_once __DIR__ . '/../../../TestInit.php';
+ 
+class SqliteSchemaManagerTest extends SchemaManagerFunctionalTestCase
+{
+    /**
+     * SQLITE does not support databases.
+     * 
+     * @expectedException \Exception
+     */
+    public function testListDatabases()
+    {
+        $this->_sm->listDatabases();
+    }
+
+    public function testCreateAndDropDatabase()
+    {
+        $path = dirname(__FILE__).'/test_create_and_drop_sqlite_database.sqlite';
+
+        $this->_sm->createDatabase($path);
+        $this->assertEquals(true, file_exists($path));
+        $this->_sm->dropDatabase($path);
+        $this->assertEquals(false, file_exists($path));
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    // This test is not correct. createSequence expects an object.
+    // PHPUnit wrapping the PHP error in an exception hides this but it shows up
+    // when the tests are run in the build (phing).
+    /*public function testCreateSequence()
+    {
+        $this->_sm->createSequence('seqname', 1, 1);
+    }*/
+
+    /**
+     * @expectedException \Exception
+     */
+    // This test is not correct. createForeignKey expects an object.
+    // PHPUnit wrapping the PHP error in an exception hides this but it shows up
+    // when the tests are run in the build (phing).
+    /*public function testCreateForeignKey()
+    {
+        $this->_sm->createForeignKey('table', array());
+    }*/
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testRenameTable()
+    {
+        $this->_sm->renameTable('oldname', 'newname');
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/TypeConversionTest.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\Types\Type;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class TypeConversionTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    static private $typeCounter = 0;
+
+    public function setUp()
+    {
+        parent::setUp();
+
+        /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+        $sm = $this->_conn->getSchemaManager();
+
+        if (!$sm->tablesExist(array('type_conversion'))) {
+
+            $table = new \Doctrine\DBAL\Schema\Table("type_conversion");
+            $table->addColumn('id', 'integer', array('notnull' => false));
+            $table->addColumn('test_string', 'string', array('notnull' => false));
+            $table->addColumn('test_boolean', 'boolean', array('notnull' => false));
+            $table->addColumn('test_bigint', 'bigint', array('notnull' => false));
+            $table->addColumn('test_smallint', 'bigint', array('notnull' => false));
+            $table->addColumn('test_datetime', 'datetime', array('notnull' => false));
+            $table->addColumn('test_datetimetz', 'datetimetz', array('notnull' => false));
+            $table->addColumn('test_date', 'date', array('notnull' => false));
+            $table->addColumn('test_time', 'time', array('notnull' => false));
+            $table->addColumn('test_text', 'text', array('notnull' => false));
+            $table->addColumn('test_array', 'array', array('notnull' => false));
+            $table->addColumn('test_object', 'object', array('notnull' => false));
+            $table->addColumn('test_float', 'float', array('notnull' => false));
+            $table->addColumn('test_decimal', 'decimal', array('notnull' => false, 'scale' => 2, 'precision' => 10));
+            $table->setPrimaryKey(array('id'));
+
+            $sm->createTable($table);
+        }
+    }
+
+    static public function dataIdempotentDataConversion()
+    {
+        $obj = new \stdClass();
+        $obj->foo = "bar";
+        $obj->bar = "baz";
+
+        return array(
+            array('string',     'ABCDEFGaaaBBB', 'string'),
+            array('boolean',    true, 'bool'),
+            array('boolean',    false, 'bool'),
+            array('bigint',     12345678, 'string'),
+            array('smallint',   123, 'int'),
+            array('datetime',   new \DateTime('2010-04-05 10:10:10'), 'DateTime'),
+            array('datetimetz', new \DateTime('2010-04-05 10:10:10'), 'DateTime'),
+            array('date',       new \DateTime('2010-04-05'), 'DateTime'),
+            array('time',       new \DateTime('10:10:10'), 'DateTime'),
+            array('text',       str_repeat('foo ', 1000), 'string'),
+            array('array',      array('foo' => 'bar'), 'array'),
+            array('object',     $obj, 'object'),
+            array('float',      1.5, 'float'),
+            array('decimal',    1.55, 'string'),
+        );
+    }
+
+    /**
+     * @dataProvider dataIdempotentDataConversion
+     * @param string $type
+     * @param mixed $originalValue
+     * @param string $expectedPhpType
+     */
+    public function testIdempotentDataConversion($type, $originalValue, $expectedPhpType)
+    {
+        $columnName = "test_" . $type;
+        $typeInstance = Type::getType($type);
+        $insertionValue = $typeInstance->convertToDatabaseValue($originalValue, $this->_conn->getDatabasePlatform());
+
+        $this->_conn->insert('type_conversion', array('id' => ++self::$typeCounter, $columnName => $insertionValue));
+
+        $sql = "SELECT " . $columnName . " FROM type_conversion WHERE id = " . self::$typeCounter;
+        $actualDbValue = $typeInstance->convertToPHPValue($this->_conn->fetchColumn($sql), $this->_conn->getDatabasePlatform());
+
+        $this->assertType($expectedPhpType, $actualDbValue, "The expected type from the conversion to and back from the database should be " . $expectedPhpType);
+
+        if ($type !== "datetimetz") {
+            $this->assertEquals($originalValue, $actualDbValue, "Conversion between values should produce the same out as in value, but doesnt!");
+
+            if ($originalValue instanceof \DateTime) {
+                $this->assertEquals($originalValue->getTimezone()->getName(), $actualDbValue->getTimezone()->getName(), "Timezones should be the same.");
+            }
+        }
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/WriteTest.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+use Doctrine\DBAL\Types\Type;
+use PDO;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class WriteTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    public function setUp()
+    {
+        parent::setUp();
+
+        try {
+            /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+            $table = new \Doctrine\DBAL\Schema\Table("write_table");
+            $table->addColumn('test_int', 'integer');
+            $table->addColumn('test_string', 'string', array('notnull' => false));
+
+            $sm = $this->_conn->getSchemaManager();
+            $sm->createTable($table);
+        } catch(\Exception $e) {
+
+        }
+        $this->_conn->executeUpdate('DELETE FROM write_table');
+    }
+
+    /**
+     * @group DBAL-80
+     */
+    public function testExecuteUpdateFirstTypeIsNull()
+    {
+        $sql = "INSERT INTO write_table (test_string, test_int) VALUES (?, ?)";
+        $this->_conn->executeUpdate($sql, array("text", 1111), array(null, PDO::PARAM_INT));
+
+        $sql = "SELECT * FROM write_table WHERE test_string = ? AND test_int = ?";
+        $this->assertTrue((bool)$this->_conn->fetchColumn($sql, array("text", 1111)));
+    }
+
+    public function testExecuteUpdate()
+    {
+        $sql = "INSERT INTO write_table (test_int) VALUES ( " . $this->_conn->quote(1) . ")";
+        $affected = $this->_conn->executeUpdate($sql);
+
+        $this->assertEquals(1, $affected, "executeUpdate() should return the number of affected rows!");
+    }
+
+    public function testExecuteUpdateWithTypes()
+    {
+        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
+        $affected = $this->_conn->executeUpdate($sql, array(1, 'foo'), array(\PDO::PARAM_INT, \PDO::PARAM_STR));
+
+        $this->assertEquals(1, $affected, "executeUpdate() should return the number of affected rows!");
+    }
+
+    public function testPrepareRowCountReturnsAffectedRows()
+    {
+        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
+        $stmt = $this->_conn->prepare($sql);
+
+        $stmt->bindValue(1, 1);
+        $stmt->bindValue(2, "foo");
+        $stmt->execute();
+
+        $this->assertEquals(1, $stmt->rowCount());
+    }
+
+    public function testPrepareWithPdoTypes()
+    {
+        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
+        $stmt = $this->_conn->prepare($sql);
+
+        $stmt->bindValue(1, 1, \PDO::PARAM_INT);
+        $stmt->bindValue(2, "foo", \PDO::PARAM_STR);
+        $stmt->execute();
+
+        $this->assertEquals(1, $stmt->rowCount());
+    }
+
+    public function testPrepareWithDbalTypes()
+    {
+        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
+        $stmt = $this->_conn->prepare($sql);
+
+        $stmt->bindValue(1, 1, Type::getType('integer'));
+        $stmt->bindValue(2, "foo", Type::getType('string'));
+        $stmt->execute();
+
+        $this->assertEquals(1, $stmt->rowCount());
+    }
+
+    public function testPrepareWithDbalTypeNames()
+    {
+        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
+        $stmt = $this->_conn->prepare($sql);
+
+        $stmt->bindValue(1, 1, 'integer');
+        $stmt->bindValue(2, "foo", 'string');
+        $stmt->execute();
+
+        $this->assertEquals(1, $stmt->rowCount());
+    }
+
+    public function insertRows()
+    {
+        $this->assertEquals(1, $this->_conn->insert('write_table', array('test_int' => 1)));
+        $this->assertEquals(1, $this->_conn->insert('write_table', array('test_int' => 2)));
+    }
+
+    public function testInsert()
+    {
+        $this->insertRows();
+    }
+
+    public function testDelete()
+    {
+        $this->insertRows();
+
+        $this->assertEquals(1, $this->_conn->delete('write_table', array('test_int' => 2)));
+        $this->assertEquals(1, count($this->_conn->fetchAll('SELECT * FROM write_table')));
+
+        $this->assertEquals(1, $this->_conn->delete('write_table', array('test_int' => 1)));
+        $this->assertEquals(0, count($this->_conn->fetchAll('SELECT * FROM write_table')));
+    }
+
+    public function testUpdate()
+    {
+        $this->insertRows();
+
+        $this->assertEquals(1, $this->_conn->update('write_table', array('test_int' => 2), array('test_int' => 1)));
+        $this->assertEquals(2, $this->_conn->update('write_table', array('test_int' => 3), array('test_int' => 2)));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Mocks/MockPlatform.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Mocks;
+
+use Doctrine\DBAL\Platforms;
+
+class MockPlatform extends \Doctrine\DBAL\Platforms\AbstractPlatform
+{
+    public function getBooleanTypeDeclarationSQL(array $columnDef) {}
+    public function getIntegerTypeDeclarationSQL(array $columnDef) {}
+    public function getBigIntTypeDeclarationSQL(array $columnDef) {}
+    public function getSmallIntTypeDeclarationSQL(array $columnDef) {}
+    public function _getCommonIntegerTypeDeclarationSQL(array $columnDef) {}
+
+    public function getVarcharTypeDeclarationSQL(array $field)
+    {
+        return "DUMMYVARCHAR()";
+    }
+    
+    /** @override */
+    public function getClobTypeDeclarationSQL(array $field)
+    {
+        return 'DUMMYCLOB';
+    }
+
+    public function getVarcharDefaultLength()
+    {
+        return 255;
+    }
+
+    public function getName()
+    {
+        return 'mock';
+    }
+    protected function initializeDoctrineTypeMappings() {
+    }
+    protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
+    {
+
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/AbstractPlatformTestCase.php

@@ -0,0 +1,218 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+abstract class AbstractPlatformTestCase extends \Doctrine\Tests\DbalTestCase
+{
+    /**
+     * @var Doctrine\DBAL\Platforms\AbstractPlatform
+     */
+    protected $_platform;
+
+    abstract public function createPlatform();
+
+    public function setUp()
+    {
+        $this->_platform = $this->createPlatform();
+    }
+
+    public function testGetInvalidtForeignKeyReferentialActionSQL()
+    {
+        $this->setExpectedException('InvalidArgumentException');
+        $this->_platform->getForeignKeyReferentialActionSQL('unknown');
+    }
+
+    public function testGetUnknownDoctrineMappingType()
+    {
+        $this->setExpectedException('Doctrine\DBAL\DBALException');
+        $this->_platform->getDoctrineTypeMapping('foobar');
+    }
+
+    public function testRegisterDoctrineMappingType()
+    {
+        $this->_platform->registerDoctrineTypeMapping('foo', 'integer');
+        $this->assertEquals('integer', $this->_platform->getDoctrineTypeMapping('foo'));
+    }
+
+    public function testRegisterUnknownDoctrineMappingType()
+    {
+        $this->setExpectedException('Doctrine\DBAL\DBALException');
+        $this->_platform->registerDoctrineTypeMapping('foo', 'bar');
+    }
+
+    public function testCreateWithNoColumns()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('test');
+
+        $this->setExpectedException('Doctrine\DBAL\DBALException');
+        $sql = $this->_platform->getCreateTableSQL($table);
+    }
+
+    public function testGeneratesTableCreationSql()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('test');
+        $table->addColumn('id', 'integer', array('notnull' => true, 'autoincrement' => true));
+        $table->addColumn('test', 'string', array('notnull' => false, 'length' => 255));
+        $table->setPrimaryKey(array('id'));
+
+        $sql = $this->_platform->getCreateTableSQL($table);
+        $this->assertEquals($this->getGenerateTableSql(), $sql[0]);
+    }
+
+    abstract public function getGenerateTableSql();
+
+    public function testGenerateTableWithMultiColumnUniqueIndex()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('test');
+        $table->addColumn('foo', 'string', array('notnull' => false, 'length' => 255));
+        $table->addColumn('bar', 'string', array('notnull' => false, 'length' => 255));
+        $table->addUniqueIndex(array("foo", "bar"));
+
+        $sql = $this->_platform->getCreateTableSQL($table);
+        $this->assertEquals($this->getGenerateTableWithMultiColumnUniqueIndexSql(), $sql);
+    }
+
+    abstract public function getGenerateTableWithMultiColumnUniqueIndexSql();
+
+    public function testGeneratesIndexCreationSql()
+    {
+        $indexDef = new \Doctrine\DBAL\Schema\Index('my_idx', array('user_name', 'last_login'));
+
+        $this->assertEquals(
+            $this->getGenerateIndexSql(),
+            $this->_platform->getCreateIndexSQL($indexDef, 'mytable')
+        );
+    }
+
+    abstract public function getGenerateIndexSql();
+
+    public function testGeneratesUniqueIndexCreationSql()
+    {
+        $indexDef = new \Doctrine\DBAL\Schema\Index('index_name', array('test', 'test2'), true);
+
+        $sql = $this->_platform->getCreateIndexSQL($indexDef, 'test');
+        $this->assertEquals($this->getGenerateUniqueIndexSql(), $sql);
+    }
+
+    abstract public function getGenerateUniqueIndexSql();
+
+    public function testGeneratesForeignKeyCreationSql()
+    {
+        $fk = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(array('fk_name_id'), 'other_table', array('id'), '');
+
+        $sql = $this->_platform->getCreateForeignKeySQL($fk, 'test');
+        $this->assertEquals($sql, $this->getGenerateForeignKeySql());
+    }
+
+    abstract public function getGenerateForeignKeySql();
+
+    public function testGeneratesConstraintCreationSql()
+    {
+        $idx = new \Doctrine\DBAL\Schema\Index('constraint_name', array('test'), true, false);
+        $sql = $this->_platform->getCreateConstraintSQL($idx, 'test');
+        $this->assertEquals($this->getGenerateConstraintUniqueIndexSql(), $sql);
+
+        $pk = new \Doctrine\DBAL\Schema\Index('constraint_name', array('test'), true, true);
+        $sql = $this->_platform->getCreateConstraintSQL($pk, 'test');
+        $this->assertEquals($this->getGenerateConstraintPrimaryIndexSql(), $sql);
+
+        $fk = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(array('fk_name'), 'foreign', array('id'), 'constraint_fk');
+        $sql = $this->_platform->getCreateConstraintSQL($fk, 'test');
+        $this->assertEquals($this->getGenerateConstraintForeignKeySql(), $sql);
+    }
+
+    public function getGenerateConstraintUniqueIndexSql()
+    {
+        return 'ALTER TABLE test ADD CONSTRAINT constraint_name UNIQUE (test)';
+    }
+
+    public function getGenerateConstraintPrimaryIndexSql()
+    {
+        return 'ALTER TABLE test ADD CONSTRAINT constraint_name PRIMARY KEY (test)';
+    }
+
+    public function getGenerateConstraintForeignKeySql()
+    {
+        return 'ALTER TABLE test ADD CONSTRAINT constraint_fk FOREIGN KEY (fk_name) REFERENCES foreign (id)';
+    }
+
+    abstract public function getGenerateAlterTableSql();
+
+    public function testGeneratesTableAlterationSql()
+    {
+        $expectedSql = $this->getGenerateAlterTableSql();
+
+        $columnDiff = new \Doctrine\DBAL\Schema\ColumnDiff(
+            'bar', new \Doctrine\DBAL\Schema\Column(
+                'baz', \Doctrine\DBAL\Types\Type::getType('string'), array('default' => 'def')
+            ),
+            array('type', 'notnull', 'default')
+        );
+
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff('mytable');
+        $tableDiff->newName = 'userlist';
+        $tableDiff->addedColumns['quota'] = new \Doctrine\DBAL\Schema\Column('quota', \Doctrine\DBAL\Types\Type::getType('integer'), array('notnull' => false));
+        $tableDiff->removedColumns['foo'] = new \Doctrine\DBAL\Schema\Column('foo', \Doctrine\DBAL\Types\Type::getType('integer'));
+        $tableDiff->changedColumns['bar'] = $columnDiff;
+
+        $sql = $this->_platform->getAlterTableSQL($tableDiff);
+
+        $this->assertEquals($expectedSql, $sql);
+    }
+
+    public function testGetCustomColumnDeclarationSql()
+    {
+        $field = array('columnDefinition' => 'MEDIUMINT(6) UNSIGNED');
+        $this->assertEquals('foo MEDIUMINT(6) UNSIGNED', $this->_platform->getColumnDeclarationSQL('foo', $field));
+    }
+
+    /**
+     * @group DBAL-42
+     */
+    public function testCreateTableColumnComments()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('test');
+        $table->addColumn('id', 'integer', array('comment' => 'This is a comment'));
+        $table->setPrimaryKey(array('id'));
+
+        $this->assertEquals($this->getCreateTableColumnCommentsSQL(), $this->_platform->getCreateTableSQL($table));
+    }
+
+    /**
+     * @group DBAL-42
+     */
+    public function testAlterTableColumnComments()
+    {
+        $tableDiff = new \Doctrine\DBAL\Schema\TableDiff('mytable');
+        $tableDiff->addedColumns['quota'] = new \Doctrine\DBAL\Schema\Column('quota', \Doctrine\DBAL\Types\Type::getType('integer'), array('comment' => 'A comment'));
+        $tableDiff->changedColumns['bar'] = new \Doctrine\DBAL\Schema\ColumnDiff(
+            'bar', new \Doctrine\DBAL\Schema\Column(
+                'baz', \Doctrine\DBAL\Types\Type::getType('string'), array('comment' => 'B comment')
+            ),
+            array('comment')
+        );
+
+        $this->assertEquals($this->getAlterTableColumnCommentsSQL(), $this->_platform->getAlterTableSQL($tableDiff));
+    }
+
+    public function getCreateTableColumnCommentsSQL()
+    {
+        $this->markTestSkipped('Platform does not support Column comments.');
+    }
+
+    public function getAlterTableColumnCommentsSQL()
+    {
+        $this->markTestSkipped('Platform does not support Column comments.');
+    }
+    
+    /**
+     * @group DBAL-45
+     */
+    public function testKeywordList()
+    {
+        $keywordList = $this->_platform->getReservedKeywordsList();
+        $this->assertInstanceOf('Doctrine\DBAL\Platforms\Keywords\KeywordList', $keywordList);
+        
+        $this->assertTrue($keywordList->isKeyword('table'));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/MsSqlPlatformTest.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\MsSqlPlatform;
+use Doctrine\DBAL\Types\Type;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+class MsSqlPlatformTest extends AbstractPlatformTestCase
+{
+
+    public function createPlatform()
+    {
+        return new MsSqlPlatform;
+    }
+
+    public function getGenerateTableSql()
+    {
+        return 'CREATE TABLE test (id INT IDENTITY NOT NULL, test NVARCHAR(255) DEFAULT NULL, PRIMARY KEY(id))';
+    }
+
+    public function getGenerateTableWithMultiColumnUniqueIndexSql()
+    {
+        return array(
+            'CREATE TABLE test (foo NVARCHAR(255) DEFAULT NULL, bar NVARCHAR(255) DEFAULT NULL)',
+            'CREATE UNIQUE INDEX UNIQ_D87F7E0C8C73652176FF8CAA ON test (foo, bar) WHERE foo IS NOT NULL AND bar IS NOT NULL'
+        );
+    }
+
+    public function getGenerateAlterTableSql()
+    {
+        return array(
+            'ALTER TABLE mytable RENAME TO userlist',
+            'ALTER TABLE mytable ADD quota INT DEFAULT NULL',
+            'ALTER TABLE mytable DROP COLUMN foo',
+            'ALTER TABLE mytable CHANGE bar baz NVARCHAR(255) DEFAULT \'def\' NOT NULL',
+        );
+    }
+
+    public function testGeneratesSqlSnippets()
+    {
+        $this->assertEquals('RLIKE', $this->_platform->getRegexpExpression(), 'Regular expression operator is not correct');
+        $this->assertEquals('"', $this->_platform->getIdentifierQuoteCharacter(), 'Identifier quote character is not correct');
+        $this->assertEquals('(column1 + column2 + column3)', $this->_platform->getConcatExpression('column1', 'column2', 'column3'), 'Concatenation expression is not correct');
+    }
+
+    public function testGeneratesTransactionsCommands()
+    {
+        $this->assertEquals(
+                'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED',
+                $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED)
+        );
+        $this->assertEquals(
+                'SET TRANSACTION ISOLATION LEVEL READ COMMITTED',
+                $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED)
+        );
+        $this->assertEquals(
+                'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ',
+                $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ)
+        );
+        $this->assertEquals(
+                'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE',
+                $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE)
+        );
+    }
+
+    public function testGeneratesDDLSnippets()
+    {
+        $dropDatabaseExpectation = 'DROP DATABASE foobar';
+
+        $this->assertEquals('SHOW DATABASES', $this->_platform->getShowDatabasesSQL());
+        $this->assertEquals('CREATE DATABASE foobar', $this->_platform->getCreateDatabaseSQL('foobar'));
+        $this->assertEquals($dropDatabaseExpectation, $this->_platform->getDropDatabaseSQL('foobar'));
+        $this->assertEquals('DROP TABLE foobar', $this->_platform->getDropTableSQL('foobar'));
+    }
+
+    public function testGeneratesTypeDeclarationForIntegers()
+    {
+        $this->assertEquals(
+                'INT',
+                $this->_platform->getIntegerTypeDeclarationSQL(array())
+        );
+        $this->assertEquals(
+                'INT IDENTITY',
+                $this->_platform->getIntegerTypeDeclarationSQL(array('autoincrement' => true)
+        ));
+        $this->assertEquals(
+                'INT IDENTITY',
+                $this->_platform->getIntegerTypeDeclarationSQL(
+                        array('autoincrement' => true, 'primary' => true)
+        ));
+    }
+
+    public function testGeneratesTypeDeclarationsForStrings()
+    {
+        $this->assertEquals(
+                'NCHAR(10)',
+                $this->_platform->getVarcharTypeDeclarationSQL(
+                        array('length' => 10, 'fixed' => true)
+        ));
+        $this->assertEquals(
+                'NVARCHAR(50)',
+                $this->_platform->getVarcharTypeDeclarationSQL(array('length' => 50)),
+                'Variable string declaration is not correct'
+        );
+        $this->assertEquals(
+                'NVARCHAR(255)',
+                $this->_platform->getVarcharTypeDeclarationSQL(array()),
+                'Long string declaration is not correct'
+        );
+    }
+
+    public function testPrefersIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->prefersIdentityColumns());
+    }
+
+    public function testSupportsIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->supportsIdentityColumns());
+    }
+
+    public function testDoesNotSupportSavePoints()
+    {
+        $this->assertTrue($this->_platform->supportsSavepoints());
+    }
+
+    public function getGenerateIndexSql()
+    {
+        return 'CREATE INDEX my_idx ON mytable (user_name, last_login)';
+    }
+
+    public function getGenerateUniqueIndexSql()
+    {
+        return 'CREATE UNIQUE INDEX index_name ON test (test, test2) WHERE test IS NOT NULL AND test2 IS NOT NULL';
+    }
+
+    public function getGenerateForeignKeySql()
+    {
+        return 'ALTER TABLE test ADD FOREIGN KEY (fk_name_id) REFERENCES other_table(id)';
+    }
+
+    public function testModifyLimitQuery()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10, 0);
+        $this->assertEquals('SELECT TOP 10 * FROM user', $sql);
+    }
+
+    public function testModifyLimitQueryWithEmptyOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10);
+        $this->assertEquals('SELECT TOP 10 * FROM user', $sql);
+    }
+
+    public function testModifyLimitQueryWithOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user ORDER BY username DESC', 10, 5);
+        $this->assertEquals('WITH outer_tbl AS (SELECT ROW_NUMBER() OVER (ORDER BY username DESC) AS "doctrine_rownum", * FROM (SELECT * FROM user) AS inner_tbl) SELECT * FROM outer_tbl WHERE "doctrine_rownum" BETWEEN 6 AND 15', $sql);
+    }
+
+    public function testModifyLimitQueryWithAscOrderBy()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user ORDER BY username ASC', 10);
+        $this->assertEquals('SELECT TOP 10 * FROM user ORDER BY username ASC', $sql);
+    }
+
+    public function testModifyLimitQueryWithDescOrderBy()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user ORDER BY username DESC', 10);
+        $this->assertEquals('SELECT TOP 10 * FROM user ORDER BY username DESC', $sql);
+    }
+
+    
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/MySqlPlatformTest.php

@@ -0,0 +1,207 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\MySqlPlatform;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+ 
+class MySqlPlatformTest extends AbstractPlatformTestCase
+{
+    public function createPlatform()
+    {
+        return new MysqlPlatform;
+    }
+
+    public function testGenerateMixedCaseTableCreate()
+    {
+        $table = new Table("Foo");
+        $table->addColumn("Bar", "integer");
+
+        $sql = $this->_platform->getCreateTableSQL($table);
+        $this->assertEquals('CREATE TABLE Foo (Bar INT NOT NULL) ENGINE = InnoDB', array_shift($sql));
+    }
+
+    public function getGenerateTableSql()
+    {
+        return 'CREATE TABLE test (id INT AUTO_INCREMENT NOT NULL, test VARCHAR(255) DEFAULT NULL, PRIMARY KEY(id)) ENGINE = InnoDB';
+    }
+
+    public function getGenerateTableWithMultiColumnUniqueIndexSql()
+    {
+        return array(
+            'CREATE TABLE test (foo VARCHAR(255) DEFAULT NULL, bar VARCHAR(255) DEFAULT NULL, UNIQUE INDEX UNIQ_D87F7E0C8C73652176FF8CAA (foo, bar)) ENGINE = InnoDB'
+        );
+    }
+
+    public function getGenerateAlterTableSql()
+    {
+        return array(
+            "ALTER TABLE mytable RENAME TO userlist, ADD quota INT DEFAULT NULL, DROP foo, CHANGE bar baz VARCHAR(255) DEFAULT 'def' NOT NULL"
+        );
+    }
+
+    public function testGeneratesSqlSnippets()
+    {
+        $this->assertEquals('RLIKE', $this->_platform->getRegexpExpression(), 'Regular expression operator is not correct');
+        $this->assertEquals('`', $this->_platform->getIdentifierQuoteCharacter(), 'Quote character is not correct');
+        $this->assertEquals('CONCAT(column1, column2, column3)', $this->_platform->getConcatExpression('column1', 'column2', 'column3'), 'Concatenation function is not correct');
+    }
+
+    public function testGeneratesTransactionsCommands()
+    {
+        $this->assertEquals(
+            'SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED),
+            ''
+        );
+        $this->assertEquals(
+            'SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED)
+        );
+        $this->assertEquals(
+            'SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ)
+        );
+        $this->assertEquals(
+            'SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE)
+        );
+    }
+
+
+    public function testGeneratesDDLSnippets()
+    {
+        $this->assertEquals('SHOW DATABASES', $this->_platform->getShowDatabasesSQL());
+        $this->assertEquals('CREATE DATABASE foobar', $this->_platform->getCreateDatabaseSQL('foobar'));
+        $this->assertEquals('DROP DATABASE foobar', $this->_platform->getDropDatabaseSQL('foobar'));
+        $this->assertEquals('DROP TABLE foobar', $this->_platform->getDropTableSQL('foobar'));
+    }
+
+    public function testGeneratesTypeDeclarationForIntegers()
+    {
+        $this->assertEquals(
+            'INT',
+            $this->_platform->getIntegerTypeDeclarationSQL(array())
+        );
+        $this->assertEquals(
+            'INT AUTO_INCREMENT',
+            $this->_platform->getIntegerTypeDeclarationSQL(array('autoincrement' => true)
+        ));
+        $this->assertEquals(
+            'INT AUTO_INCREMENT',
+            $this->_platform->getIntegerTypeDeclarationSQL(
+                array('autoincrement' => true, 'primary' => true)
+        ));
+    }
+
+    public function testGeneratesTypeDeclarationForStrings()
+    {
+        $this->assertEquals(
+            'CHAR(10)',
+            $this->_platform->getVarcharTypeDeclarationSQL(
+                array('length' => 10, 'fixed' => true)
+        ));
+        $this->assertEquals(
+            'VARCHAR(50)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array('length' => 50)),
+            'Variable string declaration is not correct'
+        );
+        $this->assertEquals(
+            'VARCHAR(255)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array()),
+            'Long string declaration is not correct'
+        );
+    }
+
+    public function testPrefersIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->prefersIdentityColumns());
+    }
+
+    public function testSupportsIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->supportsIdentityColumns());
+    }
+
+    public function testDoesSupportSavePoints()
+    {
+        $this->assertTrue($this->_platform->supportsSavepoints());   
+    }
+
+    public function getGenerateIndexSql()
+    {
+        return 'CREATE INDEX my_idx ON mytable (user_name, last_login)';
+    }
+
+    public function getGenerateUniqueIndexSql()
+    {
+        return 'CREATE UNIQUE INDEX index_name ON test (test, test2)';
+    }
+
+    public function getGenerateForeignKeySql()
+    {
+        return 'ALTER TABLE test ADD FOREIGN KEY (fk_name_id) REFERENCES other_table(id)';
+    }
+    
+    /**
+     * @group DBAL-126
+     */
+    public function testUniquePrimaryKey()
+    {        
+        $keyTable = new Table("foo");
+        $keyTable->addColumn("bar", "integer");
+        $keyTable->addColumn("baz", "string");
+        $keyTable->setPrimaryKey(array("bar"));
+        $keyTable->addUniqueIndex(array("baz"));
+        
+        $oldTable = new Table("foo");
+        $oldTable->addColumn("bar", "integer");
+        $oldTable->addColumn("baz", "string");
+        
+        $c = new \Doctrine\DBAL\Schema\Comparator;
+        $diff = $c->diffTable($oldTable, $keyTable);
+        
+        $sql = $this->_platform->getAlterTableSQL($diff);
+        
+        $this->assertEquals(array(
+            "ALTER TABLE foo ADD PRIMARY KEY (bar)",
+            "CREATE UNIQUE INDEX UNIQ_8C73652178240498 ON foo (baz)",
+        ), $sql);
+    }
+
+    public function testModifyLimitQuery()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10, 0);
+        $this->assertEquals('SELECT * FROM user LIMIT 10 OFFSET 0', $sql);
+    }
+
+    public function testModifyLimitQueryWithEmptyOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10);
+        $this->assertEquals('SELECT * FROM user LIMIT 10', $sql);
+    }
+
+    /**
+     * @group DDC-118
+     */
+    public function testGetDateTimeTypeDeclarationSql()
+    {
+        $this->assertEquals("DATETIME", $this->_platform->getDateTimeTypeDeclarationSQL(array('version' => false)));
+        $this->assertEquals("TIMESTAMP", $this->_platform->getDateTimeTypeDeclarationSQL(array('version' => true)));
+        $this->assertEquals("DATETIME", $this->_platform->getDateTimeTypeDeclarationSQL(array()));
+    }
+
+    public function getCreateTableColumnCommentsSQL()
+    {
+        return array("CREATE TABLE test (id INT NOT NULL COMMENT 'This is a comment', PRIMARY KEY(id)) ENGINE = InnoDB");
+    }
+
+    public function getAlterTableColumnCommentsSQL()
+    {
+        return array("ALTER TABLE mytable ADD quota INT NOT NULL COMMENT 'A comment', CHANGE bar baz VARCHAR(255) NOT NULL COMMENT 'B comment'");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/OraclePlatformTest.php

@@ -0,0 +1,207 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\OraclePlatform;
+use Doctrine\DBAL\Types\Type;
+
+require_once __DIR__ . '/../../TestInit.php';
+ 
+class OraclePlatformTest extends AbstractPlatformTestCase
+{
+    public function createPlatform()
+    {
+        return new OraclePlatform;
+    }
+
+    public function getGenerateTableSql()
+    {
+        return 'CREATE TABLE test (id NUMBER(10) NOT NULL, test VARCHAR2(255) DEFAULT NULL, PRIMARY KEY(id))';
+    }
+
+    public function getGenerateTableWithMultiColumnUniqueIndexSql()
+    {
+        return array(
+            'CREATE TABLE test (foo VARCHAR2(255) DEFAULT NULL, bar VARCHAR2(255) DEFAULT NULL)',
+            'CREATE UNIQUE INDEX UNIQ_D87F7E0C8C73652176FF8CAA ON test (foo, bar)',
+        );
+    }
+
+    public function getGenerateAlterTableSql()
+    {
+        return array(
+            'ALTER TABLE mytable ADD (quota NUMBER(10) DEFAULT NULL)',
+            "ALTER TABLE mytable MODIFY (baz  VARCHAR2(255) DEFAULT 'def' NOT NULL)",
+            "ALTER TABLE mytable DROP (foo)",
+            "ALTER TABLE mytable RENAME TO userlist",
+        );
+    }
+
+    /**
+     * @expectedException Doctrine\DBAL\DBALException
+     */
+    public function testRLike()
+    {
+        $this->assertEquals('RLIKE', $this->_platform->getRegexpExpression(), 'Regular expression operator is not correct');
+    }
+
+    public function testGeneratesSqlSnippets()
+    {
+        $this->assertEquals('"', $this->_platform->getIdentifierQuoteCharacter(), 'Identifier quote character is not correct');
+        $this->assertEquals('column1 || column2 || column3', $this->_platform->getConcatExpression('column1', 'column2', 'column3'), 'Concatenation expression is not correct');
+    }
+
+    public function testGeneratesTransactionsCommands()
+    {
+        $this->assertEquals(
+            'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED)
+        );
+        $this->assertEquals(
+            'SET TRANSACTION ISOLATION LEVEL READ COMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED)
+        );
+        $this->assertEquals(
+            'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ)
+        );
+        $this->assertEquals(
+            'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE)
+        );
+    }
+
+    /**
+     * @expectedException Doctrine\DBAL\DBALException
+     */
+    public function testShowDatabasesThrowsException()
+    {
+        $this->assertEquals('SHOW DATABASES', $this->_platform->getShowDatabasesSQL());
+    }
+
+    /**
+     * @expectedException Doctrine\DBAL\DBALException
+     */
+    public function testCreateDatabaseThrowsException()
+    {
+        $this->assertEquals('CREATE DATABASE foobar', $this->_platform->getCreateDatabaseSQL('foobar'));
+    }
+
+    public function testDropDatabaseThrowsException()
+    {
+        $this->assertEquals('DROP USER foobar CASCADE', $this->_platform->getDropDatabaseSQL('foobar'));
+    }
+
+    public function testDropTable()
+    {
+        $this->assertEquals('DROP TABLE foobar', $this->_platform->getDropTableSQL('foobar'));        
+    }
+
+    public function testGeneratesTypeDeclarationForIntegers()
+    {
+        $this->assertEquals(
+            'NUMBER(10)',
+            $this->_platform->getIntegerTypeDeclarationSQL(array())
+        );
+        $this->assertEquals(
+            'NUMBER(10)',
+            $this->_platform->getIntegerTypeDeclarationSQL(array('autoincrement' => true)
+        ));
+        $this->assertEquals(
+            'NUMBER(10)',
+            $this->_platform->getIntegerTypeDeclarationSQL(
+                array('autoincrement' => true, 'primary' => true)
+        ));
+    }
+
+    public function testGeneratesTypeDeclarationsForStrings()
+    {
+        $this->assertEquals(
+            'CHAR(10)',
+            $this->_platform->getVarcharTypeDeclarationSQL(
+                array('length' => 10, 'fixed' => true)
+        ));
+        $this->assertEquals(
+            'VARCHAR2(50)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array('length' => 50)),
+            'Variable string declaration is not correct'
+        );
+        $this->assertEquals(
+            'VARCHAR2(255)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array()),
+            'Long string declaration is not correct'
+        );
+    }
+
+    public function testPrefersIdentityColumns()
+    {
+        $this->assertFalse($this->_platform->prefersIdentityColumns());
+    }
+
+    public function testSupportsIdentityColumns()
+    {
+        $this->assertFalse($this->_platform->supportsIdentityColumns());
+    }
+
+    public function testSupportsSavePoints()
+    {
+        $this->assertTrue($this->_platform->supportsSavepoints());   
+    }
+    
+    public function getGenerateIndexSql()
+    {
+        return 'CREATE INDEX my_idx ON mytable (user_name, last_login)';
+    }
+
+    public function getGenerateUniqueIndexSql()
+    {
+        return 'CREATE UNIQUE INDEX index_name ON test (test, test2)';
+    }
+
+    public function getGenerateForeignKeySql()
+    {
+        return 'ALTER TABLE test ADD FOREIGN KEY (fk_name_id) REFERENCES other_table(id)';
+    }
+
+    public function testModifyLimitQuery()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10, 0);
+        $this->assertEquals('SELECT a.* FROM (SELECT * FROM user) a WHERE ROWNUM <= 10', $sql);
+    }
+
+    public function testModifyLimitQueryWithEmptyOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10);
+        $this->assertEquals('SELECT a.* FROM (SELECT * FROM user) a WHERE ROWNUM <= 10', $sql);
+    }
+
+    public function testModifyLimitQueryWithAscOrderBy()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user ORDER BY username ASC', 10);
+        $this->assertEquals('SELECT a.* FROM (SELECT * FROM user ORDER BY username ASC) a WHERE ROWNUM <= 10', $sql);
+    }
+
+    public function testModifyLimitQueryWithDescOrderBy()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user ORDER BY username DESC', 10);
+        $this->assertEquals('SELECT a.* FROM (SELECT * FROM user ORDER BY username DESC) a WHERE ROWNUM <= 10', $sql);
+    }
+
+    public function getCreateTableColumnCommentsSQL()
+    {
+        return array(
+            "CREATE TABLE test (id NUMBER(10) NOT NULL, PRIMARY KEY(id))",
+            "COMMENT ON COLUMN test.id IS 'This is a comment'",
+        );
+    }
+
+    public function getAlterTableColumnCommentsSQL()
+    {
+        return array(
+            "ALTER TABLE mytable ADD (quota NUMBER(10) NOT NULL)",
+            "ALTER TABLE mytable MODIFY (baz  VARCHAR2(255) NOT NULL)",
+            "COMMENT ON COLUMN mytable.quota IS 'A comment'",
+            "COMMENT ON COLUMN mytable.baz IS 'B comment'",
+        );
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/PostgreSqlPlatformTest.php

@@ -0,0 +1,219 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
+use Doctrine\DBAL\Types\Type;
+
+require_once __DIR__ . '/../../TestInit.php';
+ 
+class PostgreSqlPlatformTest extends AbstractPlatformTestCase
+{
+    public function createPlatform()
+    {
+        return new PostgreSqlPlatform;
+    }
+
+    public function getGenerateTableSql()
+    {
+        return 'CREATE TABLE test (id SERIAL NOT NULL, test VARCHAR(255) DEFAULT NULL, PRIMARY KEY(id))';
+    }
+
+    public function getGenerateTableWithMultiColumnUniqueIndexSql()
+    {
+        return array(
+            'CREATE TABLE test (foo VARCHAR(255) DEFAULT NULL, bar VARCHAR(255) DEFAULT NULL)',
+            'CREATE UNIQUE INDEX UNIQ_D87F7E0C8C73652176FF8CAA ON test (foo, bar)'
+        );
+    }
+
+    public function getGenerateAlterTableSql()
+    {
+        return array(
+            'ALTER TABLE mytable ADD quota INT DEFAULT NULL',
+            'ALTER TABLE mytable DROP foo',
+            'ALTER TABLE mytable ALTER bar TYPE VARCHAR(255)',
+            "ALTER TABLE mytable ALTER bar SET  DEFAULT 'def'",
+            'ALTER TABLE mytable ALTER bar SET NOT NULL',
+            'ALTER TABLE mytable RENAME TO userlist',
+        );
+    }
+
+    public function getGenerateIndexSql()
+    {
+        return 'CREATE INDEX my_idx ON mytable (user_name, last_login)';
+    }
+
+    public function getGenerateForeignKeySql()
+    {
+        return 'ALTER TABLE test ADD FOREIGN KEY (fk_name_id) REFERENCES other_table(id) NOT DEFERRABLE INITIALLY IMMEDIATE';
+    }
+
+    public function testGeneratesForeignKeySqlForNonStandardOptions()
+    {
+        $foreignKey = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(
+                array('foreign_id'), 'my_table', array('id'), 'my_fk', array('onDelete' => 'CASCADE')
+        );
+        $this->assertEquals(
+            "CONSTRAINT my_fk FOREIGN KEY (foreign_id) REFERENCES my_table(id) ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE",
+            $this->_platform->getForeignKeyDeclarationSQL($foreignKey)
+        );
+    }
+
+    public function testGeneratesSqlSnippets()
+    {
+        $this->assertEquals('SIMILAR TO', $this->_platform->getRegexpExpression(), 'Regular expression operator is not correct');
+        $this->assertEquals('"', $this->_platform->getIdentifierQuoteCharacter(), 'Identifier quote character is not correct');
+        $this->assertEquals('column1 || column2 || column3', $this->_platform->getConcatExpression('column1', 'column2', 'column3'), 'Concatenation expression is not correct');
+        $this->assertEquals('SUBSTR(column, 5)', $this->_platform->getSubstringExpression('column', 5), 'Substring expression without length is not correct');
+        $this->assertEquals('SUBSTR(column, 0, 5)', $this->_platform->getSubstringExpression('column', 0, 5), 'Substring expression with length is not correct');
+    }
+
+    public function testGeneratesTransactionCommands()
+    {
+        $this->assertEquals(
+            'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ UNCOMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED)
+        );
+        $this->assertEquals(
+            'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED)
+        );
+        $this->assertEquals(
+            'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ)
+        );
+        $this->assertEquals(
+            'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE',
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE)
+        );
+    }
+
+    public function testGeneratesDDLSnippets()
+    {
+        $this->assertEquals('CREATE DATABASE foobar', $this->_platform->getCreateDatabaseSQL('foobar'));
+        $this->assertEquals('DROP DATABASE foobar', $this->_platform->getDropDatabaseSQL('foobar'));
+        $this->assertEquals('DROP TABLE foobar', $this->_platform->getDropTableSQL('foobar'));
+    }
+
+    public function testGenerateTableWithAutoincrement()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('autoinc_table');
+        $column = $table->addColumn('id', 'integer');
+        $column->setAutoincrement(true);
+
+        $this->assertEquals(array('CREATE TABLE autoinc_table (id SERIAL NOT NULL)'), $this->_platform->getCreateTableSQL($table));
+    }
+
+    public function testGeneratesTypeDeclarationForIntegers()
+    {
+        $this->assertEquals(
+            'INT',
+            $this->_platform->getIntegerTypeDeclarationSQL(array())
+        );
+        $this->assertEquals(
+            'SERIAL',
+            $this->_platform->getIntegerTypeDeclarationSQL(array('autoincrement' => true)
+        ));
+        $this->assertEquals(
+            'SERIAL',
+            $this->_platform->getIntegerTypeDeclarationSQL(
+                array('autoincrement' => true, 'primary' => true)
+        ));
+    }
+
+    public function testGeneratesTypeDeclarationForStrings()
+    {
+        $this->assertEquals(
+            'CHAR(10)',
+            $this->_platform->getVarcharTypeDeclarationSQL(
+                array('length' => 10, 'fixed' => true))
+        );
+        $this->assertEquals(
+            'VARCHAR(50)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array('length' => 50)),
+            'Variable string declaration is not correct'
+        );
+        $this->assertEquals(
+            'VARCHAR(255)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array()),
+            'Long string declaration is not correct'
+        );
+    }
+
+    public function getGenerateUniqueIndexSql()
+    {
+        return 'CREATE UNIQUE INDEX index_name ON test (test, test2)';
+    }
+
+    public function testGeneratesSequenceSqlCommands()
+    {
+        $sequence = new \Doctrine\DBAL\Schema\Sequence('myseq', 20, 1);
+        $this->assertEquals(
+            'CREATE SEQUENCE myseq INCREMENT BY 20 MINVALUE 1 START 1',
+            $this->_platform->getCreateSequenceSQL($sequence)
+        );
+        $this->assertEquals(
+            'DROP SEQUENCE myseq',
+            $this->_platform->getDropSequenceSQL('myseq')
+        );
+        $this->assertEquals(
+            "SELECT NEXTVAL('myseq')",
+            $this->_platform->getSequenceNextValSQL('myseq')
+        );
+    }
+
+    public function testDoesNotPreferIdentityColumns()
+    {
+        $this->assertFalse($this->_platform->prefersIdentityColumns());
+    }
+
+    public function testPrefersSequences()
+    {
+        $this->assertTrue($this->_platform->prefersSequences());
+    }
+
+    public function testSupportsIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->supportsIdentityColumns());
+    }
+
+    public function testSupportsSavePoints()
+    {
+        $this->assertTrue($this->_platform->supportsSavepoints());
+    }
+
+    public function testSupportsSequences()
+    {
+        $this->assertTrue($this->_platform->supportsSequences());
+    }
+
+    public function testModifyLimitQuery()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10, 0);
+        $this->assertEquals('SELECT * FROM user LIMIT 10 OFFSET 0', $sql);
+    }
+
+    public function testModifyLimitQueryWithEmptyOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10);
+        $this->assertEquals('SELECT * FROM user LIMIT 10', $sql);
+    }
+
+    public function getCreateTableColumnCommentsSQL()
+    {
+        return array(
+            "CREATE TABLE test (id INT NOT NULL, PRIMARY KEY(id))",
+            "COMMENT ON COLUMN test.id IS 'This is a comment'",
+        );
+    }
+
+    public function getAlterTableColumnCommentsSQL()
+    {
+        return array(
+            "ALTER TABLE mytable ADD quota INT NOT NULL",
+            "COMMENT ON COLUMN mytable.quota IS 'A comment'",
+            "COMMENT ON COLUMN mytable.baz IS 'B comment'",
+        );
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/ReservedKeywordsValidatorTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\Keywords\ReservedKeywordsValidator;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Types\Type;
+
+class ReservedKeywordsValidatorTest extends \Doctrine\Tests\DbalTestCase
+{
+    /**
+     * @var ReservedKeywordsValidator
+     */
+    private $validator;
+    
+    public function setUp()
+    {
+        $this->validator = new ReservedKeywordsValidator(array(
+            new \Doctrine\DBAL\Platforms\Keywords\MySQLKeywords()
+        ));
+    }
+    
+    public function testReservedTableName()
+    {
+        $table = new Table("TABLE");
+        $this->validator->acceptTable($table);
+        
+        $this->assertEquals(
+            array('Table TABLE keyword violations: MySQL'),
+            $this->validator->getViolations()
+        );
+    }
+    
+    public function testReservedColumnName()
+    {
+        $table = new Table("TABLE");
+        $column = $table->addColumn('table', 'string');
+        
+        $this->validator->acceptColumn($table, $column);
+        
+        $this->assertEquals(
+            array('Table TABLE column table keyword violations: MySQL'),
+            $this->validator->getViolations()
+        );
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Platforms/SqlitePlatformTest.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Platforms;
+
+use Doctrine\DBAL\Platforms\SqlitePlatform;
+use Doctrine\DBAL\Types\Type;
+
+require_once __DIR__ . '/../../TestInit.php';
+ 
+class SqlitePlatformTest extends AbstractPlatformTestCase
+{
+    public function createPlatform()
+    {
+        return new SqlitePlatform;
+    }
+
+    public function getGenerateTableSql()
+    {
+        return 'CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, test VARCHAR(255) DEFAULT NULL)';
+    }
+
+    public function getGenerateTableWithMultiColumnUniqueIndexSql()
+    {
+        return array(
+            'CREATE TABLE test (foo VARCHAR(255) DEFAULT NULL, bar VARCHAR(255) DEFAULT NULL)',
+            'CREATE UNIQUE INDEX UNIQ_D87F7E0C8C73652176FF8CAA ON test (foo, bar)',
+        );
+    }
+
+    public function testGeneratesSqlSnippets()
+    {
+        $this->assertEquals('RLIKE', $this->_platform->getRegexpExpression(), 'Regular expression operator is not correct');
+        $this->assertEquals('SUBSTR(column, 5, LENGTH(column))', $this->_platform->getSubstringExpression('column', 5), 'Substring expression without length is not correct');
+        $this->assertEquals('SUBSTR(column, 0, 5)', $this->_platform->getSubstringExpression('column', 0, 5), 'Substring expression with length is not correct');
+    }
+
+    public function testGeneratesTransactionCommands()
+    {
+        $this->assertEquals(
+            'PRAGMA read_uncommitted = 0', 
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED)
+        );
+        $this->assertEquals(
+            'PRAGMA read_uncommitted = 1', 
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED)
+        );
+        $this->assertEquals(
+            'PRAGMA read_uncommitted = 1', 
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ)
+        );
+        $this->assertEquals(
+            'PRAGMA read_uncommitted = 1', 
+            $this->_platform->getSetTransactionIsolationSQL(\Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE)
+        );
+    }
+
+    public function testPrefersIdentityColumns()
+    {
+        $this->assertTrue($this->_platform->prefersIdentityColumns());
+    }
+
+    public function testGeneratesTypeDeclarationForIntegers()
+    {
+        $this->assertEquals(
+            'INTEGER',
+            $this->_platform->getIntegerTypeDeclarationSQL(array())
+        );
+        $this->assertEquals(
+            'INTEGER AUTOINCREMENT',
+            $this->_platform->getIntegerTypeDeclarationSQL(array('autoincrement' => true))
+        );
+        $this->assertEquals(
+            'INTEGER PRIMARY KEY AUTOINCREMENT',
+            $this->_platform->getIntegerTypeDeclarationSQL(
+                array('autoincrement' => true, 'primary' => true))
+        );
+    }
+
+    public function testGeneratesTypeDeclarationForStrings()
+    {
+        $this->assertEquals(
+            'CHAR(10)',
+            $this->_platform->getVarcharTypeDeclarationSQL(
+                array('length' => 10, 'fixed' => true))
+        );
+        $this->assertEquals(
+            'VARCHAR(50)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array('length' => 50)),
+            'Variable string declaration is not correct'
+        );
+        $this->assertEquals(
+            'VARCHAR(255)',
+            $this->_platform->getVarcharTypeDeclarationSQL(array()),
+            'Long string declaration is not correct'
+        );
+    }
+
+    public function getGenerateIndexSql()
+    {
+        return 'CREATE INDEX my_idx ON mytable (user_name, last_login)';
+    }
+
+    public function getGenerateUniqueIndexSql()
+    {
+        return 'CREATE UNIQUE INDEX index_name ON test (test, test2)';
+    }
+
+    public function getGenerateForeignKeySql()
+    {
+        $this->markTestSkipped('SQLite does not support ForeignKeys.');
+    }
+
+    public function testModifyLimitQuery()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10, 0);
+        $this->assertEquals('SELECT * FROM user LIMIT 10 OFFSET 0', $sql);
+    }
+
+    public function testModifyLimitQueryWithEmptyOffset()
+    {
+        $sql = $this->_platform->modifyLimitQuery('SELECT * FROM user', 10);
+        $this->assertEquals('SELECT * FROM user LIMIT 10', $sql);
+    }
+
+    public function getGenerateAlterTableSql()
+    {
+        $this->markTestSkipped('SQlite does not support ALTER Table.');
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Query/Expression/CompositeExpressionTest.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Query\Expression;
+
+use Doctrine\DBAL\Query\Expression\CompositeExpression;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+/**
+ * @group DBAL-12
+ */
+class CompositeExpressionTest extends \Doctrine\Tests\DbalTestCase
+{
+    public function testCount()
+    {
+        $expr = new CompositeExpression(CompositeExpression::TYPE_OR, array('u.group_id = 1'));
+        
+        $this->assertEquals(1, count($expr));
+        
+        $expr->add('u.group_id = 2');
+        
+        $this->assertEquals(2, count($expr));
+    }
+    
+    /**
+     * @dataProvider provideDataForConvertToString
+     */
+    public function testCompositeUsageAndGeneration($type, $parts, $expects)
+    {
+        $expr = new CompositeExpression($type, $parts);
+        
+        $this->assertEquals($expects, (string) $expr);
+    }
+    
+    public function provideDataForConvertToString()
+    {
+        return array(
+            array(
+                CompositeExpression::TYPE_AND, 
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                CompositeExpression::TYPE_AND, 
+                array('u.user = 1', 'u.group_id = 1'), 
+                '(u.user = 1) AND (u.group_id = 1)'
+            ),
+            array(
+                CompositeExpression::TYPE_OR, 
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                CompositeExpression::TYPE_OR, 
+                array('u.group_id = 1', 'u.group_id = 2'), 
+                '(u.group_id = 1) OR (u.group_id = 2)'
+            ),
+            array(
+                CompositeExpression::TYPE_AND, 
+                array(
+                    'u.user = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_OR,
+                        array('u.group_id = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
+            ),
+            array(
+                CompositeExpression::TYPE_OR, 
+                array(
+                    'u.group_id = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_AND,
+                        array('u.user = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))'
+            ),
+        );
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Query/Expression/ExpressionBuilderTest.php

@@ -0,0 +1,201 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Query\Expression;
+
+use Doctrine\DBAL\Query\Expression\ExpressionBuilder,
+    Doctrine\DBAL\Query\Expression\CompositeExpression;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+/**
+ * @group DBAL-12
+ */
+class ExpressionBuilderTest extends \Doctrine\Tests\DbalTestCase
+{
+    protected $expr;
+    
+    public function setUp()
+    {
+        $conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
+        
+        $this->expr = new ExpressionBuilder($conn);
+        
+        $conn->expects($this->any())
+             ->method('getExpressionBuilder')
+             ->will($this->returnValue($this->expr));
+    }
+    
+    /**
+     * @dataProvider provideDataForAndX
+     */
+    public function testAndX($parts, $expected)
+    {
+        $composite = $this->expr->andX();
+        
+        foreach ($parts as $part) {
+            $composite->add($part);
+        }
+        
+        $this->assertEquals($expected, (string) $composite);
+    }
+    
+    public function provideDataForAndX()
+    {
+        return array(
+            array(
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                array('u.user = 1', 'u.group_id = 1'), 
+                '(u.user = 1) AND (u.group_id = 1)'
+            ),
+            array(
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                array('u.group_id = 1', 'u.group_id = 2'), 
+                '(u.group_id = 1) AND (u.group_id = 2)'
+            ),
+            array(
+                array(
+                    'u.user = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_OR,
+                        array('u.group_id = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
+            ),
+            array(
+                array(
+                    'u.group_id = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_AND,
+                        array('u.user = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))'
+            ),
+        );
+    }
+    
+    /**
+     * @dataProvider provideDataForOrX
+     */
+    public function testOrX($parts, $expected)
+    {
+        $composite = $this->expr->orX();
+        
+        foreach ($parts as $part) {
+            $composite->add($part);
+        }
+        
+        $this->assertEquals($expected, (string) $composite);
+    }
+    
+    public function provideDataForOrX()
+    {
+        return array(
+            array(
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                array('u.user = 1', 'u.group_id = 1'), 
+                '(u.user = 1) OR (u.group_id = 1)'
+            ),
+            array(
+                array('u.user = 1'), 
+                'u.user = 1'
+            ),
+            array(
+                array('u.group_id = 1', 'u.group_id = 2'), 
+                '(u.group_id = 1) OR (u.group_id = 2)'
+            ),
+            array(
+                array(
+                    'u.user = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_OR,
+                        array('u.group_id = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))'
+            ),
+            array(
+                array(
+                    'u.group_id = 1', 
+                    new CompositeExpression(
+                        CompositeExpression::TYPE_AND,
+                        array('u.user = 1', 'u.group_id = 2')
+                    )
+                ), 
+                '(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))'
+            ),
+        );
+    }
+    
+    /**
+     * @dataProvider provideDataForComparison
+     */
+    public function testComparison($leftExpr, $operator, $rightExpr, $expected)
+    {
+        $part = $this->expr->comparison($leftExpr, $operator, $rightExpr);
+        
+        $this->assertEquals($expected, (string) $part);
+    }
+    
+    public function provideDataForComparison()
+    {
+        return array(
+            array('u.user_id', ExpressionBuilder::EQ, '1', 'u.user_id = 1'),
+            array('u.user_id', ExpressionBuilder::NEQ, '1', 'u.user_id <> 1'),
+            array('u.salary', ExpressionBuilder::LT, '10000', 'u.salary < 10000'),
+            array('u.salary', ExpressionBuilder::LTE, '10000', 'u.salary <= 10000'),
+            array('u.salary', ExpressionBuilder::GT, '10000', 'u.salary > 10000'),
+            array('u.salary', ExpressionBuilder::GTE, '10000', 'u.salary >= 10000'),
+        );
+    }
+    
+    public function testEq()
+    {
+        $this->assertEquals('u.user_id = 1', $this->expr->eq('u.user_id', '1'));
+    }
+    
+    public function testNeq()
+    {
+        $this->assertEquals('u.user_id <> 1', $this->expr->neq('u.user_id', '1'));
+    }
+    
+    public function testLt()
+    {
+        $this->assertEquals('u.salary < 10000', $this->expr->lt('u.salary', '10000'));
+    }
+    
+    public function testLte()
+    {
+        $this->assertEquals('u.salary <= 10000', $this->expr->lte('u.salary', '10000'));
+    }
+    
+    public function testGt()
+    {
+        $this->assertEquals('u.salary > 10000', $this->expr->gt('u.salary', '10000'));
+    }
+    
+    public function testGte()
+    {
+        $this->assertEquals('u.salary >= 10000', $this->expr->gte('u.salary', '10000'));
+    }
+    
+    public function testIsNull()
+    {
+        $this->assertEquals('u.deleted IS NULL', $this->expr->isNull('u.deleted'));
+    }
+    
+    public function testIsNotNull()
+    {
+        $this->assertEquals('u.updated IS NOT NULL', $this->expr->isNotNull('u.updated'));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Query/QueryBuilderTest.php

@@ -0,0 +1,551 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Query;
+
+use Doctrine\DBAL\Query\Expression\ExpressionBuilder,
+    Doctrine\DBAL\Query\QueryBuilder;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+/**
+ * @group DBAL-12
+ */
+class QueryBuilderTest extends \Doctrine\Tests\DbalTestCase
+{
+    protected $conn;
+    
+    public function setUp()
+    {
+        $this->conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
+        
+        $expressionBuilder = new ExpressionBuilder($this->conn);
+        
+        $this->conn->expects($this->any())
+                   ->method('getExpressionBuilder')
+                   ->will($this->returnValue($expressionBuilder));
+    }
+    
+    public function testSimpleSelect()
+    {
+        $qb = new QueryBuilder($this->conn);
+                    
+        $qb->select('u.id')
+           ->from('users', 'u');
+           
+        $this->assertEquals('SELECT u.id FROM users u', (string) $qb);
+    }
+    
+    public function testSelectWithSimpleWhere()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();           
+        
+        $qb->select('u.id')
+           ->from('users', 'u')
+           ->where($expr->andX($expr->eq('u.nickname', '?')));
+           
+        $this->assertEquals("SELECT u.id FROM users u WHERE u.nickname = ?", (string) $qb);
+    }
+    
+    public function testSelectWithLeftJoin()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();           
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->leftJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u LEFT JOIN phones p ON p.user_id = u.id', (string) $qb);
+    }
+    
+    public function testSelectWithJoin()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();           
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->Join('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u INNER JOIN phones p ON p.user_id = u.id', (string) $qb);
+    }
+    
+    public function testSelectWithInnerJoin()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();           
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->innerJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u INNER JOIN phones p ON p.user_id = u.id', (string) $qb);
+    }
+    
+    public function testSelectWithRightJoin()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->rightJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u RIGHT JOIN phones p ON p.user_id = u.id', (string) $qb);
+    }
+    
+    public function testSelectWithAndWhereConditions()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->where('u.username = ?')
+           ->andWhere('u.name = ?');
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) AND (u.name = ?)', (string) $qb);
+    }
+    
+    public function testSelectWithOrWhereConditions()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->where('u.username = ?')
+           ->orWhere('u.name = ?');
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) OR (u.name = ?)', (string) $qb);
+    }
+    
+    public function testSelectWithOrOrWhereConditions()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->orWhere('u.username = ?')
+           ->orWhere('u.name = ?');
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) OR (u.name = ?)', (string) $qb);
+    }
+    
+    public function testSelectWithAndOrWhereConditions()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->where('u.username = ?')
+           ->andWhere('u.username = ?')
+           ->orWhere('u.name = ?')
+           ->andWhere('u.name = ?');
+           
+        $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (((u.username = ?) AND (u.username = ?)) OR (u.name = ?)) AND (u.name = ?)', (string) $qb);
+    }
+    
+    public function testSelectGroupBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id', (string) $qb);
+    }
+    
+    public function testSelectEmptyGroupBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->groupBy(array())
+           ->from('users', 'u');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
+    }
+    
+    public function testSelectEmptyAddGroupBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->addGroupBy(array())
+           ->from('users', 'u');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
+    }
+    
+    public function testSelectAddGroupBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->addGroupBy('u.foo');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id, u.foo', (string) $qb);
+    }
+    
+    public function testSelectAddGroupBys()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->addGroupBy('u.foo', 'u.bar');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id, u.foo, u.bar', (string) $qb);
+    }
+    
+    public function testSelectHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->having('u.name = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING u.name = ?', (string) $qb);
+    }
+    
+    public function testSelectAndHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->andHaving('u.name = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING u.name = ?', (string) $qb);
+    }
+    
+    public function testSelectHavingAndHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->having('u.name = ?')
+           ->andHaving('u.username = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) AND (u.username = ?)', (string) $qb);
+    }
+    
+    public function testSelectHavingOrHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->having('u.name = ?')
+           ->orHaving('u.username = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) OR (u.username = ?)', (string) $qb);
+    }
+    
+    public function testSelectOrHavingOrHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->orHaving('u.name = ?')
+           ->orHaving('u.username = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) OR (u.username = ?)', (string) $qb);
+    }
+    
+    public function testSelectHavingAndOrHaving()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->groupBy('u.id')
+           ->having('u.name = ?')
+           ->orHaving('u.username = ?')
+           ->andHaving('u.username = ?');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING ((u.name = ?) OR (u.username = ?)) AND (u.username = ?)', (string) $qb);
+    }
+    
+    public function testSelectOrderBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->orderBy('u.name');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC', (string) $qb);
+    }
+    
+    public function testSelectAddOrderBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->orderBy('u.name')
+           ->addOrderBy('u.username', 'DESC');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC, u.username DESC', (string) $qb);
+    }
+    
+    public function testSelectAddAddOrderBy()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*', 'p.*')
+           ->from('users', 'u')
+           ->addOrderBy('u.name')
+           ->addOrderBy('u.username', 'DESC');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC, u.username DESC', (string) $qb);
+    }
+    
+    public function testEmptySelect()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb2 = $qb->select();
+        
+        $this->assertSame($qb, $qb2);
+        $this->assertEquals(QueryBuilder::SELECT, $qb->getType());
+    }
+    
+    public function testSelectAddSelect()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*')
+           ->addSelect('p.*')
+           ->from('users', 'u');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
+    }
+    
+    public function testEmptyAddSelect()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb2 = $qb->addSelect();
+        
+        $this->assertSame($qb, $qb2);
+        $this->assertEquals(QueryBuilder::SELECT, $qb->getType());
+    }
+    
+    public function testSelectMultipleFrom()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $expr = $qb->expr();
+        
+        $qb->select('u.*')
+           ->addSelect('p.*')
+           ->from('users', 'u')
+           ->from('phonenumbers', 'p');
+        
+        $this->assertEquals('SELECT u.*, p.* FROM users u, phonenumbers p', (string) $qb);
+    }
+    
+    public function testUpdate()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->update('users', 'u')
+           ->set('u.foo', '?')
+           ->set('u.bar', '?');
+        
+        $this->assertEquals(QueryBuilder::UPDATE, $qb->getType());
+        $this->assertEquals('UPDATE users u SET u.foo = ?, u.bar = ?', (string) $qb);
+    }
+    
+    public function testUpdateWithoutAlias()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->update('users')
+           ->set('foo', '?')
+           ->set('bar', '?');
+        
+        $this->assertEquals('UPDATE users SET foo = ?, bar = ?', (string) $qb);
+    }
+    
+    public function testUpdateWhere()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->update('users', 'u')
+           ->set('u.foo', '?')
+           ->where('u.foo = ?');
+        
+        $this->assertEquals('UPDATE users u SET u.foo = ? WHERE u.foo = ?', (string) $qb);
+    }
+    
+    public function testEmptyUpdate()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb2 = $qb->update();
+        
+        $this->assertEquals(QueryBuilder::UPDATE, $qb->getType());
+        $this->assertSame($qb2, $qb);
+    }
+    
+    public function testDelete()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->delete('users', 'u');
+        
+        $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
+        $this->assertEquals('DELETE FROM users u', (string) $qb);
+    }
+    
+    public function testDeleteWithoutAlias()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->delete('users');
+        
+        $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
+        $this->assertEquals('DELETE FROM users', (string) $qb);
+    }
+    
+    public function testDeleteWhere()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->delete('users', 'u')
+           ->where('u.foo = ?');
+        
+        $this->assertEquals('DELETE FROM users u WHERE u.foo = ?', (string) $qb);
+    }
+    
+    public function testEmptyDelete()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb2 = $qb->delete();
+        
+        $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
+        $this->assertSame($qb2, $qb);
+    }
+    
+    public function testGetConnection()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $this->assertSame($this->conn, $qb->getConnection());
+    }
+    
+    public function testGetState()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $this->assertEquals(QueryBuilder::STATE_CLEAN, $qb->getState());
+        
+        $qb->select('u.*')->from('users', 'u');
+        
+        $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
+        
+        $sql1 = $qb->getSQL();
+        
+        $this->assertEquals(QueryBuilder::STATE_CLEAN, $qb->getState());
+        $this->assertEquals($sql1, $qb->getSQL());
+    }
+    
+    public function testSetMaxResults()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->setMaxResults(10);
+        
+        $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
+        $this->assertEQuals(10, $qb->getMaxResults());
+    }
+    
+    public function testSetFirstResult()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        $qb->setFirstResult(10);
+        
+        $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
+        $this->assertEQuals(10, $qb->getFirstResult());
+    }
+    
+    public function testResetQueryPart()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $qb->select('u.*')->from('users', 'u')->where('u.name = ?');
+        
+        $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ?', (string)$qb);
+        $qb->resetQueryPart('where');
+        $this->assertEquals('SELECT u.* FROM users u', (string)$qb);
+    }
+    
+    public function testResetQueryParts()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $qb->select('u.*')->from('users', 'u')->where('u.name = ?')->orderBy('u.name');
+        
+        $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ? ORDER BY u.name ASC', (string)$qb);
+        $qb->resetQueryParts(array('where', 'orderBy'));
+        $this->assertEquals('SELECT u.* FROM users u', (string)$qb);
+    }
+    
+    public function testCreateNamedParameter()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $qb->select('u.*')->from('users', 'u')->where(
+            $qb->expr()->eq('u.name', $qb->createNamedParameter(10, \PDO::PARAM_INT))
+        );
+        
+        $this->assertEquals('SELECT u.* FROM users u WHERE u.name = :dcValue1', (string)$qb);
+        $this->assertEquals(10, $qb->getParameter('dcValue1'));
+    }
+    
+    public function testCreateNamedParameterCustomPlaceholder()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $qb->select('u.*')->from('users', 'u')->where(
+            $qb->expr()->eq('u.name', $qb->createNamedParameter(10, \PDO::PARAM_INT, ':test'))
+        );
+        
+        $this->assertEquals('SELECT u.* FROM users u WHERE u.name = :test', (string)$qb);
+        $this->assertEquals(10, $qb->getParameter('test'));
+    }
+    
+    public function testCreatePositionalParameter()
+    {
+        $qb   = new QueryBuilder($this->conn);
+        
+        $qb->select('u.*')->from('users', 'u')->where(
+            $qb->expr()->eq('u.name', $qb->createPositionalParameter(10, \PDO::PARAM_INT))
+        );
+        
+        $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ?', (string)$qb);
+        $this->assertEquals(10, $qb->getParameter(1));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/SQLParserUtilsTest.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Doctrine\Tests\DBAL;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\SQLParserUtils;
+
+require_once __DIR__ . '/../TestInit.php';
+
+/**
+ * @group DBAL-78
+ */
+class SQLParserUtilsTest extends \Doctrine\Tests\DbalTestCase
+{
+    static public function dataGetPlaceholderPositions()
+    {
+        return array(
+            // none
+            array('SELECT * FROM Foo', true, array()),
+            array('SELECT * FROM Foo', false, array()),
+            
+            // Positionals
+            array('SELECT ?', true, array(7)),
+            array('SELECT * FROM Foo WHERE bar IN (?, ?, ?)', true, array(32, 35, 38)),
+            array('SELECT ? FROM ?', true, array(7, 14)),
+            array('SELECT "?" FROM foo', true, array()),
+            array("SELECT '?' FROM foo", true, array()),
+            array('SELECT "?" FROM foo WHERE bar = ?', true, array(32)),
+            array("SELECT '?' FROM foo WHERE bar = ?", true, array(32)),
+            
+            // named
+            array('SELECT :foo FROM :bar', false, array(':foo' => array(7), ':bar' => array(17))),
+            array('SELECT * FROM Foo WHERE bar IN (:name1, :name2)', false, array(':name1' => array(32), ':name2' => array(40))),
+            array('SELECT ":foo" FROM Foo WHERE bar IN (:name1, :name2)', false, array(':name1' => array(37), ':name2' => array(45))),
+            array("SELECT ':foo' FROM Foo WHERE bar IN (:name1, :name2)", false, array(':name1' => array(37), ':name2' => array(45))),
+        );
+    }
+    
+    /**
+     * @dataProvider dataGetPlaceholderPositions
+     * @param type $query
+     * @param type $isPositional
+     * @param type $expectedParamPos
+     */
+    public function testGetPlaceholderPositions($query, $isPositional, $expectedParamPos)
+    {
+        $actualParamPos = SQLParserUtils::getPlaceholderPositions($query, $isPositional);
+        $this->assertEquals($expectedParamPos, $actualParamPos);
+    }
+    
+    static public function dataExpandListParameters()
+    {
+        return array(
+            // Positional: Very simple with one needle
+            array(
+                "SELECT * FROM Foo WHERE foo IN (?)",
+                array(array(1, 2, 3)),
+                array(Connection::PARAM_INT_ARRAY),
+                'SELECT * FROM Foo WHERE foo IN (?, ?, ?)',
+                array(1, 2, 3),
+                array(\PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT)
+            ),
+            // Positional: One non-list before d one after list-needle
+            array(
+                "SELECT * FROM Foo WHERE foo = ? AND bar IN (?)",
+                array("string", array(1, 2, 3)),
+                array(\PDO::PARAM_STR, Connection::PARAM_INT_ARRAY),
+                'SELECT * FROM Foo WHERE foo = ? AND bar IN (?, ?, ?)',
+                array("string", 1, 2, 3),
+                array(\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT)
+            ),
+            // Positional: One non-list after list-needle
+            array(
+                "SELECT * FROM Foo WHERE bar IN (?) AND baz = ?",
+                array(array(1, 2, 3), "foo"),
+                array(Connection::PARAM_INT_ARRAY, \PDO::PARAM_STR),
+                'SELECT * FROM Foo WHERE bar IN (?, ?, ?) AND baz = ?',
+                array(1, 2, 3, "foo"),
+                array(\PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_STR)
+            ),
+            // Positional: One non-list before and one after list-needle
+            array(
+                "SELECT * FROM Foo WHERE foo = ? AND bar IN (?) AND baz = ?",
+                array(1, array(1, 2, 3), 4),
+                array(\PDO::PARAM_INT, Connection::PARAM_INT_ARRAY, \PDO::PARAM_INT),
+                'SELECT * FROM Foo WHERE foo = ? AND bar IN (?, ?, ?) AND baz = ?',
+                array(1, 1, 2, 3, 4),
+                array(\PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT)
+            ),
+            // Positional: Two lists
+            array(
+                "SELECT * FROM Foo WHERE foo IN (?, ?)",
+                array(array(1, 2, 3), array(4, 5)),
+                array(Connection::PARAM_INT_ARRAY, Connection::PARAM_INT_ARRAY),
+                'SELECT * FROM Foo WHERE foo IN (?, ?, ?, ?, ?)',
+                array(1, 2, 3, 4, 5),
+                array(\PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT, \PDO::PARAM_INT)
+            ),
+        );
+    }
+    
+    /**
+     * @dataProvider dataExpandListParameters
+     * @param type $q
+     * @param type $p
+     * @param type $t
+     * @param type $expectedQuery
+     * @param type $expectedParams
+     * @param type $expectedTypes
+     */
+    public function testExpandListParameters($q, $p, $t, $expectedQuery, $expectedParams, $expectedTypes)
+    {
+        list($query, $params, $types) = SQLParserUtils::expandListParameters($q, $p, $t);
+        
+        $this->assertEquals($expectedQuery, $query, "Query was not rewritten correctly.");
+        $this->assertEquals($expectedParams, $params, "Params dont match");
+        $this->assertEquals($expectedTypes, $types, "Types dont match");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/ColumnTest.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Types\Type;
+
+class ColumnTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGet()
+    {
+        $column = $this->createColumn();
+
+        $this->assertEquals("foo", $column->getName());
+        $this->assertSame(Type::getType('string'), $column->getType());
+
+        $this->assertEquals(200, $column->getLength());
+        $this->assertEquals(5, $column->getPrecision());
+        $this->assertEquals(2, $column->getScale());
+        $this->assertTrue($column->getUnsigned());
+        $this->assertFalse($column->getNotNull());
+        $this->assertTrue($column->getFixed());
+        $this->assertEquals("baz", $column->getDefault());
+
+        $this->assertEquals(array('foo' => 'bar'), $column->getPlatformOptions());
+        $this->assertTrue($column->hasPlatformOption('foo'));
+        $this->assertEquals('bar', $column->getPlatformOption('foo'));
+        $this->assertFalse($column->hasPlatformOption('bar'));
+    }
+
+    public function testToArray()
+    {
+        $expected = array(
+            'name' => 'foo',
+            'type' => Type::getType('string'),
+            'default' => 'baz',
+            'notnull' => false,
+            'length' => 200,
+            'precision' => 5,
+            'scale' => 2,
+            'fixed' => true,
+            'unsigned' => true,
+            'autoincrement' => false,
+            'columnDefinition' => null,
+            'comment' => null,
+            'foo' => 'bar',
+        );
+
+        $this->assertEquals($expected, $this->createColumn()->toArray());
+    }
+
+    /**
+     * @return Column
+     */
+    public function createColumn()
+    {
+        $options = array(
+            'length' => 200,
+            'precision' => 5,
+            'scale' => 2,
+            'unsigned' => true,
+            'notnull' => false,
+            'fixed' => true,
+            'default' => 'baz',
+            'platformOptions' => array('foo' => 'bar'),
+        );
+
+        $string = Type::getType('string');
+        return new Column("foo", $string, $options);
+    }
+
+    /**
+     * @group DBAL-64
+     */
+    public function testQuotedColumnName()
+    {
+        $string = Type::getType('string');
+        $column = new Column("`bar`", $string, array());
+
+        $mysqlPlatform = new \Doctrine\DBAL\Platforms\MySqlPlatform();
+        $sqlitePlatform = new \Doctrine\DBAL\Platforms\SqlitePlatform();
+
+        $this->assertEquals('bar', $column->getName());
+        $this->assertEquals('`bar`', $column->getQuotedName($mysqlPlatform));
+        $this->assertEquals('"bar"', $column->getQuotedName($sqlitePlatform));
+    }
+
+    /**
+     * @group DBAL-42
+     */
+    public function testColumnComment()
+    {
+        $column = new Column("bar", Type::getType('string'));
+        $this->assertNull($column->getComment());
+
+        $column->setComment("foo");
+        $this->assertEquals("foo", $column->getComment());
+
+        $columnArray = $column->toArray();
+        $this->assertArrayHasKey('comment', $columnArray);
+        $this->assertEquals('foo', $columnArray['comment']);
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/ComparatorTest.php

@@ -0,0 +1,714 @@
+<?php
+/*
+ * 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.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema,
+    Doctrine\DBAL\Schema\Table,
+    Doctrine\DBAL\Schema\Column,
+    Doctrine\DBAL\Schema\Index,
+    Doctrine\DBAL\Schema\Sequence,
+    Doctrine\DBAL\Schema\SchemaDiff,
+    Doctrine\DBAL\Schema\TableDiff,
+    Doctrine\DBAL\Schema\Comparator,
+    Doctrine\DBAL\Types\Type,
+    Doctrine\DBAL\Schema\ForeignKeyConstraint;
+
+/**
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link    www.doctrine-project.org
+ * @copyright Copyright (C) 2005-2009 eZ Systems AS. All rights reserved.
+ * @license http://ez.no/licenses/new_bsd New BSD License
+ * @since   2.0
+ * @version $Revision$
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class ComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCompareSame1()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer' ) ),
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer') ),
+                )
+            ),
+        ) );
+
+        $this->assertEquals(new SchemaDiff(), Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareSame2()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                )
+            ),
+        ) );
+        $this->assertEquals(new SchemaDiff(), Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareMissingTable()
+    {
+        $schemaConfig = new \Doctrine\DBAL\Schema\SchemaConfig;
+        $table = new Table('bugdb', array ('integerfield1' => new Column('integerfield1', Type::getType('integer'))));
+        $table->setSchemaConfig($schemaConfig);
+        
+        $schema1 = new Schema( array($table), array(), $schemaConfig );
+        $schema2 = new Schema( array(),       array(), $schemaConfig );
+
+        $expected = new SchemaDiff( array(), array(), array('bugdb' => $table) );
+        
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareNewTable()
+    {
+        $schemaConfig = new \Doctrine\DBAL\Schema\SchemaConfig;
+        $table = new Table('bugdb', array ('integerfield1' => new Column('integerfield1', Type::getType('integer'))));
+        $table->setSchemaConfig($schemaConfig);
+
+        $schema1 = new Schema( array(),       array(), $schemaConfig );
+        $schema2 = new Schema( array($table), array(), $schemaConfig );
+
+        $expected = new SchemaDiff( array('bugdb' => $table), array(), array() );
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareOnlyAutoincrementChanged()
+    {
+        $column1 = new Column('foo', Type::getType('integer'), array('autoincrement' => true));
+        $column2 = new Column('foo', Type::getType('integer'), array('autoincrement' => false));
+
+        $comparator = new Comparator();
+        $changedProperties = $comparator->diffColumn($column1, $column2);
+
+        $this->assertEquals(array('autoincrement'), $changedProperties);
+    }
+
+    public function testCompareMissingField()
+    {
+        $missingColumn = new Column('integerfield1', Type::getType('integer'));
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => $missingColumn,
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff( 'bugdb', array(), array(),
+                    array (
+                        'integerfield1' => $missingColumn,
+                    )
+                )
+            )
+        );
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareNewField()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff ('bugdb',
+                    array (
+                        'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                    )
+                ),
+            )
+        );
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareChangedColumns_ChangeType()
+    {
+        $column1 = new Column('charfield1', Type::getType('string'));
+        $column2 = new Column('charfield1', Type::getType('integer'));
+
+        $c = new Comparator();
+        $this->assertEquals(array('type'), $c->diffColumn($column1, $column2));
+        $this->assertEquals(array(), $c->diffColumn($column1, $column1));
+    }
+
+    public function testCompareRemovedIndex()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary',
+                        array(
+                            'integerfield1'
+                        ),
+                        true
+                    )
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff( 'bugdb', array(), array(), array(), array(), array(),
+                    array (
+                        'primary' => new Index('primary',
+                        array(
+                            'integerfield1'
+                        ),
+                        true
+                    )
+                    )
+                ),
+            )
+        );
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareNewIndex()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary',
+                        array(
+                            'integerfield1'
+                        ),
+                        true
+                    )
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff( 'bugdb', array(), array(), array(),
+                    array (
+                        'primary' => new Index('primary',
+                            array(
+                                'integerfield1'
+                            ),
+                            true
+                        )
+                    )
+                ),
+            )
+        );
+        $this->assertEquals($expected, Comparator::compareSchemas( $schema1, $schema2 ) );
+    }
+
+    public function testCompareChangedIndex()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary',
+                        array(
+                            'integerfield1'
+                        ),
+                        true
+                    )
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary',
+                        array('integerfield1', 'integerfield2'),
+                        true
+                    )
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff( 'bugdb', array(), array(), array(), array(),
+                    array (
+                        'primary' => new Index('primary',
+                            array(
+                                'integerfield1',
+                                'integerfield2'
+                            ),
+                            true
+                        )
+                    )
+                ),
+            )
+        );
+        $actual = Comparator::compareSchemas( $schema1, $schema2 );
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function testCompareChangedIndexFieldPositions()
+    {
+        $schema1 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary', array('integerfield1', 'integerfield2'), true)
+                )
+            ),
+        ) );
+        $schema2 = new Schema( array(
+            'bugdb' => new Table('bugdb',
+                array (
+                    'integerfield1' => new Column('integerfield1', Type::getType('integer')),
+                    'integerfield2' => new Column('integerfield2', Type::getType('integer')),
+                ),
+                array (
+                    'primary' => new Index('primary', array('integerfield2', 'integerfield1'), true)
+                )
+            ),
+        ) );
+
+        $expected = new SchemaDiff ( array(),
+            array (
+                'bugdb' => new TableDiff('bugdb', array(), array(), array(), array(),
+                    array (
+                        'primary' => new Index('primary', array('integerfield2', 'integerfield1'), true)
+                    )
+                ),
+            )
+        );
+        $actual = Comparator::compareSchemas( $schema1, $schema2 );
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function testCompareSequences()
+    {
+        $seq1 = new Sequence('foo', 1, 1);
+        $seq2 = new Sequence('foo', 1, 2);
+        $seq3 = new Sequence('foo', 2, 1);
+
+        $c = new Comparator();
+
+        $this->assertTrue($c->diffSequence($seq1, $seq2));
+        $this->assertTrue($c->diffSequence($seq1, $seq3));
+    }
+
+    public function testRemovedSequence()
+    {
+        $schema1 = new Schema();
+        $seq = $schema1->createSequence('foo');
+
+        $schema2 = new Schema();
+
+        $c = new Comparator();
+        $diffSchema = $c->compare($schema1, $schema2);
+
+        $this->assertEquals(1, count($diffSchema->removedSequences));
+        $this->assertSame($seq, $diffSchema->removedSequences[0]);
+    }
+
+    public function testAddedSequence()
+    {
+        $schema1 = new Schema();
+
+        $schema2 = new Schema();
+        $seq = $schema2->createSequence('foo');
+
+        $c = new Comparator();
+        $diffSchema = $c->compare($schema1, $schema2);
+
+        $this->assertEquals(1, count($diffSchema->newSequences));
+        $this->assertSame($seq, $diffSchema->newSequences[0]);
+    }
+
+    public function testTableAddForeignKey()
+    {
+        $tableForeign = new Table("bar");
+        $tableForeign->addColumn('id', 'integer');
+
+        $table1 = new Table("foo");
+        $table1->addColumn('fk', 'integer');
+
+        $table2 = new Table("foo");
+        $table2->addColumn('fk', 'integer');
+        $table2->addForeignKeyConstraint($tableForeign, array('fk'), array('id'));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($table1, $table2);
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $tableDiff);
+        $this->assertEquals(1, count($tableDiff->addedForeignKeys));
+    }
+
+    public function testTableRemoveForeignKey()
+    {
+        $tableForeign = new Table("bar");
+        $tableForeign->addColumn('id', 'integer');
+
+        $table1 = new Table("foo");
+        $table1->addColumn('fk', 'integer');
+
+        $table2 = new Table("foo");
+        $table2->addColumn('fk', 'integer');
+        $table2->addForeignKeyConstraint($tableForeign, array('fk'), array('id'));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($table2, $table1);
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $tableDiff);
+        $this->assertEquals(1, count($tableDiff->removedForeignKeys));
+    }
+
+    public function testTableUpdateForeignKey()
+    {
+        $tableForeign = new Table("bar");
+        $tableForeign->addColumn('id', 'integer');
+
+        $table1 = new Table("foo");
+        $table1->addColumn('fk', 'integer');
+        $table1->addForeignKeyConstraint($tableForeign, array('fk'), array('id'));
+
+        $table2 = new Table("foo");
+        $table2->addColumn('fk', 'integer');
+        $table2->addForeignKeyConstraint($tableForeign, array('fk'), array('id'), array('onUpdate' => 'CASCADE'));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($table1, $table2);
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $tableDiff);
+        $this->assertEquals(1, count($tableDiff->changedForeignKeys));
+    }
+
+    public function testTablesCaseInsensitive()
+    {
+        $schemaA = new Schema();
+        $schemaA->createTable('foo');
+        $schemaA->createTable('bAr');
+        $schemaA->createTable('BAZ');
+        $schemaA->createTable('new');
+
+        $schemaB = new Schema();
+        $schemaB->createTable('FOO');
+        $schemaB->createTable('bar');
+        $schemaB->createTable('Baz');
+        $schemaB->createTable('old');
+
+        $c = new Comparator();
+        $diff = $c->compare($schemaA, $schemaB);
+
+        $this->assertSchemaTableChangeCount($diff, 1, 0, 1);
+    }
+
+    public function testSequencesCaseInsenstive()
+    {
+        $schemaA = new Schema();
+        $schemaA->createSequence('foo');
+        $schemaA->createSequence('BAR');
+        $schemaA->createSequence('Baz');
+        $schemaA->createSequence('new');
+
+        $schemaB = new Schema();
+        $schemaB->createSequence('FOO');
+        $schemaB->createSequence('Bar');
+        $schemaB->createSequence('baz');
+        $schemaB->createSequence('old');
+        
+        $c = new Comparator();
+        $diff = $c->compare($schemaA, $schemaB);
+
+        $this->assertSchemaSequenceChangeCount($diff, 1, 0, 1);
+    }
+
+    public function testCompareColumnCompareCaseInsensitive()
+    {
+        $tableA = new Table("foo");
+        $tableA->addColumn('id', 'integer');
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('ID', 'integer');
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertFalse($tableDiff);
+    }
+
+    public function testCompareIndexBasedOnPropertiesNotName()
+    {
+        $tableA = new Table("foo");
+        $tableA->addColumn('id', 'integer');
+        $tableA->addIndex(array("id"), "foo_bar_idx");
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('ID', 'integer');
+        $tableB->addIndex(array("id"), "bar_foo_idx");
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertFalse($tableDiff);
+    }
+
+    public function testCompareForeignKeyBasedOnPropertiesNotName()
+    {
+        $tableA = new Table("foo");
+        $tableA->addColumn('id', 'integer');
+        $tableA->addNamedForeignKeyConstraint('foo_constraint', 'bar', array('id'), array('id'));
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('ID', 'integer');
+        $tableB->addNamedForeignKeyConstraint('bar_constraint', 'bar', array('id'), array('id'));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertFalse($tableDiff);
+    }
+
+    public function testCompareForeignKey_RestrictNoAction_AreTheSame()
+    {
+        $fk1 = new ForeignKeyConstraint(array("foo"), "bar", array("baz"), "fk1", array('onDelete' => 'NO ACTION'));
+        $fk2 = new ForeignKeyConstraint(array("foo"), "bar", array("baz"), "fk1", array('onDelete' => 'RESTRICT'));
+
+        $c = new Comparator();
+        $this->assertFalse($c->diffForeignKey($fk1, $fk2));
+    }
+
+    public function testDetectRenameColumn()
+    {
+        $tableA = new Table("foo");
+        $tableA->addColumn('foo', 'integer');
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('bar', 'integer');
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertEquals(0, count($tableDiff->addedColumns));
+        $this->assertEquals(0, count($tableDiff->removedColumns));
+        $this->assertArrayHasKey('foo', $tableDiff->renamedColumns);
+        $this->assertEquals('bar', $tableDiff->renamedColumns['foo']->getName());
+    }
+
+    /**
+     * You can easily have ambiguouties in the column renaming. If these
+     * are detected no renaming should take place, instead adding and dropping
+     * should be used exclusively.
+     *
+     * @group DBAL-24
+     */
+    public function testDetectRenameColumnAmbiguous()
+    {
+        $tableA = new Table("foo");
+        $tableA->addColumn('foo', 'integer');
+        $tableA->addColumn('bar', 'integer');
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('baz', 'integer');
+        
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertEquals(1, count($tableDiff->addedColumns), "'baz' should be added, not created through renaming!");
+        $this->assertArrayHasKey('baz', $tableDiff->addedColumns, "'baz' should be added, not created through renaming!");
+        $this->assertEquals(2, count($tableDiff->removedColumns), "'foo' and 'bar' should both be dropped, an ambigouty exists which one could be renamed to 'baz'.");
+        $this->assertArrayHasKey('foo', $tableDiff->removedColumns, "'foo' should be removed.");
+        $this->assertArrayHasKey('bar', $tableDiff->removedColumns, "'bar' should be removed.");
+        $this->assertEquals(0, count($tableDiff->renamedColumns), "no renamings should take place.");
+    }
+
+    public function testDetectChangeIdentifierType()
+    {
+        $this->markTestSkipped('DBAL-2 was reopened, this test cannot work anymore.');
+
+        $tableA = new Table("foo");
+        $tableA->addColumn('id', 'integer', array('autoincrement' => false));
+
+        $tableB = new Table("foo");
+        $tableB->addColumn('id', 'integer', array('autoincrement' => true));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($tableA, $tableB);
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $tableDiff);
+        $this->assertArrayHasKey('id', $tableDiff->changedColumns);
+    }
+
+
+    /**
+     * @group DBAL-105
+     */
+    public function testDiff()
+    {
+        $table = new \Doctrine\DBAL\Schema\Table('twitter_users');
+        $table->addColumn('id', 'integer', array('autoincrement' => true));
+        $table->addColumn('twitterId', 'integer', array('nullable' => false));
+        $table->addColumn('displayName', 'string', array('nullable' => false));
+        $table->setPrimaryKey(array('id'));
+
+        $newtable = new \Doctrine\DBAL\Schema\Table('twitter_users');
+        $newtable->addColumn('id', 'integer', array('autoincrement' => true));
+        $newtable->addColumn('twitter_id', 'integer', array('nullable' => false));
+        $newtable->addColumn('display_name', 'string', array('nullable' => false));
+        $newtable->addColumn('logged_in_at', 'datetime', array('nullable' => true));
+        $newtable->setPrimaryKey(array('id'));
+
+        $c = new Comparator();
+        $tableDiff = $c->diffTable($table, $newtable);
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\TableDiff', $tableDiff);
+        $this->assertEquals(array('twitterid', 'displayname'), array_keys($tableDiff->renamedColumns));
+        $this->assertEquals(array('logged_in_at'), array_keys($tableDiff->addedColumns));
+        $this->assertEquals(0, count($tableDiff->removedColumns));
+    }
+    
+    
+    /**
+     * @group DBAL-112
+     */
+    public function testChangedSequence()
+    {
+        $schema = new Schema();
+        $sequence = $schema->createSequence('baz');
+        
+        $schemaNew = clone $schema;
+        /* @var $schemaNew Schema */
+        $schemaNew->getSequence('baz')->setAllocationSize(20);
+        
+        $c = new \Doctrine\DBAL\Schema\Comparator;
+        $diff = $c->compare($schema, $schemaNew);
+        
+        $this->assertSame($diff->changedSequences[0] , $schemaNew->getSequence('baz'));
+    }
+
+    /**
+     * @group DBAL-106
+     */
+    public function testDiffDecimalWithNullPrecision()
+    {
+        $column = new Column('foo', Type::getType('decimal'));
+        $column->setPrecision(null);
+
+        $column2 = new Column('foo', Type::getType('decimal'));
+
+        $c = new Comparator();
+        $this->assertEquals(array(), $c->diffColumn($column, $column2));
+    }
+
+    /**
+     * @param SchemaDiff $diff
+     * @param int $newTableCount
+     * @param int $changeTableCount
+     * @param int $removeTableCount
+     */
+    public function assertSchemaTableChangeCount($diff, $newTableCount=0, $changeTableCount=0, $removeTableCount=0)
+    {
+        $this->assertEquals($newTableCount, count($diff->newTables));
+        $this->assertEquals($changeTableCount, count($diff->changedTables));
+        $this->assertEquals($removeTableCount, count($diff->removedTables));
+    }
+
+    /**
+     * @param SchemaDiff $diff
+     * @param int $newSequenceCount
+     * @param int $changeSequenceCount
+     * @param int $changeSequenceCount
+     */
+    public function assertSchemaSequenceChangeCount($diff, $newSequenceCount=0, $changeSequenceCount=0, $removeSequenceCount=0)
+    {
+        $this->assertEquals($newSequenceCount, count($diff->newSequences), "Expected number of new sequences is wrong.");
+        $this->assertEquals($changeSequenceCount, count($diff->changedSequences), "Expected number of changed sequences is wrong.");
+        $this->assertEquals($removeSequenceCount, count($diff->removedSequences), "Expected number of removed sequences is wrong.");
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/IndexTest.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\Index;
+
+class IndexTest extends \PHPUnit_Framework_TestCase
+{
+    public function createIndex($unique=false, $primary=false)
+    {
+        return new Index("foo", array("bar", "baz"), $unique, $primary);
+    }
+
+    public function testCreateIndex()
+    {
+        $idx = $this->createIndex();
+        $this->assertEquals("foo", $idx->getName());
+        $columns = $idx->getColumns();
+        $this->assertEquals(2, count($columns));
+        $this->assertEquals(array("bar", "baz"), $columns);
+        $this->assertFalse($idx->isUnique());
+        $this->assertFalse($idx->isPrimary());
+    }
+
+    public function testCreatePrimary()
+    {
+        $idx = $this->createIndex(false, true);
+        $this->assertTrue($idx->isUnique());
+        $this->assertTrue($idx->isPrimary());
+    }
+
+    public function testCreateUnique()
+    {
+        $idx = $this->createIndex(true, false);
+        $this->assertTrue($idx->isUnique());
+        $this->assertFalse($idx->isPrimary());
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testFullfilledByUnique()
+    {
+        $idx1 = $this->createIndex(true, false);
+        $idx2 = $this->createIndex(true, false);
+        $idx3 = $this->createIndex();
+
+        $this->assertTrue($idx1->isFullfilledBy($idx2));
+        $this->assertFalse($idx1->isFullfilledBy($idx3));
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testFullfilledByPrimary()
+    {
+        $idx1 = $this->createIndex(true, true);
+        $idx2 = $this->createIndex(true, true);
+        $idx3 = $this->createIndex(true, false);
+
+        $this->assertTrue($idx1->isFullfilledBy($idx2));
+        $this->assertFalse($idx1->isFullfilledBy($idx3));
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testFullfilledByIndex()
+    {
+        $idx1 = $this->createIndex();
+        $idx2 = $this->createIndex();
+        $pri = $this->createIndex(true, true);
+        $uniq = $this->createIndex(true);
+
+        $this->assertTrue($idx1->isFullfilledBy($idx2));
+        $this->assertTrue($idx1->isFullfilledBy($pri));
+        $this->assertTrue($idx1->isFullfilledBy($uniq));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/Platforms/MySQLSchemaTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema\Platforms;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Types\Type;
+
+class MySQLSchemaTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var Comparator
+     */
+    private $comparator;
+    /**
+     *
+     * @var \Doctrine\DBAL\Platforms\AbstractPlatform
+     */
+    private $platform;
+
+    public function setUp()
+    {
+        $this->comparator = new \Doctrine\DBAL\Schema\Comparator;
+        $this->platform = new \Doctrine\DBAL\Platforms\MySqlPlatform;
+    }
+
+    public function testSwitchPrimaryKeyOrder()
+    {
+        $tableOld = new Table("test");
+        $tableOld->addColumn('foo_id', 'integer');
+        $tableOld->addColumn('bar_id', 'integer');
+        $tableNew = clone $tableOld;
+
+        $tableOld->setPrimaryKey(array('foo_id', 'bar_id'));
+        $tableNew->setPrimaryKey(array('bar_id', 'foo_id'));
+
+        $diff = $this->comparator->diffTable($tableOld, $tableNew);
+        $sql = $this->platform->getAlterTableSQL($diff);
+
+        $this->assertEquals(
+            array(
+                'ALTER TABLE test DROP PRIMARY KEY',
+                'ALTER TABLE test ADD PRIMARY KEY (bar_id, foo_id)'
+            ), $sql
+        );
+    }
+
+    /**
+     * @group DBAL-132
+     */
+    public function testGenerateForeignKeySQL()
+    {
+        $tableOld = new Table("test");
+        $tableOld->addColumn('foo_id', 'integer');
+        $tableOld->addUnnamedForeignKeyConstraint('test_foreign', array('foo_id'), array('foo_id'));
+
+        $sqls = array();
+        foreach ($tableOld->getForeignKeys() AS $fk) {
+            $sqls[] = $this->platform->getCreateForeignKeySQL($fk, $tableOld);
+        }
+
+        $this->assertEquals(array("ALTER TABLE test ADD CONSTRAINT FK_D87F7E0C8E48560F FOREIGN KEY (foo_id) REFERENCES test_foreign(foo_id)"), $sqls);
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/SchemaDiffTest.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema,
+    Doctrine\DBAL\Schema\Table,
+    Doctrine\DBAL\Schema\Column,
+    Doctrine\DBAL\Schema\Index,
+    Doctrine\DBAL\Schema\Sequence,
+    Doctrine\DBAL\Schema\SchemaDiff,
+    Doctrine\DBAL\Schema\TableDiff,
+    Doctrine\DBAL\Schema\Comparator,
+    Doctrine\DBAL\Types\Type;
+
+class SchemaDiffTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSchemaDiffToSql()
+    {
+        $diff = $this->createSchemaDiff();
+        $platform = $this->createPlatform(true);
+
+        $sql = $diff->toSql($platform);
+
+        $expected = array('drop_orphan_fk', 'alter_seq', 'drop_seq', 'create_seq', 'create_table', 'create_foreign_key', 'drop_table', 'alter_table');
+
+        $this->assertEquals($expected, $sql);
+    }
+
+    public function testSchemaDiffToSaveSql()
+    {
+        $diff = $this->createSchemaDiff();
+        $platform = $this->createPlatform(false);
+
+        $sql = $diff->toSaveSql($platform);
+
+        $expected = array('alter_seq', 'create_seq', 'create_table', 'create_foreign_key', 'alter_table');
+
+        $this->assertEquals($expected, $sql);
+    }
+
+    public function createPlatform($unsafe = false)
+    {
+        $platform = $this->getMock('Doctrine\Tests\DBAL\Mocks\MockPlatform');
+        if ($unsafe) {
+            $platform->expects($this->exactly(1))
+                 ->method('getDropSequenceSql')
+                 ->with($this->isInstanceOf('Doctrine\DBAL\Schema\Sequence'))
+                 ->will($this->returnValue('drop_seq'));
+        }
+        $platform->expects($this->exactly(1))
+                 ->method('getAlterSequenceSql')
+                 ->with($this->isInstanceOf('Doctrine\DBAL\Schema\Sequence'))
+                 ->will($this->returnValue('alter_seq'));
+        $platform->expects($this->exactly(1))
+                 ->method('getCreateSequenceSql')
+                 ->with($this->isInstanceOf('Doctrine\DBAL\Schema\Sequence'))
+                 ->will($this->returnValue('create_seq'));
+        if ($unsafe) {
+            $platform->expects($this->exactly(1))
+                     ->method('getDropTableSql')
+                     ->with($this->isInstanceof('Doctrine\DBAL\Schema\Table'))
+                     ->will($this->returnValue('drop_table'));
+        }
+        $platform->expects($this->exactly(1))
+                 ->method('getCreateTableSql')
+                 ->with($this->isInstanceof('Doctrine\DBAL\Schema\Table'))
+                 ->will($this->returnValue(array('create_table')));
+        $platform->expects($this->exactly(1))
+                 ->method('getCreateForeignKeySQL')
+                 ->with($this->isInstanceOf('Doctrine\DBAL\Schema\ForeignKeyConstraint'))
+                 ->will($this->returnValue('create_foreign_key'));
+        $platform->expects($this->exactly(1))
+                 ->method('getAlterTableSql')
+                 ->with($this->isInstanceOf('Doctrine\DBAL\Schema\TableDiff'))
+                 ->will($this->returnValue(array('alter_table')));
+        if ($unsafe) {
+            $platform->expects($this->exactly(1))
+                     ->method('getDropForeignKeySql')
+                     ->with($this->isInstanceof('Doctrine\DBAL\Schema\ForeignKeyConstraint'), $this->equalTo('local_table'))
+                     ->will($this->returnValue('drop_orphan_fk'));
+        }
+        $platform->expects($this->exactly(1))
+                ->method('supportsSequences')
+                ->will($this->returnValue(true));
+        $platform->expects($this->exactly(2))
+                ->method('supportsForeignKeyConstraints')
+                ->will($this->returnValue(true));
+        return $platform;
+    }
+
+    public function createSchemaDiff()
+    {
+        $diff = new SchemaDiff();
+        $diff->changedSequences['foo_seq'] = new Sequence('foo_seq');
+        $diff->newSequences['bar_seq'] = new Sequence('bar_seq');
+        $diff->removedSequences['baz_seq'] = new Sequence('baz_seq');
+        $diff->newTables['foo_table'] = new Table('foo_table');
+        $diff->removedTables['bar_table'] = new Table('bar_table');
+        $diff->changedTables['baz_table'] = new TableDiff('baz_table');
+        $diff->newTables['foo_table']->addColumn('foreign_id', 'integer');
+        $diff->newTables['foo_table']->addForeignKeyConstraint('foreign_table', array('foreign_id'), array('id'));
+        $fk = new \Doctrine\DBAL\Schema\ForeignKeyConstraint(array('id'), 'foreign_table', array('id'));
+        $fk->setLocalTable(new Table('local_table'));
+        $diff->orphanedForeignKeys[] = $fk;
+        return $diff;
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/SchemaTest.php

@@ -0,0 +1,211 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\Sequence;
+
+class SchemaTest extends \PHPUnit_Framework_TestCase
+{
+    public function testAddTable()
+    {
+        $tableName = "foo";
+        $table = new Table($tableName);
+
+        $schema = new Schema(array($table));
+
+        $this->assertTrue($schema->hasTable($tableName));
+
+        $tables = $schema->getTables();
+        $this->assertTrue( isset($tables[$tableName]) );
+        $this->assertSame($table, $tables[$tableName]);
+        $this->assertSame($table, $schema->getTable($tableName));
+        $this->assertTrue($schema->hasTable($tableName));
+    }
+
+    public function testTableMatchingCaseInsenstive()
+    {
+        $table = new Table("Foo");
+
+        $schema = new Schema(array($table));
+        $this->assertTrue($schema->hasTable("foo"));
+        $this->assertTrue($schema->hasTable("FOO"));
+
+        $this->assertSame($table, $schema->getTable('FOO'));
+        $this->assertSame($table, $schema->getTable('foo'));
+        $this->assertSame($table, $schema->getTable('Foo'));
+    }
+
+    public function testGetUnknownTableThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $schema = new Schema();
+        $schema->getTable("unknown");
+    }
+
+    public function testCreateTableTwiceThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $tableName = "foo";
+        $table = new Table($tableName);
+        $tables = array($table, $table);
+
+        $schema = new Schema($tables);
+    }
+
+    public function testRenameTable()
+    {
+        $tableName = "foo";
+        $table = new Table($tableName);
+        $schema = new Schema(array($table));
+
+        $this->assertTrue($schema->hasTable("foo"));
+        $schema->renameTable("foo", "bar");
+        $this->assertFalse($schema->hasTable("foo"));
+        $this->assertTrue($schema->hasTable("bar"));
+        $this->assertSame($table, $schema->getTable("bar"));
+    }
+
+    public function testDropTable()
+    {
+        $tableName = "foo";
+        $table = new Table($tableName);
+        $schema = new Schema(array($table));
+
+        $this->assertTrue($schema->hasTable("foo"));
+
+        $schema->dropTable("foo");
+
+        $this->assertFalse($schema->hasTable("foo"));
+    }
+
+    public function testCreateTable()
+    {
+        $schema = new Schema();
+
+        $this->assertFalse($schema->hasTable("foo"));
+
+        $table = $schema->createTable("foo");
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Table', $table);
+        $this->assertEquals("foo", $table->getName());
+        $this->assertTrue($schema->hasTable("foo"));
+    }
+
+    public function testAddSequences()
+    {
+        $sequence = new Sequence("a_seq", 1, 1);
+
+        $schema = new Schema(array(), array($sequence));
+
+        $this->assertTrue($schema->hasSequence("a_seq"));
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Sequence', $schema->getSequence("a_seq"));
+
+        $sequences = $schema->getSequences();
+        $this->assertArrayHasKey('a_seq', $sequences);
+    }
+
+    public function testSequenceAccessCaseInsensitive()
+    {
+        $sequence = new Sequence("a_Seq");
+
+        $schema = new Schema(array(), array($sequence));
+        $this->assertTrue($schema->hasSequence('a_seq'));
+        $this->assertTrue($schema->hasSequence('a_Seq'));
+        $this->assertTrue($schema->hasSequence('A_SEQ'));
+
+        $this->assertEquals($sequence, $schema->getSequence('a_seq'));
+        $this->assertEquals($sequence, $schema->getSequence('a_Seq'));
+        $this->assertEquals($sequence, $schema->getSequence('A_SEQ'));
+    }
+
+    public function testGetUnknownSequenceThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $schema = new Schema();
+        $schema->getSequence("unknown");
+    }
+
+    public function testCreateSequence()
+    {
+        $schema = new Schema();
+        $sequence = $schema->createSequence('a_seq', 10, 20);
+
+        $this->assertEquals('a_seq', $sequence->getName());
+        $this->assertEquals(10, $sequence->getAllocationSize());
+        $this->assertEquals(20, $sequence->getInitialValue());
+
+        $this->assertTrue($schema->hasSequence("a_seq"));
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Sequence', $schema->getSequence("a_seq"));
+
+        $sequences = $schema->getSequences();
+        $this->assertArrayHasKey('a_seq', $sequences);
+    }
+
+    public function testDropSequence()
+    {
+        $sequence = new Sequence("a_seq", 1, 1);
+
+        $schema = new Schema(array(), array($sequence));
+
+        $schema->dropSequence("a_seq");
+        $this->assertFalse($schema->hasSequence("a_seq"));
+    }
+
+    public function testAddSequenceTwiceThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $sequence = new Sequence("a_seq", 1, 1);
+
+        $schema = new Schema(array(), array($sequence, $sequence));
+    }
+
+    public function testConfigMaxIdentifierLength()
+    {
+        $schemaConfig = new \Doctrine\DBAL\Schema\SchemaConfig();
+        $schemaConfig->setMaxIdentifierLength(5);
+
+        $schema = new Schema(array(), array(), $schemaConfig);
+        $table = $schema->createTable("smalltable");
+        $table->addColumn('long_id', 'integer');
+        $table->addIndex(array('long_id'));
+
+        $index = current($table->getIndexes());
+        $this->assertEquals(5, strlen($index->getName()));
+    }
+
+    public function testDeepClone()
+    {
+        $schema = new Schema();
+        $sequence = $schema->createSequence('baz');
+
+        $tableA = $schema->createTable('foo');
+        $tableA->addColumn('id', 'integer');
+
+        $tableB = $schema->createTable('bar');
+        $tableB->addColumn('id', 'integer');
+        $tableB->addColumn('foo_id', 'integer');
+        $tableB->addForeignKeyConstraint($tableA, array('foo_id'), array('id'));
+
+        $schemaNew = clone $schema;
+
+        $this->assertNotSame($sequence, $schemaNew->getSequence('baz'));
+
+        $this->assertNotSame($tableA, $schemaNew->getTable('foo'));
+        $this->assertNotSame($tableA->getColumn('id'), $schemaNew->getTable('foo')->getColumn('id'));
+
+        $this->assertNotSame($tableB, $schemaNew->getTable('bar'));
+        $this->assertNotSame($tableB->getColumn('id'), $schemaNew->getTable('bar')->getColumn('id'));
+
+        $fk = $schemaNew->getTable('bar')->getForeignKeys();
+        $fk = current($fk);
+        $this->assertSame($schemaNew->getTable('bar'), $this->readAttribute($fk, '_localTable'));
+    }
+}

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Schema/TableTest.php

@@ -0,0 +1,476 @@
+<?php
+
+namespace Doctrine\Tests\DBAL\Schema;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\TableBuilder;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\Index;
+use Doctrine\DBAL\Schema\ForeignKeyConstraint;
+use Doctrine\DBAL\Types\Type;
+
+class TableTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCreateWithInvalidTableName()
+    {
+        $this->setExpectedException('Doctrine\DBAL\DBALException');
+        $table = new \Doctrine\DBAL\Schema\Table('');
+    }
+
+    public function testGetName()
+    {
+        $table =  new Table("foo", array(), array(), array());
+        $this->assertEquals("foo", $table->getName());
+    }
+
+    public function testColumns()
+    {
+        $type = Type::getType('integer');
+        $columns = array();
+        $columns[] = new Column("foo", $type);
+        $columns[] = new Column("bar", $type);
+        $table = new Table("foo", $columns, array(), array());
+
+        $this->assertTrue($table->hasColumn("foo"));
+        $this->assertTrue($table->hasColumn("bar"));
+        $this->assertFalse($table->hasColumn("baz"));
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Column', $table->getColumn("foo"));
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Column', $table->getColumn("bar"));
+
+        $this->assertEquals(2, count($table->getColumns()));
+    }
+
+    public function testColumnsCaseInsensitive()
+    {
+        $table = new Table("foo");
+        $column = $table->addColumn('Foo', 'integer');
+
+        $this->assertTrue($table->hasColumn('Foo'));
+        $this->assertTrue($table->hasColumn('foo'));
+        $this->assertTrue($table->hasColumn('FOO'));
+
+        $this->assertSame($column, $table->getColumn('Foo'));
+        $this->assertSame($column, $table->getColumn('foo'));
+        $this->assertSame($column, $table->getColumn('FOO'));
+    }
+
+    public function testCreateColumn()
+    {
+        $type = Type::getType('integer');
+
+        $table = new Table("foo");
+
+        $this->assertFalse($table->hasColumn("bar"));
+        $table->addColumn("bar", 'integer');
+        $this->assertTrue($table->hasColumn("bar"));
+        $this->assertSame($type, $table->getColumn("bar")->getType());
+    }
+
+    public function testDropColumn()
+    {
+        $type = Type::getType('integer');
+        $columns = array();
+        $columns[] = new Column("foo", $type);
+        $columns[] = new Column("bar", $type);
+        $table = new Table("foo", $columns, array(), array());
+
+        $this->assertTrue($table->hasColumn("foo"));
+        $this->assertTrue($table->hasColumn("bar"));
+
+        $table->dropColumn("foo")->dropColumn("bar");
+
+        $this->assertFalse($table->hasColumn("foo"));
+        $this->assertFalse($table->hasColumn("bar"));
+    }
+
+    public function testGetUnknownColumnThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo", array(), array(), array());
+        $table->getColumn('unknown');
+    }
+
+    public function testAddColumnTwiceThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array();
+        $columns[] = new Column("foo", $type);
+        $columns[] = new Column("foo", $type);
+        $table = new Table("foo", $columns, array(), array());
+    }
+
+    public function testCreateIndex()
+    {
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array(new Column("foo", $type), new Column("bar", $type), new Column("baz", $type));
+        $table = new Table("foo", $columns);
+        
+        $table->addIndex(array("foo", "bar"), "foo_foo_bar_idx");
+        $table->addUniqueIndex(array("bar", "baz"), "foo_bar_baz_uniq");
+
+        $this->assertTrue($table->hasIndex("foo_foo_bar_idx"));
+        $this->assertTrue($table->hasIndex("foo_bar_baz_uniq"));
+    }
+
+    public function testIndexCaseInsensitive()
+    {
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array(
+            new Column("foo", $type),
+            new Column("bar", $type),
+            new Column("baz", $type)
+        );
+        $table = new Table("foo", $columns);
+
+        $table->addIndex(array("foo", "bar", "baz"), "Foo_Idx");
+
+        $this->assertTrue($table->hasIndex('foo_idx'));
+        $this->assertTrue($table->hasIndex('Foo_Idx'));
+        $this->assertTrue($table->hasIndex('FOO_IDX'));
+    }
+
+    public function testAddIndexes()
+    {
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array(
+            new Column("foo", $type),
+            new Column("bar", $type),
+        );
+        $indexes = array(
+            new Index("the_primary", array("foo"), true, true),
+            new Index("bar_idx", array("bar"), false, false),
+        );
+        $table = new Table("foo", $columns, $indexes, array());
+
+        $this->assertTrue($table->hasIndex("the_primary"));
+        $this->assertTrue($table->hasIndex("bar_idx"));
+        $this->assertFalse($table->hasIndex("some_idx"));
+
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Index', $table->getPrimaryKey());
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Index', $table->getIndex('the_primary'));
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Index', $table->getIndex('bar_idx'));
+    }
+
+    public function testGetUnknownIndexThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo", array(), array(), array());
+        $table->getIndex("unknownIndex");
+    }
+
+    public function testAddTwoPrimaryThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array(new Column("foo", $type), new Column("bar", $type));
+        $indexes = array(
+            new Index("the_primary", array("foo"), true, true),
+            new Index("other_primary", array("bar"), true, true),
+        );
+        $table = new Table("foo", $columns, $indexes, array());
+    }
+
+    public function testAddTwoIndexesWithSameNameThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $type = \Doctrine\DBAL\Types\Type::getType('integer');
+        $columns = array(new Column("foo", $type), new Column("bar", $type));
+        $indexes = array(
+            new Index("an_idx", array("foo"), false, false),
+            new Index("an_idx", array("bar"), false, false),
+        );
+        $table = new Table("foo", $columns, $indexes, array());
+    }
+
+    public function testConstraints()
+    {
+        $constraint = new ForeignKeyConstraint(array(), "foo", array());
+
+        $tableA = new Table("foo", array(), array(), array($constraint));
+        $constraints = $tableA->getForeignKeys();
+
+        $this->assertEquals(1, count($constraints));
+        $this->assertSame($constraint, array_shift($constraints));
+    }
+
+    public function testOptions()
+    {
+        $table = new Table("foo", array(), array(), array(), false, array("foo" => "bar"));
+
+        $this->assertTrue($table->hasOption("foo"));
+        $this->assertEquals("bar", $table->getOption("foo"));
+    }
+
+    public function testBuilderSetPrimaryKey()
+    {
+        $table = new Table("foo");
+
+        $table->addColumn("bar", 'integer');
+        $table->setPrimaryKey(array("bar"));
+
+        $this->assertTrue($table->hasIndex("primary"));
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\Index', $table->getPrimaryKey());
+        $this->assertTrue($table->getIndex("primary")->isUnique());
+        $this->assertTrue($table->getIndex("primary")->isPrimary());
+    }
+
+    public function testBuilderAddUniqueIndex()
+    {
+        $table = new Table("foo");
+
+        $table->addColumn("bar", 'integer');
+        $table->addUniqueIndex(array("bar"), "my_idx");
+
+        $this->assertTrue($table->hasIndex("my_idx"));
+        $this->assertTrue($table->getIndex("my_idx")->isUnique());
+        $this->assertFalse($table->getIndex("my_idx")->isPrimary());
+    }
+
+    public function testBuilderAddIndex()
+    {
+        $table = new Table("foo");
+
+        $table->addColumn("bar", 'integer');
+        $table->addIndex(array("bar"), "my_idx");
+
+        $this->assertTrue($table->hasIndex("my_idx"));
+        $this->assertFalse($table->getIndex("my_idx")->isUnique());
+        $this->assertFalse($table->getIndex("my_idx")->isPrimary());
+    }
+
+    public function testBuilderAddIndexWithInvalidNameThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo");
+        $table->addColumn("bar",'integer');
+        $table->addIndex(array("bar"), "invalid name %&/");
+    }
+
+    public function testBuilderAddIndexWithUnknownColumnThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo");
+        $table->addIndex(array("bar"), "invalidName");
+    }
+
+    public function testBuilderOptions()
+    {
+        $table = new Table("foo");
+        $table->addOption("foo", "bar");
+        $this->assertTrue($table->hasOption("foo"));
+        $this->assertEquals("bar", $table->getOption("foo"));
+    }
+
+    public function testAddForeignKeyConstraint_UnknownLocalColumn_ThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo");
+        $table->addColumn("id", 'integer');
+
+        $foreignTable = new Table("bar");
+        $foreignTable->addColumn("id", 'integer');
+
+        $table->addForeignKeyConstraint($foreignTable, array("foo"), array("id"));
+    }
+
+    public function testAddForeignKeyConstraint_UnknownForeignColumn_ThrowsException()
+    {
+        $this->setExpectedException("Doctrine\DBAL\Schema\SchemaException");
+
+        $table = new Table("foo");
+        $table->addColumn("id", 'integer');
+
+        $foreignTable = new Table("bar");
+        $foreignTable->addColumn("id", 'integer');
+
+        $table->addForeignKeyConstraint($foreignTable, array("id"), array("foo"));
+    }
+
+    public function testAddForeignKeyConstraint()
+    {
+        $table = new Table("foo");
+        $table->addColumn("id", 'integer');
+
+        $foreignTable = new Table("bar");
+        $foreignTable->addColumn("id", 'integer');
+
+        $table->addForeignKeyConstraint($foreignTable, array("id"), array("id"), array("foo" => "bar"));
+
+        $constraints = $table->getForeignKeys();
+        $this->assertEquals(1, count($constraints));
+        $constraint = current($constraints);
+        
+        $this->assertInstanceOf('Doctrine\DBAL\Schema\ForeignKeyConstraint', $constraint);
+
+        $this->assertTrue($constraint->hasOption("foo"));
+        $this->assertEquals("bar", $constraint->getOption("foo"));
+    }
+
+    public function testAddIndexWithCaseSensitiveColumnProblem()
+    {
+        $table = new Table("foo");
+        $table->addColumn("id", 'integer');
+
+        $table->addIndex(array("ID"), "my_idx");
+
+        $this->assertTrue($table->hasIndex('my_idx'));
+        $this->assertEquals(array("ID"), $table->getIndex("my_idx")->getColumns());
+        $this->assertTrue($table->getIndex('my_idx')->spansColumns(array('id')));
+    }
+
+    public function testAddPrimaryKey_ColumnsAreExplicitlySetToNotNull()
+    {
+        $table = new Table("foo");
+        $column = $table->addColumn("id", 'integer', array('notnull' => false));
+
+        $this->assertFalse($column->getNotnull());
+
+        $table->setPrimaryKey(array('id'));
+        
+        $this->assertTrue($column->getNotnull());
+    }
+
+    /**
+     * @group DDC-133
+     */
+    public function testAllowImplicitSchemaTableInAutogeneratedIndexNames()
+    {
+        $table = new Table("foo.bar");
+        $table->addColumn('baz', 'integer', array());
+        $table->addIndex(array('baz'));
+
+        $this->assertEquals(1, count($table->getIndexes()));
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testAddIndexTwice_IgnoreSecond()
+    {
+        $table = new Table("foo.bar");
+        $table->addColumn('baz', 'integer', array());
+        $table->addIndex(array('baz'));
+        $table->addIndex(array('baz'));
+
+        $this->assertEquals(1, count($table->getIndexes()));
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testAddForeignKeyIndexImplicitly()
+    {
+        $table = new Table("foo");
+        $table->addColumn("id", 'integer');
+
+        $foreignTable = new Table("bar");
+        $foreignTable->addColumn("id", 'integer');
+
+        $table->addForeignKeyConstraint($foreignTable, array("id"), array("id"), array("foo" => "bar"));
+
+        $indexes = $table->getIndexes();
+        $this->assertEquals(1, count($indexes));
+        $index = current($indexes);
+
+        $this->assertTrue($table->hasIndex($index->getName()));
+        $this->assertEquals(array('id'), $index->getColumns());
+    }
+
+    /**
+     * @group DBAL-50
+     */
+    public function testOverruleIndex()
+    {
+        $table = new Table("bar");
+        $table->addColumn('baz', 'integer', array());
+        $table->addIndex(array('baz'));
+
+        $indexes = $table->getIndexes();
+        $this->assertEquals(1, count($indexes));
+        $index = current($indexes);
+
+        $table->addUniqueIndex(array('baz'));
+        $this->assertEquals(1, count($table->getIndexes()));
+        $this->assertFalse($table->hasIndex($index->getName()));
+    }
+    
+    public function testPrimaryKeyOverrulesUniqueIndex()
+    {
+        $table = new Table("bar");
+        $table->addColumn('baz', 'integer', array());
+        $table->addUniqueIndex(array('baz'));
+        
+        $table->setPrimaryKey(array('baz'));
+        
+        $indexes = $table->getIndexes();        
+        $this->assertEquals(1, count($indexes), "Table should only contain the primary key table index, not the unique one anymore, because it was overruled.");
+        
+        $index = current($indexes);
+        $this->assertTrue($index->isPrimary());
+    }
+
+    /**
+     * @group DBAL-64
+     */
+    public function testQuotedTableName()
+    {
+        $table = new Table("`bar`");
+
+        $mysqlPlatform = new \Doctrine\DBAL\Platforms\MySqlPlatform();
+        $sqlitePlatform = new \Doctrine\DBAL\Platforms\SqlitePlatform();
+
+        $this->assertEquals('bar', $table->getName());
+        $this->assertEquals('`bar`', $table->getQuotedName($mysqlPlatform));
+        $this->assertEquals('"bar"', $table->getQuotedName($sqlitePlatform));
+    }
+
+    /**
+     * @group DBAL-79
+     */
+    public function testTableHasPrimaryKey()
+    {
+        $table = new Table("test");
+
+        $this->assertFalse($table->hasPrimaryKey());
+
+        $table->addColumn("foo", "integer");
+        $table->setPrimaryKey(array("foo"));
+
+        $this->assertTrue($table->hasPrimaryKey());
+    }
+
+    /**
+     * @group DBAL-91
+     */
+    public function testAddIndexWithQuotedColumns()
+    {
+        $table = new Table("test");
+        $table->addColumn('"foo"', 'integer');
+        $table->addColumn('bar', 'integer');
+        $table->addIndex(array('"foo"', '"bar"'));
+    }
+
+    /**
+     * @group DBAL-91
+     */
+    public function testAddForeignKeyWithQuotedColumnsAndTable()
+    {
+        $table = new Table("test");
+        $table->addColumn('"foo"', 'integer');
+        $table->addColumn('bar', 'integer');
+        $table->addForeignKeyConstraint('"boing"', array('"foo"', '"bar"'), array("id"));
+    }
+}