route4me / route4me-php-sdk

src/Route4Me/Enum/OptimizationType.php

Indentation +3 added lines, -3 removed lines

@@ -4,7 +4,7 @@
 
 class OptimizationType
 {
-    const DISTANCE = 'Distance';
-    const TIME = 'Time';
-    const TIME_WITH_TRAFFIC = 'timeWithTraffic';
+	const DISTANCE = 'Distance';
+	const TIME = 'Time';
+	const TIME_WITH_TRAFFIC = 'timeWithTraffic';
 }

src/Route4Me/Enum/DistanceUnit.php

Indentation +2 added lines, -2 removed lines

@@ -4,6 +4,6 @@
 
 class DistanceUnit
 {
-    const MILES = 'mi';
-    const KILOMETERS = 'km';
+	const MILES = 'mi';
+	const KILOMETERS = 'km';
 }

src/Route4Me/Enum/Format.php

Indentation +4 added lines, -4 removed lines

@@ -4,8 +4,8 @@
 
 class Format
 {
-    const SERIALIZED = 'serialized';
-    const CSV = 'csv';
-    const XML = 'xml';
-    const JSON = 'json';
+	const SERIALIZED = 'serialized';
+	const CSV = 'csv';
+	const XML = 'xml';
+	const JSON = 'json';
 }

UnitTestFiles/Test/OptimizationProblemUntTests.php

Indentation +358 added lines, -358 removed lines

@@ -20,426 +20,426 @@
 
 class OptimizationProblemUntTests extends \PHPUnit\Framework\TestCase
 {
-    public static $problem;
-
-    public static $createdProblems = [];
-    public static $addresses = [];
-
-    public static function setUpBeforeClass()
-    {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
-        }
-
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //region Prepae Addresses
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => 'St Johns Florida 32259, USA',
-            'lat'               => 30.099642,
-            'lng'               => -81.547201,
-            'time'              => 300,
-            'time_window_start' => 46800,
-            'time_window_end'   => 48600,
-        ]);
-
-        $parameters = RouteParameters::fromArray([
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ]);
-        //endregion
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
-
-        //region Extra Testing Addresses
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-        //endregion
-
-        self::$addresses = $addresses;
-    }
-
-    public function testFromArray()
-    {
-        $problem = self::$createdProblems[0];
-
-        $this->assertNotNull($problem);
-        $this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$problem]);
-
-        $this->assertTrue(isset($problem->parameters));
-        $this->assertContainsOnlyInstancesOf(RouteParameters::class, [$problem->parameters]);
-
-        $this->assertTrue(isset($problem->addresses));
-        $this->assertTrue(sizeof($problem->addresses)>0);
-
-        $firstAddress = $problem->addresses[0];
-        $this->assertContainsOnlyInstancesOf(Address::class, [$firstAddress]);
-
-        $this->assertTrue(isset($problem->routes));
-        $this->assertTrue(sizeof($problem->routes)>0);
-
-        $firstRoute = $problem->routes[0];
-        $this->assertContainsOnlyInstancesOf(Route::class, [$firstRoute]);
-    }
-
-    public function testOptimize()
-    {
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => Algorithmtype::TSP,
-            'device_type'               => DeviceType::WEB,
-            'distance_unit'             => DistanceUnit::MILES,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'route_max_duration'        => 86400,
-            'store_route'               => true,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 1,
-            'vehicle_max_distance_mi'   => 10000,
-            'route_name'                => 'phpunit testOptimize',
-        ]);
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses(self::$addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParameters);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function testGet()
-    {
-        $problem = OptimizationProblem::get([
-            'optimization_problem_id' => self::$createdProblems[0]->getOptimizationId(),
-        ]);
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf(OptimizationProblem::class, $problem);
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function testGetOptizationsByState()
-    {
-        $problems = OptimizationProblem::get([
-            'state'     => OptimizationStates::OPTIMIZED,
-            'limit'     => 5,
-            'offset'    => 0,
-        ]);
-
-        $this->assertNotNull($problems);
-        $this->assertTrue(is_array($problems));
-        $this->assertTrue(sizeof($problems)>0);
-        $this->assertInstanceOf(OptimizationProblem::class, $problems[0]);
-
-        foreach ($problems as $problem) {
-            $this->assertEquals(OptimizationStates::OPTIMIZED, $problem->state);
-        }
-    }
-
-    public function testGetOptimizationIDsOnly()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public static $problem;
+
+	public static $createdProblems = [];
+	public static $addresses = [];
+
+	public static function setUpBeforeClass()
+	{
+		if (Constants::API_KEY == Constants::DEMO_API_KEY) {
+			$className = str_replace('UnitTestFiles\\Test\\','',get_class());
+			self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+		}
+
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//region Prepae Addresses
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => 'St Johns Florida 32259, USA',
+			'lat'               => 30.099642,
+			'lng'               => -81.547201,
+			'time'              => 300,
+			'time_window_start' => 46800,
+			'time_window_end'   => 48600,
+		]);
+
+		$parameters = RouteParameters::fromArray([
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		]);
+		//endregion
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
+
+		//region Extra Testing Addresses
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+		//endregion
+
+		self::$addresses = $addresses;
+	}
+
+	public function testFromArray()
+	{
+		$problem = self::$createdProblems[0];
+
+		$this->assertNotNull($problem);
+		$this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$problem]);
+
+		$this->assertTrue(isset($problem->parameters));
+		$this->assertContainsOnlyInstancesOf(RouteParameters::class, [$problem->parameters]);
+
+		$this->assertTrue(isset($problem->addresses));
+		$this->assertTrue(sizeof($problem->addresses)>0);
+
+		$firstAddress = $problem->addresses[0];
+		$this->assertContainsOnlyInstancesOf(Address::class, [$firstAddress]);
+
+		$this->assertTrue(isset($problem->routes));
+		$this->assertTrue(sizeof($problem->routes)>0);
+
+		$firstRoute = $problem->routes[0];
+		$this->assertContainsOnlyInstancesOf(Route::class, [$firstRoute]);
+	}
+
+	public function testOptimize()
+	{
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => Algorithmtype::TSP,
+			'device_type'               => DeviceType::WEB,
+			'distance_unit'             => DistanceUnit::MILES,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'route_max_duration'        => 86400,
+			'store_route'               => true,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 1,
+			'vehicle_max_distance_mi'   => 10000,
+			'route_name'                => 'phpunit testOptimize',
+		]);
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses(self::$addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParameters);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function testGet()
+	{
+		$problem = OptimizationProblem::get([
+			'optimization_problem_id' => self::$createdProblems[0]->getOptimizationId(),
+		]);
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf(OptimizationProblem::class, $problem);
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function testGetOptizationsByState()
+	{
+		$problems = OptimizationProblem::get([
+			'state'     => OptimizationStates::OPTIMIZED,
+			'limit'     => 5,
+			'offset'    => 0,
+		]);
+
+		$this->assertNotNull($problems);
+		$this->assertTrue(is_array($problems));
+		$this->assertTrue(sizeof($problems)>0);
+		$this->assertInstanceOf(OptimizationProblem::class, $problems[0]);
+
+		foreach ($problems as $problem) {
+			$this->assertEquals(OptimizationStates::OPTIMIZED, $problem->state);
+		}
+	}
+
+	public function testGetOptimizationIDsOnly()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        $problems = OptimizationProblem::get([
-            'id_only'   => 1,
-            'limit'     => 5,
-            'offset'    => 0,
-        ]);
+		$problems = OptimizationProblem::get([
+			'id_only'   => 1,
+			'limit'     => 5,
+			'offset'    => 0,
+		]);
 
-        $this->assertNotNull($problems);
-        $this->assertTrue(is_array($problems));
-        $this->assertTrue(sizeof($problems)>0);
-    }
+		$this->assertNotNull($problems);
+		$this->assertTrue(is_array($problems));
+		$this->assertTrue(sizeof($problems)>0);
+	}
 
-    public function testReoptimize()
-    {
-        $optimizationProblemId = self::$createdProblems[0]->getOptimizationId();
+	public function testReoptimize()
+	{
+		$optimizationProblemId = self::$createdProblems[0]->getOptimizationId();
 
-        $optimizationProblem = new OptimizationProblem();
+		$optimizationProblem = new OptimizationProblem();
 
-        $problem = $optimizationProblem->reoptimize(['optimization_problem_id' => $optimizationProblemId]);
+		$problem = $optimizationProblem->reoptimize(['optimization_problem_id' => $optimizationProblemId]);
 
-        $this->assertNotNull($problem);
+		$this->assertNotNull($problem);
 
-        $this->assertInstanceOf(
-            OptimizationProblem::class,
-            OptimizationProblem::fromArray($problem));
-    }
+		$this->assertInstanceOf(
+			OptimizationProblem::class,
+			OptimizationProblem::fromArray($problem));
+	}
 
-    public function testUpdate()
-    {
-        $problem = self::$createdProblems[0];
+	public function testUpdate()
+	{
+		$problem = self::$createdProblems[0];
 
-        $initialAddresses = sizeof($problem->addresses);
-
-        $extraAddresses = [];
+		$initialAddresses = sizeof($problem->addresses);
+
+		$extraAddresses = [];
 
-        $extraAddresses[] = self::$addresses[1]->toArray();
-        $extraAddresses[] = self::$addresses[2]->toArray();
+		$extraAddresses[] = self::$addresses[1]->toArray();
+		$extraAddresses[] = self::$addresses[2]->toArray();
 
-        $OptimizationParameters = OptimizationProblem::fromArray([
-            'optimization_problem_id'   => $problem->optimization_problem_id,
-            'addresses'                 => $extraAddresses,
-            'reoptimize'                => 1,
-        ]);
+		$OptimizationParameters = OptimizationProblem::fromArray([
+			'optimization_problem_id'   => $problem->optimization_problem_id,
+			'addresses'                 => $extraAddresses,
+			'reoptimize'                => 1,
+		]);
 
-        $result = OptimizationProblem::fromArray(
-            OptimizationProblem::update($OptimizationParameters)
-        );
+		$result = OptimizationProblem::fromArray(
+			OptimizationProblem::update($OptimizationParameters)
+		);
 
-        $this->assertNotNull($result);
-        $this->assertTrue($result instanceof OptimizationProblem);
-        $this->assertTrue(sizeof($result->addresses)==$initialAddresses+2);
-    }
+		$this->assertNotNull($result);
+		$this->assertTrue($result instanceof OptimizationProblem);
+		$this->assertTrue(sizeof($result->addresses)==$initialAddresses+2);
+	}
 
-    public function testGetRandomOptimizationId()
-    {
+	public function testGetRandomOptimizationId()
+	{
 
-        $optimization_problem_id = self::$createdProblems[0]->getRandomOptimizationId(0, 10);
+		$optimization_problem_id = self::$createdProblems[0]->getRandomOptimizationId(0, 10);
 
-        $this->assertNotNull($optimization_problem_id);
-        $this->assertTrue(strlen($optimization_problem_id)==32);
+		$this->assertNotNull($optimization_problem_id);
+		$this->assertTrue(strlen($optimization_problem_id)==32);
 
-        define('R_MD5_MATCH', '/^[a-fA-F0-9]{32}$/i');
+		define('R_MD5_MATCH', '/^[a-fA-F0-9]{32}$/i');
 
-        $this->assertTrue(preg_match(R_MD5_MATCH, $optimization_problem_id)==1);
-    }
+		$this->assertTrue(preg_match(R_MD5_MATCH, $optimization_problem_id)==1);
+	}
 
-    public function testGetAddresses()
-    {
-        $problem = self::$createdProblems[0];
+	public function testGetAddresses()
+	{
+		$problem = self::$createdProblems[0];
 
-        $addresses = $problem->getAddresses($problem->optimization_problem_id);
+		$addresses = $problem->getAddresses($problem->optimization_problem_id);
 
-        $this->assertNotNull($addresses);
-        $this->assertTrue(sizeof($addresses)>0);
+		$this->assertNotNull($addresses);
+		$this->assertTrue(sizeof($addresses)>0);
 
-        $this->assertContainsOnlyInstancesOf(Address::class, [$addresses[0]]);
-    }
+		$this->assertContainsOnlyInstancesOf(Address::class, [$addresses[0]]);
+	}
 
-    public function testGetRandomAddressFromOptimization()
-    {
-        $problem = self::$createdProblems[0];
+	public function testGetRandomAddressFromOptimization()
+	{
+		$problem = self::$createdProblems[0];
 
-        $address = $problem->getRandomAddressFromOptimization($problem->optimization_problem_id);
+		$address = $problem->getRandomAddressFromOptimization($problem->optimization_problem_id);
 
-        $this->assertNotNull($address);
-        $this->assertContainsOnlyInstancesOf(Address::class, [$address]);
-    }
+		$this->assertNotNull($address);
+		$this->assertContainsOnlyInstancesOf(Address::class, [$address]);
+	}
 
-    public function testRemoveAddress()
-    {
-        $problem = self::$createdProblems[0];
+	public function testRemoveAddress()
+	{
+		$problem = self::$createdProblems[0];
 
-        $address = end($problem->addresses);
+		$address = end($problem->addresses);
 
-        $params = [
-            'optimization_problem_id' => $problem->optimization_problem_id,
-            'route_destination_id'    => $address->route_destination_id,
-        ];
+		$params = [
+			'optimization_problem_id' => $problem->optimization_problem_id,
+			'route_destination_id'    => $address->route_destination_id,
+		];
 
-        $result = $problem->removeAddress($params);
+		$result = $problem->removeAddress($params);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['deleted']));
-        $this->assertTrue(isset($result['route_destination_id']));
-        $this->assertTrue($result['deleted']);
-        $this->assertEquals($address->route_destination_id, $result['route_destination_id']);
-    }
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['deleted']));
+		$this->assertTrue(isset($result['route_destination_id']));
+		$this->assertTrue($result['deleted']);
+		$this->assertEquals($address->route_destination_id, $result['route_destination_id']);
+	}
 
-    public function testRemoveOptimization()
-    {
-        $problem = end(self::$createdProblems);
+	public function testRemoveOptimization()
+	{
+		$problem = end(self::$createdProblems);
 
-        $params = [
-            'optimization_problem_ids' => [
-                '0' => $problem->optimization_problem_id,
-            ],
-            'redirect' => 0,
-        ];
+		$params = [
+			'optimization_problem_ids' => [
+				'0' => $problem->optimization_problem_id,
+			],
+			'redirect' => 0,
+		];
 
-        $result = $problem->removeOptimization($params);
+		$result = $problem->removeOptimization($params);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['status']));
-        $this->assertTrue(isset($result['removed']));
-        $this->assertTrue($result['status']);
-        $this->assertEquals(1, $result['removed']);
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['status']));
+		$this->assertTrue(isset($result['removed']));
+		$this->assertTrue($result['status']);
+		$this->assertEquals(1, $result['removed']);
 
