Merge branch 'master' into cache

46 files changed, 2694 insertions, 212 deletions

diff --git a/tests/data/db_structure.xml b/tests/data/db_structure.xml
index af2e5ce3439..8f6dc5e2ecd 100644
--- a/tests/data/db_structure.xml
+++ b/tests/data/db_structure.xml
@@ -9,7 +9,7 @@
 
  <table>
 
-  <name>*dbprefix*contacts_addressbooks</name>
+  <name>*dbprefix*cntcts_addrsbks</name>
 
   <declaration>
 
@@ -77,7 +77,7 @@
 
  <table>
 
-  <name>*dbprefix*contacts_cards</name>
+  <name>*dbprefix*cntcts_cards</name>
 
   <declaration>
 
diff --git a/tests/data/db_structure2.xml b/tests/data/db_structure2.xml
index c1bbb550483..6f12f81f477 100644
--- a/tests/data/db_structure2.xml
+++ b/tests/data/db_structure2.xml
@@ -9,7 +9,7 @@
 
  <table>
 
-  <name>*dbprefix*contacts_addressbooks</name>
+  <name>*dbprefix*cntcts_addrsbks</name>
 
   <declaration>
 
@@ -49,8 +49,9 @@
 
    <field>
     <name>description</name>
-    <type>clob</type>
+    <type>text</type>
     <notnull>false</notnull>
+    <length>1024</length>
    </field>
 
    <field>
diff --git a/tests/enable_all.php b/tests/enable_all.php
index 44af0115650..111ed0e1357 100644
--- a/tests/enable_all.php
+++ b/tests/enable_all.php
@@ -8,6 +8,7 @@
 
 require_once __DIR__.'/../lib/base.php';
 
+OC_App::enable('files_encryption');
 OC_App::enable('calendar');
 OC_App::enable('contacts');
 OC_App::enable('apptemplateadvanced');
diff --git a/tests/lib/app.php b/tests/lib/app.php
index c452d752c9f..5396db8143e 100644
--- a/tests/lib/app.php
+++ b/tests/lib/app.php
@@ -64,6 +64,14 @@ class Test_App extends PHPUnit_Framework_TestCase {
 	}
 
 
