Merge remote-tracking branch 'upstream/develop' into develop

11 files changed, 893 insertions, 14 deletions

diff --git a/tests/codeigniter/core/Input_test.php b/tests/codeigniter/core/Input_test.php
index 21ff6d81f..c56900d22 100644
--- a/tests/codeigniter/core/Input_test.php
+++ b/tests/codeigniter/core/Input_test.php
@@ -134,6 +134,14 @@ class Input_test extends CI_TestCase {
 		$this->assertEquals('bar', $foo);
 		$this->assertEquals("Hello, i try to <script>alert('Hack');</script> your site", $harm);
 		$this->assertEquals("Hello, i try to [removed]alert&#40;'Hack'&#41;;[removed] your site", $harmless);
+
+		$_SERVER['REQUEST_METHOD'] = 'POST';
+		$_POST['foo']['bar'] = 'baz';
+		$barArray = array('bar' => 'baz');
+
+		$this->assertEquals('baz', $this->input->post('foo[bar]'));
+		$this->assertEquals($barArray, $this->input->post('foo[]'));
+		$this->assertNull($this->input->post('foo[baz]'));
 	}
 
 	// --------------------------------------------------------------------
@@ -198,9 +206,22 @@ class Input_test extends CI_TestCase {
 		$this->markTestSkipped('TODO: Find a way to test HTTP headers');
 	}
 