-        self::$createdProblems[] = array_pop(self::$createdProblems);
-    }
+		self::$createdProblems[] = array_pop(self::$createdProblems);
+	}
 
-    public function testGetHybridOptimization()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public function testGetHybridOptimization()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        $ep = time() + 604800;
-        $scheduleDate = date('Y-m-d', $ep);
+		$ep = time() + 604800;
+		$scheduleDate = date('Y-m-d', $ep);
 
-        $hybridParams = [
-            'target_date_string'      => $scheduleDate,
-            'timezone_offset_minutes' => 480,
-        ];
+		$hybridParams = [
+			'target_date_string'      => $scheduleDate,
+			'timezone_offset_minutes' => 480,
+		];
 
-        $optimization = new OptimizationProblem();
+		$optimization = new OptimizationProblem();
 
-        $hybridOptimization = OptimizationProblem::fromArray(
-            $optimization->getHybridOptimization($hybridParams)
-        );
+		$hybridOptimization = OptimizationProblem::fromArray(
+			$optimization->getHybridOptimization($hybridParams)
+		);
 
-        $this->assertNotNull($hybridOptimization);
-        $this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$hybridOptimization]);
+		$this->assertNotNull($hybridOptimization);
+		$this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$hybridOptimization]);
 
-        self::$createdProblems[] = $hybridOptimization;
-    }
+		self::$createdProblems[] = $hybridOptimization;
+	}
 
-    public function testAddDepotsToHybrid()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public function testAddDepotsToHybrid()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        $ep = time() + 604800;
-        $scheduleDate = date('Y-m-d', $ep);
+		$ep = time() + 604800;
+		$scheduleDate = date('Y-m-d', $ep);
 
-        $hybridParams = [
-            'target_date_string'      => $scheduleDate,
-            'timezone_offset_minutes' => 480,
-        ];
+		$hybridParams = [
+			'target_date_string'      => $scheduleDate,
+			'timezone_offset_minutes' => 480,
+		];
 
-        $optimization = new OptimizationProblem();
+		$optimization = new OptimizationProblem();
 
-        $hybridOptimization = OptimizationProblem::fromArray(
-            $optimization->getHybridOptimization($hybridParams)
-        );
+		$hybridOptimization = OptimizationProblem::fromArray(
+			$optimization->getHybridOptimization($hybridParams)
+		);
 
-        $this->assertNotNull($hybridOptimization);
-        $this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$hybridOptimization]);
+		$this->assertNotNull($hybridOptimization);
+		$this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$hybridOptimization]);
 
-        self::$createdProblems[] = $hybridOptimization;
+		self::$createdProblems[] = $hybridOptimization;
 
-        $depotAddresses = [];
+		$depotAddresses = [];
 
-        $depotsParams = [
-            'optimization_problem_id' => $hybridOptimization->optimization_problem_id,
-            'delete_old_depots'       => true,
-        ];
+		$depotsParams = [
+			'optimization_problem_id' => $hybridOptimization->optimization_problem_id,
+			'delete_old_depots'       => true,
+		];
 
-        $depotAddresses[] = self::$addresses[0];
-        $depotAddresses[] = self::$addresses[1];
+		$depotAddresses[] = self::$addresses[0];
+		$depotAddresses[] = self::$addresses[1];
 
-        $depotsParams['new_depots'] = $depotAddresses;
+		$depotsParams['new_depots'] = $depotAddresses;
 
-        $resultDepots = $hybridOptimization->addDepotsToHybrid($depotsParams);
-        $this->assertNotNull($resultDepots);
+		$resultDepots = $hybridOptimization->addDepotsToHybrid($depotsParams);
+		$this->assertNotNull($resultDepots);
 
-        $problemParams = [
-            'optimization_problem_id' => $hybridOptimization->optimization_problem_id,
-        ];
+		$problemParams = [
+			'optimization_problem_id' => $hybridOptimization->optimization_problem_id,
+		];
 
-        $problem = OptimizationProblem::fromArray(
-            OptimizationProblem::reoptimize($problemParams)
-        );
+		$problem = OptimizationProblem::fromArray(
+			OptimizationProblem::reoptimize($problemParams)
+		);
 
-        $this->assertNotNull($problem);
-        $this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$problem]);
-    }
+		$this->assertNotNull($problem);
+		$this->assertContainsOnlyInstancesOf(OptimizationProblem::class, [$problem]);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        $optimizationProblemIDs = [];
+	public static function tearDownAfterClass()
+	{
+		$optimizationProblemIDs = [];
 
-        foreach (self::$createdProblems as $problem) {
-            $optimizationProblemId = $problem->optimization_problem_id;
+		foreach (self::$createdProblems as $problem) {
+			$optimizationProblemId = $problem->optimization_problem_id;
 
-            $optimizationProblemIDs[] = $optimizationProblemId;
-        }
+			$optimizationProblemIDs[] = $optimizationProblemId;
+		}
 
-        $params = [
-            'optimization_problem_ids' => $optimizationProblemIDs,
-            'redirect'                 => 0,
-        ];
+		$params = [
+			'optimization_problem_ids' => $optimizationProblemIDs,
+			'redirect'                 => 0,
+		];
 
-        $optProblem = new OptimizationProblem();
+		$optProblem = new OptimizationProblem();
 
-        $result = $optProblem->removeOptimization($params);
+		$result = $optProblem->removeOptimization($params);
 
-        if ($result!=null && $result['status']==true) {
-            echo "The test optimization was removed <br>";
-        } else {
-            echo "Cannot remove the test optimization <br>";
-        }
-    }
+		if ($result!=null && $result['status']==true) {
+			echo "The test optimization was removed <br>";
+		} else {
+			echo "Cannot remove the test optimization <br>";
+		}
+	}
 }
\ No newline at end of file

Spacing +4 added lines, -4 removed lines

@@ -27,9 +27,9 @@ 
 
     public static function setUpBeforeClass()
     {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+        if (Constants::API_KEY==Constants::DEMO_API_KEY) {
+            $className = str_replace('UnitTestFiles\\Test\\', '', get_class());
+            self::markTestSkipped('PHPUnit will skip '.$className." class - it impossible run with demo API key");
         }
 
         Route4Me::setApiKey(Constants::API_KEY);
@@ -263,7 +263,7 @@ 
 
         $this->assertNotNull($result);
         $this->assertTrue($result instanceof OptimizationProblem);
-        $this->assertTrue(sizeof($result->addresses)==$initialAddresses+2);
+        $this->assertTrue(sizeof($result->addresses)==$initialAddresses + 2);
     }
 
     public function testGetRandomOptimizationId()

UnitTestFiles/Test/CommonUnitTests.php

Indentation +29 added lines, -29 removed lines

@@ -7,37 +7,37 @@
 
 class CommonUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public $address;
+	public $address;
 
-    public function setUp()
-    {
-        $this->address = [
-            'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
-            'lat'               => 38.2513427734,
-            'lng'               => -77.5993652344,
-            'time'              => 300,
-            'time_window_end'   => 75600,
-            'time_window_start' => 28800,
-        ];
-    }
+	public function setUp()
+	{
+		$this->address = [
+			'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
+			'lat'               => 38.2513427734,
+			'lng'               => -77.5993652344,
+			'time'              => 300,
+			'time_window_end'   => 75600,
+			'time_window_start' => 28800,
+		];
+	}
 