+	public function testIsAppVersionCompatibleShouldWorkForPreAlpha(){
+		$oc = array(5, 0, 3);
+		$app = '4.93';
+
+		$this->assertTrue(OC_App::isAppVersionCompatible($oc, $app));
+	}
+
+
 	public function testIsAppVersionCompatibleShouldFailOneVersionNumbers(){
 		$oc = array(4, 3, 1);
 		$app = '5';
diff --git a/tests/lib/archive/tar.php b/tests/lib/archive/tar.php
index e66a8740879..d831487b16f 100644
--- a/tests/lib/archive/tar.php
+++ b/tests/lib/archive/tar.php
@@ -10,6 +10,12 @@ require_once 'archive.php';
 
 if (!OC_Util::runningOnWindows()) {
 class Test_Archive_TAR extends Test_Archive {
+	public function setUp() {
+		if (floatval(phpversion())>=5.5) {
+			$this->markTestSkipped('php 5.5 changed unpack function.');
+			return;
+		}
+	}
 	protected function getExisting() {
 		$dir = OC::$SERVERROOT . '/tests/data';
 		return new OC_Archive_TAR($dir . '/data.tar.gz');
diff --git a/tests/lib/autoloader.php b/tests/lib/autoloader.php
new file mode 100644
index 00000000000..0e7d606ccf6
--- /dev/null
+++ b/tests/lib/autoloader.php
@@ -0,0 +1,74 @@
+<?php
+/**
+ * Copyright (c) 2013 Thomas Müller <thomas.mueller@tmit.eu>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test;
+
+class AutoLoader extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var \OC\Autoloader $loader
+	 */
+	private $loader;
+
+	public function setUp() {
+		$this->loader = new \OC\AutoLoader();
+	}
+
+	public function testLeadingSlashOnClassName() {
+		$this->assertEquals(array('files/storage/local.php'), $this->loader->findClass('\OC\Files\Storage\Local'));
+	}
+
+	public function testNoLeadingSlashOnClassName() {
+		$this->assertEquals(array('files/storage/local.php'), $this->loader->findClass('OC\Files\Storage\Local'));
+	}
+
+	public function testLegacyPath() {
+		$this->assertEquals(array('legacy/files.php', 'files.php'), $this->loader->findClass('OC_Files'));
+	}
+
+	public function testClassPath() {
+		$this->loader->registerClass('Foo\Bar', 'foobar.php');
+		$this->assertEquals(array('foobar.php'), $this->loader->findClass('Foo\Bar'));
+	}
+
+	public function testPrefixNamespace() {
+		$this->loader->registerPrefix('Foo', 'foo');
+		$this->assertEquals(array('foo/Foo/Bar.php'), $this->loader->findClass('Foo\Bar'));
+	}
+
+	public function testPrefix() {
+		$this->loader->registerPrefix('Foo_', 'foo');
+		$this->assertEquals(array('foo/Foo/Bar.php'), $this->loader->findClass('Foo_Bar'));
+	}
+
+	public function testLoadTestNamespace() {
+		$this->assertEquals(array('tests/lib/foo/bar.php'), $this->loader->findClass('Test\Foo\Bar'));
+	}
+
+	public function testLoadTest() {
+		$this->assertEquals(array('tests/lib/foo/bar.php'), $this->loader->findClass('Test_Foo_Bar'));
+	}
+
+	public function testLoadCoreNamespace() {
+		$this->assertEquals(array('foo/bar.php'), $this->loader->findClass('OC\Foo\Bar'));
+	}
+
+	public function testLoadCore() {
+		$this->assertEquals(array('legacy/foo/bar.php', 'foo/bar.php'), $this->loader->findClass('OC_Foo_Bar'));
+	}
+
+	public function testLoadPublicNamespace() {
+		$this->assertEquals(array('public/foo/bar.php'), $this->loader->findClass('OCP\Foo\Bar'));
+	}
+
+	public function testLoadAppNamespace() {
+		$result = $this->loader->findClass('OCA\Files\Foobar');
+		$this->assertEquals(2, count($result));
+		$this->assertStringEndsWith('apps/files/foobar.php', $result[0]);
+		$this->assertStringEndsWith('apps/files/lib/foobar.php', $result[1]);
+	}
+}
diff --git a/tests/lib/backgroundjob/dummyjoblist.php b/tests/lib/backgroundjob/dummyjoblist.php
new file mode 100644
index 00000000000..d91d6b344b5
--- /dev/null
+++ b/tests/lib/backgroundjob/dummyjoblist.php
@@ -0,0 +1,131 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\BackgroundJob;
+
+class JobRun extends \Exception {
+}
+
+/**
+ * Class DummyJobList
+ *
+ * in memory job list for testing purposes
+ */
+class DummyJobList extends \OC\BackgroundJob\JobList {
+	/**
+	 * @var \OC\BackgroundJob\Job[]
+	 */
+	private $jobs = array();
+
+	private $last = 0;
+
+	/**
+	 * @param \OC\BackgroundJob\Job|string $job
+	 * @param mixed $argument
+	 */
+	public function add($job, $argument = null) {
+		$job->setArgument($argument);
+		if (!$this->has($job, null)) {
+			$this->jobs[] = $job;
+		}
+	}
+
+	/**
+	 * @param \OC\BackgroundJob\Job|string $job
+	 * @param mixed $argument
+	 */
+	public function remove($job, $argument = null) {
+		$index = array_search($job, $this->jobs);
+		if ($index !== false) {
+			unset($this->jobs[$index]);
+		}
+	}
+
+	/**
+	 * check if a job is in the list
+	 *
+	 * @param $job
+	 * @param mixed $argument
+	 * @return bool
+	 */
+	public function has($job, $argument) {
+		return array_search($job, $this->jobs) !== false;
+	}
+
+	/**
+	 * get all jobs in the list
+	 *
+	 * @return \OC\BackgroundJob\Job[]
+	 */
+	public function getAll() {
+		return $this->jobs;
+	}
+
+	/**
+	 * get the next job in the list
+	 *
+	 * @return \OC\BackgroundJob\Job
+	 */
+	public function getNext() {
+		if (count($this->jobs) > 0) {
+			if ($this->last < (count($this->jobs) - 1)) {
+				$i = $this->last + 1;
+			} else {
+				$i = 0;
+			}
+			return $this->jobs[$i];
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * set the job that was last ran
+	 *
+	 * @param \OC\BackgroundJob\Job $job
+	 */
+	public function setLastJob($job) {
+		$i = array_search($job, $this->jobs);
+		if ($i !== false) {
+			$this->last = $i;
+		} else {
+			$this->last = 0;
+		}
+	}
+
+	/**
+	 * @param int $id
+	 * @return Job
+	 */
+	public function getById($id) {
+		foreach ($this->jobs as $job) {
+			if ($job->getId() === $id) {
+				return $job;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * get the id of the last ran job
+	 *
+	 * @return int
+	 */
+	public function getLastJob() {
+		return $this->last;
+	}
+
+	/**
+	 * set the lastRun of $job to now
+	 *
+	 * @param \OC\BackgroundJob\Job $job
+	 */
+	public function setLastRun($job) {
+		$job->setLastRun(time());
+	}
+}
diff --git a/tests/lib/backgroundjob/queuedjob.php b/tests/lib/backgroundjob/queuedjob.php
new file mode 100644
index 00000000000..1d373473cd7
--- /dev/null
+++ b/tests/lib/backgroundjob/queuedjob.php
@@ -0,0 +1,42 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\BackgroundJob;
+
+class TestQueuedJob extends \OC\BackgroundJob\QueuedJob {
+	public function run($argument) {
+		throw new JobRun(); //throw an exception so we can detect if this function is called
+	}
+}
+
+class QueuedJob extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var DummyJobList $jobList
+	 */
+	private $jobList;
+	/**
+	 * @var \OC\BackgroundJob\TimedJob $job
+	 */
+	private $job;
+
+	public function setup() {
+		$this->jobList = new DummyJobList();
+		$this->job = new TestQueuedJob();
+		$this->jobList->add($this->job);
+	}
+
+	public function testJobShouldBeRemoved() {
+		try {
+			$this->assertTrue($this->jobList->has($this->job, null));
+			$this->job->execute($this->jobList);
+			$this->fail("job should have been run");
+		} catch (JobRun $e) {
+			$this->assertFalse($this->jobList->has($this->job, null));
+		}
+	}
+}
diff --git a/tests/lib/backgroundjob/timedjob.php b/tests/lib/backgroundjob/timedjob.php
new file mode 100644
index 00000000000..f3c3eb4d0dd
--- /dev/null
+++ b/tests/lib/backgroundjob/timedjob.php
@@ -0,0 +1,71 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\BackgroundJob;
+
+class TestTimedJob extends \OC\BackgroundJob\TimedJob {
+	public function __construct() {
+		$this->setInterval(10);
+	}
+
+	public function run($argument) {
+		throw new JobRun(); //throw an exception so we can detect if this function is called
+	}
+}
+
+class TimedJob extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var DummyJobList $jobList
+	 */
+	private $jobList;
+	/**
+	 * @var \OC\BackgroundJob\TimedJob $job
+	 */
+	private $job;
+
+	public function setup() {
+		$this->jobList = new DummyJobList();
+		$this->job = new TestTimedJob();
+		$this->jobList->add($this->job);
+	}
+
+	public function testShouldRunAfterInterval() {
+		$this->job->setLastRun(time() - 12);
+		try {
+			$this->job->execute($this->jobList);
+			$this->fail("job should have run");
+		} catch (JobRun $e) {
+		}
+		$this->assertTrue(true);
+	}
+
+	public function testShouldNotRunWithinInterval() {
+		$this->job->setLastRun(time() - 5);
+		try {
+			$this->job->execute($this->jobList);
+		} catch (JobRun $e) {
+			$this->fail("job should not have run");
+		}
+		$this->assertTrue(true);
+	}
+
+	public function testShouldNotTwice() {
+		$this->job->setLastRun(time() - 15);
+		try {
+			$this->job->execute($this->jobList);
+			$this->fail("job should have run the first time");
+		} catch (JobRun $e) {
+			try {
+				$this->job->execute($this->jobList);
+			} catch (JobRun $e) {
+				$this->fail("job should not have run the second time");
+			}
+		}
+		$this->assertTrue(true);
+	}
+}
diff --git a/tests/lib/cache/file.php b/tests/lib/cache/file.php
index 5dcd3268804..038cb21b257 100644
--- a/tests/lib/cache/file.php
+++ b/tests/lib/cache/file.php
@@ -22,7 +22,8 @@
 
 class Test_Cache_File extends Test_Cache {
 	private $user;
-	
+	private $datadir;
+
 	function skip() {
 		//$this->skipUnless(OC_User::isLoggedIn());
 	}
@@ -31,15 +32,20 @@ class Test_Cache_File extends Test_Cache {
 		//clear all proxies and hooks so we can do clean testing
 		OC_FileProxy::clearProxies();
 		OC_Hook::clear('OC_Filesystem');
-		
+
+		//disabled atm
 		//enable only the encryption hook if needed
-		if(OC_App::isEnabled('files_encryption')) {
-			OC_FileProxy::register(new OC_FileProxy_Encryption());
-		}
-		
+		//if(OC_App::isEnabled('files_encryption')) {
+		//	OC_FileProxy::register(new OC_FileProxy_Encryption());
+		//}
+
 		//set up temporary storage
 		\OC\Files\Filesystem::clearMounts();
-		\OC\Files\Filesystem::mount('\OC\Files\Storage\Temporary',array(),'/');
+		$storage = new \OC\Files\Storage\Temporary(array());
+		\OC\Files\Filesystem::mount($storage,array(),'/');
+		$datadir = str_replace('local::', '', $storage->getId());
+		$this->datadir = OC_Config::getValue('datadirectory', OC::$SERVERROOT.'/data');
+		OC_Config::setValue('datadirectory', $datadir);
 
 		OC_User::clearBackends();
 		OC_User::useBackend(new OC_User_Dummy());
@@ -59,5 +65,6 @@ class Test_Cache_File extends Test_Cache {
 
 	public function tearDown() {
 		OC_User::setUserId($this->user);
+		OC_Config::setValue('datadirectory', $this->datadir);
 	}
 }
diff --git a/tests/lib/config.php b/tests/lib/config.php
new file mode 100644
index 00000000000..87ee2807c2d
--- /dev/null
+++ b/tests/lib/config.php
@@ -0,0 +1,105 @@
+<?php
+/**
+ * Copyright (c) 2013 Bart Visscher <bartv@thisnet.nl>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+class Test_Config extends PHPUnit_Framework_TestCase {
+	const CONFIG_FILE = 'static://config.php';
+	const CONFIG_DIR = 'static://';
+	const TESTCONTENT = '<?php $CONFIG=array("foo"=>"bar");';
+
+	/**
+	 * @var \OC\Config
+	 */
+	private $config;
+
+	function setUp() {
+		file_put_contents(self::CONFIG_FILE, self::TESTCONTENT);
+		$this->config = new OC\Config(self::CONFIG_DIR);
+	}
+
+	public function testReadData() {
+		$config = new OC\Config('/non-existing');
+		$this->assertAttributeEquals(array(), 'cache', $config);
+
+		$this->assertAttributeEquals(array('foo' => 'bar'), 'cache', $this->config);
+	}
+
+	public function testGetKeys() {
+		$this->assertEquals(array('foo'), $this->config->getKeys());
+	}
+
+	public function testGetValue() {
+		$this->assertEquals('bar', $this->config->getValue('foo'));
+		$this->assertEquals(null, $this->config->getValue('bar'));
+		$this->assertEquals('moo', $this->config->getValue('bar', 'moo'));
+	}
+
+	public function testSetValue() {
+		$this->config->setDebugMode(false);
+		$this->config->setValue('foo', 'moo');
+		$this->assertAttributeEquals(array('foo' => 'moo'), 'cache', $this->config);
+		$content = file_get_contents(self::CONFIG_FILE);
+		$this->assertEquals(<<<EOL
+<?php
+\$CONFIG = array (
+  'foo' => 'moo',
+);
+
+EOL
+			, $content);
+		$this->config->setValue('bar', 'red');
+		$this->assertAttributeEquals(array('foo' => 'moo', 'bar' => 'red'), 'cache', $this->config);
+		$content = file_get_contents(self::CONFIG_FILE);
+		$this->assertEquals(<<<EOL
+<?php
+\$CONFIG = array (
+  'foo' => 'moo',
+  'bar' => 'red',
+);
+
+EOL
+			, $content);
+	}
+
+	public function testDeleteKey() {
+		$this->config->setDebugMode(false);
+		$this->config->deleteKey('foo');
+		$this->assertAttributeEquals(array(), 'cache', $this->config);
+		$content = file_get_contents(self::CONFIG_FILE);
+		$this->assertEquals(<<<EOL
+<?php
+\$CONFIG = array (
+);
+
+EOL
+			, $content);
+	}
+
+	public function testSavingDebugMode() {
+		$this->config->setDebugMode(true);
+		$this->config->deleteKey('foo'); // change something so we save to the config file
+		$this->assertAttributeEquals(array(), 'cache', $this->config);
+		$this->assertAttributeEquals(true, 'debugMode', $this->config);
+		$content = file_get_contents(self::CONFIG_FILE);
+		$this->assertEquals(<<<EOL
+<?php
+define('DEBUG',true);
+\$CONFIG = array (
+);
+
+EOL
+			, $content);
+	}
+
+	/**
+	 * @expectedException \OC\HintException
+	 */
+	public function testWriteData() {
+		$config = new OC\Config('/non-writable');
+		$config->setValue('foo', 'bar');
+	}
+}
diff --git a/tests/lib/db.php b/tests/lib/db.php
index 440f3fb6bfd..69e3542f926 100644
--- a/tests/lib/db.php
+++ b/tests/lib/db.php
@@ -22,8 +22,8 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 		OC_DB::createDbFromStructure(self::$schema_file);
 
 		$this->test_prefix = $r;
-		$this->table1 = $this->test_prefix.'contacts_addressbooks';
-		$this->table2 = $this->test_prefix.'contacts_cards';
+		$this->table1 = $this->test_prefix.'cntcts_addrsbks';
+		$this->table2 = $this->test_prefix.'cntcts_cards';
 		$this->table3 = $this->test_prefix.'vcategory';
 	}
 
@@ -33,49 +33,52 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 	}
 
 	public function testQuotes() {
-		$query = OC_DB::prepare('SELECT `fullname` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$query = OC_DB::prepare('SELECT `fullname` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array('uri_1'));
 		$this->assertTrue((bool)$result);
 		$row = $result->fetchRow();
-		$this->assertFalse($row);
-		$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (?,?)');
+		$this->assertFalse((bool)$row); //PDO returns false, MDB2 returns null
+		$query = OC_DB::prepare('INSERT INTO `*PREFIX*'.$this->table2.'` (`fullname`,`uri`) VALUES (?,?)');
 		$result = $query->execute(array('fullname test', 'uri_1'));
-		$this->assertTrue((bool)$result);
-		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$this->assertEquals(1, $result);
+		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array('uri_1'));
 		$this->assertTrue((bool)$result);
 		$row = $result->fetchRow();
 		$this->assertArrayHasKey('fullname', $row);
 		$this->assertEquals($row['fullname'], 'fullname test');
 		$row = $result->fetchRow();
-		$this->assertFalse($row);
+		$this->assertFalse((bool)$row); //PDO returns false, MDB2 returns null
 	}
 
+	/**
+	 * @medium
+	 */
 	public function testNOW() {
-		$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (NOW(),?)');
+		$query = OC_DB::prepare('INSERT INTO `*PREFIX*'.$this->table2.'` (`fullname`,`uri`) VALUES (NOW(),?)');
 		$result = $query->execute(array('uri_2'));
-		$this->assertTrue((bool)$result);
-		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$this->assertEquals(1, $result);
+		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array('uri_2'));
 		$this->assertTrue((bool)$result);
 	}
 
 	public function testUNIX_TIMESTAMP() {
-		$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (UNIX_TIMESTAMP(),?)');
+		$query = OC_DB::prepare('INSERT INTO `*PREFIX*'.$this->table2.'` (`fullname`,`uri`) VALUES (UNIX_TIMESTAMP(),?)');
 		$result = $query->execute(array('uri_3'));
-		$this->assertTrue((bool)$result);
-		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$this->assertEquals(1, $result);
+		$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array('uri_3'));
 		$this->assertTrue((bool)$result);
 	}
 
 	public function testinsertIfNotExist() {
 		$categoryentries = array(
-				array('user' => 'test', 'type' => 'contact', 'category' => 'Family'),
-				array('user' => 'test', 'type' => 'contact', 'category' => 'Friends'),
-				array('user' => 'test', 'type' => 'contact', 'category' => 'Coworkers'),
-				array('user' => 'test', 'type' => 'contact', 'category' => 'Coworkers'),
-				array('user' => 'test', 'type' => 'contact', 'category' => 'School'),
+				array('user' => 'test', 'type' => 'contact', 'category' => 'Family',    'expectedResult' => 1),
+				array('user' => 'test', 'type' => 'contact', 'category' => 'Friends',   'expectedResult' => 1),
+				array('user' => 'test', 'type' => 'contact', 'category' => 'Coworkers', 'expectedResult' => 1),
+				array('user' => 'test', 'type' => 'contact', 'category' => 'Coworkers', 'expectedResult' => 0),
+				array('user' => 'test', 'type' => 'contact', 'category' => 'School',    'expectedResult' => 1),
 			);
 
 		foreach($categoryentries as $entry) {
@@ -85,13 +88,13 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 					'type' => $entry['type'],
 					'category' => $entry['category'],
 				));
-			$this->assertTrue((bool)$result);
+			$this->assertEquals($entry['expectedResult'], $result);
 		}
 
-		$query = OC_DB::prepare('SELECT * FROM *PREFIX*'.$this->table3);
+		$query = OC_DB::prepare('SELECT * FROM `*PREFIX*'.$this->table3.'`');
 		$result = $query->execute();
 		$this->assertTrue((bool)$result);
-		$this->assertEquals('4', $result->numRows());
+		$this->assertEquals(4, $result->numRows());
 	}
 
 	public function testinsertIfNotExistDontOverwrite() {
@@ -100,16 +103,16 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 		$carddata = 'This is a vCard';
 
 		// Normal test to have same known data inserted.
-		$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`, `uri`, `carddata`) VALUES (?, ?, ?)');
+		$query = OC_DB::prepare('INSERT INTO `*PREFIX*'.$this->table2.'` (`fullname`, `uri`, `carddata`) VALUES (?, ?, ?)');
 		$result = $query->execute(array($fullname, $uri, $carddata));
-		$this->assertTrue((bool)$result);
-		$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$this->assertEquals(1, $result);
+		$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array($uri));
 		$this->assertTrue((bool)$result);
 		$row = $result->fetchRow();
 		$this->assertArrayHasKey('carddata', $row);
 		$this->assertEquals($carddata, $row['carddata']);
-		$this->assertEquals('1', $result->numRows());
+		$this->assertEquals(1, $result->numRows());
 
 		// Try to insert a new row
 		$result = OC_DB::insertIfNotExist('*PREFIX*'.$this->table2,
@@ -117,9 +120,9 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 				'fullname' => $fullname,
 				'uri' => $uri,
 			));
-		$this->assertTrue((bool)$result);
+		$this->assertEquals(0, $result);
 
-		$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
+		$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM `*PREFIX*'.$this->table2.'` WHERE `uri` = ?');
 		$result = $query->execute(array($uri));
 		$this->assertTrue((bool)$result);
 		$row = $result->fetchRow();
@@ -127,7 +130,7 @@ class Test_DB extends PHPUnit_Framework_TestCase {
 		// Test that previously inserted data isn't overwritten
 		$this->assertEquals($carddata, $row['carddata']);
 		// And that a new row hasn't been inserted.
-		$this->assertEquals('1', $result->numRows());
+		$this->assertEquals(1, $result->numRows());
 
 	}
 }
diff --git a/tests/lib/dbschema.php b/tests/lib/dbschema.php
index e20a04ef7fd..c2e55eabf4b 100644
--- a/tests/lib/dbschema.php
+++ b/tests/lib/dbschema.php
@@ -7,9 +7,8 @@
  */
 
 class Test_DBSchema extends PHPUnit_Framework_TestCase {
-	protected static $schema_file = 'static://test_db_scheme';
-	protected static $schema_file2 = 'static://test_db_scheme2';
-	protected $test_prefix;
+	protected $schema_file = 'static://test_db_scheme';
+	protected $schema_file2 = 'static://test_db_scheme2';
 	protected $table1;
 	protected $table2;
 
@@ -20,22 +19,26 @@ class Test_DBSchema extends PHPUnit_Framework_TestCase {
 		$r = '_'.OC_Util::generate_random_bytes('4').'_';
 		$content = file_get_contents( $dbfile );
 		$content = str_replace( '*dbprefix*', '*dbprefix*'.$r, $content );
-		file_put_contents( self::$schema_file, $content );
+		file_put_contents( $this->schema_file, $content );
 		$content = file_get_contents( $dbfile2 );
 		$content = str_replace( '*dbprefix*', '*dbprefix*'.$r, $content );
-		file_put_contents( self::$schema_file2, $content );
+		file_put_contents( $this->schema_file2, $content );
 
-		$this->test_prefix = $r;
-		$this->table1 = $this->test_prefix.'contacts_addressbooks';
-		$this->table2 = $this->test_prefix.'contacts_cards';
+		$prefix = OC_Config::getValue( "dbtableprefix", "oc_" );
+		
+		$this->table1 = $prefix.$r.'cntcts_addrsbks';
+		$this->table2 = $prefix.$r.'cntcts_cards';
 	}
 
 	public function tearDown() {
-		unlink(self::$schema_file);
-		unlink(self::$schema_file2);
+		unlink($this->schema_file);
+		unlink($this->schema_file2);
 	}
 
 	// everything in one test, they depend on each other
+	/**
+	 * @medium
+	 */
 	public function testSchema() {
 		$this->doTestSchemaCreating();
 		$this->doTestSchemaChanging();
@@ -44,13 +47,13 @@ class Test_DBSchema extends PHPUnit_Framework_TestCase {
 	}
 
 	public function doTestSchemaCreating() {
-		OC_DB::createDbFromStructure(self::$schema_file);
+		OC_DB::createDbFromStructure($this->schema_file);
 		$this->assertTableExist($this->table1);
 		$this->assertTableExist($this->table2);
 	}
 
 	public function doTestSchemaChanging() {
-		OC_DB::updateDbFromStructure(self::$schema_file2);
+		OC_DB::updateDbFromStructure($this->schema_file2);
 		$this->assertTableExist($this->table2);
 	}
 
@@ -63,62 +66,61 @@ class Test_DBSchema extends PHPUnit_Framework_TestCase {
 	}
 
 	public function doTestSchemaRemoving() {
-		OC_DB::removeDBStructure(self::$schema_file);
+		OC_DB::removeDBStructure($this->schema_file);
 		$this->assertTableNotExist($this->table1);
 		$this->assertTableNotExist($this->table2);
 	}
 
 	public function tableExist($table) {
-		$table = '*PREFIX*' . $table;
 
 		switch (OC_Config::getValue( 'dbtype', 'sqlite' )) {
 			case 'sqlite':
 			case 'sqlite3':
 				$sql = "SELECT name FROM sqlite_master "
-				. "WHERE type = 'table' AND name != 'sqlite_sequence' "
-				.  "AND name != 'geometry_columns' AND name != 'spatial_ref_sys' "
-				. "UNION ALL SELECT name FROM sqlite_temp_master "
-				. "WHERE type = 'table' AND name = '".$table."'";
-				$query = OC_DB::prepare($sql);
-				$result = $query->execute(array());
-				$exists = $result && $result->fetchOne();
+					.  "WHERE type = 'table' AND name = ? "
+					.  "UNION ALL SELECT name FROM sqlite_temp_master "
+					.  "WHERE type = 'table' AND name = ?";
+				$result = \OC_DB::executeAudited($sql, array($table, $table));
 				break;
 			case 'mysql':
-				$sql = 'SHOW TABLES LIKE "'.$table.'"';
-				$query = OC_DB::prepare($sql);
-				$result = $query->execute(array());
-				$exists = $result && $result->fetchOne();
+				$sql = 'SHOW TABLES LIKE ?';
+				$result = \OC_DB::executeAudited($sql, array($table));
 				break;
 			case 'pgsql':
-				$sql = "SELECT tablename AS table_name, schemaname AS schema_name "
-					. "FROM pg_tables WHERE schemaname NOT LIKE 'pg_%' "
-					.  "AND schemaname != 'information_schema' "
-					.  "AND tablename = '".$table."'";
-				$query = OC_DB::prepare($sql);
-				$result = $query->execute(array());
-				$exists = $result && $result->fetchOne();
+				$sql = 'SELECT tablename AS table_name, schemaname AS schema_name '
+					.  'FROM pg_tables WHERE schemaname NOT LIKE \'pg_%\' '
+					.  'AND schemaname != \'information_schema\' '
+					.  'AND tablename = ?';
+				$result = \OC_DB::executeAudited($sql, array($table));
+				break;
+			case 'oci':
+				$sql = 'SELECT TABLE_NAME FROM USER_TABLES WHERE TABLE_NAME = ?';
+				$result = \OC_DB::executeAudited($sql, array($table));
 				break;
 			case 'mssql':
-				$sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{$table}'";
-				$query = OC_DB::prepare($sql);
-				$result = $query->execute(array());
-				$exists = $result && $result->fetchOne();
+				$sql = 'SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = ?';
+				$result = \OC_DB::executeAudited($sql, array($table));
 				break;
 		}
-		return $exists;
+		
+		$name = $result->fetchOne(); //FIXME checking with '$result->numRows() === 1' does not seem to work?
+		if ($name === $table) {
+			return true;
+		} else {
+			return false;
+		}
 	}
 
 	public function assertTableExist($table) {
-		$this->assertTrue($this->tableExist($table));
+		$this->assertTrue($this->tableExist($table), 'Table ' . $table . ' does not exist');
 	}
 
 	public function assertTableNotExist($table) {
 		$type=OC_Config::getValue( "dbtype", "sqlite" );
 		if( $type == 'sqlite' || $type == 'sqlite3' ) {
 			// sqlite removes the tables after closing the DB
-		}
-		else {
-			$this->assertFalse($this->tableExist($table));
+		} else {
+			$this->assertFalse($this->tableExist($table), 'Table ' . $table . ' exists.');
 		}
 	}
 }
diff --git a/tests/lib/files/cache/cache.php b/tests/lib/files/cache/cache.php
index 250842805e5..527c1d1b2a1 100644
--- a/tests/lib/files/cache/cache.php
+++ b/tests/lib/files/cache/cache.php
@@ -8,6 +8,8 @@
 
 namespace Test\Files\Cache;
 
+use PHPUnit_Framework_MockObject_MockObject;
+
 class LongId extends \OC\Files\Storage\Temporary {
 	public function getId() {
 		return 'long:' . str_repeat('foo', 50) . parent::getId();
@@ -19,11 +21,19 @@ class Cache extends \PHPUnit_Framework_TestCase {
 	 * @var \OC\Files\Storage\Temporary $storage;
 	 */
 	private $storage;
+	/**
+	 * @var \OC\Files\Storage\Temporary $storage2;
+	 */
+	private $storage2;
 
 	/**
 	 * @var \OC\Files\Cache\Cache $cache
 	 */
 	private $cache;
+	/**
+	 * @var \OC\Files\Cache\Cache $cache2
+	 */
+	private $cache2;
 
 	public function testSimple() {
 		$file1 = 'foo';
@@ -162,13 +172,21 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$file4 = 'folder/foo/1';
 		$file5 = 'folder/foo/2';
 		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'foo/bar');
+		$folderData = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
 
-		$this->cache->put($file1, $data);
-		$this->cache->put($file2, $data);
-		$this->cache->put($file3, $data);
+		$this->cache->put($file1, $folderData);
+		$this->cache->put($file2, $folderData);
+		$this->cache->put($file3, $folderData);
 		$this->cache->put($file4, $data);
 		$this->cache->put($file5, $data);
 
+		/* simulate a second user with a different storage id but the same folder structure */
+		$this->cache2->put($file1, $folderData);
+		$this->cache2->put($file2, $folderData);
+		$this->cache2->put($file3, $folderData);
+		$this->cache2->put($file4, $data);
+		$this->cache2->put($file5, $data);
+
 		$this->cache->move('folder/foo', 'folder/foobar');
 
 		$this->assertFalse($this->cache->inCache('folder/foo'));
@@ -179,6 +197,16 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertTrue($this->cache->inCache('folder/foobar'));
 		$this->assertTrue($this->cache->inCache('folder/foobar/1'));
 		$this->assertTrue($this->cache->inCache('folder/foobar/2'));
+
+		/* the folder structure of the second user must not change! */
+		$this->assertTrue($this->cache2->inCache('folder/bar'));
+		$this->assertTrue($this->cache2->inCache('folder/foo'));
+		$this->assertTrue($this->cache2->inCache('folder/foo/1'));
+		$this->assertTrue($this->cache2->inCache('folder/foo/2'));
+
+		$this->assertFalse($this->cache2->inCache('folder/foobar'));
+		$this->assertFalse($this->cache2->inCache('folder/foobar/1'));
+		$this->assertFalse($this->cache2->inCache('folder/foobar/2'));
 	}
 
 	function testGetIncomplete() {
@@ -210,6 +238,23 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array($storageId, 'foo'), \OC\Files\Cache\Cache::getById($id));
 	}
 
+	function testStorageMTime() {
+		$data = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+		$this->cache->put('foo', $data);
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals($data['mtime'], $cachedData['storage_mtime']);//if no storage_mtime is saved, mtime should be used
+
+		$this->cache->put('foo', array('storage_mtime' => 30));//when setting storage_mtime, mtime is also set
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals(30, $cachedData['storage_mtime']);
+		$this->assertEquals(30, $cachedData['mtime']);
+
+		$this->cache->put('foo', array('mtime' => 25));//setting mtime does not change storage_mtime
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals(30, $cachedData['storage_mtime']);
+		$this->assertEquals(25, $cachedData['mtime']);
+	}
+
 	function testLongId() {
 		$storage = new LongId(array());
 		$cache = $storage->getCache();
@@ -219,12 +264,99 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array(md5($storageId), 'foo'), \OC\Files\Cache\Cache::getById($id));
 	}
 
+	/**
+	 * @brief this test show the bug resulting if we have no normalizer installed
+	 */
+	public function testWithoutNormalizer() {
+		// folder name "Schön" with U+00F6 (normalized)
+		$folderWith00F6 = "\x53\x63\x68\xc3\xb6\x6e";
+
+		// folder name "Schön" with U+0308 (un-normalized)
+		$folderWith0308 = "\x53\x63\x68\x6f\xcc\x88\x6e";
+
+		/**
+		 * @var \OC\Files\Cache\Cache | PHPUnit_Framework_MockObject_MockObject $cacheMock
+		 */
+		$cacheMock = $this->getMock('\OC\Files\Cache\Cache', array('normalize'), array($this->storage), '', true);
+
+		$cacheMock->expects($this->any())
+			->method('normalize')
+			->will($this->returnArgument(0));
+
+		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
+
+		// put root folder
+		$this->assertFalse($cacheMock->get('folder'));
+		$this->assertGreaterThan(0, $cacheMock->put('folder', $data));
+
+		// put un-normalized folder
+		$this->assertFalse($cacheMock->get('folder/' .$folderWith0308));
+		$this->assertGreaterThan(0, $cacheMock->put('folder/' .$folderWith0308, $data));
+
+		// get un-normalized folder by name
+		$unNormalizedFolderName = $cacheMock->get('folder/' .$folderWith0308);
+
+		// check if database layer normalized the folder name (this should not happen)
+		$this->assertEquals($folderWith0308, $unNormalizedFolderName['name']);
+
+		// put normalized folder
+		$this->assertFalse($cacheMock->get('folder/' . $folderWith00F6));
+		$this->assertGreaterThan(0, $cacheMock->put('folder/' .$folderWith00F6, $data));
+
+		// this is our bug, we have two different hashes with the same name (Schön)
+		$this->assertEquals(2, count($cacheMock->getFolderContents('folder')));
+	}
+
+	/**
+	 * @brief this test shows that there is no bug if we use the normalizer
+	 */
+	public function testWithNormalizer() {
+
+		if(!class_exists('Patchwork\PHP\Shim\Normalizer')) {
+			$this->markTestSkipped('The 3rdparty Normalizer extension is not available.');
+			return;
+		}
+
+		// folder name "Schön" with U+00F6 (normalized)
+		$folderWith00F6 = "\x53\x63\x68\xc3\xb6\x6e";
+
+		// folder name "Schön" with U+0308 (un-normalized)
+		$folderWith0308 = "\x53\x63\x68\x6f\xcc\x88\x6e";
+
+		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
+
+		// put root folder
+		$this->assertFalse($this->cache->get('folder'));
+		$this->assertGreaterThan(0, $this->cache->put('folder', $data));
+
+		// put un-normalized folder
+		$this->assertFalse($this->cache->get('folder/' .$folderWith0308));
+		$this->assertGreaterThan(0, $this->cache->put('folder/' .$folderWith0308, $data));
+
+		// get un-normalized folder by name
+		$unNormalizedFolderName = $this->cache->get('folder/' .$folderWith0308);
+
+		// check if folder name was normalized
+		$this->assertEquals($folderWith00F6, $unNormalizedFolderName['name']);
+
+		// put normalized folder
+		$this->assertTrue(is_array($this->cache->get('folder/' . $folderWith00F6)));
+		$this->assertGreaterThan(0, $this->cache->put('folder/' .$folderWith00F6, $data));
+
+		// at this point we should have only one folder named "Schön"
+		$this->assertEquals(1, count($this->cache->getFolderContents('folder')));
+	}
+
 	public function tearDown() {
-		$this->cache->clear();
+		if ($this->cache) {
+			$this->cache->clear();
+		}
 	}
 
 	public function setUp() {
 		$this->storage = new \OC\Files\Storage\Temporary(array());
+		$this->storage2 = new \OC\Files\Storage\Temporary(array());
 		$this->cache = new \OC\Files\Cache\Cache($this->storage);
+		$this->cache2 = new \OC\Files\Cache\Cache($this->storage2);
 	}
 }
diff --git a/tests/lib/files/cache/permissions.php b/tests/lib/files/cache/permissions.php
index 56dbbc4518e..7e6e11e2eb2 100644
--- a/tests/lib/files/cache/permissions.php
+++ b/tests/lib/files/cache/permissions.php
@@ -14,8 +14,8 @@ class Permissions extends \PHPUnit_Framework_TestCase {
 	 */
 	private $permissionsCache;
 
-	function setUp(){
-		$this->permissionsCache=new \OC\Files\Cache\Permissions('dummy');
+	function setUp() {
+		$this->permissionsCache = new \OC\Files\Cache\Permissions('dummy');
 	}
 
 	function testSimple() {
@@ -23,8 +23,10 @@ class Permissions extends \PHPUnit_Framework_TestCase {
 		$user = uniqid();
 
 		$this->assertEquals(-1, $this->permissionsCache->get(1, $user));
+		$this->assertNotContains($user, $this->permissionsCache->getUsers(1));
 		$this->permissionsCache->set(1, $user, 1);
 		$this->assertEquals(1, $this->permissionsCache->get(1, $user));
+		$this->assertContains($user, $this->permissionsCache->getUsers(1));
 		$this->assertEquals(-1, $this->permissionsCache->get(2, $user));
 		$this->assertEquals(-1, $this->permissionsCache->get(1, $user . '2'));
 
diff --git a/tests/lib/files/cache/scanner.php b/tests/lib/files/cache/scanner.php
index 3885c99e6d3..263ceadccc7 100644
--- a/tests/lib/files/cache/scanner.php
+++ b/tests/lib/files/cache/scanner.php
@@ -104,7 +104,7 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 		$this->assertNotEquals($cachedDataFolder['size'], -1);
 	}
 
-	function testBackgroundScan(){
+	function testBackgroundScan() {
 		$this->fillTestFolders();
 		$this->storage->mkdir('folder2');
 		$this->storage->file_put_contents('folder2/bar.txt', 'foobar');
@@ -126,6 +126,46 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 		$this->assertFalse($this->cache->getIncomplete());
 	}
 
+	public function testReuseExisting() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$oldData = $this->cache->get('');
+		$this->storage->unlink('folder/bar.txt');
+		$this->cache->put('folder', array('mtime' => $this->storage->filemtime('folder')));
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW, \OC\Files\Cache\Scanner::REUSE_SIZE);
+		$newData = $this->cache->get('');
+		$this->assertNotEquals($oldData['etag'], $newData['etag']);
+		$this->assertEquals($oldData['size'], $newData['size']);
+
+		$oldData = $newData;
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW, \OC\Files\Cache\Scanner::REUSE_ETAG);
+		$newData = $this->cache->get('');
+		$this->assertEquals($oldData['etag'], $newData['etag']);
+		$this->assertEquals(-1, $newData['size']);
+	}
+
+	public function testRemovedFile() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$this->assertTrue($this->cache->inCache('foo.txt'));
+		$this->storage->unlink('foo.txt');
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+		$this->assertFalse($this->cache->inCache('foo.txt'));
+	}
+
+	public function testRemovedFolder() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$this->assertTrue($this->cache->inCache('folder/bar.txt'));
+		$this->storage->unlink('/folder');
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+		$this->assertFalse($this->cache->inCache('folder'));
+		$this->assertFalse($this->cache->inCache('folder/bar.txt'));
+	}
+
 	function setUp() {
 		$this->storage = new \OC\Files\Storage\Temporary(array());
 		$this->scanner = new \OC\Files\Cache\Scanner($this->storage);
@@ -133,9 +173,11 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 	}
 
 	function tearDown() {
-		$ids = $this->cache->getAll();
-		$permissionsCache = $this->storage->getPermissionsCache();
-		$permissionsCache->removeMultiple($ids, \OC_User::getUser());
-		$this->cache->clear();
+		if ($this->cache) {
+			$ids = $this->cache->getAll();
+			$permissionsCache = $this->storage->getPermissionsCache();
+			$permissionsCache->removeMultiple($ids, \OC_User::getUser());
+			$this->cache->clear();
+		}
 	}
 }
diff --git a/tests/lib/files/cache/updater.php b/tests/lib/files/cache/updater.php
index aaf932c97fe..5d7997b0544 100644
--- a/tests/lib/files/cache/updater.php
+++ b/tests/lib/files/cache/updater.php
@@ -42,14 +42,11 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->scanner->scan('');
 		$this->cache = $this->storage->getCache();
 
+		\OC\Files\Filesystem::tearDown();
 		if (!self::$user) {
-			if (!\OC\Files\Filesystem::getView()) {
-				self::$user = uniqid();
-				\OC\Files\Filesystem::init(self::$user, '/' . self::$user . '/files');
-			} else {
-				self::$user = \OC_User::getUser();
-			}
+			self::$user = uniqid();
 		}
+		\OC\Files\Filesystem::init(self::$user, '/' . self::$user . '/files');
 
 		Filesystem::clearMounts();
 		Filesystem::mount($this->storage, array(), '/' . self::$user . '/files');
@@ -59,7 +56,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		\OC_Hook::connect('OC_Filesystem', 'post_write', '\OC\Files\Cache\Updater', 'writeHook');
 		\OC_Hook::connect('OC_Filesystem', 'post_delete', '\OC\Files\Cache\Updater', 'deleteHook');
 		\OC_Hook::connect('OC_Filesystem', 'post_rename', '\OC\Files\Cache\Updater', 'renameHook');
-
+		\OC_Hook::connect('OC_Filesystem', 'post_touch', '\OC\Files\Cache\Updater', 'touchHook');
 	}
 
 	public function tearDown() {
@@ -72,6 +69,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 	public function testWrite() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+		$this->cache->put('foo.txt', array('mtime' => 100));
 		$rootCachedData = $this->cache->get('');
 		$this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
 
@@ -80,11 +78,9 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$cachedData = $this->cache->get('foo.txt');
 		$this->assertEquals(3, $cachedData['size']);
 		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
-		$mtime = $cachedData['mtime'];
 		$cachedData = $this->cache->get('');
 		$this->assertEquals(2 * $textSize + $imageSize + 3, $cachedData['size']);
 		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
-		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $mtime);
 		$rootCachedData = $cachedData;
 
 		$this->assertFalse($this->cache->inCache('bar.txt'));
@@ -99,6 +95,27 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $mtime);
 	}
 
+	public function testWriteWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$cachedData = $cache2->get('foo.txt');
+		$this->assertEquals(3, $cachedData['size']);
+		$mtime = $cachedData['mtime'];
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($mtime, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($mtime, $cachedData['mtime']);
+	}
+
 	public function testDelete() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
@@ -106,7 +123,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
 
 		$this->assertTrue($this->cache->inCache('foo.txt'));
-		Filesystem::unlink('foo.txt', 'asd');
+		Filesystem::unlink('foo.txt');
 		$this->assertFalse($this->cache->inCache('foo.txt'));
 		$cachedData = $this->cache->get('');
 		$this->assertEquals(2 * $textSize + $imageSize, $cachedData['size']);
@@ -126,6 +143,26 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
 	}
 
+	public function testDeleteWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		Filesystem::unlink('folder/substorage/foo.txt');
+		$this->assertFalse($cache2->inCache('foo.txt'));
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($substorageCachedData['mtime'], $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($folderCachedData['mtime'], $cachedData['mtime']);
+	}
+
 	public function testRename() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
@@ -145,4 +182,87 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3 * $textSize + $imageSize, $cachedData['size']);
 		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
 	}
+
+	public function testRenameWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		$fooCachedData = $cache2->get('foo.txt');
+		Filesystem::rename('folder/substorage/foo.txt', 'folder/substorage/bar.txt');
+		$this->assertFalse($cache2->inCache('foo.txt'));
+		$this->assertTrue($cache2->inCache('bar.txt'));
+		$cachedData = $cache2->get('bar.txt');
+		$this->assertEquals($fooCachedData['fileid'], $cachedData['fileid']);
+		$mtime = $cachedData['mtime'];
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		// rename can cause mtime change - invalid assert
+//		$this->assertEquals($mtime, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		// rename can cause mtime change - invalid assert
+//		$this->assertEquals($mtime, $cachedData['mtime']);
+	}
+
+	public function testTouch() {
+		$rootCachedData = $this->cache->get('');
+		$fooCachedData = $this->cache->get('foo.txt');
+		Filesystem::touch('foo.txt');
+		$cachedData = $this->cache->get('foo.txt');
+		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($fooCachedData['mtime'], $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('');
+		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
+		$rootCachedData = $cachedData;
+
+		$time = 1371006070;
+		$barCachedData = $this->cache->get('folder/bar.txt');
+		$folderCachedData = $this->cache->get('folder');
+		Filesystem::touch('folder/bar.txt', $time);
+		$cachedData = $this->cache->get('folder/bar.txt');
+		$this->assertNotEquals($barCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('');
+		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+	}
+
+	public function testTouchWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		$fooCachedData = $cache2->get('foo.txt');
+		$cachedData = $cache2->get('foo.txt');
+		$time = 1371006070;
+		Filesystem::touch('folder/substorage/foo.txt', $time);
+		$cachedData = $cache2->get('foo.txt');
+		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+	}
+
 }
diff --git a/tests/lib/files/cache/watcher.php b/tests/lib/files/cache/watcher.php
index 8ef6ab44d10..749b1ab75a3 100644
--- a/tests/lib/files/cache/watcher.php
+++ b/tests/lib/files/cache/watcher.php
@@ -29,13 +29,16 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		}
 	}
 
+	/**
+	 * @medium
+	 */
 	function testWatcher() {
 		$storage = $this->getTestStorage();
 		$cache = $storage->getCache();
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', array('mtime' => 10));
+		$cache->put('', array('storage_mtime' => 10));
 
 		$this->assertTrue($cache->inCache('folder/bar.txt'));
 		$this->assertTrue($cache->inCache('folder/bar2.txt'));
@@ -47,14 +50,14 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$cachedData = $cache->get('bar.test');
 		$this->assertEquals(3, $cachedData['size']);
 
-		$cache->put('bar.test', array('mtime' => 10));
+		$cache->put('bar.test', array('storage_mtime' => 10));
 		$storage->file_put_contents('bar.test', 'test data');
 
 		$updater->checkUpdate('bar.test');
 		$cachedData = $cache->get('bar.test');
 		$this->assertEquals(9, $cachedData['size']);
 
-		$cache->put('folder', array('mtime' => 10));
+		$cache->put('folder', array('storage_mtime' => 10));
 
 		$storage->unlink('folder/bar2.txt');
 		$updater->checkUpdate('folder');
@@ -63,13 +66,16 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$this->assertFalse($cache->inCache('folder/bar2.txt'));
 	}
 
+	/**
+	 * @medium
+	 */
 	public function testFileToFolder() {
 		$storage = $this->getTestStorage();
 		$cache = $storage->getCache();
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', array('mtime' => 10));
+		$cache->put('', array('storage_mtime' => 10));
 
 		$storage->unlink('foo.txt');
 		$storage->rename('folder', 'foo.txt');
@@ -85,7 +91,7 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', array('mtime' => 10));
+		$cache->put('foo.txt', array('storage_mtime' => 10));
 
 		$storage->unlink('foo.txt');
 		$storage->rename('folder', 'foo.txt');
diff --git a/tests/lib/files/filesystem.php b/tests/lib/files/filesystem.php
index 6ce45e6178a..bef70cc725b 100644
--- a/tests/lib/files/filesystem.php
+++ b/tests/lib/files/filesystem.php
@@ -72,7 +72,7 @@ class Filesystem extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('\path'));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo//bar/'));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo////bar'));
-		if (class_exists('Normalizer')) {
+		if (class_exists('Patchwork\PHP\Shim\Normalizer')) {
 			$this->assertEquals("/foo/bar\xC3\xBC", \OC\Files\Filesystem::normalizePath("/foo/baru\xCC\x88"));
 		}
 	}
diff --git a/tests/lib/files/mapper.php b/tests/lib/files/mapper.php
new file mode 100644
index 00000000000..48ae95b7e72
--- /dev/null
+++ b/tests/lib/files/mapper.php
@@ -0,0 +1,64 @@
+<?php
+/**
+ * ownCloud
+ *
+ * @author Thomas Müller
+ * @copyright 2013 Thomas Müller thomas.mueller@owncloud.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU AFFERO GENERAL PUBLIC LICENSE for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace Test\Files;
+
+class Mapper extends \PHPUnit_Framework_TestCase {
+
+	/**
+	 * @var \OC\Files\Mapper
+	 */
+	private $mapper = null;
+
+	public function setUp() {
+		$this->mapper = new \OC\Files\Mapper('D:/');
+	}
+
+	public function testSlugifyPath() {
+		// with extension
+		$this->assertEquals('D:/text.txt', $this->mapper->slugifyPath('D:/text.txt'));
+		$this->assertEquals('D:/text-2.txt', $this->mapper->slugifyPath('D:/text.txt', 2));
+		$this->assertEquals('D:/a/b/text.txt', $this->mapper->slugifyPath('D:/a/b/text.txt'));
+
+		// without extension
+		$this->assertEquals('D:/text', $this->mapper->slugifyPath('D:/text'));
+		$this->assertEquals('D:/text-2', $this->mapper->slugifyPath('D:/text', 2));
+		$this->assertEquals('D:/a/b/text', $this->mapper->slugifyPath('D:/a/b/text'));
+
+		// with double dot
+		$this->assertEquals('D:/text.text.txt', $this->mapper->slugifyPath('D:/text.text.txt'));
+		$this->assertEquals('D:/text.text-2.txt', $this->mapper->slugifyPath('D:/text.text.txt', 2));
+		$this->assertEquals('D:/a/b/text.text.txt', $this->mapper->slugifyPath('D:/a/b/text.text.txt'));
+			
+		// foldername and filename with periods
+		$this->assertEquals('D:/folder.name.with.periods', $this->mapper->slugifyPath('D:/folder.name.with.periods'));
+		$this->assertEquals('D:/folder.name.with.periods/test-2.txt', $this->mapper->slugifyPath('D:/folder.name.with.periods/test.txt', 2));
+		$this->assertEquals('D:/folder.name.with.periods/test.txt', $this->mapper->slugifyPath('D:/folder.name.with.periods/test.txt'));
+
+		// foldername and filename with periods and spaces
+		$this->assertEquals('D:/folder.name.with.peri-ods', $this->mapper->slugifyPath('D:/folder.name.with.peri ods'));
+		$this->assertEquals('D:/folder.name.with.peri-ods/te-st-2.t-x-t', $this->mapper->slugifyPath('D:/folder.name.with.peri ods/te st.t x t', 2));
+		$this->assertEquals('D:/folder.name.with.peri-ods/te-st.t-x-t', $this->mapper->slugifyPath('D:/folder.name.with.peri ods/te st.t x t'));
+
+		
+	}
+}
diff --git a/tests/lib/files/mount.php b/tests/lib/files/mount.php
deleted file mode 100644
index a3dc06cc668..00000000000
--- a/tests/lib/files/mount.php
+++ /dev/null
@@ -1,58 +0,0 @@
-<?php
-/**
- * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
- * This file is licensed under the Affero General Public License version 3 or
- * later.
- * See the COPYING-README file.
- */
-
-namespace Test\Files;
-
-use \OC\Files\Storage\Temporary;
-
-class LongId extends Temporary {
-	public function getId() {
-		return 'long:' . str_repeat('foo', 50) . parent::getId();
-	}
-}
-
-class Mount extends \PHPUnit_Framework_TestCase {
-	public function setup() {
-		\OC_Util::setupFS();
-		\OC\Files\Mount::clear();
-	}
-
-	public function testFind() {
-		$this->assertNull(\OC\Files\Mount::find('/'));
-
-		$rootMount = new \OC\Files\Mount(new Temporary(array()), '/');
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/'));
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/foo/bar'));
-
-		$storage = new Temporary(array());
-		$mount = new \OC\Files\Mount($storage, '/foo');
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/'));
-		$this->assertEquals($mount, \OC\Files\Mount::find('/foo/bar'));
-
-		$this->assertEquals(1, count(\OC\Files\Mount::findIn('/')));
-		new \OC\Files\Mount(new Temporary(array()), '/bar');
-		$this->assertEquals(2, count(\OC\Files\Mount::findIn('/')));
-
-		$id = $mount->getStorageId();
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($id));
-
-		$mount2 = new \OC\Files\Mount($storage, '/foo/bar');
-		$this->assertEquals(array($mount, $mount2), \OC\Files\Mount::findByStorageId($id));
-	}
-
-	public function testLong() {
-		$storage = new LongId(array());
-		$mount = new \OC\Files\Mount($storage, '/foo');
-
-		$id = $mount->getStorageId();
-		$storageId = $storage->getId();
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($id));
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($storageId));
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId(md5($storageId)));
-	}
-}
diff --git a/tests/lib/files/mount/manager.php b/tests/lib/files/mount/manager.php
new file mode 100644
index 00000000000..154c35ccead
--- /dev/null
+++ b/tests/lib/files/mount/manager.php
@@ -0,0 +1,67 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Mount;
+
+use \OC\Files\Storage\Temporary;
+
+class LongId extends Temporary {
+	public function getId() {
+		return 'long:' . str_repeat('foo', 50) . parent::getId();
+	}
+}
+
+class Manager extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var \OC\Files\Mount\Manager
+	 */
+	private $manager;
+
+	public function setup() {
+		$this->manager = new \OC\Files\Mount\Manager();
+	}
+
+	public function testFind() {
+		$this->assertNull($this->manager->find('/'));
+
+		$rootMount = new \OC\Files\Mount\Mount(new Temporary(array()), '/');
+		$this->manager->addMount($rootMount);
+		$this->assertEquals($rootMount, $this->manager->find('/'));
+		$this->assertEquals($rootMount, $this->manager->find('/foo/bar'));
+
+		$storage = new Temporary(array());
+		$mount1 = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->manager->addMount($mount1);
+		$this->assertEquals($rootMount, $this->manager->find('/'));
+		$this->assertEquals($mount1, $this->manager->find('/foo/bar'));
+
+		$this->assertEquals(1, count($this->manager->findIn('/')));
+		$mount2 = new \OC\Files\Mount\Mount(new Temporary(array()), '/bar');
+		$this->manager->addMount($mount2);
+		$this->assertEquals(2, count($this->manager->findIn('/')));
+
+		$id = $mount1->getStorageId();
+		$this->assertEquals(array($mount1), $this->manager->findByStorageId($id));
+
+		$mount3 = new \OC\Files\Mount\Mount($storage, '/foo/bar');
+		$this->manager->addMount($mount3);
+		$this->assertEquals(array($mount1, $mount3), $this->manager->findByStorageId($id));
+	}
+
+	public function testLong() {
+		$storage = new LongId(array());
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->manager->addMount($mount);
+
+		$id = $mount->getStorageId();
+		$storageId = $storage->getId();
+		$this->assertEquals(array($mount), $this->manager->findByStorageId($id));
+		$this->assertEquals(array($mount), $this->manager->findByStorageId($storageId));
+		$this->assertEquals(array($mount), $this->manager->findByStorageId(md5($storageId)));
+	}
+}
diff --git a/tests/lib/files/mount/mount.php b/tests/lib/files/mount/mount.php
new file mode 100644
index 00000000000..b057204ad35
--- /dev/null
+++ b/tests/lib/files/mount/mount.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Mount;
+
+
+use OC\Files\Storage\Loader;
+use OC\Files\Storage\Wrapper\Wrapper;
+
+class Mount extends \PHPUnit_Framework_TestCase {
+	public function testFromStorageObject() {
+		$storage = $this->getMockBuilder('\OC\Files\Storage\Temporary')
+			->disableOriginalConstructor()
+			->getMock();
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->assertInstanceOf('\OC\Files\Storage\Temporary', $mount->getStorage());
+	}
+
+	public function testFromStorageClassname() {
+		$mount = new \OC\Files\Mount\Mount('\OC\Files\Storage\Temporary', '/foo');
+		$this->assertInstanceOf('\OC\Files\Storage\Temporary', $mount->getStorage());
+	}
+
+	public function testWrapper() {
+		$test = $this;
+		$wrapper = function ($mountPoint, $storage) use (&$test) {
+			$test->assertEquals('/foo/', $mountPoint);
+			$test->assertInstanceOf('\OC\Files\Storage\Storage', $storage);
+			return new Wrapper(array('storage' => $storage));
+		};
+
+		$loader = new Loader();
+		$loader->addStorageWrapper($wrapper);
+
+		$storage = $this->getMockBuilder('\OC\Files\Storage\Temporary')
+			->disableOriginalConstructor()
+			->getMock();
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo', array(), $loader);
+		$this->assertInstanceOf('\OC\Files\Storage\Wrapper\Wrapper', $mount->getStorage());
+	}
+}
diff --git a/tests/lib/files/storage/storage.php b/tests/lib/files/storage/storage.php
index 3d68efea5fc..fb3e05e66b3 100644
--- a/tests/lib/files/storage/storage.php
+++ b/tests/lib/files/storage/storage.php
@@ -257,4 +257,22 @@ abstract class Storage extends \PHPUnit_Framework_TestCase {
 		$content = stream_get_contents($fh);
 		$this->assertEquals(file_get_contents($textFile), $content);
 	}
+
+	public function testTouchCreateFile() {
+		$this->assertFalse($this->instance->file_exists('foo'));
+		$this->instance->touch('foo');
+		$this->assertTrue($this->instance->file_exists('foo'));
+	}
+
+	public function testRecursiveRmdir() {
+		$this->instance->mkdir('folder');
+		$this->instance->mkdir('folder/bar');
+		$this->instance->file_put_contents('folder/asd.txt', 'foobar');
+		$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
+		$this->instance->rmdir('folder');
+		$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
+		$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
+		$this->assertFalse($this->instance->file_exists('folder/bar'));
+		$this->assertFalse($this->instance->file_exists('folder'));
+	}
 }
diff --git a/tests/lib/files/storage/wrapper.php b/tests/lib/files/storage/wrapper.php
new file mode 100644
index 00000000000..2794a0a6263
--- /dev/null
+++ b/tests/lib/files/storage/wrapper.php
@@ -0,0 +1,26 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Storage;
+
+class Wrapper extends Storage {
+	/**
+	 * @var string tmpDir
+	 */
+	private $tmpDir;
+
+	public function setUp() {
+		$this->tmpDir = \OC_Helper::tmpFolder();
+		$storage = new \OC\Files\Storage\Local(array('datadir' => $this->tmpDir));
+		$this->instance = new \OC\Files\Storage\Wrapper\Wrapper(array('storage' => $storage));
+	}
+
+	public function tearDown() {
+		\OC_Helper::rmdirr($this->tmpDir);
+	}
+}
diff --git a/tests/lib/files/stream/staticstream.php b/tests/lib/files/stream/staticstream.php
new file mode 100644
index 00000000000..d55086196a0
--- /dev/null
+++ b/tests/lib/files/stream/staticstream.php
@@ -0,0 +1,68 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Stream;
+
+class StaticStream extends \PHPUnit_Framework_TestCase {
+
+	private $sourceFile;
+	private $sourceText;
+
+	public function __construct() {
+		$this->sourceFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$this->sourceText = file_get_contents($this->sourceFile);
+	}
+
+	public function tearDown() {
+		\OC\Files\Stream\StaticStream::clear();
+	}
+
+	public function testContent() {
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertEquals($this->sourceText, file_get_contents('static://foo'));
+	}
+
+	public function testMultipleFiles() {
+		file_put_contents('static://foo', $this->sourceText);
+		file_put_contents('static://bar', strrev($this->sourceText));
+		$this->assertEquals($this->sourceText, file_get_contents('static://foo'));
+		$this->assertEquals(strrev($this->sourceText), file_get_contents('static://bar'));
+	}
+
+	public function testOverwrite() {
+		file_put_contents('static://foo', $this->sourceText);
+		file_put_contents('static://foo', 'qwerty');
+		$this->assertEquals('qwerty', file_get_contents('static://foo'));
+	}
+
+	public function testIsFile() {
+		$this->assertFalse(is_file('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertTrue(is_file('static://foo'));
+	}
+
+	public function testIsDir() {
+		$this->assertFalse(is_dir('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertFalse(is_dir('static://foo'));
+	}
+
+	public function testFileType() {
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertEquals('file', filetype('static://foo'));
+	}
+
+	public function testUnlink() {
+		$this->assertFalse(file_exists('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertTrue(file_exists('static://foo'));
+		unlink('static://foo');
+		clearstatcache();
+		$this->assertFalse(file_exists('static://foo'));
+	}
+}
diff --git a/tests/lib/files/view.php b/tests/lib/files/view.php
index a064e44f3ef..830913a91ad 100644
--- a/tests/lib/files/view.php
+++ b/tests/lib/files/view.php
@@ -7,6 +7,12 @@
 
 namespace Test\Files;
 
+class TemporaryNoTouch extends \OC\Files\Storage\Temporary {
+	public function touch($path, $mtime = null) {
+		return false;
+	}
+}
+
 class View extends \PHPUnit_Framework_TestCase {
 	/**
 	 * @var \OC\Files\Storage\Storage[] $storages;
@@ -27,6 +33,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		}
 	}
 
+	/**
+	 * @medium
+	 */
 	public function testCacheAPI() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -98,6 +107,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array(), $rootView->getDirectoryContent('/non/existing'));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testGetPath() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -121,6 +133,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertNull($folderView->getPath($id1));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testMountPointOverwrite() {
 		$storage1 = $this->getTestStorage(false);
 		$storage2 = $this->getTestStorage();
@@ -164,6 +179,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals($textSize, $folderData[0]['size']);
 	}
 
+	/**
+	 * @medium
+	 */
 	function testSearch() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -211,6 +229,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3, count($folderView->searchByMime('text')));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testWatcher() {
 		$storage1 = $this->getTestStorage();
 		\OC\Files\Filesystem::mount($storage1, array(), '/');
@@ -220,7 +241,7 @@ class View extends \PHPUnit_Framework_TestCase {
 		$cachedData = $rootView->getFileInfo('foo.txt');
 		$this->assertEquals(16, $cachedData['size']);
 
-		$rootView->putFileInfo('foo.txt', array('mtime' => 10));
+		$rootView->putFileInfo('foo.txt', array('storage_mtime' => 10));
 		$storage1->file_put_contents('foo.txt', 'foo');
 		clearstatcache();
 
@@ -229,11 +250,81 @@ class View extends \PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @medium
+	 */
+	function testCopyBetweenStorages() {
+		$storage1 = $this->getTestStorage();
+		$storage2 = $this->getTestStorage();
+		\OC\Files\Filesystem::mount($storage1, array(), '/');
+		\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+
+		$rootView = new \OC\Files\View('');
+		$rootView->mkdir('substorage/emptyfolder');
+		$rootView->copy('substorage', 'anotherfolder');
+		$this->assertTrue($rootView->is_dir('/anotherfolder'));
+		$this->assertTrue($rootView->is_dir('/substorage'));
+		$this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
+		$this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
+		$this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
+		$this->assertTrue($rootView->file_exists('/substorage/foo.png'));
+		$this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
+	}
+
+	/**
+	 * @medium
+	 */
+	function testMoveBetweenStorages() {
+		$storage1 = $this->getTestStorage();
+		$storage2 = $this->getTestStorage();
+		\OC\Files\Filesystem::mount($storage1, array(), '/');
+		\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+
+		$rootView = new \OC\Files\View('');
+		$rootView->rename('foo.txt', 'substorage/folder/foo.txt');
+		$this->assertFalse($rootView->file_exists('foo.txt'));
+		$this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
+		$rootView->rename('substorage/folder', 'anotherfolder');
+		$this->assertFalse($rootView->is_dir('substorage/folder'));
+		$this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
+		$this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
+	}
+
+	/**
+	 * @medium
+	 */
+	function testTouch() {
+		$storage = $this->getTestStorage(true, '\Test\Files\TemporaryNoTouch');
+
+		\OC\Files\Filesystem::mount($storage, array(), '/');
+
+		$rootView = new \OC\Files\View('');
+		$oldCachedData = $rootView->getFileInfo('foo.txt');
+
+		$rootView->touch('foo.txt', 500);
+
+		$cachedData = $rootView->getFileInfo('foo.txt');
+		$this->assertEquals(500, $cachedData['mtime']);
+		$this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
+
+		$rootView->putFileInfo('foo.txt', array('storage_mtime' => 1000)); //make sure the watcher detects the change
+		$rootView->file_put_contents('foo.txt', 'asd');
+		$cachedData = $rootView->getFileInfo('foo.txt');
+		$this->assertGreaterThanOrEqual($cachedData['mtime'], $oldCachedData['mtime']);
+		$this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
+	}
+
+	/**
 	 * @param bool $scan
 	 * @return \OC\Files\Storage\Storage
 	 */
-	private function getTestStorage($scan = true) {
-		$storage = new \OC\Files\Storage\Temporary(array());
+	private function getTestStorage($scan = true, $class = '\OC\Files\Storage\Temporary') {
+		/**
+		 * @var \OC\Files\Storage\Storage $storage
+		 */
+		$storage = new $class(array());
 		$textData = "dummy file data\n";
 		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
 		$storage->mkdir('folder');
diff --git a/tests/lib/geo.php b/tests/lib/geo.php
index 82e61608687..2c3611c092e 100644
--- a/tests/lib/geo.php
+++ b/tests/lib/geo.php
@@ -7,6 +7,10 @@
  */
 
 class Test_Geo extends PHPUnit_Framework_TestCase {
+	
+	/**
+	 * @medium
+	 */
 	function testTimezone() {
 		$result = OC_Geo::timezone(3, 3);
 		$expected = 'Africa/Porto-Novo';
diff --git a/tests/lib/helper.php b/tests/lib/helper.php
index 336e8f8b3c5..6acb0dfaa6b 100644
--- a/tests/lib/helper.php
+++ b/tests/lib/helper.php
@@ -67,6 +67,15 @@ class Test_Helper extends PHPUnit_Framework_TestCase {
 		$this->assertEquals($result, $expected);
 	}
 
+	function testGetFileNameMimeType() {
+		$this->assertEquals('text/plain', OC_Helper::getFileNameMimeType('foo.txt'));
+		$this->assertEquals('image/png', OC_Helper::getFileNameMimeType('foo.png'));
+		$this->assertEquals('image/png', OC_Helper::getFileNameMimeType('foo.bar.png'));
+		$this->assertEquals('application/octet-stream', OC_Helper::getFileNameMimeType('.png'));
+		$this->assertEquals('application/octet-stream', OC_Helper::getFileNameMimeType('foo'));
+		$this->assertEquals('application/octet-stream', OC_Helper::getFileNameMimeType(''));
+	}
+
 	function testGetStringMimeType() {
 		$result = OC_Helper::getStringMimeType("/data/data.tar.gz");
 		$expected = 'text/plain; charset=us-ascii';
diff --git a/tests/lib/hooks/basicemitter.php b/tests/lib/hooks/basicemitter.php
new file mode 100644
index 00000000000..0eae730d030
--- /dev/null
+++ b/tests/lib/hooks/basicemitter.php
@@ -0,0 +1,279 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Hooks;
+
+/**
+ * Class DummyEmitter
+ *
+ * class to make BasicEmitter::emit publicly available
+ *
+ * @package Test\Hooks
+ */
+class DummyEmitter extends \OC\Hooks\BasicEmitter {
+	public function emitEvent($scope, $method, $arguments = array()) {
+		$this->emit($scope, $method, $arguments);
+	}
+}
+
+/**
+ * Class EmittedException
+ *
+ * a dummy exception so we can check if an event is emitted
+ *
+ * @package Test\Hooks
+ */
+class EmittedException extends \Exception {
+}
+
+class BasicEmitter extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var \OC\Hooks\Emitter $emitter
+	 */
+	protected $emitter;
+
+	public function setUp() {
+		$this->emitter = new DummyEmitter();
+	}
+
+	public function nonStaticCallBack() {
+		throw new EmittedException;
+	}
+
+	public static function staticCallBack() {
+		throw new EmittedException;
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testAnonymousFunction() {
+		$this->emitter->listen('Test', 'test', function () {
+			throw new EmittedException;
+		});
+		$this->emitter->emitEvent('Test', 'test');
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testStaticCallback() {
+		$this->emitter->listen('Test', 'test', array('\Test\Hooks\BasicEmitter', 'staticCallBack'));
+		$this->emitter->emitEvent('Test', 'test');
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testNonStaticCallback() {
+		$this->emitter->listen('Test', 'test', array($this, 'nonStaticCallBack'));
+		$this->emitter->emitEvent('Test', 'test');
+	}
+
+	public function testOnlyCallOnce() {
+		$count = 0;
+		$listener = function () use (&$count) {
+			$count++;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->assertEquals(1, $count, 'Listener called an invalid number of times (' . $count . ') expected 1');
+	}
+
+	public function testDifferentMethods() {
+		$count = 0;
+		$listener = function () use (&$count) {
+			$count++;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Test', 'foo', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->emitter->emitEvent('Test', 'foo');
+		$this->assertEquals(2, $count, 'Listener called an invalid number of times (' . $count . ') expected 2');
+	}
+
+	public function testDifferentScopes() {
+		$count = 0;
+		$listener = function () use (&$count) {
+			$count++;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Bar', 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->emitter->emitEvent('Bar', 'test');
+		$this->assertEquals(2, $count, 'Listener called an invalid number of times (' . $count . ') expected 2');
+	}
+
+	public function testDifferentCallbacks() {
+		$count = 0;
+		$listener1 = function () use (&$count) {
+			$count++;
+		};
+		$listener2 = function () use (&$count) {
+			$count++;
+		};
+		$this->emitter->listen('Test', 'test', $listener1);
+		$this->emitter->listen('Test', 'test', $listener2);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->assertEquals(2, $count, 'Listener called an invalid number of times (' . $count . ') expected 2');
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testArguments() {
+		$this->emitter->listen('Test', 'test', function ($foo, $bar) {
+			if ($foo == 'foo' and $bar == 'bar') {
+				throw new EmittedException;
+			}
+		});
+		$this->emitter->emitEvent('Test', 'test', array('foo', 'bar'));
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testNamedArguments() {
+		$this->emitter->listen('Test', 'test', function ($foo, $bar) {
+			if ($foo == 'foo' and $bar == 'bar') {
+				throw new EmittedException;
+			}
+		});
+		$this->emitter->emitEvent('Test', 'test', array('foo' => 'foo', 'bar' => 'bar'));
+	}
+
+	public function testRemoveAllSpecified() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->removeListener('Test', 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	public function testRemoveWildcardListener() {
+		$listener1 = function () {
+			throw new EmittedException;
+		};
+		$listener2 = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener1);
+		$this->emitter->listen('Test', 'test', $listener2);
+		$this->emitter->removeListener('Test', 'test');
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	public function testRemoveWildcardMethod() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Test', 'foo', $listener);
+		$this->emitter->removeListener('Test', null, $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->emitter->emitEvent('Test', 'foo');
+
+		$this->assertTrue(true);
+	}
+
+	public function testRemoveWildcardScope() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Bar', 'test', $listener);
+		$this->emitter->removeListener(null, 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->emitter->emitEvent('Bar', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	public function testRemoveWildcardScopeAndMethod() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Test', 'foo', $listener);
+		$this->emitter->listen('Bar', 'foo', $listener);
+		$this->emitter->removeListener(null, null, $listener);
+		$this->emitter->emitEvent('Test', 'test');
+		$this->emitter->emitEvent('Test', 'foo');
+		$this->emitter->emitEvent('Bar', 'foo');
+
+		$this->assertTrue(true);
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testRemoveKeepOtherCallback() {
+		$listener1 = function () {
+			throw new EmittedException;
+		};
+		$listener2 = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener1);
+		$this->emitter->listen('Test', 'test', $listener2);
+		$this->emitter->removeListener('Test', 'test', $listener1);
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testRemoveKeepOtherMethod() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Test', 'foo', $listener);
+		$this->emitter->removeListener('Test', 'foo', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testRemoveKeepOtherScope() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->listen('Bar', 'test', $listener);
+		$this->emitter->removeListener('Bar', 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+
+	/**
+	 * @expectedException \Test\Hooks\EmittedException
+	 */
+	public function testRemoveNonExistingName() {
+		$listener = function () {
+			throw new EmittedException;
+		};
+		$this->emitter->listen('Test', 'test', $listener);
+		$this->emitter->removeListener('Bar', 'test', $listener);
+		$this->emitter->emitEvent('Test', 'test');
+
+		$this->assertTrue(true);
+	}
+}
diff --git a/tests/lib/hooks/forwardingemitter.php b/tests/lib/hooks/forwardingemitter.php
new file mode 100644
index 00000000000..decf6bb354c
--- /dev/null
+++ b/tests/lib/hooks/forwardingemitter.php
@@ -0,0 +1,74 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Hooks;
+use OC\Hooks\PublicEmitter;
+
+class DummyForwardingEmitter extends \OC\Hooks\ForwardingEmitter {
+	public function emitEvent($scope, $method, $arguments = array()) {
+		$this->emit($scope, $method, $arguments);
+	}
+
+	/**
+	 * @param \OC\Hooks\Emitter $emitter
+	 */
+	public function forward($emitter) {
+		parent::forward($emitter);
+	}
+}
+
+/**
+ * Class ForwardingEmitter
+ *
+ * allows forwarding all listen calls to other emitters
+ *
+ * @package OC\Hooks
+ */
+class ForwardingEmitter extends BasicEmitter {
+	public function testSingleForward() {
+		$baseEmitter = new PublicEmitter();
+		$forwardingEmitter = new DummyForwardingEmitter();
+		$forwardingEmitter->forward($baseEmitter);
+		$hookCalled = false;
+		$forwardingEmitter->listen('Test', 'test', function () use (&$hookCalled) {
+			$hookCalled = true;
+		});
+		$baseEmitter->emit('Test', 'test');
+		$this->assertTrue($hookCalled);
+	}
+
+	public function testMultipleForwards() {
+		$baseEmitter1 = new PublicEmitter();
+		$baseEmitter2 = new PublicEmitter();
+		$forwardingEmitter = new DummyForwardingEmitter();
+		$forwardingEmitter->forward($baseEmitter1);
+		$forwardingEmitter->forward($baseEmitter2);
+		$hookCalled = 0;
+		$forwardingEmitter->listen('Test', 'test1', function () use (&$hookCalled) {
+			$hookCalled++;
+		});
+		$forwardingEmitter->listen('Test', 'test2', function () use (&$hookCalled) {
+			$hookCalled++;
+		});
+		$baseEmitter1->emit('Test', 'test1');
+		$baseEmitter1->emit('Test', 'test2');
+		$this->assertEquals(2, $hookCalled);
+	}
+
+	public function testForwardExistingHooks() {
+		$baseEmitter = new PublicEmitter();
+		$forwardingEmitter = new DummyForwardingEmitter();
+		$hookCalled = false;
+		$forwardingEmitter->listen('Test', 'test', function () use (&$hookCalled) {
+			$hookCalled = true;
+		});
+		$forwardingEmitter->forward($baseEmitter);
+		$baseEmitter->emit('Test', 'test');
+		$this->assertTrue($hookCalled);
+	}
+}
diff --git a/tests/lib/hooks/legacyemitter.php b/tests/lib/hooks/legacyemitter.php
new file mode 100644
index 00000000000..a7bed879a72
--- /dev/null
+++ b/tests/lib/hooks/legacyemitter.php
@@ -0,0 +1,55 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Hooks;
+
+/**
+ * Class DummyLegacyEmitter
+ *
+ * class to make LegacyEmitter::emit publicly available
+ *
+ * @package Test\Hooks
+ */
+class DummyLegacyEmitter extends \OC\Hooks\LegacyEmitter {
+	public function emitEvent($scope, $method, $arguments = array()) {
+		$this->emit($scope, $method, $arguments);
+	}
+}
+
+class LegacyEmitter extends BasicEmitter {
+
+	//we can't use exceptions here since OC_Hooks catches all exceptions
+	private static $emitted = false;
+
+	public function setUp() {
+		$this->emitter = new DummyLegacyEmitter();
+		self::$emitted = false;
+		\OC_Hook::clear('Test','test');
+	}
+
+	public static function staticLegacyCallBack() {
+		self::$emitted = true;
+	}
+
+	public static function staticLegacyArgumentsCallBack($arguments) {
+		if ($arguments['foo'] == 'foo' and $arguments['bar'] == 'bar')
+			self::$emitted = true;
+	}
+
+	public function testLegacyHook() {
+		\OC_Hook::connect('Test', 'test', '\Test\Hooks\LegacyEmitter', 'staticLegacyCallBack');
+		$this->emitter->emitEvent('Test', 'test');
+		$this->assertEquals(true, self::$emitted);
+	}
+
+	public function testLegacyArguments() {
+		\OC_Hook::connect('Test', 'test', '\Test\Hooks\LegacyEmitter', 'staticLegacyArgumentsCallBack');
+		$this->emitter->emitEvent('Test', 'test', array('foo' => 'foo', 'bar' => 'bar'));
+		$this->assertEquals(true, self::$emitted);
+	}
+}
diff --git a/tests/lib/public/contacts.php b/tests/lib/public/contacts.php
index ce5d762226b..d6008876a00 100644
--- a/tests/lib/public/contacts.php
+++ b/tests/lib/public/contacts.php
@@ -19,8 +19,6 @@
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-OC::autoload('OCP\Contacts');
-
 class Test_Contacts extends PHPUnit_Framework_TestCase
 {
 
diff --git a/tests/lib/session/memory.php b/tests/lib/session/memory.php
new file mode 100644
index 00000000000..2dc236b73bf
--- /dev/null
+++ b/tests/lib/session/memory.php
@@ -0,0 +1,16 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Session;
+
+class Memory extends Session {
+	public function setUp() {
+		$this->instance = new \OC\Session\Memory(uniqid());
+	}
+}
diff --git a/tests/lib/session/session.php b/tests/lib/session/session.php
new file mode 100644
index 00000000000..9ce11274c84
--- /dev/null
+++ b/tests/lib/session/session.php
@@ -0,0 +1,66 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Session;
+
+abstract class Session extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var \OC\Session\Session
+	 */
+	protected $instance;
+
+	public function tearDown() {
+		$this->instance->clear();
+	}
+
+	public function testNotExistsEmpty() {
+		$this->assertFalse($this->instance->exists('foo'));
+	}
+
+	public function testExistsAfterSet() {
+		$this->instance->set('foo', 1);
+		$this->assertTrue($this->instance->exists('foo'));
+	}
+
+	public function testNotExistsAfterRemove() {
+		$this->instance->set('foo', 1);
+		$this->instance->remove('foo');
+		$this->assertFalse($this->instance->exists('foo'));
+	}
+
+	public function testGetNonExisting() {
+		$this->assertNull($this->instance->get('foo'));
+	}
+
+	public function testGetAfterSet() {
+		$this->instance->set('foo', 'bar');
+		$this->assertEquals('bar', $this->instance->get(('foo')));
+	}
+
+	public function testRemoveNonExisting() {
+		$this->assertFalse($this->instance->exists('foo'));
+		$this->instance->remove('foo');
+		$this->assertFalse($this->instance->exists('foo'));
+	}
+
+	public function testNotExistsAfterClear() {
+		$this->instance->set('foo', 1);
+		$this->instance->clear();
+		$this->assertFalse($this->instance->exists('foo'));
+	}
+
+	public function testArrayInterface() {
+		$this->assertFalse(isset($this->instance['foo']));
+		$this->instance['foo'] = 'bar';
+		$this->assertTrue(isset($this->instance['foo']));
+		$this->assertEquals('bar', $this->instance['foo']);
+		unset($this->instance['foo']);
+		$this->assertFalse(isset($this->instance['foo']));
+	}
+}
diff --git a/tests/lib/streamwrappers.php b/tests/lib/streamwrappers.php
index 2237ee7d378..d15b712139d 100644
--- a/tests/lib/streamwrappers.php
+++ b/tests/lib/streamwrappers.php
@@ -33,18 +33,6 @@ class Test_StreamWrappers extends PHPUnit_Framework_TestCase {
 		$this->assertEquals(count($items), count($result));
 	}
 
-	public function testStaticStream() {
-		$sourceFile = OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$staticFile = 'static://test';
-		$this->assertFalse(file_exists($staticFile));
-		file_put_contents($staticFile, file_get_contents($sourceFile));
-		$this->assertTrue(file_exists($staticFile));
-		$this->assertEquals(file_get_contents($sourceFile), file_get_contents($staticFile));
-		unlink($staticFile);
-		clearstatcache();
-		$this->assertFalse(file_exists($staticFile));
-	}
-
 	public function testCloseStream() {
 		//ensure all basic stream stuff works
 		$sourceFile = OC::$SERVERROOT . '/tests/data/lorem.txt';
@@ -77,10 +65,10 @@ class Test_StreamWrappers extends PHPUnit_Framework_TestCase {
 	}
 
 	public function testOC() {
-		\OC\Files\Mount::clear();
+		\OC\Files\Filesystem::clearMounts();
 		$storage = new \OC\Files\Storage\Temporary(array());
 		$storage->file_put_contents('foo.txt', 'asd');
-		new \OC\Files\Mount($storage, '/');
+		\OC\Files\Filesystem::mount($storage, array(), '/');
 
 		$this->assertTrue(file_exists('oc:///foo.txt'));
 		$this->assertEquals('asd', file_get_contents('oc:///foo.txt'));
diff --git a/tests/lib/template.php b/tests/lib/template.php
index 6e88d4c07fc..fd12119da58 100644
--- a/tests/lib/template.php
+++ b/tests/lib/template.php
@@ -20,10 +20,13 @@
 *
 */
 
-OC::autoload('OC_Template');
-
 class Test_TemplateFunctions extends PHPUnit_Framework_TestCase {
 
+	public function setUp() {
+		$loader = new \OC\Autoloader();
+		$loader->load('OC_Template');
+	}
+
 	public function testP() {
 		// FIXME: do we need more testcases?
 		$htmlString = "<script>alert('xss');</script>";
diff --git a/tests/lib/user/manager.php b/tests/lib/user/manager.php
new file mode 100644
index 00000000000..bc49f6db4b2
--- /dev/null
+++ b/tests/lib/user/manager.php
@@ -0,0 +1,304 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\User;
+
+class Manager extends \PHPUnit_Framework_TestCase {
+	public function testUserExistsSingleBackendExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$this->assertTrue($manager->userExists('foo'));
+	}
+
+	public function testUserExistsSingleBackendNotExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$this->assertFalse($manager->userExists('foo'));
+	}
+
+	public function testUserExistsNoBackends() {
+		$manager = new \OC\User\Manager();
+
+		$this->assertFalse($manager->userExists('foo'));
+	}
+
+	public function testUserExistsTwoBackendsSecondExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
+		 */
+		$backend1 = $this->getMock('\OC_User_Dummy');
+		$backend1->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
+		 */
+		$backend2 = $this->getMock('\OC_User_Dummy');
+		$backend2->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend1);
+		$manager->registerBackend($backend2);
+
+		$this->assertTrue($manager->userExists('foo'));
+	}
+
+	public function testUserExistsTwoBackendsFirstExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
+		 */
+		$backend1 = $this->getMock('\OC_User_Dummy');
+		$backend1->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
+		 */
+		$backend2 = $this->getMock('\OC_User_Dummy');
+		$backend2->expects($this->never())
+			->method('userExists');
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend1);
+		$manager->registerBackend($backend2);
+
+		$this->assertTrue($manager->userExists('foo'));
+	}
+
+	public function testGetOneBackendExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$this->assertEquals('foo', $manager->get('foo')->getUID());
+	}
+
+	public function testGetOneBackendNotExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$this->assertEquals(null, $manager->get('foo'));
+	}
+
+	public function testSearchOneBackend() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('getUsers')
+			->with($this->equalTo('fo'))
+			->will($this->returnValue(array('foo', 'afoo')));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$result = $manager->search('fo');
+		$this->assertEquals(2, count($result));
+		$this->assertEquals('afoo', $result[0]->getUID());
+		$this->assertEquals('foo', $result[1]->getUID());
+	}
+
+	public function testSearchTwoBackendLimitOffset() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
+		 */
+		$backend1 = $this->getMock('\OC_User_Dummy');
+		$backend1->expects($this->once())
+			->method('getUsers')
+			->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
+			->will($this->returnValue(array('foo1', 'foo2')));
+
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
+		 */
+		$backend2 = $this->getMock('\OC_User_Dummy');
+		$backend2->expects($this->once())
+			->method('getUsers')
+			->with($this->equalTo('fo'), $this->equalTo(1), $this->equalTo(0))
+			->will($this->returnValue(array('foo3')));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend1);
+		$manager->registerBackend($backend2);
+
+		$result = $manager->search('fo', 3, 1);
+		$this->assertEquals(3, count($result));
+		$this->assertEquals('foo1', $result[0]->getUID());
+		$this->assertEquals('foo2', $result[1]->getUID());
+		$this->assertEquals('foo3', $result[2]->getUID());
+	}
+
+	public function testCreateUserSingleBackendNotExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->once())
+			->method('createUser')
+			->with($this->equalTo('foo'), $this->equalTo('bar'));
+
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$user = $manager->createUser('foo', 'bar');
+		$this->assertEquals('foo', $user->getUID());
+	}
+
+	/**
+	 * @expectedException \Exception
+	 */
+	public function testCreateUserSingleBackendExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->never())
+			->method('createUser');
+
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$manager->createUser('foo', 'bar');
+	}
+
+	public function testCreateUserSingleBackendNotSupported() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$backend->expects($this->never())
+			->method('createUser');
+
+		$backend->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$this->assertFalse($manager->createUser('foo', 'bar'));
+	}
+
+	public function testCreateUserNoBackends() {
+		$manager = new \OC\User\Manager();
+
+		$this->assertFalse($manager->createUser('foo', 'bar'));
+	}
+
+	/**
+	 * @expectedException \Exception
+	 */
+	public function testCreateUserTwoBackendExists() {
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
+		 */
+		$backend1 = $this->getMock('\OC_User_Dummy');
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend1->expects($this->never())
+			->method('createUser');
+
+		$backend1->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(false));
+
+		/**
+		 * @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
+		 */
+		$backend2 = $this->getMock('\OC_User_Dummy');
+		$backend2->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend2->expects($this->never())
+			->method('createUser');
+
+		$backend2->expects($this->once())
+			->method('userExists')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend1);
+		$manager->registerBackend($backend2);
+
+		$manager->createUser('foo', 'bar');
+	}
+}
diff --git a/tests/lib/user/session.php b/tests/lib/user/session.php
new file mode 100644
index 00000000000..274e9e2831e
--- /dev/null
+++ b/tests/lib/user/session.php
@@ -0,0 +1,155 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\User;
+
+class Session extends \PHPUnit_Framework_TestCase {
+	public function testGetUser() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->once())
+			->method('get')
+			->with('user_id')
+			->will($this->returnValue('foo'));
+
+		$backend = $this->getMock('OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('userExists')
+			->with('foo')
+			->will($this->returnValue(true));
+
+		$manager = new \OC\User\Manager();
+		$manager->registerBackend($backend);
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$user = $userSession->getUser();
+		$this->assertEquals('foo', $user->getUID());
+	}
+
+	public function testSetUser() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->once())
+			->method('set')
+			->with('user_id', 'foo');
+
+		$manager = $this->getMock('\OC\User\Manager');
+
+		$backend = $this->getMock('OC_User_Dummy');
+
+		$user = $this->getMock('\OC\User\User', array(), array('foo', $backend));
+		$user->expects($this->once())
+			->method('getUID')
+			->will($this->returnValue('foo'));
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$userSession->setUser($user);
+	}
+
+	public function testLoginValidPasswordEnabled() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->once())
+			->method('set')
+			->with('user_id', 'foo');
+
+		$manager = $this->getMock('\OC\User\Manager');
+
+		$backend = $this->getMock('OC_User_Dummy');
+
+		$user = $this->getMock('\OC\User\User', array(), array('foo', $backend));
+		$user->expects($this->once())
+			->method('checkPassword')
+			->with('bar')
+			->will($this->returnValue(true));
+		$user->expects($this->once())
+			->method('isEnabled')
+			->will($this->returnValue(true));
+		$user->expects($this->any())
+			->method('getUID')
+			->will($this->returnValue('foo'));
+
+		$manager->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue($user));
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$userSession->login('foo', 'bar');
+		$this->assertEquals($user, $userSession->getUser());
+	}
+
+	public function testLoginValidPasswordDisabled() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->never())
+			->method('set');
+
+		$manager = $this->getMock('\OC\User\Manager');
+
+		$backend = $this->getMock('OC_User_Dummy');
+
+		$user = $this->getMock('\OC\User\User', array(), array('foo', $backend));
+		$user->expects($this->once())
+			->method('checkPassword')
+			->with('bar')
+			->will($this->returnValue(true));
+		$user->expects($this->once())
+			->method('isEnabled')
+			->will($this->returnValue(false));
+
+		$manager->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue($user));
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$userSession->login('foo', 'bar');
+	}
+
+	public function testLoginInValidPassword() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->never())
+			->method('set');
+
+		$manager = $this->getMock('\OC\User\Manager');
+
+		$backend = $this->getMock('OC_User_Dummy');
+
+		$user = $this->getMock('\OC\User\User', array(), array('foo', $backend));
+		$user->expects($this->once())
+			->method('checkPassword')
+			->with('bar')
+			->will($this->returnValue(false));
+		$user->expects($this->never())
+			->method('isEnabled');
+
+		$manager->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue($user));
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$userSession->login('foo', 'bar');
+	}
+
+	public function testLoginNonExisting() {
+		$session = $this->getMock('\OC\Session\Memory', array(), array(''));
+		$session->expects($this->never())
+			->method('set');
+
+		$manager = $this->getMock('\OC\User\Manager');
+
+		$backend = $this->getMock('OC_User_Dummy');
+
+		$manager->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue(null));
+
+		$userSession = new \OC\User\Session($manager, $session);
+		$userSession->login('foo', 'bar');
+	}
+}
diff --git a/tests/lib/user/user.php b/tests/lib/user/user.php
new file mode 100644
index 00000000000..b0d170cbfc5
--- /dev/null
+++ b/tests/lib/user/user.php
@@ -0,0 +1,364 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\User;
+
+use OC\Hooks\PublicEmitter;
+
+class User extends \PHPUnit_Framework_TestCase {
+	public function testDisplayName() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Backend');
+		$backend->expects($this->once())
+			->method('getDisplayName')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue('Foo'));
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->with($this->equalTo(\OC_USER_BACKEND_GET_DISPLAYNAME))
+			->will($this->returnValue(true));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertEquals('Foo', $user->getDisplayName());
+	}
+
+	public function testDisplayNameNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Backend');
+		$backend->expects($this->never())
+			->method('getDisplayName');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->with($this->equalTo(\OC_USER_BACKEND_GET_DISPLAYNAME))
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertEquals('foo', $user->getDisplayName());
+	}
+
+	public function testSetPassword() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('setPassword')
+			->with($this->equalTo('foo'), $this->equalTo('bar'));
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->setPassword('bar',''));
+	}
+
+	public function testSetPasswordNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->never())
+			->method('setPassword');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertFalse($user->setPassword('bar',''));
+	}
+
+	public function testDelete() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('deleteUser')
+			->with($this->equalTo('foo'));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->delete());
+	}
+
+	public function testCheckPassword() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('checkPassword')
+			->with($this->equalTo('foo'), $this->equalTo('bar'))
+			->will($this->returnValue(true));
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_CHECK_PASSWORD) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->checkPassword('bar'));
+	}
+
+	public function testCheckPasswordNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->never())
+			->method('checkPassword');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertFalse($user->checkPassword('bar'));
+	}
+
+	public function testGetHome() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('getHome')
+			->with($this->equalTo('foo'))
+			->will($this->returnValue('/home/foo'));
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_GET_HOME) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertEquals('/home/foo', $user->getHome());
+	}
+
+	public function testGetHomeNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->never())
+			->method('getHome');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertEquals(\OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data") . '/foo', $user->getHome());
+	}
+
+	public function testCanChangePassword() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->canChangePassword());
+	}
+
+	public function testCanChangePasswordNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertFalse($user->canChangePassword());
+	}
+
+	public function testCanChangeDisplayName() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_SET_DISPLAYNAME) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->canChangeDisplayName());
+	}
+
+	public function testCanChangeDisplayNameNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(false));
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertFalse($user->canChangeDisplayName());
+	}
+
+	public function testSetDisplayNameSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Database');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_SET_DISPLAYNAME) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$backend->expects($this->once())
+			->method('setDisplayName')
+			->with('foo','Foo');
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertTrue($user->setDisplayName('Foo'));
+		$this->assertEquals('Foo',$user->getDisplayName());
+	}
+
+	public function testSetDisplayNameNotSupported() {
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Database');
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+					return false;
+			}));
+
+		$backend->expects($this->never())
+			->method('setDisplayName');
+
+		$user = new \OC\User\User('foo', $backend);
+		$this->assertFalse($user->setDisplayName('Foo'));
+		$this->assertEquals('foo',$user->getDisplayName());
+	}
+
+	public function testSetPasswordHooks() {
+		$hooksCalled = 0;
+		$test = $this;
+
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('setPassword');
+
+		/**
+		 * @param \OC\User\User $user
+		 * @param string $password
+		 */
+		$hook = function ($user, $password) use ($test, &$hooksCalled) {
+			$hooksCalled++;
+			$test->assertEquals('foo', $user->getUID());
+			$test->assertEquals('bar', $password);
+		};
+
+		$emitter = new PublicEmitter();
+		$emitter->listen('\OC\User', 'preSetPassword', $hook);
+		$emitter->listen('\OC\User', 'postSetPassword', $hook);
+
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnCallback(function ($actions) {
+				if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
+					return true;
+				} else {
+					return false;
+				}
+			}));
+
+		$user = new \OC\User\User('foo', $backend, $emitter);
+
+		$user->setPassword('bar','');
+		$this->assertEquals(2, $hooksCalled);
+	}
+
+	public function testDeleteHooks() {
+		$hooksCalled = 0;
+		$test = $this;
+
+		/**
+		 * @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
+		 */
+		$backend = $this->getMock('\OC_User_Dummy');
+		$backend->expects($this->once())
+			->method('deleteUser');
+
+		/**
+		 * @param \OC\User\User $user
+		 */
+		$hook = function ($user) use ($test, &$hooksCalled) {
+			$hooksCalled++;
+			$test->assertEquals('foo', $user->getUID());
+		};
+
+		$emitter = new PublicEmitter();
+		$emitter->listen('\OC\User', 'preDelete', $hook);
+		$emitter->listen('\OC\User', 'postDelete', $hook);
+
+		$user = new \OC\User\User('foo', $backend, $emitter);
+		$this->assertTrue($user->delete());
+		$this->assertEquals(2, $hooksCalled);
+	}
+}
diff --git a/tests/lib/util.php b/tests/lib/util.php
index b904c359807..9742d57ac7a 100644
--- a/tests/lib/util.php
+++ b/tests/lib/util.php
@@ -37,6 +37,12 @@ class Test_Util extends PHPUnit_Framework_TestCase {
 		$result = OC_Util::sanitizeHTML($goodString);
 		$this->assertEquals("This is an harmless string.", $result);
 	}
+	
+	function testEncodePath(){
+		$component = '/§#@test%&^ä/-child';
+		$result = OC_Util::encodePath($component);
+		$this->assertEquals("/%C2%A7%23%40test%25%26%5E%C3%A4/-child", $result);
+	}
 
 	function testGenerate_random_bytes() {
 		$result = strlen(OC_Util::generate_random_bytes(59));
@@ -47,4 +53,16 @@ class Test_Util extends PHPUnit_Framework_TestCase {
 		$email = \OCP\Util::getDefaultEmailAddress("no-reply");
 		$this->assertEquals('no-reply@localhost.localdomain', $email);
 	}
-}
\ No newline at end of file
+
+	function testGetDefaultEmailAddressFromConfig() {
+		OC_Config::setValue('mail_domain', 'example.com');
+		$email = \OCP\Util::getDefaultEmailAddress("no-reply");
+		$this->assertEquals('no-reply@example.com', $email);
+		OC_Config::deleteKey('mail_domain');
+	}
+
+  function testGetInstanceIdGeneratesValidId() {
+    OC_Config::deleteKey('instanceid');
+    $this->assertStringStartsWith('oc', OC_Util::getInstanceId());
+  }
+}
diff --git a/tests/lib/vcategories.php b/tests/lib/vcategories.php
index e79dd49870c..df5f600f20d 100644
--- a/tests/lib/vcategories.php
+++ b/tests/lib/vcategories.php
@@ -81,6 +81,17 @@ class Test_VCategories extends PHPUnit_Framework_TestCase {
 
 	}
 
+	public function testrenameCategory() {
+		$defcategories = array('Friends', 'Family', 'Wrok', 'Other');
+		$catmgr = new OC_VCategories($this->objectType, $this->user, $defcategories);
+
+		$this->assertTrue($catmgr->rename('Wrok', 'Work'));
+		$this->assertTrue($catmgr->hasCategory('Work'));
+		$this->assertFalse($catmgr->hasCategory('Wrok'));
+		$this->assertFalse($catmgr->rename('Wrok', 'Work'));
+
+	}
+
 	public function testAddToCategory() {
 		$objids = array(1, 2, 3, 4, 5, 6, 7, 8, 9);
 
diff --git a/tests/lib/vobject.php b/tests/lib/vobject.php
new file mode 100644
index 00000000000..f28d22a1fcd
--- /dev/null
+++ b/tests/lib/vobject.php
@@ -0,0 +1,38 @@
+<?php
+/**
+ * Copyright (c) 2013 Thomas Tanghus (thomas@tanghus.net)
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+class Test_VObject extends PHPUnit_Framework_TestCase {
+
+	public function setUp() {
+		Sabre\VObject\Property::$classMap['SUMMARY'] = 'OC\VObject\StringProperty';
+		Sabre\VObject\Property::$classMap['ORG'] = 'OC\VObject\CompoundProperty';
+	}
+
+	function testStringProperty() {
+		$property = Sabre\VObject\Property::create('SUMMARY', 'Escape;this,please');
+		$this->assertEquals("SUMMARY:Escape\;this\,please\r\n", $property->serialize());
+	}
+
+	function testCompoundProperty() {
+
+		$arr = array(
+			'ABC, Inc.',
+			'North American Division',
+			'Marketing;Sales',
+		);
+
+		$property = Sabre\VObject\Property::create('ORG');
+		$property->setParts($arr);
+
+		$this->assertEquals('ABC\, Inc.;North American Division;Marketing\;Sales', $property->value);
+		$this->assertEquals('ORG:ABC\, Inc.;North American Division;Marketing\;Sales' . "\r\n", $property->serialize());
+		$this->assertEquals(3, count($property->getParts()));
+		$parts = $property->getParts();
+		$this->assertEquals('Marketing;Sales', $parts[2]);
+	}
+}
\ No newline at end of file
diff --git a/tests/phpunit-autotest.xml b/tests/phpunit-autotest.xml
index 23cd123edc6..23b2d6c0060 100644
--- a/tests/phpunit-autotest.xml
+++ b/tests/phpunit-autotest.xml
@@ -1,14 +1,38 @@
 <?xml version="1.0" encoding="utf-8" ?>
-<phpunit bootstrap="bootstrap.php">
+<phpunit bootstrap="bootstrap.php"
+		 strict="true"
+		 timeoutForSmallTests="900"
+		 timeoutForMediumTests="900"
+		 timeoutForLargeTests="900"
+>
 	<testsuite name='ownCloud'>
 		<directory suffix='.php'>lib/</directory>
 		<file>apps.php</file>
 	</testsuite>
 	<!-- filters for code coverage -->
-	<whitelist processUncoveredFilesFromWhitelist="true">
-		<directory suffix=".php">..</directory>
-		<exclude>
-			<directory suffix=".php">../3rdparty</directory>
-		</exclude>
-	</whitelist>
+	<filter>
+		<!-- whitelist processUncoveredFilesFromWhitelist="true" -->
+		<whitelist>
+			<directory suffix=".php">..</directory>
+			<exclude>
+				<directory suffix=".php">../3rdparty</directory>
+				<directory suffix=".php">../apps/files/l10n</directory>
+				<directory suffix=".php">../apps/files_external/l10n</directory>
+				<directory suffix=".php">../apps/files_external/3rdparty</directory>
+				<directory suffix=".php">../apps/files_versions/l10n</directory>
+				<directory suffix=".php">../apps/files_encryption/l10n</directory>
+				<directory suffix=".php">../apps/files_encryption/3rdparty</directory>
+				<directory suffix=".php">../apps/files_sharing/l10n</directory>
+				<directory suffix=".php">../apps/files_trashbin/l10n</directory>
+				<directory suffix=".php">../apps/user_ldap/l10n</directory>
+				<directory suffix=".php">../apps/user_webdavauth/l10n</directory>
+				<directory suffix=".php">../lib/MDB2</directory>
+				<directory suffix=".php">../lib/l10n</directory>
+				<directory suffix=".php">../core/l10n</directory>
+				<directory suffix=".php">../settings/l10n</directory>
+				<directory suffix=".php">../tests</directory>
+			</exclude>
+		</whitelist>
+	</filter>
 </phpunit>
+
diff --git a/tests/phpunit.xml b/tests/phpunit.xml
deleted file mode 100644
index f5a686c3020..00000000000
--- a/tests/phpunit.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<phpunit bootstrap="bootstrap.php">
-	<testsuite name='ownCloud'>
-		<directory suffix='.php'>lib/</directory>
-		<file>apps.php</file>
-	</testsuite>
-	<!-- filters for code coverage -->
-	<whitelist processUncoveredFilesFromWhitelist="true">
-		<directory suffix=".php">..</directory>
-		<exclude>
-			<directory suffix=".php">../3rdparty</directory>
-		</exclude>
-	</whitelist>
-	<listeners>
-		<listener class="PHPUnit_Util_Log_JSON"></listener>
-	</listeners>
-</phpunit>
diff --git a/tests/phpunit.xml.dist b/tests/phpunit.xml.dist
new file mode 100644
index 00000000000..25dfc64cfeb
--- /dev/null
+++ b/tests/phpunit.xml.dist
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<phpunit bootstrap="bootstrap.php">
+	<testsuite name='ownCloud'>
+		<directory suffix='.php'>lib/</directory>
+		<file>apps.php</file>
+	</testsuite>
+	<!-- filters for code coverage -->
+	<filter>
+		<!-- whitelist processUncoveredFilesFromWhitelist="true" -->
+		<whitelist>
+			<directory suffix=".php">..</directory>
+			<exclude>
+				<directory suffix=".php">../3rdparty</directory>
+				<directory suffix=".php">../lib/MDB2</directory>
+			</exclude>
+		</whitelist>
+	</filter>
+</phpunit>