+	// --------------------------------------------------------------------
+
+	public function test_get_request_header()
+	{
+		$this->markTestSkipped('TODO: Find a way to test HTTP headers');
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_ip_address()
 	{
+		$this->input->ip_address = '127.0.0.1';
+		$this->assertEquals('127.0.0.1', $this->input->ip_address());
+
 		// 127.0.0.1 is set in our Bootstrap file
+		$this->input->ip_address = FALSE;
 		$this->assertEquals('127.0.0.1', $this->input->ip_address());
 
 		// Invalid
@@ -208,10 +229,47 @@ class Input_test extends CI_TestCase {
 		$this->input->ip_address = FALSE; // reset cached value
 		$this->assertEquals('0.0.0.0', $this->input->ip_address());
 
-		// TODO: Add proxy_ips tests
+		$_SERVER['REMOTE_ADDR'] = '127.0.0.1';
 
-		// Back to reality
+		// Proxy_ips tests
+		$this->input->ip_address = FALSE;
+		$this->ci_set_config('proxy_ips', '127.0.0.3, 127.0.0.4, 127.0.0.2');
+		$_SERVER['HTTP_CLIENT_IP'] = '127.0.0.2';
+		$this->assertEquals('127.0.0.1', $this->input->ip_address());
+
+		// Invalid spoof
+		$this->input->ip_address = FALSE;
+		$this->ci_set_config('proxy_ips', 'invalid_ip_address');
+		$_SERVER['HTTP_CLIENT_IP'] = 'invalid_ip_address';
+		$this->assertEquals('127.0.0.1', $this->input->ip_address());
+
+		$this->input->ip_address = FALSE;
+		$this->ci_set_config('proxy_ips', 'http://foo/bar/baz, 127.0.0.1/1');
+		$_SERVER['HTTP_CLIENT_IP'] = '127.0.0.1';
+		$this->assertEquals('127.0.0.1', $this->input->ip_address());
+
+		$this->input->ip_address = FALSE;
+		$this->ci_set_config('proxy_ips', 'http://foo/bar/baz, 127.0.0.2');
+		$_SERVER['HTTP_CLIENT_IP'] = '127.0.0.2';
+		$_SERVER['REMOTE_ADDR'] = '127.0.0.2';
+		$this->assertEquals('127.0.0.2', $this->input->ip_address());
+
+		//IPv6
+		$this->input->ip_address = FALSE;
+		$this->ci_set_config('proxy_ips', 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329/1, FE80:0000:0000:0000:0202:B3FF:FE1E:8300/2');
+		$_SERVER['HTTP_CLIENT_IP'] = 'FE80:0000:0000:0000:0202:B3FF:FE1E:8300';
+		$_SERVER['REMOTE_ADDR'] = 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329';
+		$this->assertEquals('FE80:0000:0000:0000:0202:B3FF:FE1E:8300', $this->input->ip_address());
+
+		$this->input->ip_address = FALSE;
 		$_SERVER['REMOTE_ADDR'] = '127.0.0.1'; // back to reality
 	}
 
-}
\ No newline at end of file
+	// --------------------------------------------------------------------
+
+	public function test_user_agent()
+	{
+		$_SERVER['HTTP_USER_AGENT'] = 'test';
+		$this->assertEquals('test', $this->input->user_agent());
+	}
+}
diff --git a/tests/codeigniter/core/Lang_test.php b/tests/codeigniter/core/Lang_test.php
index 87a71c885..d2dd7598a 100644
--- a/tests/codeigniter/core/Lang_test.php
+++ b/tests/codeigniter/core/Lang_test.php
@@ -32,7 +32,7 @@ class Lang_test extends CI_TestCase {
 		// A language other than english
 		$this->ci_vfs_clone('system/language/english/email_lang.php', 'system/language/german/');
 		$this->assertTrue($this->lang->load('email', 'german'));
-		$this->assertEquals('german', $this->lang->is_loaded['email_lang.php'] );
+		$this->assertEquals('german', $this->lang->is_loaded['email_lang.php']);
 
 		// Non-alpha idiom (should act the same as unspecified language)
 		$this->ci_vfs_clone('system/language/english/number_lang.php');
@@ -49,6 +49,32 @@ class Lang_test extends CI_TestCase {
 
 	// --------------------------------------------------------------------
 
+	public function test_multiple_file_load()
+	{
+		// Multiple files
+		$this->ci_vfs_clone('system/language/english/profiler_lang.php');
+		$files = array(
+			0 => 'profiler',
+			1 => 'nonexistent'
+		);
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: Unable to load the requested language file: language/english/nonexistent_lang.php'
+		);
+		$this->lang->load($files, 'english');
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_alternative_path_load()
+	{
+		// Alternative Path
+		$this->ci_vfs_clone('system/language/english/profiler_lang.php');
+		$this->assertTrue($this->lang->load('profiler', 'english', FALSE, TRUE, 'vfs://system/'));
+	}
+
+	// --------------------------------------------------------------------
+
 	/**
 	 * @depends	test_load
 	 */
@@ -60,5 +86,4 @@ class Lang_test extends CI_TestCase {
 		$this->assertFalse($this->lang->line('nonexistent_string'));
 		$this->assertFalse($this->lang->line(NULL));
 	}
-
 }
diff --git a/tests/codeigniter/core/Loader_test.php b/tests/codeigniter/core/Loader_test.php
index 9e2092e05..cfaf6c74b 100644
--- a/tests/codeigniter/core/Loader_test.php
+++ b/tests/codeigniter/core/Loader_test.php
@@ -22,6 +22,9 @@ class Loader_test extends CI_TestCase {
 
 	public function test_library()
 	{
+		// Test getting CI_Loader object
+		$this->assertInstanceOf('CI_Loader', $this->load->library(NULL));
+
 		// Create library in VFS
 		$lib = 'unit_test_lib';
 		$class = 'CI_'.ucfirst($lib);
@@ -35,6 +38,13 @@ class Loader_test extends CI_TestCase {
 		$this->assertTrue(class_exists($class), $class.' does not exist');
 		$this->assertAttributeInstanceOf($class, $lib, $this->ci_obj);
 
+		// Create library in VFS
+		$lib = array('unit_test_lib' => 'unit_test_lib');
+
+		// Test loading as an array (int).
+		$this->assertInstanceOf('CI_Loader', $this->load->library($lib));
+		$this->assertTrue(class_exists($class), $class.' does not exist');
+
 		// Test a string given to params
 		$this->assertInstanceOf('CI_Loader', $this->load->library($lib, ' '));
 
@@ -319,6 +329,24 @@ class Loader_test extends CI_TestCase {
 
 	// --------------------------------------------------------------------
 
+	public function test_clear_vars()
+	{
+		$key1 = 'foo';
+		$val1 = 'bar';
+		$key2 = 'boo';
+		$val2 = 'hoo';
+		$this->assertInstanceOf('CI_Loader', $this->load->vars(array($key1 => $val1)));
+		$this->assertInstanceOf('CI_Loader', $this->load->vars($key2, $val2));
+		$this->assertEquals($val1, $this->load->get_var($key1));
+		$this->assertEquals(array($key1 => $val1, $key2 => $val2), $this->load->get_vars());
+
+		$this->assertInstanceOf('CI_Loader', $this->load->clear_vars());
+		$this->assertEquals('', $this->load->get_var($key1));
+		$this->assertEquals('', $this->load->get_var($key2));
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_helper()
 	{
 		// Create helper in VFS
@@ -443,6 +471,24 @@ class Loader_test extends CI_TestCase {
 
 	// --------------------------------------------------------------------
 
+	public function test_remove_package_path()
+	{
+		$dir = 'third-party';
+		$path = APPPATH.$dir.'/';
+		$path2 = APPPATH.'another/';
+		$paths = $this->load->get_package_paths(TRUE);
+
+		$this->assertInstanceOf('CI_Loader', $this->load->add_package_path($path));
+		$this->assertInstanceOf('CI_Loader', $this->load->remove_package_path($path));
+		$this->assertEquals($paths, $this->load->get_package_paths(TRUE));
+
+		$this->assertInstanceOf('CI_Loader', $this->load->add_package_path($path2));
+		$this->assertInstanceOf('CI_Loader', $this->load->remove_package_path());
+		$this->assertNotContains($path2, $this->load->get_package_paths(TRUE));
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_load_config()
 	{
 		$cfg = 'someconfig';
@@ -511,5 +557,4 @@ class Loader_test extends CI_TestCase {
 		// Verify config calls
 		$this->assertEquals($cfg['config'], $this->ci_obj->config->loaded);
 	}
-
-}
\ No newline at end of file
+}
diff --git a/tests/codeigniter/core/Security_test.php b/tests/codeigniter/core/Security_test.php
index 402422ff8..3acd2a598 100644
--- a/tests/codeigniter/core/Security_test.php
+++ b/tests/codeigniter/core/Security_test.php
@@ -71,6 +71,47 @@ class Security_test extends CI_TestCase {
 		$this->assertEquals("Hello, i try to [removed]alert&#40;'Hack'&#41;;[removed] your site", $harmless_string);
 	}
 
+        // --------------------------------------------------------------------
+
+	public function test_xss_clean_string_array()
+	{
+		$harm_strings = array(
+			"Hello, i try to <script>alert('Hack');</script> your site",
+			"Simple clean string",
+			"Hello, i try to <script>alert('Hack');</script> your site"
+		);
+
+		$harmless_strings = $this->security->xss_clean($harm_strings);
+
+		$this->assertEquals("Hello, i try to [removed]alert&#40;'Hack'&#41;;[removed] your site", $harmless_strings[0]);
+		$this->assertEquals("Simple clean string", $harmless_strings[1]);
+		$this->assertEquals("Hello, i try to [removed]alert&#40;'Hack'&#41;;[removed] your site", $harmless_strings[2]);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_xss_clean_image_valid()
+	{
+		$harm_string = '<img src="test.png">';
+
+		$xss_clean_return = $this->security->xss_clean($harm_string, TRUE);
+
+		$this->assertTrue($xss_clean_return);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_xss_clean_image_invalid()
+	{
+		$harm_string = '<img src=javascript:alert(String.fromCharCode(88,83,83))>';
+
+		$xss_clean_return = $this->security->xss_clean($harm_string, TRUE);
+
+		$this->assertFalse($xss_clean_return);
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_xss_clean_entity_double_encoded()
 	{
 		$input = '<a href="&#38&#35&#49&#48&#54&#38&#35&#57&#55&#38&#35&#49&#49&#56&#38&#35&#57&#55&#38&#35&#49&#49&#53&#38&#35&#57&#57&#38&#35&#49&#49&#52&#38&#35&#49&#48&#53&#38&#35&#49&#49&#50&#38&#35&#49&#49&#54&#38&#35&#53&#56&#38&#35&#57&#57&#38&#35&#49&#49&#49&#38&#35&#49&#49&#48&#38&#35&#49&#48&#50&#38&#35&#49&#48&#53&#38&#35&#49&#49&#52&#38&#35&#49&#48&#57&#38&#35&#52&#48&#38&#35&#52&#57&#38&#35&#52&#49">Clickhere</a>';
@@ -79,6 +120,36 @@ class Security_test extends CI_TestCase {
 
 	// --------------------------------------------------------------------
 
+	public function test_xss_clean_js_img_removal()
+	{
+		$input = '<img src="&#38&#35&#49&#48&#54&#38&#35&#57&#55&#38&#35&#49&#49&#56&#38&#35&#57&#55&#38&#35&#49&#49&#53&#38&#35&#57&#57&#38&#35&#49&#49&#52&#38&#35&#49&#48&#53&#38&#35&#49&#49&#50&#38&#35&#49&#49&#54&#38&#35&#53&#56&#38&#35&#57&#57&#38&#35&#49&#49&#49&#38&#35&#49&#49&#48&#38&#35&#49&#48&#50&#38&#35&#49&#48&#53&#38&#35&#49&#49&#52&#38&#35&#49&#48&#57&#38&#35&#52&#48&#38&#35&#52&#57&#38&#35&#52&#49">Clickhere';
+		$this->assertEquals('<img >', $this->security->xss_clean($input));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_xss_clean_sanitize_naughty_html()
+	{
+		$input = '<blink>';
+		$this->assertEquals('&lt;blink&gt;', $this->security->xss_clean($input));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_remove_evil_attributes()
+	{
+		$this->assertEquals('<foo [removed]>', $this->security->remove_evil_attributes('<foo onAttribute="bar">', FALSE));
+		$this->assertEquals('<foo [removed]>', $this->security->remove_evil_attributes('<foo onAttributeNoQuotes=bar>', FALSE));
+		$this->assertEquals('<foo [removed]>', $this->security->remove_evil_attributes('<foo onAttributeWithSpaces = bar>', FALSE));
+		$this->assertEquals('<foo prefixOnAttribute="bar">', $this->security->remove_evil_attributes('<foo prefixOnAttribute="bar">', FALSE));
+		$this->assertEquals('<foo>onOutsideOfTag=test</foo>', $this->security->remove_evil_attributes('<foo>onOutsideOfTag=test</foo>', FALSE));
+		$this->assertEquals('onNoTagAtAll = true', $this->security->remove_evil_attributes('onNoTagAtAll = true', FALSE));
+		$this->assertEquals('<foo [removed]>', $this->security->remove_evil_attributes('<foo fscommand=case-insensitive>', FALSE));
+		$this->assertEquals('<foo [removed]>', $this->security->remove_evil_attributes('<foo seekSegmentTime=whatever>', FALSE));
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_xss_hash()
 	{
 		$this->assertEmpty($this->security->xss_hash);
@@ -91,6 +162,17 @@ class Security_test extends CI_TestCase {
 
 	// --------------------------------------------------------------------
 
+	public function test_get_random_bytes()
+	{
+		$length = "invalid";
+		$this->assertFalse($this->security->get_random_bytes($length));
+
+		$length = 10;
+		$this->assertNotEmpty($this->security->get_random_bytes($length));
+	}
+
+	// --------------------------------------------------------------------
+
 	public function test_entity_decode()
 	{
 		$encoded = '&lt;div&gt;Hello &lt;b&gt;Booya&lt;/b&gt;&lt;/div&gt;';
@@ -115,4 +197,54 @@ class Security_test extends CI_TestCase {
 		$this->assertEquals('foo', $safe_filename);
 	}
 
-}
\ No newline at end of file
+	// --------------------------------------------------------------------
+
+	public function test_strip_image_tags()
+	{
+		$imgtags = array(
+			'<img src="smiley.gif" alt="Smiley face" height="42" width="42">',
+			'<img alt="Smiley face" height="42" width="42" src="smiley.gif">',
+			'<img src="http://www.w3schools.com/images/w3schools_green.jpg">',
+			'<img src="/img/sunset.gif" height="100%" width="100%">',
+			'<img src="mdn-logo-sm.png" alt="MD Logo" srcset="mdn-logo-HD.png 2x, mdn-logo-small.png 15w, mdn-banner-HD.png 100w 2x" />',
+			'<img sqrc="/img/sunset.gif" height="100%" width="100%">',
+			'<img srqc="/img/sunset.gif" height="100%" width="100%">',
+			'<img srcq="/img/sunset.gif" height="100%" width="100%">'
+		);
+
+		$urls = array(
+			'smiley.gif',
+			'smiley.gif',
+			'http://www.w3schools.com/images/w3schools_green.jpg',
+			'/img/sunset.gif',
+			'mdn-logo-sm.png',
+			'<img sqrc="/img/sunset.gif" height="100%" width="100%">',
+			'<img srqc="/img/sunset.gif" height="100%" width="100%">',
+			'<img srcq="/img/sunset.gif" height="100%" width="100%">'
+		);
+
+		for ($i = 0; $i < count($imgtags); $i++)
+		{
+			$this->assertEquals($urls[$i], $this->security->strip_image_tags($imgtags[$i]));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_csrf_set_hash()
+	{
+		// Set cookie for security test
+		$_COOKIE['ci_csrf_cookie'] = md5(uniqid(mt_rand(), TRUE));
+
+		// Set config for Security class
+		$this->ci_set_config('csrf_protection', TRUE);
+		$this->ci_set_config('csrf_token_name', 'ci_csrf_token');
+
+		// leave csrf_cookie_name as blank to test _csrf_set_hash function
+		$this->ci_set_config('csrf_cookie_name', '');
+
+		$this->security = new Mock_Core_Security();
+
+		$this->assertNotEmpty($this->security->get_csrf_hash());
+	}
+}
diff --git a/tests/codeigniter/core/compat/password_test.php b/tests/codeigniter/core/compat/password_test.php
index c37c6ac0c..8a507d14a 100644
--- a/tests/codeigniter/core/compat/password_test.php
+++ b/tests/codeigniter/core/compat/password_test.php
@@ -132,7 +132,7 @@ class password_test extends CI_TestCase {
 		$this->assertFalse(password_needs_rehash('$2y$10$MTIzNDU2Nzg5MDEyMzQ1Nej0NmcAWSLR.oP7XOR9HD/vjUuOj100y', PASSWORD_BCRYPT, array('cost' => 10, 'foo' => 3)));
 
 		// invalid: different (lower) cost
-		$this->assertTrue(password_needs_rehash('$2y$10$MTIzNDU2Nzg5MDEyMzQ1Nej0NmcAWSLR.oP7XOR9HD/vjUuOj100y', PASSWORD_BCRYPT, array('cost' => 09)));
+		$this->assertTrue(password_needs_rehash('$2y$10$MTIzNDU2Nzg5MDEyMzQ1Nej0NmcAWSLR.oP7XOR9HD/vjUuOj100y', PASSWORD_BCRYPT, array('cost' => 9)));
 
 		// invalid: different (higher) cost
 		$this->assertTrue(password_needs_rehash('$2y$10$MTIzNDU2Nzg5MDEyMzQ1Nej0NmcAWSLR.oP7XOR9HD/vjUuOj100y', PASSWORD_BCRYPT, array('cost' => 11)));
diff --git a/tests/codeigniter/database/DB_driver_test.php b/tests/codeigniter/database/DB_driver_test.php
index c04c42b09..26416d3fc 100644
--- a/tests/codeigniter/database/DB_driver_test.php
+++ b/tests/codeigniter/database/DB_driver_test.php
@@ -6,7 +6,7 @@ class DB_driver_test extends CI_TestCase {
 	{
 		$config = Mock_Database_DB::config(DB_DRIVER);
 		sscanf(DB_DRIVER, '%[^/]/', $driver_name);
-		$driver = $this->$driver_name($config[DB_DRIVER]);
+		$driver = $this->{$driver_name}($config[DB_DRIVER]);
 
 		$this->assertTrue($driver->initialize());
 	}
diff --git a/tests/codeigniter/database/DB_test.php b/tests/codeigniter/database/DB_test.php
index d5c0dea08..dc4fae986 100644
--- a/tests/codeigniter/database/DB_test.php
+++ b/tests/codeigniter/database/DB_test.php
@@ -15,7 +15,7 @@ class DB_test extends CI_TestCase {
 			),
 		));
 
-		$this->setExpectedException('InvalidArgumentException', 'CI Error: Invalid DB driver');
+		$this->setExpectedException('RuntimeException', 'CI Error: Invalid DB driver');
 
 		Mock_Database_DB::DB($connection->set_dsn('undefined'), TRUE);
 	}
@@ -26,6 +26,14 @@ class DB_test extends CI_TestCase {
 	{
 		$config = Mock_Database_DB::config(DB_DRIVER);
 		$connection = new Mock_Database_DB($config);
+
+		// E_DEPRECATED notices thrown by mysql_connect(), mysql_pconnect()
+		// on PHP 5.5+ cause the tests to fail
+		if (DB_DRIVER === 'mysql' && version_compare(PHP_VERSION, '5.5', '>='))
+		{
+			error_reporting(E_ALL & ~E_DEPRECATED);
+		}
+
 		$db = Mock_Database_DB::DB($connection->set_dsn(DB_DRIVER), TRUE);
 
 		$this->assertTrue($db instanceof CI_DB);
@@ -34,6 +42,11 @@ class DB_test extends CI_TestCase {
 
 	// ------------------------------------------------------------------------
 
+/*
+	This test is unusable, because whoever wrote it apparently thought that
+	an E_WARNING should equal an Exception and based the whole test suite
+	around that bogus assumption.
+
 	public function test_db_failover()
 	{
 		$config = Mock_Database_DB::config(DB_DRIVER);
@@ -43,5 +56,6 @@ class DB_test extends CI_TestCase {
 		$this->assertTrue($db instanceof CI_DB);
 		$this->assertTrue($db instanceof CI_DB_Driver);
 	}
+*/
 
 }
\ No newline at end of file
diff --git a/tests/codeigniter/libraries/Form_validation_test.php b/tests/codeigniter/libraries/Form_validation_test.php
new file mode 100644
index 000000000..26d82ec93
--- /dev/null
+++ b/tests/codeigniter/libraries/Form_validation_test.php
@@ -0,0 +1,593 @@
+<?php
+
+class Form_validation_test extends CI_TestCase {
+
+	public function set_up()
+	{
+		$_SERVER['REQUEST_METHOD'] = 'POST';
+
+		// Create a mock loader since load->helper() looks in the wrong directories for unit tests,
+		// We'll use CI_TestCase->helper() instead
+		$loader = $this->getMock('CI_Loader', array('helper'));
+
+		// Same applies for lang
+		$lang = $this->getMock('CI_Lang', array('load'));
+
+		$this->ci_set_config('charset', 'UTF-8');
+		$utf8 = new Mock_Core_Utf8();
+		$security = new Mock_Core_Security();
+		$input = new Mock_Core_Input($security, $utf8);
+
+		$this->ci_instance_var('lang', $lang);
+		$this->ci_instance_var('load', $loader);
+		$this->ci_instance_var('input', $input);
+
+		$this->lang('form_validation');
+		$this->helper('form');
+
+		$this->form_validation = new CI_Form_validation();
+	}
+
+	public function test_rule_required()
+	{
+		$rules = array(array('field' => 'foo', 'label' => 'foo_label', 'rules' => 'required'));
+		$this->assertTrue($this->run_rules($rules, array('foo' => 'bar')));
+
+		$this->assertFalse($this->run_rules($rules, array('foo' => '')));
+		$this->assertFalse($this->run_rules($rules, array('foo' => ' ')));
+	}
+
+	public function test_rule_matches()
+	{
+		$rules = array(
+			array('field' => 'foo', 'label' => 'label', 'rules' => 'required'),
+			array('field' => 'bar', 'label' => 'label2', 'rules' => 'matches[foo]')
+		);
+		$values_base = array('foo' => 'sample');
+
+		$this->assertTrue($this->run_rules($rules, array_merge($values_base, array('bar' => ''))));
+		$this->assertTrue($this->run_rules($rules, array_merge($values_base, array('bar' => 'sample'))));
+
+		$this->assertFalse($this->run_rules($rules, array_merge($values_base, array('bar' => 'Sample'))));
+		$this->assertFalse($this->run_rules($rules, array_merge($values_base, array('bar' => ' sample'))));
+	}
+
+	public function test_rule_differs()
+	{
+		$rules = array(
+			array('field' => 'foo', 'label' => 'label', 'rules' => 'required'),
+			array('field' => 'bar', 'label' => 'label2', 'rules' => 'differs[foo]')
+		);
+		$values_base = array('foo' => 'sample');
+
+		$this->assertTrue($this->run_rules($rules, array_merge($values_base, array('bar' => 'does_not_match'))));
+		$this->assertTrue($this->run_rules($rules, array_merge($values_base, array('bar' => 'Sample'))));
+		$this->assertTrue($this->run_rules($rules, array_merge($values_base, array('bar' => ' sample'))));
+
+		$this->assertFalse($this->run_rules($rules, array_merge($values_base, array('bar' => 'sample'))));
+	}
+
+	public function test_rule_min_length()
+	{
+		$this->assertTrue($this->form_validation->min_length('12345', '5'));
+		$this->assertTrue($this->form_validation->min_length('test', '0'));
+
+		$this->assertFalse($this->form_validation->min_length('123', '4'));
+		$this->assertFalse($this->form_validation->min_length('should_fail', 'A'));
+		$this->assertFalse($this->form_validation->min_length('', '4'));
+	}
+
+	public function test_rule_max_length()
+	{
+		$this->assertTrue($this->form_validation->max_length('', '4'));
+		$this->assertTrue($this->form_validation->max_length('1234', '4'));
+
+		$this->assertFalse($this->form_validation->max_length('12345', '4'));
+		$this->assertFalse($this->form_validation->max_length('should_fail', 'A'));
+	}
+
+	public function test_rule_exact_length()
+	{
+		$this->assertTrue($this->form_validation->exact_length('1234', '4'));
+
+		$this->assertFalse($this->form_validation->exact_length('', '3'));
+		$this->assertFalse($this->form_validation->exact_length('12345', '4'));
+		$this->assertFalse($this->form_validation->exact_length('123', '4'));
+		$this->assertFalse($this->form_validation->exact_length('should_fail', 'A'));
+	}
+
+	public function test_rule_greater_than()
+	{
+		$this->assertTrue($this->form_validation->greater_than('-10', '-11'));
+		$this->assertTrue($this->form_validation->greater_than('10', '9'));
+
+		$this->assertFalse($this->form_validation->greater_than('10', '10'));
+		$this->assertFalse($this->form_validation->greater_than('10', 'a'));
+		$this->assertFalse($this->form_validation->greater_than('10a', '10'));
+	}
+
+	public function test_rule_greater_than_equal_to()
+	{
+		$this->assertTrue($this->form_validation->greater_than_equal_to('0', '0'));
+		$this->assertTrue($this->form_validation->greater_than_equal_to('1', '0'));
+
+		$this->assertFalse($this->form_validation->greater_than_equal_to('-1', '0'));
+		$this->assertFalse($this->form_validation->greater_than_equal_to('10a', '0'));
+	}
+
+	public function test_rule_less_than()
+	{
+		$this->assertTrue($this->form_validation->less_than('4', '5'));
+		$this->assertTrue($this->form_validation->less_than('-1', '0'));
+
+		$this->assertFalse($this->form_validation->less_than('4', '4'));
+		$this->assertFalse($this->form_validation->less_than('10a', '5'));
+	}
+
+	public function test_rule_less_than_equal_to()
+	{
+		$this->assertTrue($this->form_validation->less_than_equal_to('-1', '0'));
+		$this->assertTrue($this->form_validation->less_than_equal_to('-1', '-1'));
+		$this->assertTrue($this->form_validation->less_than_equal_to('4', '4'));
+
+		$this->assertFalse($this->form_validation->less_than_equal_to('0', '-1'));
+		$this->assertFalse($this->form_validation->less_than_equal_to('10a', '0'));
+	}
+
+	public function test_rule_in_list()
+	{
+		$this->assertTrue($this->form_validation->in_list('red', 'red,Blue,123'));
+		$this->assertTrue($this->form_validation->in_list('Blue', 'red,Blue,123'));
+		$this->assertTrue($this->form_validation->in_list('123', 'red,Blue,123'));
+
+		$this->assertFalse($this->form_validation->in_list('Red', 'red,Blue,123'));
+		$this->assertFalse($this->form_validation->in_list(' red', 'red,Blue,123'));
+		$this->assertFalse($this->form_validation->in_list('1234', 'red,Blue,123'));
+	}
+
+	public function test_rule_alpha()
+	{
+		$this->assertTrue($this->form_validation->alpha('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ'));
+
+		$this->assertFalse($this->form_validation->alpha('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ '));
+		$this->assertFalse($this->form_validation->alpha('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ1'));
+		$this->assertFalse($this->form_validation->alpha('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ*'));
+	}
+
+	public function test_rule_alpha_numeric()
+	{
+		$this->assertTrue($this->form_validation->alpha_numeric('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789'));
+
+		$this->assertFalse($this->form_validation->alpha_numeric('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789\ '));
+		$this->assertFalse($this->form_validation->alpha_numeric('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789_'));
+	}
+
+	public function test_rule_alpha_numeric_spaces()
+	{
+		$this->assertTrue($this->form_validation->alpha_numeric_spaces(' abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789'));
+
+		$this->assertFalse($this->form_validation->alpha_numeric_spaces(' abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789_'));
+	}
+
+	public function test_rule_alpha_dash()
+	{
+		$this->assertTrue($this->form_validation->alpha_dash('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789-_'));
+
+		$this->assertFalse($this->form_validation->alpha_dash('abcdefghijklmnopqrstuvwxyzABCDEFGHLIJKLMNOPQRSTUVWXYZ0123456789-_\ '));
+	}
+
+	public function test_rule_numeric()
+	{
+		$this->assertTrue($this->form_validation->numeric('0'));
+		$this->assertTrue($this->form_validation->numeric('12314'));
+		$this->assertTrue($this->form_validation->numeric('-42'));
+
+		$this->assertFalse($this->form_validation->numeric('123a'));
+		$this->assertFalse($this->form_validation->numeric('--1'));
+	}
+
+	public function test_rule_integer()
+	{
+		$this->assertTrue($this->form_validation->integer('0'));
+		$this->assertTrue($this->form_validation->integer('42'));
+		$this->assertTrue($this->form_validation->integer('-1'));
+
+		$this->assertFalse($this->form_validation->integer('124a'));
+		$this->assertFalse($this->form_validation->integer('1.9'));
+		$this->assertFalse($this->form_validation->integer('--1'));
+	}
+
+	public function test_rule_decimal()
+	{
+		$this->assertTrue($this->form_validation->decimal('1.0'));
+		$this->assertTrue($this->form_validation->decimal('-0.98'));
+
+		$this->assertFalse($this->form_validation->decimal('0'));
+		$this->assertFalse($this->form_validation->decimal('1.0a'));
+		$this->assertFalse($this->form_validation->decimal('-i'));
+		$this->assertFalse($this->form_validation->decimal('--1'));
+	}
+
+	public function test_rule_is_natural()
+	{
+		$this->assertTrue($this->form_validation->is_natural('0'));
+		$this->assertTrue($this->form_validation->is_natural('12'));
+
+		$this->assertFalse($this->form_validation->is_natural('42a'));
+		$this->assertFalse($this->form_validation->is_natural('-1'));
+	}
+
+	public function test_rule_is_natural_no_zero()
+	{
+		$this->assertTrue($this->form_validation->is_natural_no_zero('42'));
+
+		$this->assertFalse($this->form_validation->is_natural_no_zero('0'));
+		$this->assertFalse($this->form_validation->is_natural_no_zero('42a'));
+		$this->assertFalse($this->form_validation->is_natural_no_zero('-1'));
+	}
+
+	public function test_rule_valid_url()
+	{
+		$this->assertTrue($this->form_validation->valid_url('www.codeigniter.com'));
+		$this->assertTrue($this->form_validation->valid_url('http://codeigniter.eu'));
+
+		$this->assertFalse($this->form_validation->valid_url('htt://www.codeIgniter.com'));
+		$this->assertFalse($this->form_validation->valid_url(''));
+		$this->assertFalse($this->form_validation->valid_url('code igniter'));
+	}
+
+	public function test_rule_valid_email()
+	{
+		$this->assertTrue($this->form_validation->valid_email('email@sample.com'));
+
+		$this->assertFalse($this->form_validation->valid_email('valid_email', '@sample.com'));
+	}
+
+	public function test_rule_valid_emails()
+	{
+		$this->assertTrue($this->form_validation->valid_emails('1@sample.com,2@sample.com'));
+		$this->assertTrue($this->form_validation->valid_emails('email@sample.com'));
+
+		$this->assertFalse($this->form_validation->valid_emails('valid_email', '@sample.com'));
+		$this->assertFalse($this->form_validation->valid_emails('@sample.com,2@sample.com,validemail@email.ca'));
+	}
+
+	public function test_rule_valid_ip()
+	{
+		$this->assertTrue($this->form_validation->valid_ip('127.0.0.1'));
+		$this->assertTrue($this->form_validation->valid_ip('127.0.0.1', 'ipv4'));
+		$this->assertTrue($this->form_validation->valid_ip('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
+		$this->assertTrue($this->form_validation->valid_ip('2001:0db8:85a3:0000:0000:8a2e:0370:7334', 'ipv6'));
+
+		$this->assertFalse($this->form_validation->valid_ip('2001:0db8:85a3:0000:0000:8a2e:0370:7334', 'ipv4'));
+		$this->assertFalse($this->form_validation->valid_ip('127.0.0.1', 'ipv6'));
+		$this->assertFalse($this->form_validation->valid_ip('H001:0db8:85a3:0000:0000:8a2e:0370:7334'));
+		$this->assertFalse($this->form_validation->valid_ip('127.0.0.259'));
+	}
+
+	public function test_rule_valid_base64()
+	{
+		$this->assertTrue($this->form_validation->valid_base64(base64_encode('string')));
+
+		$this->assertFalse($this->form_validation->valid_base64('FA08GG'));
+	}
+
+	public function test_set_data()
+	{
+		// Reset test environment
+		$_POST = array();
+		$this->form_validation->reset_validation();
+		$data = array('field' => 'some_data');
+		$this->form_validation->set_data($data);
+		$this->form_validation->set_rules('field', 'label', 'required');
+		$this->assertTrue($this->form_validation->run());
+
+		// Test with empty array
+		$_POST = array();
+		$this->form_validation->reset_validation();
+		$data = array('field' => 'some_data');
+		$this->form_validation->set_data($data);
+		// This should do nothing. Old data will still be used
+		$this->form_validation->set_data(array());
+		$this->form_validation->set_rules('field', 'label', 'required');
+		$this->assertTrue($this->form_validation->run());
+	}
+
+	public function test_set_message()
+	{
+		// Reset test environment
+		$_POST = array();
+		$this->form_validation->reset_validation();
+		$err_message = 'What a terrible error!';
+		$rules = array(
+			array(
+				'field' => 'req_field',
+				'label' => 'label',
+				'rules' => 'required'
+			)
+		);
+		$errorless_data = array('req_field' => 'some text');
+		$erroneous_data = array('req_field' => '');
+
+		$this->form_validation->set_message('required', $err_message);
+		$this->form_validation->set_data($erroneous_data);
+		$this->form_validation->set_rules($rules);
+		$this->form_validation->run();
+		$this->assertEquals('<p>'.$err_message.'</p>', $this->form_validation->error('req_field'));
+
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_message('required', $err_message);
+		$this->form_validation->set_data($errorless_data);
+		$this->form_validation->set_rules($rules);
+		$this->form_validation->run();
+		$this->assertEquals('', $this->form_validation->error('req_field'));
+	}
+
+	public function test_set_error_delimiters()
+	{
+		$this->form_validation->reset_validation();
+		$prefix = '<div class="error">';
+		$suffix = '</div>';
+		$this->form_validation->set_error_delimiters($prefix, $suffix);
+		$this->form_validation->set_rules('foo', 'label', 'required');
+		$_POST = array('foo' => '');
+		$this->form_validation->run();
+		$error_msg = $this->form_validation->error('foo');
+
+		$this->assertTrue(strrpos($error_msg, $prefix) === 0);
+		$this->assertTrue(strrpos($error_msg, $suffix, -strlen($suffix)) === (strlen($error_msg) - strlen($suffix)));
+	}
+
+	public function test_error_array()
+	{
+		$this->form_validation->reset_validation();
+		$error_message = 'What a terrible error!';
+		$this->form_validation->set_message('required', $error_message);
+		$this->form_validation->set_rules('foo', 'label', 'required');
+		$_POST = array('foo' => '');
+		$this->form_validation->run();
+		$error_array = $this->form_validation->error_array();
+		$this->assertEquals($error_message, $error_array['foo']);
+	}
+
+	public function test_error_string()
+	{
+		$this->form_validation->reset_validation();
+		$error_message = 'What a terrible error!';
+		$prefix_default = '<foo>';
+		$suffix_default = '</foo>';
+		$prefix_test = '<bar>';
+		$suffix_test = '</bar>';
+		$this->form_validation->set_error_delimiters($prefix_default, $suffix_default);
+		$this->form_validation->set_message('required', $error_message);
+		$this->form_validation->set_rules('foo', 'label', 'required');
+		$_POST = array('foo' => '');
+		$this->form_validation->run();
+
+		$this->assertEquals($prefix_default.$error_message.$suffix_default."\n", $this->form_validation->error_string());
+		$this->assertEquals($prefix_test.$error_message.$suffix_default."\n", $this->form_validation->error_string($prefix_test, ''));
+		$this->assertEquals($prefix_default.$error_message.$suffix_test."\n", $this->form_validation->error_string('', $suffix_test));
+		$this->assertEquals($prefix_test.$error_message.$suffix_test."\n", $this->form_validation->error_string($prefix_test, $suffix_test));
+
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('foo', 'label', 'required');
+		$_POST = array('foo' => 'bar');
+		$this->form_validation->run();
+		$this->assertEquals('', $this->form_validation->error_string());
+	}
+
+	public function test_run()
+	{
+		// form_validation->run() is tested in many of the other unit tests
+		// This test will only test run(group='') when group is not empty
+		$config = array(
+			'pass' => array(
+				array(
+					'field' => 'username',
+					'label' => 'user',
+					'rules' => 'alpha_numeric'
+				)
+			),
+			'fail' => array(
+				array(
+					'field' => 'username',
+					'label' => 'user',
+					'rules' => 'alpha'
+				)
+			)
+		);
+		$_POST = array('username' => 'foo42');
+		$form_validation = new CI_Form_validation($config);
+		$this->assertTrue($form_validation->run('pass'));
+
+		$form_validation = new CI_Form_validation($config);
+		$this->assertFalse($form_validation->run('fail'));
+	}
+
+	public function test_has_rule()
+	{
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('foo', 'label', 'required');
+
+		$this->assertTrue($this->form_validation->has_rule('foo'));
+		$this->assertFalse($this->form_validation->has_rule('bar'));
+	}
+
+	public function test_set_value()
+	{
+		$this->form_validation->reset_validation();
+		$default = 'default';
+		$this->form_validation->set_rules('foo', 'label', 'required');
+		$this->form_validation->set_rules('bar[]', 'label', 'required');
+
+		// No post data yet: should return the default value provided
+		$this->assertEquals($default, $this->form_validation->set_value('foo', $default));
+		$_POST = array('foo' => 'foo', 'bar' => array('bar1', 'bar2'));
+		$this->form_validation->run();
+		$this->assertEquals('foo', $this->form_validation->set_value('foo', $default));
+		$this->assertEquals('bar1', $this->form_validation->set_value('bar[]', $default));
+		$this->assertEquals('bar2', $this->form_validation->set_value('bar[]', $default));
+	}
+
+	public function test_set_select()
+	{
+		// Test 1: No options selected
+		$this->form_validation->reset_validation();
+		$_POST = array();
+		$this->form_validation->run();
+
+		$this->assertEquals('', $this->form_validation->set_select('select', 'foo'));
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select', 'bar', TRUE));
+
+		// Test 2: 1 option selected
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select', 'label', 'alpha_numeric');
+		$_POST = array('select' => 'foo');
+		$this->form_validation->run();
+
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select', 'foo'));
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select', 'foo', TRUE));
+		$this->assertEquals('', $this->form_validation->set_select('select', 'bar'));
+		$this->assertEquals('', $this->form_validation->set_select('select', 'bar', TRUE));
+
+		// Test 3: Multiple options selected
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select[]', 'label', 'alpha_numeric');
+		$_POST = array('select' => array('foo', 'bar'));
+		$this->form_validation->run();
+
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select[]', 'foo'));
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select[]', 'foo', TRUE));
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select[]', 'bar'));
+		$this->assertEquals(' selected="selected"', $this->form_validation->set_select('select[]', 'bar', TRUE));
+		$this->assertEquals('', $this->form_validation->set_select('select[]', 'foobar'));
+		$this->assertEquals('', $this->form_validation->set_select('select[]', 'foobar', TRUE));
+	}
+
+	public function test_set_radio()
+	{
+		// Test 1: No options selected
+		$this->form_validation->reset_validation();
+		$_POST = array();
+		$this->form_validation->run();
+
+		$this->assertEquals('', $this->form_validation->set_radio('select', 'foo'));
+		// Default should only work when no rules are set
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select', 'bar', TRUE));
+
+		// Test 2: 1 option selected
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select', 'label', 'alpha_numeric');
+		$_POST = array('select' => 'foo');
+		$this->form_validation->run();
+
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select', 'foo'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select', 'foo', TRUE));
+		$this->assertEquals('', $this->form_validation->set_radio('select', 'bar'));
+		$this->assertEquals('', $this->form_validation->set_radio('select', 'bar', TRUE));
+
+		// Test 3: Multiple options checked
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select[]', 'label', 'alpha_numeric');
+		$_POST = array('select' => array('foo', 'bar'));
+		$this->form_validation->run();
+
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select[]', 'foo'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select[]', 'foo', TRUE));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select[]', 'bar'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_radio('select[]', 'bar', TRUE));
+		$this->assertEquals('', $this->form_validation->set_radio('select[]', 'foobar'));
+		$this->assertEquals('', $this->form_validation->set_radio('select[]', 'foobar', TRUE));
+	}
+
+	public function test_set_checkbox()
+	{
+		// Test 1: No options selected
+		$this->form_validation->reset_validation();
+		$_POST = array();
+		$this->form_validation->run();
+
+		$this->assertEquals('', $this->form_validation->set_checkbox('select', 'foo'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select', 'bar', TRUE));
+
+		// Test 2: 1 option selected
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select', 'label', 'alpha_numeric');
+		$_POST = array('select' => 'foo');
+		$this->form_validation->run();
+
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select', 'foo'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select', 'foo', TRUE));
+		$this->assertEquals('', $this->form_validation->set_checkbox('select', 'bar'));
+		$this->assertEquals('', $this->form_validation->set_checkbox('select', 'bar', TRUE));
+
+		// Test 3: Multiple options selected
+		$this->form_validation->reset_validation();
+		$this->form_validation->set_rules('select[]', 'label', 'alpha_numeric');
+		$_POST = array('select' => array('foo', 'bar'));
+		$this->form_validation->run();
+
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select[]', 'foo'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select[]', 'foo', TRUE));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select[]', 'bar'));
+		$this->assertEquals(' checked="checked"', $this->form_validation->set_checkbox('select[]', 'bar', TRUE));
+		$this->assertEquals('', $this->form_validation->set_checkbox('select[]', 'foobar'));
+		$this->assertEquals('', $this->form_validation->set_checkbox('select[]', 'foobar', TRUE));
+	}
+
+	public function test_regex_match()
+	{
+		$regex = '/f[a-zA-Z]+/';
+		$this->assertTrue($this->form_validation->regex_match('foo', $regex));
+		$this->assertFalse($this->form_validation->regex_match('bar', $regex));
+	}
+
+	public function test_prep_for_form()
+	{
+		$this->form_validation->reset_validation();
+		$error_msg_unprepped = '<error =\'foobar\'">';
+		$error_msg_prepped = '&lt;error =&#39;foobar&#39;&quot;&gt;';
+		$this->form_validation->set_rules('foo', 'label', 'required', array('required' => $error_msg_unprepped));
+		$_POST = array('foo' => '');
+		$this->form_validation->run();
+		$error_arr = $this->form_validation->error_array();
+
+		$this->assertEquals('', $this->form_validation->prep_for_form(''));
+		$this->assertEquals(array('foo' => $error_msg_prepped), $this->form_validation->prep_for_form($error_arr));
+	}
+
+	public function test_prep_url()
+	{
+		$this->assertEquals('', $this->form_validation->prep_url(''));
+		$this->assertEquals('http://codeigniter.com', $this->form_validation->prep_url('codeigniter.com'));
+		$this->assertEquals('https://codeigniter.com', $this->form_validation->prep_url('https://codeigniter.com'));
+		$this->assertEquals('http://codeigniter.com', $this->form_validation->prep_url('http://codeigniter.com'));
+		$this->assertEquals('http://www.codeigniter.com', $this->form_validation->prep_url('www.codeigniter.com'));
+	}
+
+	public function test_encode_php_tags()
+	{
+		$this->assertEquals("&lt;?php", $this->form_validation->encode_php_tags('<?php'));
+		$this->assertEquals('?&gt;', $this->form_validation->encode_php_tags('?>'));
+	}
+
+	/**
+	 * Run rules
+	 *
+	 * Helper method to set rules and run them at once, not
+	 * an actual test case.
+	 */
+	public function run_rules($rules, $values)
+	{
+		$this->form_validation->reset_validation();
+		$_POST = array();
+
+		$this->form_validation->set_rules($rules);
+		foreach ($values as $field => $value)
+		{
+			$_POST[$field] = $value;
+		}
+
+		return $this->form_validation->run();
+	}
+}
diff --git a/tests/mocks/core/input.php b/tests/mocks/core/input.php
index 0d1873849..40e27441f 100644
--- a/tests/mocks/core/input.php
+++ b/tests/mocks/core/input.php
@@ -38,4 +38,12 @@ class Mock_Core_Input extends CI_Input {
 		return FALSE;
 	}
 
+	public function __set($name, $value)
+	{
+		if ($name === 'ip_address')
+		{
+			$this->ip_address = $value;
+		}
+	}
+
 }
\ No newline at end of file
diff --git a/tests/mocks/core/security.php b/tests/mocks/core/security.php
index a21fc5cb3..6cff85860 100644
--- a/tests/mocks/core/security.php
+++ b/tests/mocks/core/security.php
@@ -16,6 +16,11 @@ class Mock_Core_Security extends CI_Security {
 		return isset($this->{'_'.$property}) ? $this->{'_'.$property} : NULL;
 	}
 
+	public function remove_evil_attributes($str, $is_image)
+	{
+		return $this->_remove_evil_attributes($str, $is_image);
+	}
+
 	// Override inaccessible protected method
 	public function __call($method, $params)
 	{
diff --git a/tests/mocks/database/db.php b/tests/mocks/database/db.php
index 968476dea..00dd884b0 100644
--- a/tests/mocks/database/db.php
+++ b/tests/mocks/database/db.php
@@ -56,8 +56,7 @@ class Mock_Database_DB {
 			'char_set' => 'utf8',
 			'dbcollat' => 'utf8_general_ci',
 			'swap_pre' => '',
-			'autoinit' => TRUE,
-			'stricton' => FALSE,
+			'stricton' => FALSE
 		);
 
 		$config = array_merge($this->config[$group], $params);
@@ -134,7 +133,7 @@ class Mock_Database_DB {
 		}
 		catch (Exception $e)
 		{
-			throw new InvalidArgumentException($e->getMessage());
+			throw new RuntimeException($e->getMessage());
 		}
 
 		return $db;