-    public function testCheckValue()
-    {
-        $addressName = Common::getValue($this->address, 'address');
-        $this->assertNotNull($addressName);
-        $this->assertEquals($addressName, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
-    }
+	public function testCheckValue()
+	{
+		$addressName = Common::getValue($this->address, 'address');
+		$this->assertNotNull($addressName);
+		$this->assertEquals($addressName, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
+	}
 
-    public function testCheckNonExistsValue()
-    {
-        $badKey = Common::getValue($this->address, 'badkey');
-        $this->assertNull($badKey);
-    }
+	public function testCheckNonExistsValue()
+	{
+		$badKey = Common::getValue($this->address, 'badkey');
+		$this->assertNull($badKey);
+	}
 
-    public function testCheckNonExistsValueWithDefaultValue()
-    {
-        $memberId = Common::getValue($this->address, 'member_id', 1);
-        $this->assertNotNull($memberId);
-        $this->assertEquals($memberId, 1);
-    }
+	public function testCheckNonExistsValueWithDefaultValue()
+	{
+		$memberId = Common::getValue($this->address, 'member_id', 1);
+		$this->assertNotNull($memberId);
+		$this->assertEquals($memberId, 1);
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/OrderCustomUserFieldsTests.php

Indentation +183 added lines, -183 removed lines

@@ -8,187 +8,187 @@
 
 class OrderCustomUserFieldsTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdCustomUserFields = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $orderCustomField = new OrderCustomField();
-
-        $orderCustomFieldParameters = OrderCustomField::fromArray([]);
-
-        $response = $orderCustomField->getOrderCustomUserFields($orderCustomFieldParameters);
-
-        $field333Exists = false;
-        $field444Id = null;
-
-        foreach ($response as $userCustomField) {
-            if ($userCustomField['order_custom_field_name']=='CustomField333') {
-                $field333Exists = true;
-            }
-
-            if ($userCustomField['order_custom_field_name']=='CustomField444') {
-                $field444Id = $userCustomField['order_custom_field_id'];
-            }
-        }
-
-        if (!$field333Exists) {
-            $orderCustomFieldParameters = OrderCustomField::fromArray([
-                'order_custom_field_name'      => 'CustomField333',
-                'order_custom_field_label'     => 'Custom Field 333',
-                'order_custom_field_type'      => 'checkbox',
-                'order_custom_field_type_info' => ['short_label' => 'cFl333']
-            ]);
-
-            $newField = $orderCustomField->addOrderCustomUserField($orderCustomFieldParameters);
-
-            if (!is_null($newField) && isset($newField['result']) && $newField['result']=='OK') {
-                self::$createdCustomUserFields[] = $newField['data']['order_custom_field_id'];
-            }
-        }
-
-        if ($field444Id!=null) {
-            $orderCustomFieldParameters = OrderCustomField::fromArray([
-                'order_custom_field_id' => $field444Id
-            ]);
-
-            $response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
-
-            if (!is_null($response) &&
-                isset($response['result']) &&
-                $response['result']=='OK' &&
-                $response['affected']==1) {
-                echo "The order custom user field $field444Id removed <br>";
-            }
-        }
-    }
-
-    public function testFromArray()
-    {
-        $orderCustomFields = OrderCustomField::fromArray([
-            'order_custom_field_name'      => 'CustomField4',
-            'order_custom_field_label'     => 'Custom Field 4',
-            'order_custom_field_type'      => 'checkbox',
-            'order_custom_field_type_info' => ['short_label' => 'cFl4']
-        ]);
-
-        $this->assertEquals('CustomField4', $orderCustomFields->order_custom_field_name);
-        $this->assertEquals('Custom Field 4', $orderCustomFields->order_custom_field_label);
-        $this->assertEquals('checkbox', $orderCustomFields->order_custom_field_type);
-        $this->assertEquals(['short_label' => 'cFl4'], $orderCustomFields->order_custom_field_type_info);
-    }
-
-    public function testToArray()
-    {
-        $orderCustomFields = OrderCustomField::fromArray([
-            'order_custom_field_name'      => 'CustomField4',
-            'order_custom_field_label'     => 'Custom Field 4',
-            'order_custom_field_type'      => 'checkbox',
-            'order_custom_field_type_info' => ['short_label' => 'cFl4']
-        ]);
-
-        $this->assertEquals($orderCustomFields->toArray(),
-            [
-                'order_custom_field_name'      => 'CustomField4',
-                'order_custom_field_label'     => 'Custom Field 4',
-                'order_custom_field_type'      => 'checkbox',
-                'order_custom_field_type_info' => ['short_label' => 'cFl4']
-            ]
-        );
-    }
-
-    public function testGetOrderCustomUserFields()
-    {
-        $orderCustomField = new OrderCustomField();
-
-        $orderCustomFieldParameters = OrderCustomField::fromArray([]);
-
-        $response = $orderCustomField->getOrderCustomUserFields($orderCustomFieldParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(OrderCustomField::class, OrderCustomField::fromArray($response[0]));
-    }
-
-    public function testAddOrderCustomUserField()
-    {
-        $orderCustomField = new OrderCustomField();
-
-        $orderCustomFieldParameters = OrderCustomField::fromArray([
-            'order_custom_field_name'      => 'CustomField444',
-            'order_custom_field_label'     => 'Custom Field 444',
-            'order_custom_field_type'      => 'checkbox',
-            'order_custom_field_type_info' => ['short_label' => 'cFl444']
-        ]);
-
-        $response = $orderCustomField->addOrderCustomUserField($orderCustomFieldParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(isset($response['result']));
-        $this->assertEquals('OK', $response['result']);
-
-        self::$createdCustomUserFields[] = $response['data']['order_custom_field_id'];
-    }
-
-    public function testUpdateOrderCustomUserField()
-    {
-        $orderCustomField = new OrderCustomField();
-
-        $orderCustomFieldParameters = OrderCustomField::fromArray([
-            'order_custom_field_id'        => self::$createdCustomUserFields[0],
-            'order_custom_field_label'     => 'Custom Field 333 Updated',
-            'order_custom_field_type'      => 'checkbox',
-            'order_custom_field_type_info' => ['short_label' => 'cFl333']
-        ]);
-
-        $response = $orderCustomField->updateOrderCustomUserField($orderCustomFieldParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(isset($response['result']));
-        $this->assertEquals('OK', $response['result']);
-
-        $this->assertEquals('Custom Field 333 Updated', $response['data']['order_custom_field_label']);
-    }
-
-    public function testRemoveOrderCustomUserField()
-    {
-        $orderCustomField = new OrderCustomField();
-
-        $orderCustomFieldParameters = OrderCustomField::fromArray([
-            'order_custom_field_id' => self::$createdCustomUserFields[0]
-        ]);
-
-        $response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(isset($response['result']));
-        $this->assertEquals('OK', $response['result']);
-        $this->assertTrue(isset($response['affected']));
-        $this->assertEquals(1, $response['affected']);
-
-        array_shift(self::$createdCustomUserFields);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdCustomUserFields)>0) {
-            $orderCustomField = new OrderCustomField();
-
-            foreach (self::$createdCustomUserFields as $customFieldId) {
-                $orderCustomFieldParameters = OrderCustomField::fromArray([
-                    'order_custom_field_id' => $customFieldId
-                ]);
-
-                $response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
-
-                if (!is_null($response) &&
-                    isset($response['result']) &&
-                    $response['result']=='OK' &&
-                    $response['affected']==1) {
-                        echo "The order custom user field $customFieldId removed <br>";
-                }
-            }
-        }
-    }
+	public static $createdCustomUserFields = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$orderCustomField = new OrderCustomField();
+
+		$orderCustomFieldParameters = OrderCustomField::fromArray([]);
+
+		$response = $orderCustomField->getOrderCustomUserFields($orderCustomFieldParameters);
+
+		$field333Exists = false;
+		$field444Id = null;
+
+		foreach ($response as $userCustomField) {
+			if ($userCustomField['order_custom_field_name']=='CustomField333') {
+				$field333Exists = true;
+			}
+
+			if ($userCustomField['order_custom_field_name']=='CustomField444') {
+				$field444Id = $userCustomField['order_custom_field_id'];
+			}
+		}
+
+		if (!$field333Exists) {
+			$orderCustomFieldParameters = OrderCustomField::fromArray([
+				'order_custom_field_name'      => 'CustomField333',
+				'order_custom_field_label'     => 'Custom Field 333',
+				'order_custom_field_type'      => 'checkbox',
+				'order_custom_field_type_info' => ['short_label' => 'cFl333']
+			]);
+
+			$newField = $orderCustomField->addOrderCustomUserField($orderCustomFieldParameters);
+
+			if (!is_null($newField) && isset($newField['result']) && $newField['result']=='OK') {
+				self::$createdCustomUserFields[] = $newField['data']['order_custom_field_id'];
+			}
+		}
+
+		if ($field444Id!=null) {
+			$orderCustomFieldParameters = OrderCustomField::fromArray([
+				'order_custom_field_id' => $field444Id
+			]);
+
+			$response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
+
+			if (!is_null($response) &&
+				isset($response['result']) &&
+				$response['result']=='OK' &&
+				$response['affected']==1) {
+				echo "The order custom user field $field444Id removed <br>";
+			}
+		}
+	}
+
+	public function testFromArray()
+	{
+		$orderCustomFields = OrderCustomField::fromArray([
+			'order_custom_field_name'      => 'CustomField4',
+			'order_custom_field_label'     => 'Custom Field 4',
+			'order_custom_field_type'      => 'checkbox',
+			'order_custom_field_type_info' => ['short_label' => 'cFl4']
+		]);
+
+		$this->assertEquals('CustomField4', $orderCustomFields->order_custom_field_name);
+		$this->assertEquals('Custom Field 4', $orderCustomFields->order_custom_field_label);
+		$this->assertEquals('checkbox', $orderCustomFields->order_custom_field_type);
+		$this->assertEquals(['short_label' => 'cFl4'], $orderCustomFields->order_custom_field_type_info);
+	}
+
+	public function testToArray()
+	{
+		$orderCustomFields = OrderCustomField::fromArray([
+			'order_custom_field_name'      => 'CustomField4',
+			'order_custom_field_label'     => 'Custom Field 4',
+			'order_custom_field_type'      => 'checkbox',
+			'order_custom_field_type_info' => ['short_label' => 'cFl4']
+		]);
+
+		$this->assertEquals($orderCustomFields->toArray(),
+			[
+				'order_custom_field_name'      => 'CustomField4',
+				'order_custom_field_label'     => 'Custom Field 4',
+				'order_custom_field_type'      => 'checkbox',
+				'order_custom_field_type_info' => ['short_label' => 'cFl4']
+			]
+		);
+	}
+
+	public function testGetOrderCustomUserFields()
+	{
+		$orderCustomField = new OrderCustomField();
+
+		$orderCustomFieldParameters = OrderCustomField::fromArray([]);
+
+		$response = $orderCustomField->getOrderCustomUserFields($orderCustomFieldParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(OrderCustomField::class, OrderCustomField::fromArray($response[0]));
+	}
+
+	public function testAddOrderCustomUserField()
+	{
+		$orderCustomField = new OrderCustomField();
+
+		$orderCustomFieldParameters = OrderCustomField::fromArray([
+			'order_custom_field_name'      => 'CustomField444',
+			'order_custom_field_label'     => 'Custom Field 444',
+			'order_custom_field_type'      => 'checkbox',
+			'order_custom_field_type_info' => ['short_label' => 'cFl444']
+		]);
+
+		$response = $orderCustomField->addOrderCustomUserField($orderCustomFieldParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(isset($response['result']));
+		$this->assertEquals('OK', $response['result']);
+
+		self::$createdCustomUserFields[] = $response['data']['order_custom_field_id'];
+	}
+
+	public function testUpdateOrderCustomUserField()
+	{
+		$orderCustomField = new OrderCustomField();
+
+		$orderCustomFieldParameters = OrderCustomField::fromArray([
+			'order_custom_field_id'        => self::$createdCustomUserFields[0],
+			'order_custom_field_label'     => 'Custom Field 333 Updated',
+			'order_custom_field_type'      => 'checkbox',
+			'order_custom_field_type_info' => ['short_label' => 'cFl333']
+		]);
+
+		$response = $orderCustomField->updateOrderCustomUserField($orderCustomFieldParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(isset($response['result']));
+		$this->assertEquals('OK', $response['result']);
+
+		$this->assertEquals('Custom Field 333 Updated', $response['data']['order_custom_field_label']);
+	}
+
+	public function testRemoveOrderCustomUserField()
+	{
+		$orderCustomField = new OrderCustomField();
+
+		$orderCustomFieldParameters = OrderCustomField::fromArray([
+			'order_custom_field_id' => self::$createdCustomUserFields[0]
+		]);
+
+		$response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(isset($response['result']));
+		$this->assertEquals('OK', $response['result']);
+		$this->assertTrue(isset($response['affected']));
+		$this->assertEquals(1, $response['affected']);
+
+		array_shift(self::$createdCustomUserFields);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdCustomUserFields)>0) {
+			$orderCustomField = new OrderCustomField();
+
+			foreach (self::$createdCustomUserFields as $customFieldId) {
+				$orderCustomFieldParameters = OrderCustomField::fromArray([
+					'order_custom_field_id' => $customFieldId
+				]);
+
+				$response = $orderCustomField->removeOrderCustomUserField($orderCustomFieldParameters);
+
+				if (!is_null($response) &&
+					isset($response['result']) &&
+					$response['result']=='OK' &&
+					$response['affected']==1) {
+						echo "The order custom user field $customFieldId removed <br>";
+				}
+			}
+		}
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/RouteExampleTests.php

Indentation +844 added lines, -844 removed lines

@@ -24,848 +24,848 @@
 
 class RouteExampleTests extends \PHPUnit\Framework\TestCase
 {
-    public static $problem;
-
-    public static $createdProblems = [];
-    public static $testRoutes = [];
-    public static $addresses = [];
-
-    public static $removedOptimizationIDs = [];
-    public static $removedRouteIDs = [];
-    public static $removedVehicle;
-
-    public static function setUpBeforeClass()
-    {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
-        }
-
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //region Prepae Addresses
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => 'St Johns Florida 32259, USA',
-            'lat'               => 30.099642,
-            'lng'               => -81.547201,
-            'time'              => 300,
-            'time_window_start' => 46800,
-            'time_window_end'   => 48600,
-        ]);
-
-        $parameters = RouteParameters::fromArray([
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ]);
-        //endregion
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
-
-        self::$testRoutes = self::$createdProblems[0]->routes;
-
-        //region Extra Testing Addresses
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-        //endregion
-
-        self::$addresses = $addresses;
-    }
-
-    public function testOptimizationWithBundledAddresses()
-    {
-        $this->markTestSkipped('The test requires special permission to use the address bundling feature.');
-
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $bundling = new AddressBundling();
-
-        $bundling->mode = AddressBundlingModes\Mode::ADDRESS;
-        $bundling->merge_mode = AddressBundlingModes\FirstItemMode::KEEP_ORIGINAL;
-        $bundling->service_time_rules->first_item_mode = AddressBundlingModes\FirstItemMode::KEEP_ORIGINAL;
-        $bundling->service_time_rules->additional_items_mode = AddressBundlingModes\AdditionalItemsMode::KEEP_ORIGINAL;
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'    => Algorithmtype::TSP,
-            'route_name'        => 'Single Driver Multiple TimeWindows 50 Stops',
-            'route_date'        => time() + 24 * 60 * 60,
-            'route_time'        => 5 * 3600 + 30 * 60,
-            'distance_unit'     => DistanceUnit::MILES,
-            'device_type'       => DeviceType::WEB,
-            'optimize'          => OptimizationType::DISTANCE,
-            'metric'            => Metric::GEODESIC,
-            'bundling'          => $bundling,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function testGetScheduleCalendar()
-    {
-        $now            = new \DateTime();
-
-        $schedCalendarParams = new ScheduleCalendarParameters();
-
-        $schedCalendarParams->date_from_string   = $now
-            ->add(\DateInterval::createFromDateString('-5 days'))
-            ->format('Y-m-d');
-        $schedCalendarParams->date_to_string     = $now
-            ->add(\DateInterval::createFromDateString('5 days'))
-            ->format('Y-m-d');
-        $schedCalendarParams->orders             = true;
-        $schedCalendarParams->ab                 = true;
-        $schedCalendarParams->routes_count       = true;
-
-        $scheduleCalendar = ScheduleCalendarResponse::fromArray(
-            $schedCalendarParams->getScheduleCalendar($schedCalendarParams)
-        );
-
-        $this->assertNotNull($scheduleCalendar);
-        $this->assertInstanceOf('Route4Me\ScheduleCalendarResponse', $scheduleCalendar);
-    }
-
-    public function testMergeRoutes()
-    {
-        $route = new Route();
-
-        $routeIDs = [self::$testRoutes[0]->route_id];
-
-        $routeDuplicate = $route->duplicateRoute($routeIDs);
-
-        $this->assertTrue(isset($routeDuplicate['status']), "Cannot created duplicate route");
-        $this->assertTrue($routeDuplicate['status'], "Cannot created duplicate route");
-
-        $duplicatedRouteId = $routeDuplicate['route_ids'][0];
-
-        self::$removedRouteIDs[] = $duplicatedRouteId;
-
-        $depot = self::$testRoutes[0]->addresses[0];
-
-        // Merge the selected routes
-        $params = [
-            'route_ids'     => $routeIDs[0].','.$duplicatedRouteId,
-            'depot_address' => $depot->address,
-            'remove_origin' => false,
-            'depot_lat'     => $depot->lat,
-            'depot_lng'     => $depot->lng,
-        ];
-
-        $result = $route->mergeRoutes($params);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['status']), "Cannot merge the routes");
-        $this->assertTrue($result['status'], "Cannot merge the routes");
-        $this->assertTrue(isset($result['optimization_problem_id']), "Cannot merge the routes");
-        $this->assertEquals(32,strlen($result['optimization_problem_id']), "Cannot merge the routes");
-
-        self::$removedOptimizationIDs[] = $result['optimization_problem_id'];
-    }
-
-    public function testMultipleDepotMultipleDriverFineTuning()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
-        $json = array_slice($json, 0, 19);
-
-        $addresses = [];
-
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        //region Optimization With Duration Priority FineTuning
-        $parameters = RouteParameters::fromArray([
-            'route_name'        => 'Optimization With Duration Priority FineTuning. '.date('Y-m-d H:i'),
-            'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
-            'route_time'                => 23200,
-            'optimize'                  => OptimizationType::TIME,
-            'device_type'               => DeviceType::WEB,
-            'udu_distance_unit'         => 'km',
-            'route_max_duration'        => 86400,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 30,
-            'vehicle_max_distance_mi'   => 10000,
-            'rt'                        => true,
-            'target_duration'           => 100,
-            'target_distance'           => 0,
-            'target_wait_by_tail_size'  => 0
-
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problems = OptimizationProblem::optimize($optimizationParams);
-        $this->assertTrue(!is_null($problems), "Cannot generate an optimization with duration priority fine-tuning");
-
-        self::$createdProblems[] = $problems;
-
-        $routes=$problems->getRoutes();
-        $this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
-
-        $totalTripDistanceByDuration = $routes[0]->trip_distance + $routes[1]->trip_distance;
-        $totalTripDurationByDuration = $routes[0]->route_duration_sec + $routes[1]->route_duration_sec;
-        $totalTripWaitingTimeByDuration = $routes[0]->total_wait_time + $routes[1]->total_wait_time;
-
-        echo "Generated an optimization with the <b>duration</b> priority fine-tuning:<br>";
-        echo "   Total Trip Distance:     $totalTripDistanceByDuration <br>";
-        echo "   Total Trip Duration:     $totalTripDurationByDuration <br>";
-        echo "   Total Trip Waiting Time: $totalTripWaitingTimeByDuration <br><br><br>";
-
-        //endregion
-
-        //region Optimization With Distance Priority FineTuning
-        $parameters = RouteParameters::fromArray([
-            'route_name'        => 'Optimization With Distance Priority FineTuning. '.date('Y-m-d H:i'),
-            'algorithm_type'            => AlgorithmType::CVRP_TW_SD,
-            'route_time'                => 23200,
-            'optimize'                  => OptimizationType::TIME,
-            'device_type'               => DeviceType::WEB,
-            'udu_distance_unit'         => 'km',
-            'route_max_duration'        => 86400,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 30,
-            'vehicle_max_distance_mi'   => 10000,
-            'rt'                        => true,
-            'target_duration'           => 0,
-            'target_distance'           => 100,
-            'target_wait_by_tail_size'  => 0
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problems = OptimizationProblem::optimize($optimizationParams);
-        $this->assertTrue(!is_null($problems), "Cannot generate an optimization with the distance priority fine-tuning");
-
-        self::$createdProblems[]=$problems;
-
-        $routes=$problems->getRoutes();
-        $this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
-
-        $totalTripDistanceByDistance = $routes[0]->trip_distance + $routes[1]->trip_distance;
-        $totalTripDurationByDistance = $routes[0]->route_duration_sec + $routes[1]->route_duration_sec;
-        $totalTripWaitingTimeByDistance = $routes[0]->total_wait_time + $routes[1]->total_wait_time;
-
-        $this->assertTrue($totalTripDistanceByDistance>0);
-        $this->assertTrue($totalTripDurationByDistance>0);
-        $this->assertTrue($totalTripWaitingTimeByDistance>0);
-    }
-
-    public function testMultipleDepotMultipleDriver()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME,
-            'metric'                    => Metric::MATRIX,
-            'route_max_duration'        => 86400 ,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 50,
-            'vehicle_max_distance_mi'   => 10000,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-        $this->assertTrue(sizeof($problem->getRoutes())>1);
-    }
-
-    public function testMultipleDepotMultipleDriverTimeWindow()
-    {
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
-
-        $addresses = [];
-
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => Algorithmtype::CVRP_TW_MD,
-            'route_name'                => 'Multiple Depot, Multiple Driver, Time Window',
-            'route_date'                => time() + 24 * 60 * 60,
-            'route_time'                => 60 * 60 * 7,
-            'rt'                        => true,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME,
-            'metric'                    => Metric::GEODESIC,
-            'route_max_duration'        => 86400 * 3,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 99,
-            'vehicle_max_distance_mi'   => 99999,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function testMultipleDepotMultipleDriverWith24StopsTimeWindow()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $addresses[7]->is_depot = true;
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => Algorithmtype::CVRP_TW_MD,
-            'route_name'                => 'Multiple Depot, Multiple Driver with 24 Stops, Time Window',
-            'route_date'                => time() + 24 * 60 * 60,
-            'route_time'                => 60 * 60 * 7,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME,
-            'metric'                    => Metric::MATRIX,
-            'route_max_duration'        => 86400,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 5,
-            'vehicle_max_distance_mi'   => 10000,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-        $this->assertTrue(sizeof($problem->getRoutes())>1);
-    }
-
-    public function testMultipleSeparateDepostMultipleDriver()
-    {
-        // List of addresses
-        $jsonAddresses = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_only.json'), true);
-
-        $addresses = [];
-        foreach ($jsonAddresses as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $jsonDepots = json_decode(file_get_contents(dirname(__FILE__).'/data/depots.json'), true);
-
-        // List of depots
-        $depots = [];
-        foreach ($jsonDepots as $depot) {
-            $depots[] = Address::fromArray($depot);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'route_name'                => 'Multiple Depots Seprate Section '.date('Y-m-d H:i'),
-            'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME,
-            'metric'                    => Metric::GEODESIC,
-            'route_max_duration'        => 86400 * 2,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 50,
-            'vehicle_max_distance_mi'   => 10000,
-            'parts'                     => 50,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setDepots($depots);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function  testOptimizationSingleDriverRoute10Stops()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-        $json = array_slice($json, 0, 10);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::TSP,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'travel_mode'               => TravelMode::DRIVING,
-            'route_max_duration'        => 86400,
-            'vehicle_capacity'          => 1,
-            'vehicle_max_distance_mi'   => 10000,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-    }
-
-    public function testRouteSlowDown()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-        $json = array_slice($json, 0, 10);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::TSP,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'travel_mode'               => TravelMode::DRIVING,
-            'route_name'                => 'SD 10 stops slowdown route '.date('Y-m-d H:i'),
-            'route_max_duration'        => 86400,
-            'vehicle_capacity'          => 1,
-            'vehicle_max_distance_mi'   => 10000,
-            'slowdowns' =>  [
-                'service_time'  => 15,
-                'travel_time'   => 20
-            ],
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->parameters);
-
-        $this->assertNotNull($problem->parameters->route_time_multiplier);
-        $this->assertNotNull($problem->parameters->route_service_time_multiplier);
-        $this->assertEquals(15, $problem->parameters->route_service_time_multiplier);
-        $this->assertEquals(20, $problem->parameters->route_time_multiplier);
-    }
-
-    public function testSingleDriverRoundTrip()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-        $json = array_slice($json, 0, 16);
-
-        $addresses = [];
-
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::TSP,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'travel_mode'               => TravelMode::DRIVING,
-            'route_max_duration'        => 86400,
-            'vehicle_capacity'          => 1,
-            'vehicle_max_distance_mi'   => 10000,
-            'rt' => true,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-        $this->assertNotNull($problem->addresses);
-
-        $firstAddress = $problem->routes[0]->addresses[0];
-        $lastAddress = $problem->routes[0]->addresses[sizeof($problem->routes[0]->addresses)-1];
-
-        $this->assertEquals($firstAddress->route_destination_id, $lastAddress->route_destination_id);
-    }
-
-    public function testSingleDepotMultipleDriverNoTimeWindow()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => Algorithmtype::CVRP_TW_SD,
-            'route_name'                => 'Single Depot, Multiple Driver, No Time Window',
-            'route_date'                => time() + 24 * 60 * 60,
-            'route_time'                => 60 * 60 * 7,
-            'rt'                        => true,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME,
-            'metric'                    => Metric::GEODESIC,
-            'route_max_duration'        => 86400,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 20,
-            'vehicle_max_distance_mi'   => 99999,
-            'parts'                     => 4,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-
-        $this->assertNotNull(sizeof($problem->routes)>1);
-    }
-
-    public function testSingleDriverMultipleTimeWindows()
-    {
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
-        $json = array_slice($json, 0, 20);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'    => Algorithmtype::TSP,
-            'route_name'        => 'Single Driver Multiple TimeWindows 20 Stops '.date('Y-m-d H:i'),
-            'route_date'        => time() + 24 * 60 * 60,
-            'route_time'        => 5 * 3600 + 30 * 60,
-            'distance_unit'     => DistanceUnit::MILES,
-            'device_type'       => DeviceType::WEB,
-            'optimize'          => OptimizationType::TIME,
-            'metric'            => Metric::MATRIX,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-
-        $this->assertNotNull(sizeof($problem->routes)>1);
-    }
-
-    public function testTruckingSingleDriverMultipleTimeWindows()
-    {
-        #region Create Medium Truck
-
-        $vehicle = new Vehicle();
-
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_name'                      => 'GMC TopKick C5500 Medium',
-            'vehicle_alias'                     => 'GMC TopKick C5500 Medium',
-            'vehicle_vin'                       => 'SAJXA01A06FN08012',
-            'vehicle_license_plate'             => 'CVH4561',
-            'vehicle_model'                     => 'TopKick C5500',
-            'vehicle_model_year'                => 1995,
-            'vehicle_year_acquired'             => 2008,
-            'vehicle_reg_country_id'            => '223',
-            'vehicle_make'                      => 'GMC',
-            'vehicle_type_id'                   => 'pickup_truck',
-            'vehicle_axle_count'                => 2,
-            'mpg_city'                          => 7,
-            'mpg_highway'                       => 14,
-            'fuel_type'                         => 'diesel',
-            'height_inches'                     => 97,
-            'height_metric'                     => 243,
-            'weight_lb'                         => 19000,
-            'maxWeightPerAxleGroupInPounds'     => 9500,
-            'max_weight_per_axle_group_metric'  => 4300,
-            'widthInInches'                     => 96,
-            'width_metric'                      => 240,
-            'lengthInInches'                    => 244,
-            'length_metric'                     => 610,
-            'Use53FootTrailerRouting'           => 'YES',
-            'UseTruckRestrictions'              => 'YES',
-            'DividedHighwayAvoidPreference'     => 'NEUTRAL',
-            'FreewayAvoidPreference'            => 'NEUTRAL',
-            'truck_config'                      => 'FULLSIZEVAN',
-        ]);
-
-        $result = $vehicle->createVehicle($vehicleParameters);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['status']));
-        $this->assertTrue($result['status']);
-        $this->assertTrue(isset($result['vehicle_guid']));
-        $vehicleId = $result['vehicle_guid'];
-
-        self::$removedVehicle = $vehicleId;
-
-        #endregion
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
-        $json = array_slice($json, 0, 18);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => Algorithmtype::CVRP_TW_SD,
-            'route_name'                => 'Trucking SD Multiple TW 18 Stops '.date('Y-m-d H:i'),
-            'route_date'                => time() + 24 * 60 * 60,
-            'route_time'                => 5 * 3600 + 30 * 60,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::TIME_WITH_TRAFFIC,
-            'metric'                    => Metric::MATRIX,
-            'route_max_duration'        => 8 * 3600 + 30 * 60,
-            'vehicle_id'                => $vehicleId,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_max_cargo_weight'  => 30,
-            'vehicle_capacity'          => 10,
-            'vehicle_max_distance_mi'   => 10000,
-            'trailer_weight_t'          => 10,
-            'weight_per_axle_t'         => 10,
-            'limited_weight_t'          => 20,
-            'rt'                        => true
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        $this->assertNotNull($problem);
-        $this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
-        $this->assertNotNull($problem->getOptimizationId());
-        $this->assertNotNull($problem->getRoutes());
-
-        $this->assertNotNull(sizeof($problem->routes)>1);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdProblems)>0) {
-            $optimizationProblemIDs = [];
-
-            foreach (self::$createdProblems as $problem) {
-                $optimizationProblemId = $problem->optimization_problem_id;
-
-                $optimizationProblemIDs[] = $optimizationProblemId;
-            }
-
-            if (sizeof(self::$removedOptimizationIDs)>0) {
-                $optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
-            }
-
-            $params = [
-                'optimization_problem_ids' => $optimizationProblemIDs,
-                'redirect'                 => 0,
-            ];
-
-            $problem = new OptimizationProblem();
-            $result = $problem->removeOptimization($params);
-
-            if ($result!=null && $result['status']==true) {
-                echo "The test optimizations were removed <br>";
-            } else {
-                echo "Cannot remove the test optimizations <br>";
-            }
-        }
-
-        if (sizeof(self::$removedRouteIDs)>0) {
-            $route = new Route();
-
-            $route_ids = join(',', self::$removedRouteIDs);
-
-            $result = $route->deleteRoutes($route_ids);
-
-            if ($result!=null && $result['deleted']==true) {
-                echo "The test routes were removed <br>";
-            } else {
-                echo "Cannot remove the test routes <br>";
-            }
-        }
-
-        if (!is_null(self::$removedVehicle!=null) && strlen(self::$removedVehicle)==32) {
-
-            $vehicle = new Vehicle();
-
-            $vehicleParameters = Vehicle::fromArray([
-                'vehicle_id' => self::$removedVehicle,
-            ]);
-
-             $result = $vehicle->removeVehicle($vehicleParameters);
-
-            if (!is_null($result)) {
-                echo "The vehicle ".$result['vehicle_id']." removed <br>";
-            } else {
-                echo "Cannot remove the vehicle ".$vehicle['vehicle_id']."<br>";
-            }
-
-        }
-    }
+	public static $problem;
+
+	public static $createdProblems = [];
+	public static $testRoutes = [];
+	public static $addresses = [];
+
+	public static $removedOptimizationIDs = [];
+	public static $removedRouteIDs = [];
+	public static $removedVehicle;
+
+	public static function setUpBeforeClass()
+	{
+		if (Constants::API_KEY == Constants::DEMO_API_KEY) {
+			$className = str_replace('UnitTestFiles\\Test\\','',get_class());
+			self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+		}
+
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//region Prepae Addresses
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => 'St Johns Florida 32259, USA',
+			'lat'               => 30.099642,
+			'lng'               => -81.547201,
+			'time'              => 300,
+			'time_window_start' => 46800,
+			'time_window_end'   => 48600,
+		]);
+
+		$parameters = RouteParameters::fromArray([
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		]);
+		//endregion
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
+
+		self::$testRoutes = self::$createdProblems[0]->routes;
+
+		//region Extra Testing Addresses
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+		//endregion
+
+		self::$addresses = $addresses;
+	}
+
+	public function testOptimizationWithBundledAddresses()
+	{
+		$this->markTestSkipped('The test requires special permission to use the address bundling feature.');
+
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$bundling = new AddressBundling();
+
+		$bundling->mode = AddressBundlingModes\Mode::ADDRESS;
+		$bundling->merge_mode = AddressBundlingModes\FirstItemMode::KEEP_ORIGINAL;
+		$bundling->service_time_rules->first_item_mode = AddressBundlingModes\FirstItemMode::KEEP_ORIGINAL;
+		$bundling->service_time_rules->additional_items_mode = AddressBundlingModes\AdditionalItemsMode::KEEP_ORIGINAL;
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'    => Algorithmtype::TSP,
+			'route_name'        => 'Single Driver Multiple TimeWindows 50 Stops',
+			'route_date'        => time() + 24 * 60 * 60,
+			'route_time'        => 5 * 3600 + 30 * 60,
+			'distance_unit'     => DistanceUnit::MILES,
+			'device_type'       => DeviceType::WEB,
+			'optimize'          => OptimizationType::DISTANCE,
+			'metric'            => Metric::GEODESIC,
+			'bundling'          => $bundling,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function testGetScheduleCalendar()
+	{
+		$now            = new \DateTime();
+
+		$schedCalendarParams = new ScheduleCalendarParameters();
+
+		$schedCalendarParams->date_from_string   = $now
+			->add(\DateInterval::createFromDateString('-5 days'))
+			->format('Y-m-d');
+		$schedCalendarParams->date_to_string     = $now
+			->add(\DateInterval::createFromDateString('5 days'))
+			->format('Y-m-d');
+		$schedCalendarParams->orders             = true;
+		$schedCalendarParams->ab                 = true;
+		$schedCalendarParams->routes_count       = true;
+
+		$scheduleCalendar = ScheduleCalendarResponse::fromArray(
+			$schedCalendarParams->getScheduleCalendar($schedCalendarParams)
+		);
+
+		$this->assertNotNull($scheduleCalendar);
+		$this->assertInstanceOf('Route4Me\ScheduleCalendarResponse', $scheduleCalendar);
+	}
+
+	public function testMergeRoutes()
+	{
+		$route = new Route();
+
+		$routeIDs = [self::$testRoutes[0]->route_id];
+
+		$routeDuplicate = $route->duplicateRoute($routeIDs);
+
+		$this->assertTrue(isset($routeDuplicate['status']), "Cannot created duplicate route");
+		$this->assertTrue($routeDuplicate['status'], "Cannot created duplicate route");
+
+		$duplicatedRouteId = $routeDuplicate['route_ids'][0];
+
+		self::$removedRouteIDs[] = $duplicatedRouteId;
+
+		$depot = self::$testRoutes[0]->addresses[0];
+
+		// Merge the selected routes
+		$params = [
+			'route_ids'     => $routeIDs[0].','.$duplicatedRouteId,
+			'depot_address' => $depot->address,
+			'remove_origin' => false,
+			'depot_lat'     => $depot->lat,
+			'depot_lng'     => $depot->lng,
+		];
+
+		$result = $route->mergeRoutes($params);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['status']), "Cannot merge the routes");
+		$this->assertTrue($result['status'], "Cannot merge the routes");
+		$this->assertTrue(isset($result['optimization_problem_id']), "Cannot merge the routes");
+		$this->assertEquals(32,strlen($result['optimization_problem_id']), "Cannot merge the routes");
+
+		self::$removedOptimizationIDs[] = $result['optimization_problem_id'];
+	}
+
+	public function testMultipleDepotMultipleDriverFineTuning()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
+		$json = array_slice($json, 0, 19);
+
+		$addresses = [];
+
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		//region Optimization With Duration Priority FineTuning
+		$parameters = RouteParameters::fromArray([
+			'route_name'        => 'Optimization With Duration Priority FineTuning. '.date('Y-m-d H:i'),
+			'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
+			'route_time'                => 23200,
+			'optimize'                  => OptimizationType::TIME,
+			'device_type'               => DeviceType::WEB,
+			'udu_distance_unit'         => 'km',
+			'route_max_duration'        => 86400,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 30,
+			'vehicle_max_distance_mi'   => 10000,
+			'rt'                        => true,
+			'target_duration'           => 100,
+			'target_distance'           => 0,
+			'target_wait_by_tail_size'  => 0
+
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problems = OptimizationProblem::optimize($optimizationParams);
+		$this->assertTrue(!is_null($problems), "Cannot generate an optimization with duration priority fine-tuning");
+
+		self::$createdProblems[] = $problems;
+
+		$routes=$problems->getRoutes();
+		$this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
+
+		$totalTripDistanceByDuration = $routes[0]->trip_distance + $routes[1]->trip_distance;
+		$totalTripDurationByDuration = $routes[0]->route_duration_sec + $routes[1]->route_duration_sec;
+		$totalTripWaitingTimeByDuration = $routes[0]->total_wait_time + $routes[1]->total_wait_time;
+
+		echo "Generated an optimization with the <b>duration</b> priority fine-tuning:<br>";
+		echo "   Total Trip Distance:     $totalTripDistanceByDuration <br>";
+		echo "   Total Trip Duration:     $totalTripDurationByDuration <br>";
+		echo "   Total Trip Waiting Time: $totalTripWaitingTimeByDuration <br><br><br>";
+
+		//endregion
+
+		//region Optimization With Distance Priority FineTuning
+		$parameters = RouteParameters::fromArray([
+			'route_name'        => 'Optimization With Distance Priority FineTuning. '.date('Y-m-d H:i'),
+			'algorithm_type'            => AlgorithmType::CVRP_TW_SD,
+			'route_time'                => 23200,
+			'optimize'                  => OptimizationType::TIME,
+			'device_type'               => DeviceType::WEB,
+			'udu_distance_unit'         => 'km',
+			'route_max_duration'        => 86400,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 30,
+			'vehicle_max_distance_mi'   => 10000,
+			'rt'                        => true,
+			'target_duration'           => 0,
+			'target_distance'           => 100,
+			'target_wait_by_tail_size'  => 0
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problems = OptimizationProblem::optimize($optimizationParams);
+		$this->assertTrue(!is_null($problems), "Cannot generate an optimization with the distance priority fine-tuning");
+
+		self::$createdProblems[]=$problems;
+
+		$routes=$problems->getRoutes();
+		$this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
+
+		$totalTripDistanceByDistance = $routes[0]->trip_distance + $routes[1]->trip_distance;
+		$totalTripDurationByDistance = $routes[0]->route_duration_sec + $routes[1]->route_duration_sec;
+		$totalTripWaitingTimeByDistance = $routes[0]->total_wait_time + $routes[1]->total_wait_time;
+
+		$this->assertTrue($totalTripDistanceByDistance>0);
+		$this->assertTrue($totalTripDurationByDistance>0);
+		$this->assertTrue($totalTripWaitingTimeByDistance>0);
+	}
+
+	public function testMultipleDepotMultipleDriver()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME,
+			'metric'                    => Metric::MATRIX,
+			'route_max_duration'        => 86400 ,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 50,
+			'vehicle_max_distance_mi'   => 10000,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+		$this->assertTrue(sizeof($problem->getRoutes())>1);
+	}
+
+	public function testMultipleDepotMultipleDriverTimeWindow()
+	{
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
+
+		$addresses = [];
+
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => Algorithmtype::CVRP_TW_MD,
+			'route_name'                => 'Multiple Depot, Multiple Driver, Time Window',
+			'route_date'                => time() + 24 * 60 * 60,
+			'route_time'                => 60 * 60 * 7,
+			'rt'                        => true,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME,
+			'metric'                    => Metric::GEODESIC,
+			'route_max_duration'        => 86400 * 3,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 99,
+			'vehicle_max_distance_mi'   => 99999,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function testMultipleDepotMultipleDriverWith24StopsTimeWindow()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$addresses[7]->is_depot = true;
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => Algorithmtype::CVRP_TW_MD,
+			'route_name'                => 'Multiple Depot, Multiple Driver with 24 Stops, Time Window',
+			'route_date'                => time() + 24 * 60 * 60,
+			'route_time'                => 60 * 60 * 7,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME,
+			'metric'                    => Metric::MATRIX,
+			'route_max_duration'        => 86400,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 5,
+			'vehicle_max_distance_mi'   => 10000,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+		$this->assertTrue(sizeof($problem->getRoutes())>1);
+	}
+
+	public function testMultipleSeparateDepostMultipleDriver()
+	{
+		// List of addresses
+		$jsonAddresses = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_only.json'), true);
+
+		$addresses = [];
+		foreach ($jsonAddresses as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$jsonDepots = json_decode(file_get_contents(dirname(__FILE__).'/data/depots.json'), true);
+
+		// List of depots
+		$depots = [];
+		foreach ($jsonDepots as $depot) {
+			$depots[] = Address::fromArray($depot);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'route_name'                => 'Multiple Depots Seprate Section '.date('Y-m-d H:i'),
+			'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME,
+			'metric'                    => Metric::GEODESIC,
+			'route_max_duration'        => 86400 * 2,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 50,
+			'vehicle_max_distance_mi'   => 10000,
+			'parts'                     => 50,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setDepots($depots);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function  testOptimizationSingleDriverRoute10Stops()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+		$json = array_slice($json, 0, 10);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::TSP,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'travel_mode'               => TravelMode::DRIVING,
+			'route_max_duration'        => 86400,
+			'vehicle_capacity'          => 1,
+			'vehicle_max_distance_mi'   => 10000,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+	}
+
+	public function testRouteSlowDown()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+		$json = array_slice($json, 0, 10);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::TSP,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'travel_mode'               => TravelMode::DRIVING,
+			'route_name'                => 'SD 10 stops slowdown route '.date('Y-m-d H:i'),
+			'route_max_duration'        => 86400,
+			'vehicle_capacity'          => 1,
+			'vehicle_max_distance_mi'   => 10000,
+			'slowdowns' =>  [
+				'service_time'  => 15,
+				'travel_time'   => 20
+			],
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->parameters);
+
+		$this->assertNotNull($problem->parameters->route_time_multiplier);
+		$this->assertNotNull($problem->parameters->route_service_time_multiplier);
+		$this->assertEquals(15, $problem->parameters->route_service_time_multiplier);
+		$this->assertEquals(20, $problem->parameters->route_time_multiplier);
+	}
+
+	public function testSingleDriverRoundTrip()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+		$json = array_slice($json, 0, 16);
+
+		$addresses = [];
+
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::TSP,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'travel_mode'               => TravelMode::DRIVING,
+			'route_max_duration'        => 86400,
+			'vehicle_capacity'          => 1,
+			'vehicle_max_distance_mi'   => 10000,
+			'rt' => true,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+		$this->assertNotNull($problem->addresses);
+
+		$firstAddress = $problem->routes[0]->addresses[0];
+		$lastAddress = $problem->routes[0]->addresses[sizeof($problem->routes[0]->addresses)-1];
+
+		$this->assertEquals($firstAddress->route_destination_id, $lastAddress->route_destination_id);
+	}
+
+	public function testSingleDepotMultipleDriverNoTimeWindow()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => Algorithmtype::CVRP_TW_SD,
+			'route_name'                => 'Single Depot, Multiple Driver, No Time Window',
+			'route_date'                => time() + 24 * 60 * 60,
+			'route_time'                => 60 * 60 * 7,
+			'rt'                        => true,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME,
+			'metric'                    => Metric::GEODESIC,
+			'route_max_duration'        => 86400,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 20,
+			'vehicle_max_distance_mi'   => 99999,
+			'parts'                     => 4,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+
+		$this->assertNotNull(sizeof($problem->routes)>1);
+	}
+
+	public function testSingleDriverMultipleTimeWindows()
+	{
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
+		$json = array_slice($json, 0, 20);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'    => Algorithmtype::TSP,
+			'route_name'        => 'Single Driver Multiple TimeWindows 20 Stops '.date('Y-m-d H:i'),
+			'route_date'        => time() + 24 * 60 * 60,
+			'route_time'        => 5 * 3600 + 30 * 60,
+			'distance_unit'     => DistanceUnit::MILES,
+			'device_type'       => DeviceType::WEB,
+			'optimize'          => OptimizationType::TIME,
+			'metric'            => Metric::MATRIX,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+
+		$this->assertNotNull(sizeof($problem->routes)>1);
+	}
+
+	public function testTruckingSingleDriverMultipleTimeWindows()
+	{
+		#region Create Medium Truck
+
+		$vehicle = new Vehicle();
+
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_name'                      => 'GMC TopKick C5500 Medium',
+			'vehicle_alias'                     => 'GMC TopKick C5500 Medium',
+			'vehicle_vin'                       => 'SAJXA01A06FN08012',
+			'vehicle_license_plate'             => 'CVH4561',
+			'vehicle_model'                     => 'TopKick C5500',
+			'vehicle_model_year'                => 1995,
+			'vehicle_year_acquired'             => 2008,
+			'vehicle_reg_country_id'            => '223',
+			'vehicle_make'                      => 'GMC',
+			'vehicle_type_id'                   => 'pickup_truck',
+			'vehicle_axle_count'                => 2,
+			'mpg_city'                          => 7,
+			'mpg_highway'                       => 14,
+			'fuel_type'                         => 'diesel',
+			'height_inches'                     => 97,
+			'height_metric'                     => 243,
+			'weight_lb'                         => 19000,
+			'maxWeightPerAxleGroupInPounds'     => 9500,
+			'max_weight_per_axle_group_metric'  => 4300,
+			'widthInInches'                     => 96,
+			'width_metric'                      => 240,
+			'lengthInInches'                    => 244,
+			'length_metric'                     => 610,
+			'Use53FootTrailerRouting'           => 'YES',
+			'UseTruckRestrictions'              => 'YES',
+			'DividedHighwayAvoidPreference'     => 'NEUTRAL',
+			'FreewayAvoidPreference'            => 'NEUTRAL',
+			'truck_config'                      => 'FULLSIZEVAN',
+		]);
+
+		$result = $vehicle->createVehicle($vehicleParameters);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['status']));
+		$this->assertTrue($result['status']);
+		$this->assertTrue(isset($result['vehicle_guid']));
+		$vehicleId = $result['vehicle_guid'];
+
+		self::$removedVehicle = $vehicleId;
+
+		#endregion
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/mdp_mdr_24stops_tw.json'), true);
+		$json = array_slice($json, 0, 18);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => Algorithmtype::CVRP_TW_SD,
+			'route_name'                => 'Trucking SD Multiple TW 18 Stops '.date('Y-m-d H:i'),
+			'route_date'                => time() + 24 * 60 * 60,
+			'route_time'                => 5 * 3600 + 30 * 60,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::TIME_WITH_TRAFFIC,
+			'metric'                    => Metric::MATRIX,
+			'route_max_duration'        => 8 * 3600 + 30 * 60,
+			'vehicle_id'                => $vehicleId,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_max_cargo_weight'  => 30,
+			'vehicle_capacity'          => 10,
+			'vehicle_max_distance_mi'   => 10000,
+			'trailer_weight_t'          => 10,
+			'weight_per_axle_t'         => 10,
+			'limited_weight_t'          => 20,
+			'rt'                        => true
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		$this->assertNotNull($problem);
+		$this->assertInstanceOf('Route4Me\OptimizationProblem', $problem);
+		$this->assertNotNull($problem->getOptimizationId());
+		$this->assertNotNull($problem->getRoutes());
+
+		$this->assertNotNull(sizeof($problem->routes)>1);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdProblems)>0) {
+			$optimizationProblemIDs = [];
+
+			foreach (self::$createdProblems as $problem) {
+				$optimizationProblemId = $problem->optimization_problem_id;
+
+				$optimizationProblemIDs[] = $optimizationProblemId;
+			}
+
+			if (sizeof(self::$removedOptimizationIDs)>0) {
+				$optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
+			}
+
+			$params = [
+				'optimization_problem_ids' => $optimizationProblemIDs,
+				'redirect'                 => 0,
+			];
+
+			$problem = new OptimizationProblem();
+			$result = $problem->removeOptimization($params);
+
+			if ($result!=null && $result['status']==true) {
+				echo "The test optimizations were removed <br>";
+			} else {
+				echo "Cannot remove the test optimizations <br>";
+			}
+		}
+
+		if (sizeof(self::$removedRouteIDs)>0) {
+			$route = new Route();
+
+			$route_ids = join(',', self::$removedRouteIDs);
+
+			$result = $route->deleteRoutes($route_ids);
+
+			if ($result!=null && $result['deleted']==true) {
+				echo "The test routes were removed <br>";
+			} else {
+				echo "Cannot remove the test routes <br>";
+			}
+		}
+
+		if (!is_null(self::$removedVehicle!=null) && strlen(self::$removedVehicle)==32) {
+
+			$vehicle = new Vehicle();
+
+			$vehicleParameters = Vehicle::fromArray([
+				'vehicle_id' => self::$removedVehicle,
+			]);
+
+			 $result = $vehicle->removeVehicle($vehicleParameters);
+
+			if (!is_null($result)) {
+				echo "The vehicle ".$result['vehicle_id']." removed <br>";
+			} else {
+				echo "Cannot remove the vehicle ".$vehicle['vehicle_id']."<br>";
+			}
+
+		}
+	}
 }
