diff --git a/tests/extensions/7.0/memcached.so b/tests/extensions/7.0/memcached.so
deleted file mode 100755
index 544ba6d5..00000000
Binary files a/tests/extensions/7.0/memcached.so and /dev/null differ
diff --git a/tests/extensions/7.0/redis.so b/tests/extensions/7.0/redis.so
deleted file mode 100755
index e3aea8fc..00000000
Binary files a/tests/extensions/7.0/redis.so and /dev/null differ
diff --git a/tests/thinkphp/library/think/cacheTest.php b/tests/thinkphp/library/think/cacheTest.php
new file mode 100644
index 00000000..dbcd7053
--- /dev/null
+++ b/tests/thinkphp/library/think/cacheTest.php
@@ -0,0 +1,315 @@
+<?php
+// +----------------------------------------------------------------------
+// | ThinkPHP [ WE CAN DO IT JUST THINK ]
+// +----------------------------------------------------------------------
+// | Copyright (c) 2006~2016 http://thinkphp.cn All rights reserved.
+// +----------------------------------------------------------------------
+// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
+// +----------------------------------------------------------------------
+// | Author: liu21st <liu21st@gmail.com>
+// +----------------------------------------------------------------------
+
+namespace tests\thinkphp\library\think;
+
+use tests\thinkphp\library\think\config\ConfigInitTrait;
+use think\Cache;
+use think\Config;
+
+class cacheTest extends \PHPUnit_Framework_TestCase
+{
+    use ConfigInitTrait {
+        ConfigInitTrait::tearDown as ConfigTearDown;
+    }
+
+    public function tearDown()
+    {
+        $this->ConfigTearDown();
+
+        call_user_func(\Closure::bind(function () {
+            Cache::$handler    = null;
+            Cache::$instance   = [];
+            Cache::$readTimes  = 0;
+            Cache::$writeTimes = 0;
+        }, null, '\think\Cache'));
+    }
+
+    /**
+     * @dataProvider provideTestConnect
+     */
+    public function testConnect($options, $expected)
+    {
+        $connection = Cache::connect($options);
+        $this->assertInstanceOf($expected, $connection);
+        $this->assertSame($connection, Cache::connect($options));
+
+        $instance = $this->getPropertyVal('instance');
+        $this->assertArrayHasKey(md5(serialize($options)), $instance);
+
+        $newConnection = Cache::connect($options, true);
+        $newInstance = $this->getPropertyVal('instance');
+        $this->assertInstanceOf($expected, $connection);
+        $this->assertNotSame($connection, $newConnection);
+        $this->assertEquals($instance, $newInstance);
+    }
+
+    /**
+     * @dataProvider provideTestInit
+     */
+    public function testInit($options, $expected)
+    {
+        $connection = Cache::init($options);
+        $this->assertInstanceOf($expected, $connection);
+
+        $connectionNew = Cache::init(['type' => 'foo']);
+        $this->assertSame($connection, $connectionNew);
+    }
+
+    public function testStore()
+    {
+        Config::set('cache.redis', ['type' => 'redis']);
+
+        $connectionDefault = Cache::store();
+        $this->assertInstanceOf('\think\cache\driver\File', $connectionDefault);
+
+        Config::set('cache.type', false);
+        $connectionNotRedis = Cache::store('redis');
+        $this->assertSame($connectionDefault, $connectionNotRedis);
+
+        Config::set('cache.type', 'complex');
+        $connectionRedis = Cache::store('redis');
+        $this->assertNotSame($connectionNotRedis, $connectionRedis);
+        $this->assertInstanceOf('\think\cache\driver\Redis', $connectionRedis);
+
+        // 即便成功切换到其他存储类型，也不影响原先的操作句柄
+        $this->assertSame($connectionDefault, Cache::store());
+    }
+
+    public function testHas()
+    {
+        $key = $this->buildTestKey('Has');
+
+        $this->assertFalse(Cache::has($key));
+
+        Cache::set($key, 5);
+        $this->assertTrue(Cache::has($key));
+    }
+
+    public function testGet()
+    {
+        $key = $this->buildTestKey('Get');
+
+        $this->assertFalse(Cache::get($key));
+
+        $this->assertEquals('default', Cache::get($key, 'default'));
+
+        Cache::set($key, 5);
+        $this->assertSame(5, Cache::get($key));
+    }
+
+    public function testSet()
+    {
+        $key = $this->buildTestKey('Set');
+
+        $this->assertTrue(Cache::set(null, null));
+        $this->assertTrue(Cache::set($key, 'ThinkPHP3.2'));
+        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', null));
+        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', -1));
+        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', 0));
+        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', 7200));
+    }
+
+    public function testInc()
+    {
+        $key = $this->buildTestKey('Inc');
+
+        Cache::inc($key);
+        $this->assertEquals(1, Cache::get($key));
+
+        Cache::inc($key, '2');
+        $this->assertEquals(3, Cache::get($key));
+
+        Cache::inc($key, -1);
+        $this->assertEquals(2, Cache::get($key));
+
+        Cache::inc($key, null);
+        $this->assertEquals(2, Cache::get($key));
+
+        Cache::inc($key, true);
+        $this->assertEquals(3, Cache::get($key));
+
+        Cache::inc($key, false);
+        $this->assertEquals(3, Cache::get($key));
+
+        Cache::inc($key, 0.789);
+        $this->assertEquals(3.789, Cache::get($key));
+    }
+    public function testDec()
+    {
+        $key = $this->buildTestKey('Dec');
+
+        Cache::dec($key);
+        $this->assertEquals(-1, Cache::get($key));
+
+        Cache::dec($key, '2');
+        $this->assertEquals(-3, Cache::get($key));
+
+        Cache::dec($key, -1);
+        $this->assertEquals(-2, Cache::get($key));
+
+        Cache::dec($key, null);
+        $this->assertEquals(-2, Cache::get($key));
+
+        Cache::dec($key, true);
+        $this->assertEquals(-3, Cache::get($key));
+
+        Cache::dec($key, false);
+        $this->assertEquals(-3, Cache::get($key));
+
+        Cache::dec($key, 0.359);
+        $this->assertEquals(-3.359, Cache::get($key));
+    }
+
+    public function testRm()
+    {
+        $key = $this->buildTestKey('Rm');
+
+        $this->assertFalse(Cache::rm($key));
+
+        Cache::set($key, 'ThinkPHP');
+        $this->assertTrue(Cache::rm($key));
+    }
+
+    public function testClear()
+    {
+        $key1 = $this->buildTestKey('Clear1');
+        $key2 = $this->buildTestKey('Clear2');
+
+        Cache::set($key1, 'ThinkPHP3.2');
+        Cache::set($key2, 'ThinkPHP5.0');
+
+        $this->assertEquals('ThinkPHP3.2', Cache::get($key1));
+        $this->assertEquals('ThinkPHP5.0', Cache::get($key2));
+        Cache::clear();
+        $this->assertFalse(Cache::get($key1));
+        $this->assertFalse(Cache::get($key2));
+    }
+
+    public function testPull()
+    {
+        $key = $this->buildTestKey('Pull');
+
+        $this->assertNull(Cache::pull($key));
+
+        Cache::set($key, 'ThinkPHP');
+        $this->assertEquals('ThinkPHP', Cache::pull($key));
+        $this->assertFalse(Cache::get($key));
+    }
+
+    public function testRemember()
+    {
+        $key1 = $this->buildTestKey('Remember1');
+        $key2 = $this->buildTestKey('Remember2');
+
+        $this->assertEquals('ThinkPHP3.2', Cache::remember($key1, 'ThinkPHP3.2'));
+        $this->assertEquals('ThinkPHP3.2', Cache::remember($key1, 'ThinkPHP5.0'));
+
+        $this->assertEquals('ThinkPHP5.0', Cache::remember($key2, function () {
+            return 'ThinkPHP5.0';
+        }));
+        $this->assertEquals('ThinkPHP5.0', Cache::remember($key2, function () {
+            return 'ThinkPHP3.2';
+        }));
+    }
+
+    public function testTag()
+    {
+        $key = $this->buildTestKey('Tag');
+
+        $cacheTagWithoutName = Cache::tag(null);
+        $this->assertInstanceOf('think\cache\Driver', $cacheTagWithoutName);
+
+        $cacheTagWithKey = Cache::tag($key, [1, 2, 3]);
+        $this->assertSame($cacheTagWithoutName, $cacheTagWithKey);
+    }
+
+    protected function getPropertyVal($name)
+    {
+        static $reflectionClass;
+        if (empty($reflectionClass)) {
+            $reflectionClass = new \ReflectionClass('\think\Cache');
+        }
+
+        $property = $reflectionClass->getProperty($name);
+        $property->setAccessible(true);
+
+        return $property->getValue();
+    }
+
+    public function provideTestConnect()
+    {
+        $provideData = [];
+
+        $options   = ['type' => null];
+        $expected  = '\think\cache\driver\File';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'File'];
+        $expected  = '\think\cache\driver\File';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'Lite'];
+        $expected  = '\think\cache\driver\Lite';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'Memcached'];
+        $expected  = '\think\cache\driver\Memcached';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'Redis'];
+        $expected  = '\think\cache\driver\Redis';
+        $provideData[] = [$options, $expected];
+
+        // TODO
+        // $options   = ['type' => 'Memcache'];
+        // $expected  = '\think\cache\driver\Memcache';
+        // $provideData[] = [$options, $expected];
+        //
+        // $options   = ['type' => 'Wincache'];
+        // $expected  = '\think\cache\driver\Wincache';
+        // $provideData[] = [$options, $expected];
+
+        // $options   = ['type' => 'Sqlite'];
+        // $expected  = '\think\cache\driver\Sqlite';
+        // $provideData[] = [$options, $expected];
+        //
+        // $options   = ['type' => 'Xcache'];
+        // $expected  = '\think\cache\driver\Xcache';
+        // $provideData[] = [$options, $expected];
+
+        return $provideData;
+    }
+
+    public function provideTestInit()
+    {
+        $provideData = [];
+
+        $options   = [];
+        $expected  = '\think\cache\driver\File';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'File'];
+        $expected  = '\think\cache\driver\File';
+        $provideData[] = [$options, $expected];
+
+        $options   = ['type' => 'Lite'];
+        $expected  = '\think\cache\driver\Lite';
+        $provideData[] = [$options, $expected];
+
+        return $provideData;
+    }
+
+    protected function buildTestKey($tag)
+    {
+        return sprintf('ThinkPHP_Test_%s_%d_%d', $tag, time(), rand(0, 10000));
+    }
+}
diff --git a/tests/thinkphp/library/traits/think/instanceTest.php b/tests/thinkphp/library/traits/think/instanceTest.php
index fae37a09..f93f22bb 100644
--- a/tests/thinkphp/library/traits/think/instanceTest.php
+++ b/tests/thinkphp/library/traits/think/instanceTest.php
@@ -11,15 +11,8 @@ class instanceTest extends \PHPUnit_Framework_TestCase
         $this->assertInstanceOf('\tests\thinkphp\library\traits\think\InstanceTestFather', $father);
         $this->assertEquals([], $father->options);
 
-        $father2 = InstanceTestFather::instance(['father']);
-        $this->assertEquals([], $father2->options);
-
-        $father2->options = ['father'];
-        $this->assertEquals(['father'], $father->options);
-
-        $son = InstanceTestSon::instance(['son']);
-        $this->assertInstanceOf('\tests\thinkphp\library\traits\think\InstanceTestFather', $son);
-        $this->assertEquals(['father'], $son->options);
+        $son = InstanceTestFather::instance(['son']);
+        $this->assertSame($father, $son);
     }
 
     public function testCallStatic()