Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tasks/install.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Tasks;
+
+/**
+ * Install task
+ *
+ * Run this task to set default write permissions and environment stuff
+ * for your app. This could be expanded in app/tasks for applicaiton specific stuff.
+ *
+ * @package		Fuel
+ * @version		1.0
+ * @author		Phil Sturgeon
+ */
+
+class Install
+{
+
+	public static function run()
+	{
+		$writable_paths = array(APPPATH.'cache', APPPATH.'logs', APPPATH.'tmp', APPPATH.'config');
+
+		foreach ($writable_paths as $path)
+		{
+			if (@chmod($path, 0777))
+			{
+				\Cli::write("\t".'Made writable: '.$path, 'green');
+			}
+
+			else
+			{
+				\Cli::write("\t".'Failed to make writable: '.$path, 'red');
+			}
+		}
+	}
+}
+

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tasks/migrate.php

@@ -0,0 +1,383 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Tasks;
+
+/**
+ * migrate task
+ *
+ * use this command line task to deploy and rollback changes
+ */
+class Migrate
+{
+	/**
+	 * @var	boolean	if true, migrate the app
+	 */
+	protected static $default = true;
+
+	/**
+	 * @var	array	list of modules to migrate
+	 */
+	protected static $modules = array();
+
+	/**
+	 * @var	array	list of packages to migrate
+	 */
+	protected static $packages = array();
+
+	/**
+	 * @var	int	number of modules migrated
+	 */
+	protected static $module_count = 0;
+
+	/**
+	 * @var	int	number of packages migrated
+	 */
+	protected static $package_count = 0;
+
+	/**
+	 * sets the properties by grabbing Cli options
+	 */
+	public function __construct()
+	{
+		// load config
+		\Config::load('migrations', true);
+
+		// get Cli options
+		$modules = \Cli::option('modules', \Cli::option('m'));
+		$packages = \Cli::option('packages', \Cli::option('p'));
+		$default = \Cli::option('default');
+		$all = \Cli::option('all');
+
+		if ($all)
+		{
+			$modules = true;
+			$packages = true;
+			$default = true;
+		}
+
+		// if modules option set
+		if ( ! empty($modules))
+		{
+			// if true - get all modules
+			if ($modules === true)
+			{
+				// loop through module paths
+				foreach (\Config::get('module_paths') as $path)
+				{
+					// get all modules that have files in the migration folder
+					foreach(new \GlobIterator(realpath($path).DS.'*') as $m)
+					{
+						if (count(new \GlobIterator($m->getPathname().rtrim(DS.\Config::get('migrations.folder'),'\\/').DS.'*.php')))
+						{
+							static::$modules[] = $m->getBasename();
+						}
+					}
+				}
+			}
+			// else do selected modules
+			else
+			{
+				static::$modules = explode(',', $modules);
+			}
+		}
+
+		// if packages option set
+		if ( ! empty($packages))
+		{
+			// if true - get all packages
+			if ($packages === true)
+			{
+				// get all packages that have files in the migration folder
+				foreach (\Config::get('package_paths', array(PKGPATH)) as $path)
+				{
+					// get all modules that have files in the migration folder
+					foreach(new \GlobIterator(realpath($path).DS.'*') as $p)
+					{
+						if (count(new \GlobIterator($p->getPathname().rtrim(DS.\Config::get('migrations.folder'),'\\/').DS.'*.php')))
+						{
+							static::$packages[] = $p->getBasename();
+						}
+					}
+				}
+			}
+			// else do selected packages
+			else
+			{
+				static::$packages = explode(',', $packages);
+			}
+		}
+
+		// if packages or modules are specified, and the app isn't, disable app migrations
+		if ( ( ! empty($packages) or ! empty($modules)) and empty($default))
+		{
+			static::$default = false;
+		}
+
+		// set the module and package count
+		static::$module_count = count(static::$modules);
+		static::$package_count = count(static::$packages);
+	}
+
+	/**
+	 * catches requested method call and runs as needed
+	 *
+	 * @param string	name of the method to run
+	 * @param string	any additional method arguments (not used here!)
+	 */
+	public function __call($name, $args)
+	{
+		// set method name
+		$name = '_'.$name;
+
+		// make sure the called name exists
+		if ( ! method_exists(get_called_class(), $name))
+		{
+			return static::help();
+		}
+
+		// run app (default) migrations if default is true
+		if (static::$default)
+		{
+			static::$name('default', 'app');
+		}
+
+		// run migrations on all specified modules
+		foreach (static::$modules as $module)
+		{
+			static::$name($module, 'module');
+		}
+
+		// run migrations on all specified packages
+		foreach (static::$packages as $package)
+		{
+			static::$name($package, 'package');
+		}
+	}
+
+	/**
+	 * migrates to the latest version unless -version is specified
+	 *
+	 * @param string	name of the type (in case of app, it's 'default')
+	 * @param string	type (app, module or package)
+	 * @param string	direction of migration (up or down)
+	 */
+	protected static function _run($name, $type)
+	{
+		// -v or --version
+		$version = \Cli::option('v', \Cli::option('version', ''));
+
+		// version is used as a flag, so show it
+		if ($version === true)
+		{
+			\Cli::write('Currently installed migrations for '.$type.':'.$name.':', 'green');
+
+			foreach (\Config::get('migrations.version.'.$type.'.'.$name, array()) as $version)
+			{
+				\Cli::write('- '.$version);
+			}
+			return;
+		}
+
+		// version contains a timestamp of sorts
+		elseif ($version !== '')
+		{
+			// if version has a value, make sure only 1 item was passed
+			if (static::$default + static::$module_count + static::$package_count > 1)
+			{
+				\Cli::write('Migration: version only accepts 1 item.');
+				return;
+			}
+			$migrations = \Migrate::version($version, $name, $type, \Cli::option('catchup', false));
+		}
+
+		// migrate to the latest version
+		else
+		{
+			$migrations = \Migrate::latest($name, $type, \Cli::option('catchup', false));
+		}
+
+		// any migrations executed?
+		if ($migrations)
+		{
+			\Cli::write('Performed migrations for '.$type.':'.$name.':', 'green');
+
+			foreach ($migrations as $migration)
+			{
+				\Cli::write($migration);
+			}
+		}
+		else
+		{
+			if ($migrations === false)
+			{
+				\Cli::write('Some migrations where skipped for '.$type.':'.$name.'. Please re-run the migrations.', 'cyan');
+			}
+			elseif ($version !== '')
+			{
+				\Cli::write('No migrations were found for '.$type.':'.$name.'.');
+			}
+			else
+			{
+				\Cli::write('Already on the latest migration for '.$type.':'.$name.'.');
+			}
+		}
+	}
+
+	/**
+	 * migrates item to current config version
+	 *
+	 * @param string	name of the type (in case of app, it's 'default')
+	 * @param string	type (app, module or package)
+	 */
+	protected static function _current($name, $type)
+	{
+		// -v or --version
+		if (\Cli::option('v', \Cli::option('version', '')) !== '')
+		{
+			\Cli::write('You can not define a version when using the "current" command.', 'red');
+		}
+
+		$migrations = \Migrate::current($name, $type);
+
+		if ($migrations)
+		{
+			\Cli::write('Newly installed migrations for '.$type.':'.$name.':', 'green');
+			foreach ($migrations as $migration)
+			{
+				\Cli::write('- '.$migration);
+			}
+		}
+		else
+		{
+			// migration is already on current version
+			\Cli::write('Already on the current migration version for '.$type.':'.$name.'.');
+		}
+	}
+
+	/**
+	 * migrates item up to the given version
+	 *
+	 * @param string
+	 * @param string
+	 */
+	protected static function _up($name, $type)
+	{
+		// -v or --version
+		$version = \Cli::option('v', \Cli::option('version', null));
+
+		// if version has a value, make sure only 1 item was passed
+		if ($version and (static::$default + static::$module_count + static::$package_count > 1))
+		{
+			\Cli::write('Migration: version only accepts 1 item.');
+			return;
+		}
+
+		$migrations = \Migrate::up($version, $name, $type);
+
+		if ($migrations)
+		{
+			\Cli::write('Newly installed migrations for '.$type.':'.$name.':', 'green');
+			foreach ($migrations as $migration)
+			{
+				\Cli::write('- '.$migration);
+			}
+		}
+		else
+		{
+			// there is no 'up'...
+			\Cli::write('You are already on the latest migration version for '.$type.':'.$name.'.');
+		}
+	}
+
+	/**
+	 * migrates item down to the given version
+	 *
+	 * @param string
+	 * @param string
+	 */
+	protected static function _down($name, $type)
+	{
+		// -v or --version
+		$version = \Cli::option('v', \Cli::option('version', null));
+
+		// if version has a value, make sure only 1 item was passed
+		if ($version and (static::$default + static::$module_count + static::$package_count > 1))
+		{
+			\Cli::write('Migration: version only accepts 1 item.');
+			return;
+		}
+
+		$migrations = \Migrate::down($version, $name, $type);
+
+		if ($migrations)
+		{
+			\Cli::write('Reverted migrations for '.$type.':'.$name.':', 'green');
+			foreach ($migrations as $migration)
+			{
+				\Cli::write('- '.$migration);
+			}
+		}
+		else
+		{
+			// there is no 'down'...
+			\Cli::write('There are no migrations installed to revert for '.$type.':'.$name.'.');
+		}
+	}
+
+	/**
+	 * Shows basic help instructions for using migrate in oil
+	 */
+	public static function help()
+	{
+		echo <<<HELP
+Usage:
+    php oil refine migrate[:command] [--version=X]
+
+Fuel commands:
+    help     shows this text
+    current  migrates to the version defined in the migration configuration file
+    up       migrate up to the next version
+    down     migrate down to the previous version
+    run      run all migrations (default)
+
+Fuel options:
+    -v, [--version]  # Migrate to a specific version ( only 1 item at a time)
+    --catchup        # Use if you have out-of-sequence migrations that can be safely run
+
+    # The following disable default migrations unless you add --default to the command
+    --default                               # re-enables default migration
+    --modules -m                            # Migrates all modules
+    --modules=item1,item2 -m=item1,item2    # Migrates specific modules
+    --packages -p                           # Migrates all packages
+    --packages=item1,item2 -p=item1,item2   # Migrates specific modules
+    --all                                   # shortcut for --modules --packages --default
+
+Description:
+    The migrate task can run migrations. You can go up, down or by default go to the current migration marked in the config file.
+
+Examples:
+    php oil r migrate
+    php oil r migrate:current
+    php oil r migrate:up -v=6
+    php oil r migrate:down
+    php oil r migrate --version=201203171206
+    php oil r migrate --modules --packages --default
+    php oil r migrate:up --modules=module1,module2 --packages=package1
+    php oil r migrate --modules=module1 -v=3
+    php oil r migrate --all
+
+HELP;
+
+	}
+
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tasks/session.php

@@ -0,0 +1,181 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Tasks;
+
+/**
+ * Sessions DB Table Task
+ *
+ * @PullRequest https://github.com/fuel/core/pull/786
+ *
+ * Run this task to set add/remove/clear the db sessions table
+ * Table name will be generated from your config file.
+ * for your app. This could be expanded in app/tasks for application specific stuff.
+ *
+ * @package     Fuel
+ * @version		1.1
+ * @author		Daniel Berry
+ * @license     MIT License
+ *
+ * Usage:
+ * php oil r session         = will prompt with menu
+ * php oil r session:create  = create the db table.
+ * php oil r session:remove  = remove the sessions table
+ * php oil r session:clear   = clear the sessions table
+ */
+
+class Session
+{
+
+    // default function if no command is selected. Provided user with menu
+    public static function run()
+    {
+        // Prompt the user with menu options
+        $option = \Cli::prompt('What would you like to do?', array('create','remove', 'clear', 'help'));
+
+        switch($option)
+        {
+            case "create":
+                return static::create();
+                break;
+            case "remove":
+                return static::remove();
+                break;
+            case "clear":
+                return static::clear();
+                break;
+            default:
+                return static::help();
+                break;
+        }
+    }
+
+    /**
+     * create the sessions table
+     * php oil r session:create
+     */
+    public static function create()
+    {
+        // load session config
+        \Config::load('session', true);
+
+        if (\Config::get('session.driver') != 'db')
+        {
+            // prompt the user to confirm they want to remove the table.
+            $continue = \Cli::prompt(\Cli::color('Your current driver type is not set db. Would you like to continue and add the sessions table anyway?', 'yellow'), array('y','n'));
+
+            if ($continue === 'n')
+            {
+                return \Cli::color('Database sessions table was not created.', 'red');
+            }
+        }
+
+        if (\DBUtil::table_exists(\Config::get('session.db.table')))
+        {
+            return \Cli::write('Session table already exists.');
+        }
+
+        // create the session table using the table name from the config file
+        \DBUtil::create_table(\Config::get('session.db.table'), array(
+            'session_id'   => array('constraint' => 40, 'type' => 'varchar'),
+            'previous_id'  => array('constraint' => 40, 'type' => 'varchar'),
+            'user_agent'   => array('type' => 'text', 'null' => false),
+            'ip_hash'      => array('constraint' => 32, 'type' => 'char'),
+            'created'      => array('constraint' => 10, 'type' => 'int', 'unsigned' => true),
+            'updated'      => array('constraint' => 10, 'type' => 'int', 'unsigned' => true),
+            'payload'      => array('type' => 'longtext'),
+        ), array('session_id'), false, 'InnoDB', \Config::get('db.default.charset'));
+
+        // make previous_id a unique_key. speeds up query and prevents duplicate id's
+        \DBUtil::create_index(\Config::get('session.db.table'), 'previous_id', 'previous_id', 'unique');
+
+        if (\Config::get('session.driver') === 'db')
+        {
+            // return success message.
+            return \Cli::color('Success! Your session table has been created!', 'green');
+        }
+        else
+        {
+            // return success message notifying that the driver is not db.
+            return \Cli::color('Success! Your session table has been created! Your current session driver type is set to '.\Config::get('session.driver').'. In order to use the table you just created to manage your sessions, you will need to set your driver type to "db" in your session config file.', 'green');
+        }
+    }
+
+    /**
+     * remove the sessions table
+     * php oil r session:remove
+     */
+    public static function remove()
+    {
+        // load session config
+        \Config::load('session', true);
+
+        // prompt the user to confirm they want to remove the table.
+        $iamsure = \Cli::prompt('Are you sure you want to delete the sessions table?', array('y','n'));
+
+        // if they are sure, then let's drop it
+        if ($iamsure === 'y')
+        {
+            \DBUtil::drop_table(\Config::get('session.db.table'));
+            return \Cli::color('Session database table deleted.', 'green');
+        }
+
+        // if we made it to here, than that means the user said no.
+        return \Cli::color('Session database table was not deleted.', 'red');
+    }
+
+    /**
+     * clear the sessions table
+     * php oil r session:clear
+     */
+    public static function clear()
+    {
+        // load session config
+        \Config::load('session', true);
+
+        // prompt the user to confirm they want to clear the table.
+        $iamsure = \Cli::prompt('Are you sure you want to clear the sessions table?', array('y','n'));
+
+        // if they are sure, then let's drop it
+        if ($iamsure === 'y')
+        {
+            \DBUtil::truncate_table(\Config::get('session.db.table'));
+            return \Cli::color('Session database table successfully truncated.', 'green');
+        }
+
+        // if we made it to here, than that means the user said no.
+        return \Cli::color('Session database table was not cleared.', 'red');
+    }
+
+    /**
+     * Shows basic help instructions for using migrate in oil
+     */
+    public static function help()
+    {
+        echo <<<HELP
+            Usage:
+                php oil refine session
+
+            Description:
+                The session task will create the necessary db tables.
+
+            Examples:
+                php oil r session:create
+                php oil r session:remove
+                php oil r session:clear
+                php oil r session:help
+
+HELP;
+    }
+}
+
+/* End of file tasks/session.php */

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/agent.php

@@ -0,0 +1,247 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Agent class tests
+ *
+ * @group Core
+ * @group Agent
+ */
+class Test_Agent extends TestCase
+{
+
+	/**
+	 * need to setup a fake browser environment
+	 */
+	protected function setUp()
+	{
+		// make sure we've got the Agent class in a known state
+		$_SERVER['HTTP_ACCEPT_LANGUAGE'] = 'en-us,en;q=0.8,nl-be;q=0.5,nl;q=0.3';
+		$_SERVER['HTTP_ACCEPT_CHARSET'] = 'UTF-8,ISO-8859-1,*';
+		$_SERVER['HTTP_USER_AGENT'] = 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.16) Gecko/20110322 Fedora/3.6.16-1.fc14 Firefox/3.6.16';
+
+		// by re-running the class init manually
+		\Agent::_init();
+	}
+
+	/**
+	 * Tests Agent::browser()
+	 *
+	 * @test
+	 */
+	public function test_browser()
+ 	{
+		$expected = "Firefox";
+		$output = Agent::browser();
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Agent::platform()
+	 *
+	 * @test
+	 */
+	public function test_platform()
+ 	{
+		$expected = "Linux";
+		$output = Agent::platform();
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Agent::version()
+	 *
+	 * @test
+	 */
+	public function test_version()
+ 	{
+		$expected = 3.6;
+		$output = Agent::version();
+		$this->assertInternalType('float', $output);
+		$this->assertEquals($expected, $output);
+	}
+
+	public function property_provider()
+ 	{
+		return array(
+			array(
+				'Browser','Firefox',
+			),
+			array(
+				'Version',3.6,
+			),
+			array(
+				'MajorVer',3,
+			),
+			array(
+				'MinorVer',6,
+			),
+			array(
+				'Platform','Linux',
+			),
+			array(
+				'Alpha',false,
+			),
+			array(
+				'Beta',false,
+			),
+			array(
+				'Win16',false,
+			),
+			array(
+				'Win32',false,
+			),
+			array(
+				'Win64',false,
+			),
+			array(
+				'Frames',true,
+			),
+			array(
+				'IFrames',true,
+			),
+			array(
+				'Tables',true,
+			),
+			array(
+				'Cookies',true,
+			),
+			array(
+				'BackgroundSounds',false,
+			),
+			array(
+				'JavaScript',true,
+			),
+			array(
+				'VBScript',false,
+			),
+			array(
+				'JavaApplets',true,
+			),
+			array(
+				'ActiveXControls',false,
+			),
+			array(
+				'isBanned',false,
+			),
+			array(
+				'isMobile',false,
+			),
+			array(
+				'isSyndicationReader',false,
+			),
+			array(
+				'Crawler',false,
+			),
+			array(
+				'CssVersion',3,
+			),
+			array(
+				'AolVersion',0,
+			),
+		);
+	}
+
+	/**
+	 * Tests Agent::property()
+	 *
+	 * @test
+	 * @dataProvider property_provider
+	 */
+	public function test_property($property, $expected)
+ 	{
+		$output = Agent::property($property);
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Agent::is_robot()
+	 *
+	 * @test
+	 */
+	public function test_is_robot()
+ 	{
+		$output = Agent::is_robot();
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Agent::is_mobiledevice()
+	 *
+	 * @test
+	 */
+	public function test_is_mobiledevice()
+ 	{
+		$output = Agent::is_mobiledevice();
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Agent::languages()
+	 *
+	 * @test
+	 */
+	public function test_languages()
+ 	{
+		$expected = array("en-us", "en", "nl-be", "nl");
+		$output = Agent::languages();
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Agent::accepts_language()
+	 *
+	 * @test
+	 */
+	public function test_accepts_language_success()
+ 	{
+		$output = Agent::accepts_language('en-us');
+		$this->assertTrue($output);
+	}
+
+	public function test_accepts_language_fail()
+ 	{
+		$output = Agent::accepts_language('pt-br');
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Agent::charsets()
+	 *
+	 * @test
+	 */
+	public function test_charsets()
+ 	{
+		$expected = array("utf-8", "iso-8859-1", "*");
+		$output = Agent::charsets();
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Agent::accepts_charset()
+	 *
+	 * @test
+	 */
+	public function test_accepts_charset_success()
+ 	{
+		$output = Agent::accepts_charset('utf-8');
+		$this->assertTrue($output);
+	}
+
+	public function test_accepts_charset_fail()
+ 	{
+		$output = Agent::accepts_charset('cp2');
+		$this->assertFalse($output);
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/arr.php

@@ -0,0 +1,1008 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Arr class tests
+ *
+ * @group Core
+ * @group Arr
+ */
+class Test_Arr extends TestCase
+{
+
+	public static function person_provider()
+	{
+		return array(
+			array(
+				array(
+					"name" => "Jack",
+					"age" => "21",
+					"weight" => 200,
+					"location" => array(
+						"city" => "Pittsburgh",
+						"state" => "PA",
+						"country" => "US"
+					),
+				),
+			),
+		);
+	}
+
+	public static function collection_provider()
+	{
+		$object = new \stdClass;
+		$object->id = 7;
+		$object->name = 'Bert';
+		$object->surname = 'Visser';
+
+		return array(
+			array(
+				array(
+					array(
+						'id' => 2,
+						'name' => 'Bill',
+						'surname' => 'Cosby',
+					),
+					array(
+						'id' => 5,
+						'name' => 'Chris',
+						'surname' => 'Rock',
+					),
+					$object,
+				),
+			),
+		);
+	}
+
+	/**
+	 * Test Arr::pluck()
+	 *
+	 * @test
+	 * @dataProvider collection_provider
+	 */
+	public function test_pluck($collection)
+	{
+		$output = \Arr::pluck($collection, 'id');
+		$expected = array(2, 5, 7);
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test Arr::pluck()
+	 *
+	 * @test
+	 * @dataProvider collection_provider
+	 */
+	public function test_pluck_with_index($collection)
+	{
+		$output = \Arr::pluck($collection, 'name', 'id');
+		$expected = array(2 => 'Bill', 5 => 'Chris', 7 => 'Bert');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::assoc_to_keyval()
+	 *
+	 * @test
+	 */
+	public function test_assoc_to_keyval()
+	{
+		$assoc = array(
+			array(
+				'color' => 'red',
+				'rank' => 4,
+				'name' => 'Apple',
+				),
+			array(
+				'color' => 'yellow',
+				'rank' => 3,
+				'name' => 'Banana',
+				),
+			array(
+				'color' => 'purple',
+				'rank' => 2,
+				'name' => 'Grape',
+				),
+			);
+
+		$expected = array(
+			'red' => 'Apple',
+			'yellow' => 'Banana',
+			'purple' => 'Grape',
+			);
+		$output = Arr::assoc_to_keyval($assoc, 'color', 'name');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::key_exists()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_key_exists_with_key_found($person)
+	{
+		$expected = true;
+		$output = Arr::key_exists($person, "name");
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::key_exists()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_key_exists_with_key_not_found($person)
+	{
+		$expected = false;
+		$output = Arr::key_exists($person, "unknown");
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::key_exists()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_key_exists_with_dot_separated_key($person)
+	{
+		$expected = true;
+		$output = Arr::key_exists($person, "location.city");
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_with_element_found($person)
+	{
+		$expected = "Jack";
+		$output = Arr::get($person, "name", "Unknown Name");
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_with_element_not_found($person)
+	{
+		$expected = "Unknown job";
+		$output = Arr::get($person, "job", "Unknown job");
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_with_dot_separated_key($person)
+	{
+		$expected = "Pittsburgh";
+		$output = Arr::get($person, "location.city", "Unknown City");
+		$this->assertEquals($expected, $output);
+
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @expectedException InvalidArgumentException
+	 */
+	public function test_get_throws_exception_when_array_is_not_an_array()
+	{
+		$output = Arr::get('Jack', 'name', 'Unknown Name');
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_when_dot_notated_key_is_not_array($person)
+	{
+		$expected = "Unknown Name";
+		$output = Arr::get($person, 'foo.first', 'Unknown Name');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_with_all_elements_found($person)
+	{
+		$expected = array(
+			'name' => 'Jack',
+			'weight' => 200,
+		);
+		$output = Arr::get($person, array('name', 'weight'), 'Unknown');
+		$this->assertEquals($expected, $output);
+	}
+
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_with_all_elements_not_found($person)
+	{
+		$expected = array(
+			'name' => 'Jack',
+			'height' => 'Unknown',
+		);
+		$output = Arr::get($person, array('name', 'height'), 'Unknown');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::get()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_get_when_keys_is_not_an_array($person)
+	{
+		$expected = 'Jack';
+		$output = Arr::get($person, 'name', 'Unknown');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::flatten()
+	 *
+	 * @test
+	 */
+	public function test_flatten()
+	{
+		$indexed = array ( array('a'), array('b'), array('c') );
+
+		$expected = array(
+			"0_0" => "a",
+			"1_0" => "b",
+			"2_0" => "c",
+		);
+
+		$output = Arr::flatten($indexed, '_');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::flatten_assoc()
+	 *
+	 * @test
+	 */
+	public function test_flatten_assoc()
+	{
+		$people = array(
+			array(
+				"name" => "Jack",
+				"age" => 21
+			),
+			array(
+				"name" => "Jill",
+				"age" => 23
+			)
+		);
+
+		$expected = array(
+			"0:name" => "Jack",
+			"0:age" => 21,
+			"1:name" => "Jill",
+			"1:age" => 23
+		);
+
+		$output = Arr::flatten_assoc($people);
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::merge_assoc()
+	 *
+	 * @test
+	 */
+	public function test_merge_assoc()
+	{
+		$arr1 = array(
+			'one' => 1,
+			2 => 2,
+			3 => 3,
+			4 => array(
+				56
+			),
+			5=> 87
+		);
+
+		$arr2 = array(
+			1 => 27,
+			2 => 90,
+			4 => array(
+				'give_me' => 'bandwidth',
+			),
+			6 => '90',
+			7 => 'php',
+		);
+
+		$expected = array(
+			'one' => 1,
+			2 => 90,
+			3 => 3,
+			4 => array(
+				56,
+				'give_me' => 'bandwidth',
+			),
+			5=> 87,
+			1 => 27,
+			6 => '90',
+			7 => 'php',
+		);
+
+		$output = Arr::merge_assoc($arr1, $arr2);
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::insert()
+	 *
+	 * @test
+	 */
+	public function test_insert()
+	{
+		$people = array("Jack", "Jill");
+
+		$expected = array("Humpty", "Jack", "Jill");
+		$output = Arr::insert($people, "Humpty", 0);
+
+		$this->assertEquals(true, $output);
+		$this->assertEquals($expected, $people);
+	}
+
+	/**
+	 * Tests Arr::insert()
+	 *
+	 * @test
+	 */
+	public function test_insert_with_index_out_of_range()
+	{
+		$people = array("Jack", "Jill");
+
+		$output = Arr::insert($people, "Humpty", 4);
+
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Arr::insert_after_key()
+	 *
+	 * @test
+	 */
+	public function test_insert_after_key_that_exists()
+	{
+		$people = array("Jack", "Jill");
+
+		$expected = array("Jack", "Jill", "Humpty");
+		$output = Arr::insert_after_key($people, "Humpty", 1);
+
+		$this->assertTrue($output);
+		$this->assertEquals($expected, $people);
+	}
+
+	/**
+	 * Tests Arr::insert_after_key()
+	 *
+	 * @test
+	 */
+	public function test_insert_after_key_that_does_not_exist()
+	{
+		$people = array("Jack", "Jill");
+		$output = Arr::insert_after_key($people, "Humpty", 6);
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Arr::insert_after_value()
+	 *
+	 * @test
+	 */
+	public function test_insert_after_value_that_exists()
+	{
+		$people = array("Jack", "Jill");
+		$expected = array("Jack", "Humpty", "Jill");
+		$output = Arr::insert_after_value($people, "Humpty", "Jack");
+		$this->assertTrue($output);
+		$this->assertEquals($expected, $people);
+	}
+
+	/**
+	 * Tests Arr::insert_after_value()
+	 *
+	 * @test
+	 */
+	public function test_insert_after_value_that_does_not_exists()
+	{
+		$people = array("Jack", "Jill");
+		$output = Arr::insert_after_value($people, "Humpty", "Joe");
+		$this->assertFalse($output);
+	}
+
+	/**
+	 * Tests Arr::average()
+	 *
+	 * @test
+	 */
+	public function test_average()
+	{
+		$arr = array(13, 8, 6);
+		$this->assertEquals(9, Arr::average($arr));
+	}
+
+	/**
+	 * Tests Arr::average()
+	 *
+	 * @test
+	 */
+	public function test_average_of_empty_array()
+	{
+		$arr = array();
+		$this->assertEquals(0, Arr::average($arr));
+	}
+
+	/**
+	 * Tests Arr::filter_prefixed()
+	 *
+	 * @test
+	 */
+	public function test_filter_prefixed()
+	{
+		$arr = array('foo' => 'baz', 'prefix_bar' => 'yay');
+
+		$output = Arr::filter_prefixed($arr, 'prefix_');
+		$this->assertEquals(array('bar' => 'yay'), $output);
+	}
+
+	/**
+	 * Tests Arr::sort()
+	 *
+	 * @test
+	 * @expectedException InvalidArgumentException
+	 */
+	public function test_sort_of_non_array()
+	{
+		$sorted = Arr::sort('not an array', 'foo.key');
+	}
+
+	public function sort_provider()
+	{
+		return array(
+			array(
+				// Unsorted Array
+				array(
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'dog'
+							)
+						),
+					),
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'fish'
+							)
+						),
+					),
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'cat'
+							)
+						),
+					),
+				),
+
+				// Sorted Array
+				array(
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'cat'
+							)
+						),
+					),
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'dog'
+							)
+						),
+					),
+					array(
+						'info' => array(
+							'pet' => array(
+								'type' => 'fish'
+							)
+						),
+					),
+				)
+			)
+		);
+	}
+
+	/**
+	 * Tests Arr::sort()
+	 *
+	 * @test
+	 * @dataProvider sort_provider
+	 */
+	public function test_sort_asc($data, $expected)
+	{
+		$this->assertEquals($expected, Arr::sort($data, 'info.pet.type', 'asc'));
+	}
+
+	/**
+	 * Tests Arr::sort()
+	 *
+	 * @test
+	 * @dataProvider sort_provider
+	 */
+	public function test_sort_desc($data, $expected)
+	{
+		$expected = array_reverse($expected);
+		$this->assertEquals($expected, Arr::sort($data, 'info.pet.type', 'desc'));
+	}
+
+	/**
+	 * Tests Arr::sort()
+	 *
+	 * @test
+	 * @dataProvider sort_provider
+	 * @expectedException InvalidArgumentException
+	 */
+	public function test_sort_invalid_direction($data, $expected)
+	{
+		$this->assertEquals($expected, Arr::sort($data, 'info.pet.type', 'downer'));
+	}
+
+	public function test_sort_empty()
+	{
+		$expected = array();
+		$output = Arr::sort(array(), 'test', 'test');
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Tests Arr::filter_keys()
+	 *
+	 * @test
+	 */
+	public function test_filter_keys()
+	{
+		$data = array(
+			'epic' => 'win',
+			'weak' => 'sauce',
+			'foo' => 'bar'
+		);
+		$expected = array(
+			'epic' => 'win',
+			'foo' => 'bar'
+		);
+		$expected_remove = array(
+			'weak' => 'sauce',
+		);
+		$keys = array('epic', 'foo');
+		$this->assertEquals($expected, Arr::filter_keys($data, $keys));
+		$this->assertEquals($expected_remove, Arr::filter_keys($data, $keys, true));
+	}
+
+	/**
+	 * Tests Arr::to_assoc()
+	 *
+	 * @test
+	 */
+	public function test_to_assoc_with_even_number_of_elements()
+	{
+		$arr = array('foo', 'bar', 'baz', 'yay');
+		$expected = array('foo' => 'bar', 'baz' => 'yay');
+		$this->assertEquals($expected, Arr::to_assoc($arr));
+	}
+
+	/**
+	 * Tests Arr::to_assoc()
+	 *
+	 * @test
+	 * @expectedException BadMethodCallException
+	 */
+	public function test_to_assoc_with_odd_number_of_elements()
+	{
+		$arr = array('foo', 'bar', 'baz');
+		Arr::to_assoc($arr);
+	}
+
+	/**
+	 * Tests Arr::prepend()
+	 *
+	 * @test
+	 */
+	public function test_prepend()
+	{
+		$arr = array(
+			'two' => 2,
+			'three' => 3,
+		);
+		$expected = array(
+			'one' => 1,
+			'two' => 2,
+			'three' => 3,
+		);
+		Arr::prepend($arr, 'one', 1);
+		$this->assertEquals($expected, $arr);
+	}
+
+	/**
+	 * Tests Arr::prepend()
+	 *
+	 * @test
+	 */
+	public function test_prepend_array()
+	{
+		$arr = array(
+			'two' => 2,
+			'three' => 3,
+		);
+		$expected = array(
+			'one' => 1,
+			'two' => 2,
+			'three' => 3,
+		);
+		Arr::prepend($arr, array('one' => 1));
+		$this->assertEquals($expected, $arr);
+	}
+
+	/**
+	 * Tests Arr::is_multi()
+	 *
+	 * @test
+	 */
+	public function test_multidimensional_array()
+	{
+		// Single array
+		$arr_single = array('one' => 1, 'two' => 2);
+		$this->assertFalse(Arr::is_multi($arr_single));
+
+		// Multi-dimensional array
+		$arr_multi = array('one' => array('test' => 1), 'two' => array('test' => 2), 'three' => array('test' => 3));
+		$this->assertTrue(Arr::is_multi($arr_multi));
+
+		// Multi-dimensional array (not all elements are arrays)
+		$arr_multi_strange = array('one' => array('test' => 1), 'two' => array('test' => 2), 'three' => 3);
+		$this->assertTrue(Arr::is_multi($arr_multi_strange, false));
+		$this->assertFalse(Arr::is_multi($arr_multi_strange, true));
+	}
+
+	/**
+	 * Tests Arr::search()
+	 *
+	 * @test
+	 */
+	public function test_search_single_array()
+	{
+		// Single array
+		$arr_single = array('one' => 1, 'two' => 2);
+		$expected = 'one';
+		$this->assertEquals($expected, Arr::search($arr_single, 1));
+
+		// Default
+		$expected = null;
+		$this->assertEquals($expected, Arr::search($arr_single, 3));
+		$expected = 'three';
+		$this->assertEquals($expected, Arr::search($arr_single, 3, 'three'));
+
+		// Single array (int key)
+		$arr_single = array(0 => 'zero', 'one' => 1, 'two' => 2);
+		$expected = 0;
+		$this->assertEquals($expected, Arr::search($arr_single, 0));
+	}
+
+	/**
+	 * Tests Arr::search()
+	 *
+	 * @test
+	 */
+	public function test_search_multi_array()
+	{
+		// Multi-dimensional array
+		$arr_multi = array('one' => array('test' => 1), 'two' => array('test' => 2), 'three' => array('test' => array('a' => 'a', 'b' => 'b')));
+		$expected = 'one';
+		$this->assertEquals($expected, Arr::search($arr_multi, array('test' => 1), null, false));
+		$expected = null;
+		$this->assertEquals($expected, Arr::search($arr_multi, 1, null, false));
+
+		// Multi-dimensional array (recursive)
+		$expected = 'one.test';
+		$this->assertEquals($expected, Arr::search($arr_multi, 1));
+
+		$expected = 'three.test.b';
+		$this->assertEquals($expected, Arr::search($arr_multi, 'b', null, true));
+	}
+
+
+	/**
+	 * Tests Arr::sum()
+	 *
+	 * @test
+	 */
+	public function test_sum_multi_array()
+	{
+		$arr_multi = array(
+			array(
+				'name' => 'foo',
+				'scores' => array(
+					'sports' => 5,
+					'math' => 20,
+				),
+			),
+			array(
+				'name' => 'bar',
+				'scores' => array(
+					'sports' => 7,
+					'math' => 15,
+				),
+			),
+			array(
+				'name' => 'fuel',
+				'scores' => array(
+					'sports' => 8,
+					'math' => 5,
+				),
+			),
+			array(
+				'name' => 'php',
+				'scores' => array(
+					'math' => 10,
+				),
+			),
+		);
+
+		$expected = 50;
+		$test = \Arr::sum($arr_multi, 'scores.math');
+		$this->assertEquals($expected, $test);
+
+		$expected = 20;
+		$test = \Arr::sum($arr_multi, 'scores.sports');
+		$this->assertEquals($expected, $test);
+	}
+
+	/**
+	 * Tests Arr::previous_by_key()
+	 *
+	 * @test
+	 */
+	public function test_previous_by_key()
+	{
+		// our test array
+		$arr = array(2 => 'A', 4 => 'B', 6 => 'C');
+
+		// test: key not found in array
+		$expected = false;
+		$test = \Arr::previous_by_key($arr, 1);
+		$this->assertTrue($expected === $test);
+
+		// test: no previous key
+		$expected = null;
+		$test = \Arr::previous_by_key($arr, 2);
+		$this->assertTrue($expected === $test);
+
+		// test: strict key comparison
+		$expected = false;
+		$test = \Arr::previous_by_key($arr, '2', false, true);
+		$this->assertTrue($expected === $test);
+
+		// test: get previous key
+		$expected = 2;
+		$test = \Arr::previous_by_key($arr, 4);
+		$this->assertTrue($expected === $test);
+
+		// test: get previous value
+		$expected = 'A';
+		$test = \Arr::previous_by_key($arr, 4, true);
+		$this->assertTrue($expected === $test);
+	}
+
+	/**
+	 * Tests Arr::next_by_key()
+	 *
+	 * @test
+	 */
+	public function test_next_by_key()
+	{
+		// our test array
+		$arr = array(2 => 'A', 4 => 'B', 6 => 'C');
+
+		// test: key not found in array
+		$expected = false;
+		$test = \Arr::next_by_key($arr, 1);
+		$this->assertTrue($expected === $test);
+
+		// test: no next key
+		$expected = null;
+		$test = \Arr::next_by_key($arr, 6);
+		$this->assertTrue($expected === $test);
+
+		// test: strict key comparison
+		$expected = false;
+		$test = \Arr::next_by_key($arr, '6', false, true);
+		$this->assertTrue($expected === $test);
+
+		// test: get next key
+		$expected = 6;
+		$test = \Arr::next_by_key($arr, 4);
+		$this->assertTrue($expected === $test);
+
+		// test: get next value
+		$expected = 'C';
+		$test = \Arr::next_by_key($arr, 4, true);
+		$this->assertTrue($expected === $test);
+	}
+
+	/**
+	 * Tests Arr::previous_by_value()
+	 *
+	 * @test
+	 */
+	public function test_previous_by_value()
+	{
+		// our test array
+		$arr = array(2 => 'A', 4 => '2', 6 => 'C');
+
+		// test: value not found in array
+		$expected = false;
+		$test = \Arr::previous_by_value($arr, 'Z');
+		$this->assertTrue($expected === $test);
+
+		// test: no previous value
+		$expected = null;
+		$test = \Arr::previous_by_value($arr, 'A');
+		$this->assertTrue($expected === $test);
+
+		// test: strict value comparison
+		$expected = false;
+		$test = \Arr::previous_by_value($arr, 2, true, true);
+		$this->assertTrue($expected === $test);
+
+		// test: get previous value
+		$expected = 'A';
+		$test = \Arr::previous_by_value($arr, '2');
+		$this->assertTrue($expected === $test);
+
+		// test: get previous key
+		$expected = 4;
+		$test = \Arr::previous_by_value($arr, 'C', false);
+		$this->assertTrue($expected === $test);
+	}
+
+	/**
+	 * Tests Arr::next_by_value()
+	 *
+	 * @test
+	 */
+	public function test_next_by_value()
+	{
+		// our test array
+		$arr = array(2 => 'A', 4 => '2', 6 => 'C');
+
+		// test: value not found in array
+		$expected = false;
+		$test = \Arr::next_by_value($arr, 'Z');
+		$this->assertTrue($expected === $test);
+
+		// test: no next value
+		$expected = null;
+		$test = \Arr::next_by_value($arr, 'C');
+		$this->assertTrue($expected === $test);
+
+		// test: strict value comparison
+		$expected = false;
+		$test = \Arr::next_by_value($arr, 2, true, true);
+		$this->assertTrue($expected === $test);
+
+		// test: get next value
+		$expected = 'C';
+		$test = \Arr::next_by_value($arr, '2');
+		$this->assertTrue($expected === $test);
+
+		// test: get next key
+		$expected = 4;
+		$test = \Arr::next_by_value($arr, 'A', false);
+		$this->assertTrue($expected === $test);
+	}
+
+	/**
+	 * Tests Arr::subset()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_subset_basic_usage($person)
+	{
+		$expected = array(
+			"name" => "Jack",
+			"location" => array(
+				"city" => "Pittsburgh",
+				"state" => "PA",
+				"country" => "US"
+			),
+		);
+
+		$got = \Arr::subset($person, array("name", "location"));
+		$this->assertEquals($expected, $got);
+
+		$expected = array(
+			"name" => "Jack",
+			"location" => array(
+				"country" => "US"
+			),
+		);
+
+		$got = \Arr::subset($person, array("name", "location.country"));
+		$this->assertEquals($expected, $got);
+	}
+
+	/**
+	 * Tests Arr::subset()
+	 *
+	 * @test
+	 * @dataProvider person_provider
+	 */
+	public function test_subset_missing_items($person)
+	{
+		$expected = array(
+			"name" => "Jack",
+			"location" => array(
+				"street" => null,
+				"country" => "US"
+			),
+			"occupation" => null
+		);
+
+		$got = \Arr::subset($person, array("name", "location.street", "location.country", "occupation"));
+		$this->assertEquals($expected, $got);
+
+		$expected = array(
+			"name" => "Jack",
+			"location" => array(
+				"street" => "Unknown",
+				"country" => "US"
+			),
+			"occupation" => "Unknown"
+		);
+
+		$got = \Arr::subset($person, array("name", "location.street", "location.country", "occupation"), "Unknown");
+		$this->assertEquals($expected, $got);
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/asset.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Asset class tests
+ *
+ * @group Core
+ * @group Asset
+ */
+class Test_Asset extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/autoloader.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.6
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Autoloader class tests
+ *
+ * @group Core
+ * @group Autoloader
+ */
+class Test_Autoloader extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/cache.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Cache class tests
+ *
+ * @group Core
+ * @group Cache
+ */
+class Test_Cache extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/cli.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Cli class tests
+ *
+ * @group Core
+ * @group Cli
+ */
+class Test_Cli extends TestCase
+{
+
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/config.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.6
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Config class tests
+ *
+ * @group Core
+ * @group Config
+ */
+class Test_Config extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/controller.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.6
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Controller class tests
+ *
+ * @group Core
+ * @group Controller
+ */
+class Test_Controller extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/cookie.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Cookie class tests
+ *
+ * @group Core
+ * @group Cookie
+ */
+class Test_Cookie extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/crypt.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Crypt class tests
+ *
+ * @group Core
+ * @group Crypt
+ */
+class Test_Crypt extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/date.php

@@ -0,0 +1,170 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Date class tests
+ *
+ * @group Core
+ * @group Date
+ */
+class Test_Date extends TestCase
+{
+	protected function setUp()
+	{
+		// make sure the locale and language are is set correctly for the tests
+		setlocale(LC_ALL, 'en_US') === false and setlocale(LC_ALL, 'en_US.UTF8');
+		\Config::set('language', 'en');
+	}
+
+	/**
+	 * Test for Date::days_in_month()
+	 *
+	 * @test
+	 */
+	public function test_days_in_month()
+	{
+		$output = Date::days_in_month(8);
+		$expected = 31;
+		$this->assertEquals($expected, $output);
+
+		$output = Date::days_in_month(2,2001);
+		$expected = 28;
+		$this->assertEquals($expected, $output);
+
+		$output = Date::days_in_month(2,2000);
+		$expected = 29;
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test for Date::days_in_month(0)
+	 * @expectedException UnexpectedValueException
+	 * @test
+	 */
+	public function test_days_in_month_0_exception()
+	{
+		$output = Date::days_in_month(0);
+	}
+
+	/**
+	 * Test for Date::days_in_month(13)
+	 * @expectedException UnexpectedValueException
+	 * @test
+	 */
+	public function test_days_in_month_13_exception()
+	{
+		$output = Date::days_in_month(13);
+	}
+
+
+
+	/**
+	 * Test for Date::format()
+	 *
+	 * @test
+	 */
+	public function test_format()
+	{
+		$default_timezone = date_default_timezone_get();
+		date_default_timezone_set('UTC');
+
+		$output = Date::forge( 1294176140 )->format("%m/%d/%Y");
+		$expected = "01/04/2011";
+
+		date_default_timezone_set($default_timezone);
+
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test for Date::get_timestamp()
+	 *
+	 * @test
+	 */
+	public function test_get_timestamp()
+	{
+		$output = Date::forge( 1294176140 )->get_timestamp();
+		$expected = 1294176140;
+
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test for Date::get_timezone()
+	 *
+	 * @test
+	 */
+	public function test_get_timezone()
+	{
+		$output = Date::forge( 1294176140, "Europe/London" )->get_timezone();
+		$expected = "Europe/London";
+
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test for Date::set_timezone()
+	 *
+	 * @test
+	 */
+	public function test_set_timezone()
+	{
+		$output = Date::forge( 1294176140 )->set_timezone("America/Chicago")->get_timezone();
+		$expected = "America/Chicago";
+
+		$this->assertEquals($expected, $output);
+	}
+
+	/**
+	 * Test for Date::time_ago()
+	 *
+	 * @test
+	 */
+	public function test_time_ago_null_timestamp()
+	{
+		$output = Date::time_ago(null);
+
+		$this->assertEquals(null, $output);
+	}
+
+	/**
+	 * Test for Date::time_ago()
+	 *
+	 * @test
+	 */
+	public function test_time_ago_one_month()
+	{
+		$march_30_2011 = 1301461200;
+		$april_30_2011 = 1304139600;
+		$output = Date::time_ago($march_30_2011, $april_30_2011);
+
+		$this->assertEquals('1 month ago', $output);
+	}
+
+	/**
+	 * Test for Date::time_ago()
+	 *
+	 * @test
+	 */
+	public function test_time_ago_two_months()
+	{
+		$march_30_2011 = 1301461200;
+		$may_30_2011 = 1306731600;
+
+		$output = Date::time_ago($march_30_2011, $may_30_2011);
+
+		$this->assertEquals('2 months ago', $output);
+	}
+}
+

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/db.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.6
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Db class tests
+ *
+ * @group Core
+ * @group Db
+ */
+class Test_Db extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/dbutil.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.6
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Dbutil class tests
+ *
+ * @group Core
+ * @group Dbutil
+ */
+class Test_Dbutil extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/debug.php

@@ -0,0 +1,68 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Debug class tests
+ *
+ * @group Core
+ * @group Debug
+ */
+class Test_Debug extends TestCase
+{
+ 	public function test_debug_dump_normally()
+ 	{
+ 		// Set to browser mode.
+ 		\Fuel::$is_cli = false;
+
+		$expected = '	<script type="text/javascript">function fuel_debug_toggle(a){if(document.getElementById){if(document.getElementById(a).style.display=="none"){document.getElementById(a).style.display="block"}else{document.getElementById(a).style.display="none"}}else{if(document.layers){if(document.id.display=="none"){document.id.display="block"}else{document.id.display="none"}}else{if(document.all.id.style.display=="none"){document.all.id.style.display="block"}else{document.all.id.style.display="none"}}}};</script><div class="fuelphp-dump" style="font-size: 13px;background: #EEE !important; border:1px solid #666; color: #000 !important; padding:10px;"><h1 style="border-bottom: 1px solid #CCC; padding: 0 0 5px 0; margin: 0 0 5px 0; font: bold 120% sans-serif;">COREPATH/tests/debug.php @ line: 31</h1><pre style="overflow:auto;font-size:100%;"><strong>Variable #1:</strong>'."\n".'<i></i> <strong></strong> (Integer): 1'."\n\n\n".'<strong>Variable #2:</strong>'."\n".'<i></i> <strong></strong> (Integer): 2'."\n\n\n".'<strong>Variable #3:</strong>'."\n".'<i></i> <strong></strong> (Integer): 3'."\n\n\n".'</pre></div>';
+
+		ob_start();
+ 		\Debug::dump(1, 2, 3);
+ 		$output = ob_get_contents();
+ 		ob_end_clean();
+
+		$this->assertEquals($expected, $output);
+ 	}
+
+  	public function test_debug_dump_by_call_user_func_array()
+ 	{
+ 		// Set to browser mode.
+ 		\Fuel::$is_cli = false;
+
+		$expected = '<div class="fuelphp-dump" style="font-size: 13px;background: #EEE !important; border:1px solid #666; color: #000 !important; padding:10px;"><h1 style="border-bottom: 1px solid #CCC; padding: 0 0 5px 0; margin: 0 0 5px 0; font: bold 120% sans-serif;">COREPATH/tests/debug.php @ line: 46</h1><pre style="overflow:auto;font-size:100%;"><strong>Variable #1:</strong>'."\n".'<i></i> <strong></strong> (Integer): 1'."\n\n\n".'<strong>Variable #2:</strong>'."\n".'<i></i> <strong></strong> (Integer): 2'."\n\n\n".'<strong>Variable #3:</strong>'."\n".'<i></i> <strong></strong> (Integer): 3'."\n\n\n".'</pre></div>';
+
+		ob_start();
+ 		call_user_func_array('\\Debug::dump', array(1, 2, 3));
+ 		$output = ob_get_contents();
+ 		ob_end_clean();
+
+		$this->assertEquals($expected, $output);
+ 	}
+
+  	public function test_debug_dump_by_call_fuel_func_array()
+ 	{
+ 		// Set to browser mode.
+ 		\Fuel::$is_cli = false;
+
+		$expected = '<div class="fuelphp-dump" style="font-size: 13px;background: #EEE !important; border:1px solid #666; color: #000 !important; padding:10px;"><h1 style="border-bottom: 1px solid #CCC; padding: 0 0 5px 0; margin: 0 0 5px 0; font: bold 120% sans-serif;">COREPATH/base.php @ line: 462</h1><pre style="overflow:auto;font-size:100%;"><strong>Variable #1:</strong>'."\n".'<i></i> <strong></strong> (Integer): 1'."\n\n\n".'<strong>Variable #2:</strong>'."\n".'<i></i> <strong></strong> (Integer): 2'."\n\n\n".'<strong>Variable #3:</strong>'."\n".'<i></i> <strong></strong> (Integer): 3'."\n\n\n".'</pre></div>';
+
+		ob_start();
+ 		call_fuel_func_array('\\Debug::dump', array(1, 2, 3));
+ 		$output = ob_get_contents();
+ 		ob_end_clean();
+
+		$this->assertEquals($expected, $output);
+ 	}
+}
+

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/email.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Email class tests
+ *
+ * @group Core
+ * @group Email
+ */
+class Test_Email extends TestCase
+{
+ 	public function test_foo() {}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/core/tests/error.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * Part of the Fuel framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Core;
+
+/**
+ * Error class tests
+ *
+ * @group Core
+ * @group Error
+ */
+class Test_Error extends TestCase
+{
+ 	public function test_foo() {}
+}
+// TestCase {
+// 	public function test_foo() {}
+// }