\ No newline at end of file

Spacing +11 added lines, -11 removed lines

@@ -36,9 +36,9 @@ 
 
     public static function setUpBeforeClass()
     {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+        if (Constants::API_KEY==Constants::DEMO_API_KEY) {
+            $className = str_replace('UnitTestFiles\\Test\\', '', get_class());
+            self::markTestSkipped('PHPUnit will skip '.$className." class - it impossible run with demo API key");
         }
 
         Route4Me::setApiKey(Constants::API_KEY);
@@ -187,7 +187,7 @@ 
 
     public function testGetScheduleCalendar()
     {
-        $now            = new \DateTime();
+        $now = new \DateTime();
 
         $schedCalendarParams = new ScheduleCalendarParameters();
 
@@ -241,7 +241,7 @@ 
         $this->assertTrue(isset($result['status']), "Cannot merge the routes");
         $this->assertTrue($result['status'], "Cannot merge the routes");
         $this->assertTrue(isset($result['optimization_problem_id']), "Cannot merge the routes");
-        $this->assertEquals(32,strlen($result['optimization_problem_id']), "Cannot merge the routes");
+        $this->assertEquals(32, strlen($result['optimization_problem_id']), "Cannot merge the routes");
 
         self::$removedOptimizationIDs[] = $result['optimization_problem_id'];
     }
@@ -286,7 +286,7 @@ 
 
         self::$createdProblems[] = $problems;
 
-        $routes=$problems->getRoutes();
+        $routes = $problems->getRoutes();
         $this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
 
         $totalTripDistanceByDuration = $routes[0]->trip_distance + $routes[1]->trip_distance;
@@ -325,9 +325,9 @@ 
         $problems = OptimizationProblem::optimize($optimizationParams);
         $this->assertTrue(!is_null($problems), "Cannot generate an optimization with the distance priority fine-tuning");
 
-        self::$createdProblems[]=$problems;
+        self::$createdProblems[] = $problems;
 
-        $routes=$problems->getRoutes();
+        $routes = $problems->getRoutes();
         $this->assertTrue(sizeof($routes)==2, "The generated optimization hasn't two routes");
 
         $totalTripDistanceByDistance = $routes[0]->trip_distance + $routes[1]->trip_distance;
@@ -355,7 +355,7 @@ 
             'device_type'               => DeviceType::WEB,
             'optimize'                  => OptimizationType::TIME,
             'metric'                    => Metric::MATRIX,
-            'route_max_duration'        => 86400 ,
+            'route_max_duration'        => 86400,
             'travel_mode'               => TravelMode::DRIVING,
             'vehicle_capacity'          => 50,
             'vehicle_max_distance_mi'   => 10000,
@@ -626,7 +626,7 @@ 
         $this->assertNotNull($problem->addresses);
 
         $firstAddress = $problem->routes[0]->addresses[0];
-        $lastAddress = $problem->routes[0]->addresses[sizeof($problem->routes[0]->addresses)-1];
+        $lastAddress = $problem->routes[0]->addresses[sizeof($problem->routes[0]->addresses) - 1];
 
         $this->assertEquals($firstAddress->route_destination_id, $lastAddress->route_destination_id);
     }
@@ -818,7 +818,7 @@ 
             }
 
             if (sizeof(self::$removedOptimizationIDs)>0) {
-                $optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
+                $optimizationProblemIDs = array_merge($optimizationProblemIDs, self::$removedOptimizationIDs);
             }
 
             $params = [

UnitTestFiles/Test/RouteTests.php

Indentation +601 added lines, -601 removed lines

@@ -22,800 +22,800 @@
 
 class RouteTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdProblems = [];
-    public static $testRoutes = [];
-    public static $addresses = [];
-
-    public static $removedOptimizationIDs = [];
-    public static $removedRouteIDs = [];
-    public static $removedVehicleIDs = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //region -- Prepae Addresses --
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'metric'                    => Metric::GEODESIC,
-            'route_max_duration'        => 86400 * 2,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 50,
-            'vehicle_max_distance_mi'   => 10000,
-            'parts'                     => 50,
-        ]);
-        //endregion
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
-
-        self::$testRoutes = self::$createdProblems[0]->routes;
-
-        //region -- Extra Testing Addresses --
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-        //endregion
-
-        self::$addresses = $addresses;
-
-        //region -- Create Test Order --
-
-
-
-        //endregion
-    }
-
-    public function testFromArray()
-    {
-        //region -- Prepare Addresses --
-
-        $addresses = [];
-        $addresses[] = [
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ];
-
-        $addresses[] = [
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ];
-
-        $addresses[] = [
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ];
-
-        $addresses[] = [
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ];
-
-        $addresses[] = [
-            'address'           => 'St Johns Florida 32259, USA',
-            'lat'               => 30.099642,
-            'lng'               => -81.547201,
-            'time'              => 300,
-            'time_window_start' => 46800,
-            'time_window_end'   => 48600,
-        ];
+	public static $createdProblems = [];
+	public static $testRoutes = [];
+	public static $addresses = [];
+
+	public static $removedOptimizationIDs = [];
+	public static $removedRouteIDs = [];
+	public static $removedVehicleIDs = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//region -- Prepae Addresses --
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'metric'                    => Metric::GEODESIC,
+			'route_max_duration'        => 86400 * 2,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 50,
+			'vehicle_max_distance_mi'   => 10000,
+			'parts'                     => 50,
+		]);
+		//endregion
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
+
+		self::$testRoutes = self::$createdProblems[0]->routes;
+
+		//region -- Extra Testing Addresses --
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+		//endregion
+
+		self::$addresses = $addresses;
+
+		//region -- Create Test Order --
+
+
+
+		//endregion
+	}
+
+	public function testFromArray()
+	{
+		//region -- Prepare Addresses --
+
+		$addresses = [];
+		$addresses[] = [
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		];
+
+		$addresses[] = [
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		];
+
+		$addresses[] = [
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		];
+
+		$addresses[] = [
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		];
+
+		$addresses[] = [
+			'address'           => 'St Johns Florida 32259, USA',
+			'lat'               => 30.099642,
+			'lng'               => -81.547201,
+			'time'              => 300,
+			'time_window_start' => 46800,
+			'time_window_end'   => 48600,
+		];
 
-        //endregion
-
-        $parameters = [
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ];
-
-        $routeParameters = Route::fromArray([
-            'parameters'    => $parameters,
-            'addresses'     => $addresses
-        ]);
-
-        $this->assertEquals(RouteParameters::fromArray($parameters), $routeParameters->parameters);
-    }
-
-    public function testAssignMemberToRoute()
-    {
-        //region -- Get Random Member --
+		//endregion
+
+		$parameters = [
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		];
+
+		$routeParameters = Route::fromArray([
+			'parameters'    => $parameters,
+			'addresses'     => $addresses
+		]);
+
+		$this->assertEquals(RouteParameters::fromArray($parameters), $routeParameters->parameters);
+	}
+
+	public function testAssignMemberToRoute()
+	{
+		//region -- Get Random Member --
 
-        $member = new Member();
+		$member = new Member();
 
-        $users = $member->getUsers();
+		$users = $member->getUsers();
 
-        assert(!is_null($users), 'Cannot retrieve list of the users');
-        assert(2 == sizeof($users), 'Cannot retrieve list of the users');
-        assert(isset($users['results']), 'Cannot retrieve list of the users');
-        assert(isset($users['total']), 'Cannot retrieve list of the users');
+		assert(!is_null($users), 'Cannot retrieve list of the users');
+		assert(2 == sizeof($users), 'Cannot retrieve list of the users');
+		assert(isset($users['results']), 'Cannot retrieve list of the users');
+		assert(isset($users['total']), 'Cannot retrieve list of the users');
 
-        $randIndex = rand(0, $users['total'] - 1);
+		$randIndex = rand(0, $users['total'] - 1);
 
-        $randomUserID = $users['results'][$randIndex]['member_id'];
+		$randomUserID = $users['results'][$randIndex]['member_id'];
 
-        //endregion
+		//endregion
 
-        //region -- Assign Member To Route
+		//region -- Assign Member To Route
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeId = self::$createdProblems[0]
-            ->routes[sizeof(self::$createdProblems[0]->routes) - 1]
-            ->route_id;
+		$routeId = self::$createdProblems[0]
+			->routes[sizeof(self::$createdProblems[0]->routes) - 1]
+			->route_id;
 
-        $route->route_id = $routeId;
+		$route->route_id = $routeId;
 
-        $route->parameters = new \stdClass();
+		$route->parameters = new \stdClass();
 
-        $route->parameters = [
-            'member_id' => $randomUserID,
-        ];
+		$route->parameters = [
+			'member_id' => $randomUserID,
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $route->update();
+		$route->update();
 
-        $this->assertNotNull($route);
-        $this->assertInstanceOf(Route::class,$route);
+		$this->assertNotNull($route);
+		$this->assertInstanceOf(Route::class,$route);
 
-        //endregion
+		//endregion
 
-        //region -- Check the Route Assigned --
+		//region -- Check the Route Assigned --
 
-        $route = new Route();
+		$route = new Route();
 
-        $assignedRoute= $route->getRoutes(['route_id' => $routeId]);
+		$assignedRoute= $route->getRoutes(['route_id' => $routeId]);
 
-        $this->assertNotNull($assignedRoute);
-        $this->assertInstanceOf(Route::class,$assignedRoute);
-        $this->assertEquals($randomUserID, $assignedRoute->parameters->member_id);
+		$this->assertNotNull($assignedRoute);
+		$this->assertInstanceOf(Route::class,$assignedRoute);
+		$this->assertEquals($randomUserID, $assignedRoute->parameters->member_id);
 
-        //endregion
-    }
+		//endregion
+	}
 
-    public function testAssignVehicleToRoute()
-    {
-        //region -- Get Random Vehicle --
+	public function testAssignVehicleToRoute()
+	{
+		//region -- Get Random Vehicle --
 
-        $vehicle = new Vehicle();
+		$vehicle = new Vehicle();
 
-        $vehicleParameters = [
-            'with_pagination'   => true,
-            'page'              => 1,
-            'perPage'           => 10,
-        ];
+		$vehicleParameters = [
+			'with_pagination'   => true,
+			'page'              => 1,
+			'perPage'           => 10,
+		];
 
-        $response = $vehicle->getVehicles($vehicleParameters);
+		$response = $vehicle->getVehicles($vehicleParameters);
 
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
 
-        if (sizeof($response)<1) {
-            $vehicle = new VehicleV4();
+		if (sizeof($response)<1) {
+			$vehicle = new VehicleV4();
 
-            $vehicleParameters = Vehicle::fromArray([
-                'vehicle_name'              => 'Ford Transit Test 5',
-                'vehicle_alias'             => 'Ford Transit Test 5',
-                'vehicle_vin'               => 'JS3TD62V1Y4107898',
-                'vehicle_reg_country_id'    => '223',
-                'vehicle_make'              => 'Ford',
-                'vehicle_model_year'        => 2013,
-                'vehicle_axle_count'        => 2,
-                'mpg_city'                  => 8,
-                'mpg_highway'               => 14,
-                'fuel_type'                 => 'unleaded 93',
-                'height_inches'             => 72,
-                'weight_lb'                 => 2000,
-            ]);
+			$vehicleParameters = Vehicle::fromArray([
+				'vehicle_name'              => 'Ford Transit Test 5',
+				'vehicle_alias'             => 'Ford Transit Test 5',
+				'vehicle_vin'               => 'JS3TD62V1Y4107898',
+				'vehicle_reg_country_id'    => '223',
+				'vehicle_make'              => 'Ford',
+				'vehicle_model_year'        => 2013,
+				'vehicle_axle_count'        => 2,
+				'mpg_city'                  => 8,
+				'mpg_highway'               => 14,
+				'fuel_type'                 => 'unleaded 93',
+				'height_inches'             => 72,
+				'weight_lb'                 => 2000,
+			]);
 
-            $result = $vehicle->createVehicle($vehicleParameters);
+			$result = $vehicle->createVehicle($vehicleParameters);
 
-            self::assertNotNull($result);
-            self::assertInstanceOf(
-                VehicleV4::class,
-                VehicleV4::fromArray($result)
-            );
+			self::assertNotNull($result);
+			self::assertInstanceOf(
+				VehicleV4::class,
+				VehicleV4::fromArray($result)
+			);
 
-            $response[] = $result;
+			$response[] = $result;
 
-            $removedVehicleIDs[] = $result['vehicle_id'];
-        }
+			$removedVehicleIDs[] = $result['vehicle_id'];
+		}
 
-        $randomIndex = rand(0, sizeof($response)-1);
-        $vehicleId = $response[$randomIndex]['vehicle_id'];
+		$randomIndex = rand(0, sizeof($response)-1);
+		$vehicleId = $response[$randomIndex]['vehicle_id'];
 
-        //endregion
+		//endregion
 
-        //region -- Assign Vehicle To Route
+		//region -- Assign Vehicle To Route
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeId = self::$createdProblems[0]
-            ->routes[sizeof(self::$createdProblems[0]->routes) - 1]
-            ->route_id;
+		$routeId = self::$createdProblems[0]
+			->routes[sizeof(self::$createdProblems[0]->routes) - 1]
+			->route_id;
 
-        $route->route_id = $routeId;
+		$route->route_id = $routeId;
 
-        $route->parameters = new \stdClass();
+		$route->parameters = new \stdClass();
 
-        $route->parameters = [
-            'vehicle_id' => $vehicleId,
-        ];
+		$route->parameters = [
+			'vehicle_id' => $vehicleId,
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $route->update();
+		$route->update();
 
-        $this->assertNotNull($route);
-        $this->assertInstanceOf(Route::class,$route);
+		$this->assertNotNull($route);
+		$this->assertInstanceOf(Route::class,$route);
 
-        //endregion
+		//endregion
 
-        //region -- Check the Route Assigned --
+		//region -- Check the Route Assigned --
 
-        $route = new Route();
+		$route = new Route();
 
-        $assignedRoute= $route->getRoutes(['route_id' => $routeId]);
+		$assignedRoute= $route->getRoutes(['route_id' => $routeId]);
 
-        $this->assertNotNull($assignedRoute);
-        $this->assertInstanceOf(Route::class,$assignedRoute);
-        $this->assertEquals($vehicleId, $assignedRoute->parameters->vehicle_id);
+		$this->assertNotNull($assignedRoute);
+		$this->assertInstanceOf(Route::class,$assignedRoute);
+		$this->assertEquals($vehicleId, $assignedRoute->parameters->vehicle_id);
 
-        //endregion
-    }
+		//endregion
+	}
 
-    public function testDuplicateRoute()
-    {
-        $route = new Route();
+	public function testDuplicateRoute()
+	{
+		$route = new Route();
 
-        $routeIDs = [self::$testRoutes[0]->route_id];
+		$routeIDs = [self::$testRoutes[0]->route_id];
 
-        $routeDuplicate = $route->duplicateRoute($routeIDs);
+		$routeDuplicate = $route->duplicateRoute($routeIDs);
 
-        $this->assertTrue(isset($routeDuplicate['status']), "Cannot created duplicate route");
-        $this->assertTrue($routeDuplicate['status'], "Cannot created duplicate route");
+		$this->assertTrue(isset($routeDuplicate['status']), "Cannot created duplicate route");
+		$this->assertTrue($routeDuplicate['status'], "Cannot created duplicate route");
 
-        $duplicatedRouteId = $routeDuplicate['route_ids'][0];
+		$duplicatedRouteId = $routeDuplicate['route_ids'][0];
 
-        self::$removedRouteIDs[] = $duplicatedRouteId;
-    }
+		self::$removedRouteIDs[] = $duplicatedRouteId;
+	}
 
-    public function testGetRouteDirections()
-    {
-        $route = new Route();
+	public function testGetRouteDirections()
+	{
+		$route = new Route();
 
-        $route_id = self::$testRoutes[0]->route_id;
+		$route_id = self::$testRoutes[0]->route_id;
 
-        // Note: not every optimization includes information about directions,
-        // only thus, which was generated with the parameter directions = 1
+		// Note: not every optimization includes information about directions,
+		// only thus, which was generated with the parameter directions = 1
 
-        // Get a route with the directions
-        $params = new RouteParametersQuery();
+		// Get a route with the directions
+		$params = new RouteParametersQuery();
 
-        $params->route_id = $route_id;
-        $params->directions = true;
+		$params->route_id = $route_id;
+		$params->directions = true;
 
-        $routeResult = (array)$route->getRoutePoints($params->toArray());
+		$routeResult = (array)$route->getRoutePoints($params->toArray());
 
-        $this->assertNotNull($routeResult);
-        $this->assertTrue(is_array($routeResult));
-        $this->assertTrue(sizeof($routeResult)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
-        $this->assertTrue(isset($routeResult['directions']));
-        $this->assertTrue(sizeof($routeResult['directions'])>0);
-    }
+		$this->assertNotNull($routeResult);
+		$this->assertTrue(is_array($routeResult));
+		$this->assertTrue(sizeof($routeResult)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
+		$this->assertTrue(isset($routeResult['directions']));
+		$this->assertTrue(sizeof($routeResult['directions'])>0);
+	}
 
-    public function testGetRoutePathPoints()
-    {
-        $route = new Route();
+	public function testGetRoutePathPoints()
+	{
+		$route = new Route();
 
-        $route_id = self::$testRoutes[0]->route_id;
+		$route_id = self::$testRoutes[0]->route_id;
 
-        // Note: not every optimization includes information about path points, only thus,
-        // which was generated with the parameter route_path_output = "Points"
+		// Note: not every optimization includes information about path points, only thus,
+		// which was generated with the parameter route_path_output = "Points"
 
-        // Get a route with the path points
+		// Get a route with the path points
 
-        $params = new RouteParametersQuery();
+		$params = new RouteParametersQuery();
 
-        $params->route_id           = $route_id;
-        $params->route_path_output  = 'Points';
+		$params->route_id           = $route_id;
+		$params->route_path_output  = 'Points';
 
-        $routeResult = (array) $route->getRoutePoints($params->toArray());
+		$routeResult = (array) $route->getRoutePoints($params->toArray());
 
-        $this->assertNotNull($routeResult);
-        $this->assertTrue(is_array($routeResult));
-        $this->assertTrue(sizeof($routeResult)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
-        $this->assertTrue(isset($routeResult['path']));
-        $this->assertTrue(sizeof($routeResult['path'])>0);
-    }
+		$this->assertNotNull($routeResult);
+		$this->assertTrue(is_array($routeResult));
+		$this->assertTrue(sizeof($routeResult)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
+		$this->assertTrue(isset($routeResult['path']));
+		$this->assertTrue(sizeof($routeResult['path'])>0);
+	}
 
-    public function testGetRoute()
-    {
-        $route = new Route();
+	public function testGetRoute()
+	{
+		$route = new Route();
 
-        $route_id = self::$testRoutes[0]->route_id;
+		$route_id = self::$testRoutes[0]->route_id;
 
-        // get a route by ID
-        $routeResult = $route->getRoutes(['route_id' => $route_id]);
+		// get a route by ID
+		$routeResult = $route->getRoutes(['route_id' => $route_id]);
 
-        $this->assertNotNull($routeResult);
-        $this->assertInstanceOf(Route::class, $routeResult);
-        $this->assertEquals($route_id, $routeResult->route_id);
-    }
+		$this->assertNotNull($routeResult);
+		$this->assertInstanceOf(Route::class, $routeResult);
+		$this->assertEquals($route_id, $routeResult->route_id);
+	}
 
-    public function testGetRoutesByIDs()
-    {
-        $params = new RouteParametersQuery();
+	public function testGetRoutesByIDs()
+	{
+		$params = new RouteParametersQuery();
 
-        $params->limit = 5;
-        $params->offset = 0;
+		$params->limit = 5;
+		$params->offset = 0;
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeResults = $route->getRoutes($params->toArray());
+		$routeResults = $route->getRoutes($params->toArray());
 
-        $routeId1 = $routeResults[0]->route_id;
-        $routeId2 = $routeResults[1]->route_id;
+		$routeId1 = $routeResults[0]->route_id;
+		$routeId2 = $routeResults[1]->route_id;
 
-        $routesResult = $route->getRoutes(['route_id' => $routeId1.','.$routeId2]);
+		$routesResult = $route->getRoutes(['route_id' => $routeId1.','.$routeId2]);
 
-        $this->assertNotNull($routesResult);
-        $this->assertTrue(is_array($routesResult));
-        $this->assertTrue(sizeof($routesResult)==2);
-        $this->assertInstanceOf(
-            Route::class,
-            Route::fromArray($routesResult[0])
-        );
-    }
+		$this->assertNotNull($routesResult);
+		$this->assertTrue(is_array($routesResult));
+		$this->assertTrue(sizeof($routesResult)==2);
+		$this->assertInstanceOf(
+			Route::class,
+			Route::fromArray($routesResult[0])
+		);
+	}
 
-    public function testGetRoutesFromDateRange()
-    {
-        $params = new RouteParametersQuery();
+	public function testGetRoutesFromDateRange()
+	{
+		$params = new RouteParametersQuery();
 
-        $params->start_date = date('Y-m-d', strtotime('-1 days'));
-        $params->end_date   = date('Y-m-d', strtotime('+1 days'));
+		$params->start_date = date('Y-m-d', strtotime('-1 days'));
+		$params->end_date   = date('Y-m-d', strtotime('+1 days'));
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeResults = $route->getRoutes($params->toArray());
+		$routeResults = $route->getRoutes($params->toArray());
 
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
 
-        $startDateUnix = date_create($params->start_date)->format('U');
-        $endtDateUnix = date_create($params->end_date)->format('U');
+		$startDateUnix = date_create($params->start_date)->format('U');
+		$endtDateUnix = date_create($params->end_date)->format('U');
 
-        $tz = date('Z');
+		$tz = date('Z');
 
-        foreach ($routeResults as $routeResult) {
+		foreach ($routeResults as $routeResult) {
 
-            $this->assertTrue(
-                $routeResult->parameters->route_date - $tz >= $startDateUnix &&
-                $routeResult->parameters->route_date - $tz <= $endtDateUnix
-            );
-        }
-    }
+			$this->assertTrue(
+				$routeResult->parameters->route_date - $tz >= $startDateUnix &&
+				$routeResult->parameters->route_date - $tz <= $endtDateUnix
+			);
+		}
+	}
 
-    public function testGetRoutes()
-    {
-        $params = new RouteParametersQuery();
+	public function testGetRoutes()
+	{
+		$params = new RouteParametersQuery();
 
-        $params->limit = 10;
-        $params->offset = 0;
+		$params->limit = 10;
+		$params->offset = 0;
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeResults = $route->getRoutes($params->toArray());
+		$routeResults = $route->getRoutes($params->toArray());
 
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
 
-    public function testReoptimizeRoute()
-    {
-        $route = new Route();
+	public function testReoptimizeRoute()
+	{
+		$route = new Route();
 
-        $route_id = self::$testRoutes[0]->route_id;
+		$route_id = self::$testRoutes[0]->route_id;
 
-        // Re-sequence all addresses
-        $params = new RouteParametersQuery();
+		// Re-sequence all addresses
+		$params = new RouteParametersQuery();
 
-        $params->route_id   = $route_id;
-        $params->reoptimize = true;
+		$params->route_id   = $route_id;
+		$params->reoptimize = true;
 
-        $routeResult = $route->updateRoute($params->toArray());
+		$routeResult = $route->updateRoute($params->toArray());
 
-        $this->assertNotNull($routeResult);
-        $this->assertTrue(is_array($routeResult));
-        $this->assertTrue(sizeof($routeResult)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
-    }
+		$this->assertNotNull($routeResult);
+		$this->assertTrue(is_array($routeResult));
+		$this->assertTrue(sizeof($routeResult)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResult));
+	}
 
-    public function testResequenceReoptimizeRoute()
-    {
-        $route = new Route();
+	public function testResequenceReoptimizeRoute()
+	{
+		$route = new Route();
 
-        $selectedRoute = null;
+		$selectedRoute = null;
 
-        foreach (self::$testRoutes as $route1) {
-            if (isset($route1->destination_count)) {
-                if ($route1->destination_count > 4) {
-                    $selectedRoute = $route->getRoutes(['route_id' => $route1->route_id]);
-                    break;
-                }
-            }
-        }
+		foreach (self::$testRoutes as $route1) {
+			if (isset($route1->destination_count)) {
+				if ($route1->destination_count > 4) {
+					$selectedRoute = $route->getRoutes(['route_id' => $route1->route_id]);
+					break;
+				}
+			}
+		}
 
-        $this->assertNotNull(
-            $selectedRoute,
-            "Cannot select a route with more than 4 addresses");
+		$this->assertNotNull(
+			$selectedRoute,
+			"Cannot select a route with more than 4 addresses");
 
-        // Resequence a route destination
-        $routeID = $selectedRoute->route_id;
-        $routeDestinationID = $selectedRoute->addresses[2]->route_destination_id;
+		// Resequence a route destination
+		$routeID = $selectedRoute->route_id;
+		$routeDestinationID = $selectedRoute->addresses[2]->route_destination_id;
 
-        echo "Route ID-> $routeID, Route destination ID -> $routeDestinationID <br>";
+		echo "Route ID-> $routeID, Route destination ID -> $routeDestinationID <br>";
 
-        $params = [
-            'route_id'              => $routeID,
-            'route_destination_id'  => $routeDestinationID,
-            'addresses'             => [
-                '0' => [
-                    'route_destination_id'  => $routeDestinationID,
-                    'sequence_no'           => 3,
-                ],
-            ],
-        ];
+		$params = [
+			'route_id'              => $routeID,
+			'route_destination_id'  => $routeDestinationID,
+			'addresses'             => [
+				'0' => [
+					'route_destination_id'  => $routeDestinationID,
+					'sequence_no'           => 3,
+				],
+			],
+		];
 
-        $response = $route->resequenceRoute($params);
+		$response = $route->resequenceRoute($params);
 
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(sizeof($response)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($response));
-    }
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(sizeof($response)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($response));
+	}
 
-    public function testResequenceRouteDestinations()
-    {
-        $route = new Route();
-        $address = new Address();
+	public function testResequenceRouteDestinations()
+	{
+		$route = new Route();
+		$address = new Address();
 
-        $routeID = self::$testRoutes[0]->route_id;
-        $routeDestinationID = self::$testRoutes[0]->addresses[2]->route_destination_id;
+		$routeID = self::$testRoutes[0]->route_id;
+		$routeDestinationID = self::$testRoutes[0]->addresses[2]->route_destination_id;
 
-        $this->assertNotNull($routeID);
-        $this->assertNotNull($routeDestinationID);
+		$this->assertNotNull($routeID);
+		$this->assertNotNull($routeDestinationID);
 
-        //region -- Re-sequence a route destination --
+		//region -- Re-sequence a route destination --
 
-        $params = [
-            'route_id'              => $routeID,
-            'route_destination_id'  => $routeDestinationID,
-            'addresses' => [
-                '0' => [
-                    'route_destination_id'  => $routeDestinationID,
-                    'sequence_no'           => 3,
-                ],
-            ],
-        ];
+		$params = [
+			'route_id'              => $routeID,
+			'route_destination_id'  => $routeDestinationID,
+			'addresses' => [
+				'0' => [
+					'route_destination_id'  => $routeDestinationID,
+					'sequence_no'           => 3,
+				],
+			],
+		];
 
-        $response = $route->resequenceRoute($params);
+		$response = $route->resequenceRoute($params);
 
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(sizeof($response)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($response));
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(sizeof($response)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($response));
 
-        //endregion
+		//endregion
 
-        //region -- Check the Address re-sequenced --
+		//region -- Check the Address re-sequenced --
 
-        $addressRetrieved = $address->getAddress($routeID, $routeDestinationID);
+		$addressRetrieved = $address->getAddress($routeID, $routeDestinationID);
 
-        $this->assertEquals(3, $addressRetrieved->sequence_no);
+		$this->assertEquals(3, $addressRetrieved->sequence_no);
 
-        //endregion
-    }
+		//endregion
+	}
 
-    public function  testRouteOriginParameter()
-    {
-        $route = new Route();
+	public function  testRouteOriginParameter()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        //region -- Re-sequence the route --
+		//region -- Re-sequence the route --
 
-        $params = new RouteParametersQuery();
-        $params->route_id = $routeID;
+		$params = new RouteParametersQuery();
+		$params->route_id = $routeID;
 
-        $result = $route->reoptimizeRoute($params);
+		$result = $route->reoptimizeRoute($params);
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Route::class, Route::fromArray($result));
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Route::class, Route::fromArray($result));
 
-        $params = new RouteParametersQuery();
+		$params = new RouteParametersQuery();
 
-        $params->route_id = $routeID;
-        $params->original = true;
+		$params->route_id = $routeID;
+		$params->original = true;
 
-        $routeWithOriginRoute = $route->getRoutes($params->toArray());
+		$routeWithOriginRoute = $route->getRoutes($params->toArray());
 
-        //endregion
+		//endregion
 
-        $this->assertNotNull($routeWithOriginRoute);
-        $this->assertInstanceOf(Route::class, $routeWithOriginRoute);
+		$this->assertNotNull($routeWithOriginRoute);
+		$this->assertInstanceOf(Route::class, $routeWithOriginRoute);
 
-        $this->assertNotNull($routeWithOriginRoute->original_route);
-        $this->assertInstanceOf(Route::class, $routeWithOriginRoute->original_route);
-    }
+		$this->assertNotNull($routeWithOriginRoute->original_route);
+		$this->assertInstanceOf(Route::class, $routeWithOriginRoute->original_route);
+	}
 
-    public function testShareRoute()
-    {
-        $route = new Route();
+	public function testShareRoute()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        // Share a route with an email
-        $params = [
-            'route_id'          => $routeID,
-            'response_format'   => 'json',
-            'recipient_email'   => 'rrrrrrrrrrrrrrrr+share1234@gmail.com',
-        ];
+		// Share a route with an email
+		$params = [
+			'route_id'          => $routeID,
+			'response_format'   => 'json',
+			'recipient_email'   => 'rrrrrrrrrrrrrrrr+share1234@gmail.com',
+		];
 
-        $result = $route->shareRoute($params);
+		$result = $route->shareRoute($params);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['status']));
-        $this->assertTrue($result['status']);
-    }
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['status']));
+		$this->assertTrue($result['status']);
+	}
 
-    public function testUnlinkRouteFromOptimization()
-    {
-        $route = new Route();
+	public function testUnlinkRouteFromOptimization()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        //region -- Unlink a route from master destination --
+		//region -- Unlink a route from master destination --
 
-        $route->route_id = $routeID;
-        $route->parameters = new \stdClass();
+		$route->route_id = $routeID;
+		$route->parameters = new \stdClass();
 
-        $parameters = [
-            'route_id'                          => $routeID,
-            'unlink_from_master_optimization'   => true,
-        ];
+		$parameters = [
+			'route_id'                          => $routeID,
+			'unlink_from_master_optimization'   => true,
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $result = $route->updateRoute($parameters);
+		$result = $route->updateRoute($parameters);
 
-        //endregion
+		//endregion
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Route::class, Route::fromArray($result));
-        $this->assertNull($result['optimization_problem_id']);
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Route::class, Route::fromArray($result));
+		$this->assertNull($result['optimization_problem_id']);
 
-        $removedRouteIDs[]= $result['route_id'];
-    }
+		$removedRouteIDs[]= $result['route_id'];
+	}
 
-    public function testUpdateRouteAvoidanceZone()
-    {
-        $route = new Route();
+	public function testUpdateRouteAvoidanceZone()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        $parameters = [
-            'route_id'   => $routeID,
-            'parameters' => [
-                'avoidance_zones' => [
-                    'FAA49711A0F1144CE4E203DC18ABDFFB',
-                    '9C48E8008E9865006336B99D3595E66A'
-                ]
-            ]
-        ];
+		$parameters = [
+			'route_id'   => $routeID,
+			'parameters' => [
+				'avoidance_zones' => [
+					'FAA49711A0F1144CE4E203DC18ABDFFB',
+					'9C48E8008E9865006336B99D3595E66A'
+				]
+			]
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $result = $route->updateRoute($parameters);
+		$result = $route->updateRoute($parameters);
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Route::class, Route::fromArray($result));
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Route::class, Route::fromArray($result));
 
-        $this->assertNotNull($result['parameters']['avoidance_zones']);
-        $this->assertTrue(is_array($result['parameters']['avoidance_zones']));
-        $this->assertEquals(2, sizeof($result['parameters']['avoidance_zones']));
-    }
+		$this->assertNotNull($result['parameters']['avoidance_zones']);
+		$this->assertTrue(is_array($result['parameters']['avoidance_zones']));
+		$this->assertEquals(2, sizeof($result['parameters']['avoidance_zones']));
+	}
 
-    public function testUpdateRouteCustomData()
-    {
-        $route = new Route();
+	public function testUpdateRouteCustomData()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        // Get a random address ID from selected route above
-        $addressRand = (array)$route->GetRandomAddressFromRoute($routeID);
+		// Get a random address ID from selected route above
+		$addressRand = (array)$route->GetRandomAddressFromRoute($routeID);
 
-        $route->route_id = $routeID;
-        $route->route_destination_id = $addressRand['route_destination_id'];
+		$route->route_id = $routeID;
+		$route->route_destination_id = $addressRand['route_destination_id'];
 
-        // Update destination custom data
-        $route->parameters = new \stdClass();
+		// Update destination custom data
+		$route->parameters = new \stdClass();
 
-        $route->parameters->custom_fields = [
-            'animal'    => 'tiger',
-            'bird'      => 'canary',
-        ];
+		$route->parameters->custom_fields = [
+			'animal'    => 'tiger',
+			'bird'      => 'canary',
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $result = $route->updateAddress();
+		$result = $route->updateAddress();
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Address::class, Address::fromArray($result));
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Address::class, Address::fromArray($result));
 
-        $this->assertTrue(isset($result['custom_fields']));
-        $this->assertTrue(is_array($result['custom_fields']));
-        $this->assertEquals('tiger', $result['custom_fields']['animal']);
-        $this->assertEquals('canary', $result['custom_fields']['bird']);
-    }
+		$this->assertTrue(isset($result['custom_fields']));
+		$this->assertTrue(is_array($result['custom_fields']));
+		$this->assertEquals('tiger', $result['custom_fields']['animal']);
+		$this->assertEquals('canary', $result['custom_fields']['bird']);
+	}
 
-    public function testUpdateRoute()
-    {
-        $route = new Route();
+	public function testUpdateRoute()
+	{
+		$route = new Route();
 
-        $routeID = self::$testRoutes[0]->route_id;
+		$routeID = self::$testRoutes[0]->route_id;
 
-        $initialRoute = self::$testRoutes[0];
+		$initialRoute = self::$testRoutes[0];
 
-        // Update the route parameters
-        $route->route_id = $routeID;
+		// Update the route parameters
+		$route->route_id = $routeID;
 
-        $route->parameters = new \stdClass();
+		$route->parameters = new \stdClass();
 
-        $route->parameters = [
-            'member_id'             => $initialRoute->member_id,
-            'optimize'              => 'Distance',
-            'route_max_duration'    => '82400',
-            'route_name'            => 'updated '.date('m-d-Y'),
-        ];
+		$route->parameters = [
+			'member_id'             => $initialRoute->member_id,
+			'optimize'              => 'Distance',
+			'route_max_duration'    => '82400',
+			'route_name'            => 'updated '.date('m-d-Y'),
+		];
 
-        $route->httpheaders = 'Content-type: application/json';
+		$route->httpheaders = 'Content-type: application/json';
 
-        $result = $route->update();
+		$result = $route->update();
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Route::class, $result);
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Route::class, $result);
+	}
 
-    public function testDeleteRoutes()
-    {
-        $route = new Route();
+	public function testDeleteRoutes()
+	{
+		$route = new Route();
 
-        $route_ids = join(',', [self::$createdProblems[0]->routes[0]->route_id]);
+		$route_ids = join(',', [self::$createdProblems[0]->routes[0]->route_id]);
 
-        $result = $route->deleteRoutes($route_ids);
+		$result = $route->deleteRoutes($route_ids);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['deleted']));
-        $this->assertTrue($result['deleted']);
-    }
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['deleted']));
+		$this->assertTrue($result['deleted']);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdProblems)>0) {
-            $optimizationProblemIDs = [];
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdProblems)>0) {
+			$optimizationProblemIDs = [];
 
-            foreach (self::$createdProblems as $problem) {
-                $optimizationProblemId = $problem->optimization_problem_id;
+			foreach (self::$createdProblems as $problem) {
+				$optimizationProblemId = $problem->optimization_problem_id;
 
-                $optimizationProblemIDs[] = $optimizationProblemId;
-            }
+				$optimizationProblemIDs[] = $optimizationProblemId;
+			}
 
-            if (sizeof(self::$removedOptimizationIDs)>0) {
-                $optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
-            }
+			if (sizeof(self::$removedOptimizationIDs)>0) {
+				$optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
+			}
 
-            $params = [
-                'optimization_problem_ids' => $optimizationProblemIDs,
-                'redirect'                 => 0,
-            ];
+			$params = [
+				'optimization_problem_ids' => $optimizationProblemIDs,
+				'redirect'                 => 0,
+			];
 
-            $problem = new OptimizationProblem();
-            $result = $problem->removeOptimization($params);
+			$problem = new OptimizationProblem();
+			$result = $problem->removeOptimization($params);
 
-            if ($result!=null && $result['status']==true) {
-                echo "The test optimizations were removed <br>";
-            } else {
-                echo "Cannot remove the test optimizations <br>";
-            }
-        }
+			if ($result!=null && $result['status']==true) {
+				echo "The test optimizations were removed <br>";
+			} else {
+				echo "Cannot remove the test optimizations <br>";
+			}
+		}
 
-        if (sizeof(self::$removedRouteIDs)>0) {
-            $route = new Route();
+		if (sizeof(self::$removedRouteIDs)>0) {
+			$route = new Route();
 
-            $route_ids = join(',', self::$removedRouteIDs);
+			$route_ids = join(',', self::$removedRouteIDs);
 
-            $result = $route->deleteRoutes($route_ids);
+			$result = $route->deleteRoutes($route_ids);
 
-            if ($result!=null && $result['deleted']==true) {
-                echo "The test routes were removed <br>";
-            } else {
-                echo "Cannot remove the test routes <br>";
-            }
-        }
+			if ($result!=null && $result['deleted']==true) {
+				echo "The test routes were removed <br>";
+			} else {
+				echo "Cannot remove the test routes <br>";
+			}
+		}
 
-        if (sizeof(self::$removedVehicleIDs)>0) {
-            $vehicle = new VehicleV4();
+		if (sizeof(self::$removedVehicleIDs)>0) {
+			$vehicle = new VehicleV4();
 
-            foreach (self::$removedVehicleIDs as $vehicleID) {
-                $vehicleParameters = VehicleV4::fromArray([
-                    'vehicle_id' => $vehicleID,
-                ]);
+			foreach (self::$removedVehicleIDs as $vehicleID) {
+				$vehicleParameters = VehicleV4::fromArray([
+					'vehicle_id' => $vehicleID,
+				]);
 
-                $result = $vehicle->removeVehicle($vehicleParameters);
-            }
-        }
-    }
+				$result = $vehicle->removeVehicle($vehicleParameters);
+			}
+		}
+	}
 
 }
\ No newline at end of file

Spacing +14 added lines, -14 removed lines

@@ -180,7 +180,7 @@ 
         $users = $member->getUsers();
 
         assert(!is_null($users), 'Cannot retrieve list of the users');
-        assert(2 == sizeof($users), 'Cannot retrieve list of the users');
+        assert(2==sizeof($users), 'Cannot retrieve list of the users');
         assert(isset($users['results']), 'Cannot retrieve list of the users');
         assert(isset($users['total']), 'Cannot retrieve list of the users');
 
@@ -211,7 +211,7 @@ 
         $route->update();
 
         $this->assertNotNull($route);
-        $this->assertInstanceOf(Route::class,$route);
+        $this->assertInstanceOf(Route::class, $route);
 
         //endregion
 
@@ -219,10 +219,10 @@ 
 
         $route = new Route();
 
-        $assignedRoute= $route->getRoutes(['route_id' => $routeId]);
+        $assignedRoute = $route->getRoutes(['route_id' => $routeId]);
 
         $this->assertNotNull($assignedRoute);
-        $this->assertInstanceOf(Route::class,$assignedRoute);
+        $this->assertInstanceOf(Route::class, $assignedRoute);
         $this->assertEquals($randomUserID, $assignedRoute->parameters->member_id);
 
         //endregion
@@ -276,7 +276,7 @@ 
             $removedVehicleIDs[] = $result['vehicle_id'];
         }
 
-        $randomIndex = rand(0, sizeof($response)-1);
+        $randomIndex = rand(0, sizeof($response) - 1);
         $vehicleId = $response[$randomIndex]['vehicle_id'];
 
         //endregion
@@ -302,7 +302,7 @@ 
         $route->update();
 
         $this->assertNotNull($route);
-        $this->assertInstanceOf(Route::class,$route);
+        $this->assertInstanceOf(Route::class, $route);
 
         //endregion
 
@@ -310,10 +310,10 @@ 
 
         $route = new Route();
 
-        $assignedRoute= $route->getRoutes(['route_id' => $routeId]);
+        $assignedRoute = $route->getRoutes(['route_id' => $routeId]);
 
         $this->assertNotNull($assignedRoute);
-        $this->assertInstanceOf(Route::class,$assignedRoute);
+        $this->assertInstanceOf(Route::class, $assignedRoute);
         $this->assertEquals($vehicleId, $assignedRoute->parameters->vehicle_id);
 
         //endregion
@@ -376,7 +376,7 @@ 
         $params->route_id           = $route_id;
         $params->route_path_output  = 'Points';
 
-        $routeResult = (array) $route->getRoutePoints($params->toArray());
+        $routeResult = (array)$route->getRoutePoints($params->toArray());
 
         $this->assertNotNull($routeResult);
         $this->assertTrue(is_array($routeResult));
@@ -449,8 +449,8 @@ 
         foreach ($routeResults as $routeResult) {
 
             $this->assertTrue(
-                $routeResult->parameters->route_date - $tz >= $startDateUnix &&
-                $routeResult->parameters->route_date - $tz <= $endtDateUnix
+                $routeResult->parameters->route_date - $tz>=$startDateUnix &&
+                $routeResult->parameters->route_date - $tz<=$endtDateUnix
             );
         }
     }
@@ -500,7 +500,7 @@ 
 
         foreach (self::$testRoutes as $route1) {
             if (isset($route1->destination_count)) {
-                if ($route1->destination_count > 4) {
+                if ($route1->destination_count>4) {
                     $selectedRoute = $route->getRoutes(['route_id' => $route1->route_id]);
                     break;
                 }
@@ -656,7 +656,7 @@ 
         $this->assertInstanceOf(Route::class, Route::fromArray($result));
         $this->assertNull($result['optimization_problem_id']);
 
-        $removedRouteIDs[]= $result['route_id'];
+        $removedRouteIDs[] = $result['route_id'];
     }
 
     public function testUpdateRouteAvoidanceZone()
@@ -773,7 +773,7 @@ 
             }
 
             if (sizeof(self::$removedOptimizationIDs)>0) {
-                $optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
+                $optimizationProblemIDs = array_merge($optimizationProblemIDs, self::$removedOptimizationIDs);
             }
 
             $params = [

UnitTestFiles/Test/Route4MeUnitTests.php

Indentation +11 added lines, -11 removed lines

@@ -11,18 +11,18 @@
 use Route4Me\AvoidanceZone;
 
 class Route4MeUnitTests extends \PHPUnit\Framework\TestCase {
-    protected $AvoidanceZone;
+	protected $AvoidanceZone;
 
-    public function setUp()
-    {
-        $this->AvoidanceZone = new AvoidanceZone();
-    }
+	public function setUp()
+	{
+		$this->AvoidanceZone = new AvoidanceZone();
+	}
 
-    public function testgetAvoidanceZones()
-    {
-        echo "This Is Route4MeUnitTests <br>";
-        $condition = true;
-        $this->assertTrue($condition);
-    }
+	public function testgetAvoidanceZones()
+	{
+		echo "This Is Route4MeUnitTests <br>";
+		$condition = true;
+		$this->assertTrue($condition);
+	}
 }
  
\ No newline at end of file