SolidCharity/TimeTrex
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
TimeTrex/unit_tests/testcases/other/DateTimeTest.php

3125 lines
197 KiB
PHP
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<?php /** @noinspection PhpMissingDocCommentInspection */
/*********************************************************************************
*
* TimeTrex is a Workforce Management program developed by
* TimeTrex Software Inc. Copyright (C) 2003 - 2021 TimeTrex Software Inc.
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU Affero General Public License version 3 as published by
* the Free Software Foundation with the addition of the following permission
* added to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED
* WORK IN WHICH THE COPYRIGHT IS OWNED BY TIMETREX, TIMETREX DISCLAIMS THE
* WARRANTY OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
* details.
*
*
* You should have received a copy of the GNU Affero General Public License along
* with this program; if not, see http://www.gnu.org/licenses or write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA.
*
*
* You can contact TimeTrex headquarters at Unit 22 - 2475 Dobbin Rd. Suite
* #292 West Kelowna, BC V4T 2E9, Canada or at email address info@timetrex.com.
*
*
* The interactive user interfaces in modified source and object code versions
* of this program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU Affero General Public License version 3.
*
*
* In accordance with Section 7(b) of the GNU Affero General Public License
* version 3, these Appropriate Legal Notices must retain the display of the
* "Powered by TimeTrex" logo. If the display of the logo is not reasonably
* feasible for technical reasons, the Appropriate Legal Notices must display
* the words "Powered by TimeTrex".
*
********************************************************************************/
/**
* @group DateTime
*/
class DateTimeTest extends PHPUnit\Framework\TestCase {
public function setUp(): void {
Debug::text( 'Running setUp(): ', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setTimeZone( 'Etc/GMT+8', true ); //Due to being a singleton and PHPUnit resetting the state, always force the timezone to be set.
//If using loadbalancer, we need to make a SQL query to initiate at least one connection to a database.
//This is needed for testTimeZone() to work with the load balancer.
global $db;
$db->Execute( 'SELECT 1' );
}
public function tearDown(): void {
Debug::text( 'Running tearDown(): ', __FILE__, __LINE__, __METHOD__, 10 );
}
function testTimeUnit1() {
Debug::text( 'Testing Time Unit Format: hh:mm', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'dMY' );
TTDate::setTimeFormat( 'g:i A' );
/*
10 => 'hh:mm (2:15)',
12 => 'hh:mm:ss (2:15:59)',
20 => 'Hours (2.25)',
22 => 'Hours (2.241)',
30 => 'Minutes (135)'
*/
TTDate::setTimeUnitFormat( 10 );
$this->assertEquals( 60, TTDate::parseTimeUnit( '00:01' ) );
$this->assertEquals( -60, TTDate::parseTimeUnit( '-00:01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01:00' ) );
$this->assertEquals( 36000, TTDate::parseTimeUnit( '10:00' ) );
$this->assertEquals( 360000, TTDate::parseTimeUnit( '100:00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1000:00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1,000:00' ) );
$this->assertEquals( 36000000, TTDate::parseTimeUnit( '10,000:00' ) );
$this->assertEquals( 36000060, TTDate::parseTimeUnit( '10,000:01.5' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1' ) );
$this->assertEquals( -3600, TTDate::parseTimeUnit( '-1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:00:00' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '1:00:01' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '"1:00:01"' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '00:60' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( ':60' ) );
$this->assertEquals( 60, TTDate::parseTimeUnit( ':1' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '1:00:01.5' ) );
$this->assertEquals( 3660, TTDate::parseTimeUnit( '1:1.5' ) );
//Hybrid mode
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1.000' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1.00' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1' ) );
$this->assertEquals( -3600, TTDate::parseTimeUnit( '-1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01' ) );
$this->assertEquals( 900, TTDate::parseTimeUnit( '0.25' ) );
$this->assertEquals( 1800, TTDate::parseTimeUnit( '0.50' ) );
$this->assertEquals( 1200, TTDate::parseTimeUnit( '0.34' ) ); //Automatically rounds to nearest 1min
TTDate::setTimeUnitFormat( 12 ); //HH:MM:SS
$this->assertEquals( 60, TTDate::parseTimeUnit( '00:01' ) );
$this->assertEquals( -60, TTDate::parseTimeUnit( '-00:01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01:00' ) );
$this->assertEquals( 36000, TTDate::parseTimeUnit( '10:00' ) );
$this->assertEquals( 360000, TTDate::parseTimeUnit( '100:00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1000:00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1,000:00' ) );
$this->assertEquals( 36000000, TTDate::parseTimeUnit( '10,000:00' ) );
$this->assertEquals( 36000060, TTDate::parseTimeUnit( '10,000:01.5' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1' ) );
$this->assertEquals( -3600, TTDate::parseTimeUnit( '-1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:00:00' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '1:00:01' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '"1:00:01"' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '00:60' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( ':60' ) );
$this->assertEquals( 60, TTDate::parseTimeUnit( ':1' ) );
$this->assertEquals( 3601, TTDate::parseTimeUnit( '1:00:01.5' ) );
$this->assertEquals( 3660, TTDate::parseTimeUnit( '1:1.5' ) );
TTDate::setTimeUnitFormat( 40 ); //Seconds
$this->assertEquals( 3600, TTDate::parseTimeUnit( '3600' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '3600.001' ) );
$this->assertEquals( 3600.001, TTDate::parseTimeUnit( '"3600.001"' ) );
$this->assertEquals( 3629, TTDate::parseTimeUnit( '3629.001' ) );
$this->assertEquals( 3629.001, TTDate::parseTimeUnit( '"3629.001"' ) );
}
function testTimeUnit2() {
Debug::text( 'Testing Time Unit Format: Decimal', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'dMY' );
TTDate::setTimeFormat( 'g:i A' );
/*
10 => 'hh:mm (2:15)',
12 => 'hh:mm:ss (2:15:59)',
20 => 'Hours (2.25)',
22 => 'Hours (2.241)',
30 => 'Minutes (135)'
*/
TTDate::setTimeUnitFormat( 20 );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1.000' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1.00' ) );
$this->assertEquals( 36000, TTDate::parseTimeUnit( '10.00' ) );
$this->assertEquals( 360000, TTDate::parseTimeUnit( '100.00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1000.00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1000.0001' ) );
$this->assertEquals( 3600000.36, TTDate::parseTimeUnit( '"1000.0001"' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '1,000.00' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( '"1,000.00"' ) );
$this->assertEquals( 3600000, TTDate::parseTimeUnit( ' "1, 000.00" ' ) );
$this->assertEquals( -3600000, TTDate::parseTimeUnit( ' "-1, 000.00" ' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1' ) );
$this->assertEquals( -3600, TTDate::parseTimeUnit( '-1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01' ) );
$this->assertEquals( 900, TTDate::parseTimeUnit( '0.25' ) );
$this->assertEquals( 1800, TTDate::parseTimeUnit( '0.50' ) );
$this->assertEquals( 1200, TTDate::parseTimeUnit( '0.34' ) ); //Automatically rounds to nearest 1min
//Hybrid mode
$this->assertEquals( 60, TTDate::parseTimeUnit( '00:01' ) );
$this->assertEquals( -60, TTDate::parseTimeUnit( '-00:01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01:00' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '01' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1' ) );
$this->assertEquals( -3600, TTDate::parseTimeUnit( '-1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:00:00' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '00:60' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( ':60' ) );
$this->assertEquals( 60, TTDate::parseTimeUnit( ':1' ) );
$this->assertEquals( 3600, TTDate::parseTimeUnit( '1:00:01.5' ) );
$this->assertEquals( 3660, TTDate::parseTimeUnit( '1:1.5' ) );
}
function testTimeUnit3() {
Debug::text( 'Testing Time Unit Format: Decimal', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'dMY' );
TTDate::setTimeFormat( 'g:i A' );
/*
10 => 'hh:mm (2:15)',
12 => 'hh:mm:ss (2:15:59)',
20 => 'Hours (2.25)',
22 => 'Hours (2.241)',
30 => 'Minutes (135)'
*/
TTDate::setTimeUnitFormat( 20 );
$this->assertEquals( TTDate::parseTimeUnit( '0.02' ), ( 1 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.03' ), ( 2 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.05' ), ( 3 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.07' ), ( 4 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.08' ), ( 5 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.10' ), ( 6 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.12' ), ( 7 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.13' ), ( 8 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.15' ), ( 9 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.17' ), ( 10 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.18' ), ( 11 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.20' ), ( 12 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.22' ), ( 13 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.23' ), ( 14 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.25' ), ( 15 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.27' ), ( 16 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.28' ), ( 17 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.30' ), ( 18 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.32' ), ( 19 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.33' ), ( 20 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.35' ), ( 21 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.37' ), ( 22 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.38' ), ( 23 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.40' ), ( 24 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.42' ), ( 25 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.43' ), ( 26 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.45' ), ( 27 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.47' ), ( 28 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.48' ), ( 29 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.50' ), ( 30 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.52' ), ( 31 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.53' ), ( 32 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.55' ), ( 33 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.57' ), ( 34 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.58' ), ( 35 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.60' ), ( 36 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.62' ), ( 37 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.63' ), ( 38 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.65' ), ( 39 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.67' ), ( 40 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.68' ), ( 41 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.70' ), ( 42 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.72' ), ( 43 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.73' ), ( 44 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.75' ), ( 45 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.77' ), ( 46 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.78' ), ( 47 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.80' ), ( 48 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.82' ), ( 49 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.84' ), ( 50 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.85' ), ( 51 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.87' ), ( 52 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.89' ), ( 53 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.90' ), ( 54 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.92' ), ( 55 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.94' ), ( 56 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.95' ), ( 57 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.97' ), ( 58 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '0.99' ), ( 59 * 60 ) );
$this->assertEquals( TTDate::parseTimeUnit( '1.00' ), ( 60 * 60 ) );
}
function testTimeUnit4() {
Debug::text( 'Testing Time Unit Format: Decimal', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'dMY' );
TTDate::setTimeFormat( 'g:i A' );
/*
10 => 'hh:mm (2:15)',
12 => 'hh:mm:ss (2:15:59)',
20 => 'Hours (2.25)',
22 => 'Hours (2.241)',
30 => 'Minutes (135)'
*/
TTDate::setTimeUnitFormat( 10 );
$this->assertEquals( '01:00', TTDate::getTimeUnit( 3600 ) );
$this->assertEquals( '01:01', TTDate::getTimeUnit( 3660 ) );
$this->assertEquals( '10:01', TTDate::getTimeUnit( 36060 ) );
$this->assertEquals( '10:11', TTDate::getTimeUnit( 36660 ) );
$this->assertEquals( '100:11', TTDate::getTimeUnit( 360660 ) );
$this->assertEquals( '1000:11', TTDate::getTimeUnit( 3600660 ) );
$this->assertEquals( '10000:11', TTDate::getTimeUnit( 36000660 ) );
$this->assertEquals( '100000:11', TTDate::getTimeUnit( 360000660 ) );
$this->assertEquals( '1000000:11', TTDate::getTimeUnit( 3600000660 ) );
//$this->assertEquals( TTDate::getTimeUnit( ( PHP_INT_MAX + PHP_INT_MAX ) ), 'ERR(FLOAT)' ); //This is passing a float that is losing precision.
$this->assertEquals( '5124095576030431:00', TTDate::getTimeUnit( bcadd( PHP_INT_MAX, PHP_INT_MAX ) ) );
$this->assertEquals( '5124095576030431:11', TTDate::getTimeUnit( bcadd( bcadd( PHP_INT_MAX, PHP_INT_MAX ), 660 ) ) );
TTDate::setTimeUnitFormat( 10 );
$this->assertEquals( '-01:00', TTDate::getTimeUnit( -3600 ) );
$this->assertEquals( '-01:01', TTDate::getTimeUnit( -3660 ) );
$this->assertEquals( '-10:01', TTDate::getTimeUnit( -36060 ) );
$this->assertEquals( '-10:11', TTDate::getTimeUnit( -36660 ) );
$this->assertEquals( '-100:11', TTDate::getTimeUnit( -360660 ) );
$this->assertEquals( '-1000:11', TTDate::getTimeUnit( -3600660 ) );
$this->assertEquals( '-10000:11', TTDate::getTimeUnit( -36000660 ) );
$this->assertEquals( '-100000:11', TTDate::getTimeUnit( -360000660 ) );
$this->assertEquals( '-1000000:11', TTDate::getTimeUnit( -3600000660 ) );
//$this->assertEquals( TTDate::getTimeUnit( ( ( PHP_INT_MAX + PHP_INT_MAX ) * -1 ) ), 'ERR(FLOAT)' );
$this->assertEquals( '-5124095576030431:00', TTDate::getTimeUnit( bcmul( bcadd( PHP_INT_MAX, PHP_INT_MAX ), -1 ) ) );
TTDate::setTimeUnitFormat( 12 );
$this->assertEquals( '01:00:00', TTDate::getTimeUnit( 3600 ) );
$this->assertEquals( '01:01:01', TTDate::getTimeUnit( 3661 ) );
$this->assertEquals( '10:01:00', TTDate::getTimeUnit( 36060 ) );
$this->assertEquals( '10:11:00', TTDate::getTimeUnit( 36660 ) );
$this->assertEquals( '100:11:00', TTDate::getTimeUnit( 360660 ) );
$this->assertEquals( '1000:11:00', TTDate::getTimeUnit( 3600660 ) );
$this->assertEquals( '10000:11:00', TTDate::getTimeUnit( 36000660 ) );
$this->assertEquals( '100000:11:00', TTDate::getTimeUnit( 360000660 ) );
$this->assertEquals( '1000000:11:00', TTDate::getTimeUnit( 3600000660 ) );
//$this->assertEquals( TTDate::getTimeUnit( ( PHP_INT_MAX + PHP_INT_MAX ) ), 'ERR(FLOAT)' );
$this->assertEquals( '5124095576030431:00:14', TTDate::getTimeUnit( bcadd( PHP_INT_MAX, PHP_INT_MAX ) ) );
$this->assertEquals( '9223372036854775807:00:49', TTDate::getTimeUnit( bcmul( PHP_INT_MAX, PHP_INT_MAX ) ) );
$this->assertEquals( '9223372036854775807:00:49', TTDate::getTimeUnit( bcadd( bcmul( PHP_INT_MAX, PHP_INT_MAX ), '0.99999' ) ) );
$this->assertEquals( '9223372036854775807:00:49', TTDate::getTimeUnit( bcadd( bcmul( PHP_INT_MAX, PHP_INT_MAX ), '0.00001' ) ) ); // (float)0.00001 gets converted to scientific notation when casted to string, resulting in bcadd() throwing a non-well formed argument error.
TTDate::setTimeUnitFormat( 12 );
$this->assertEquals( '-01:00:00', TTDate::getTimeUnit( -3600 ) );
$this->assertEquals( '-01:01:01', TTDate::getTimeUnit( -3661 ) );
$this->assertEquals( '-10:01:00', TTDate::getTimeUnit( -36060 ) );
$this->assertEquals( '-10:11:00', TTDate::getTimeUnit( -36660 ) );
$this->assertEquals( '-100:11:00', TTDate::getTimeUnit( -360660 ) );
$this->assertEquals( '-1000:11:00', TTDate::getTimeUnit( -3600660 ) );
$this->assertEquals( '-10000:11:00', TTDate::getTimeUnit( -36000660 ) );
$this->assertEquals( '-100000:11:00', TTDate::getTimeUnit( -360000660 ) );
$this->assertEquals( '-1000000:11:00', TTDate::getTimeUnit( -3600000660 ) );
//$this->assertEquals( TTDate::getTimeUnit( ( ( PHP_INT_MAX + PHP_INT_MAX ) * -1 ) ), 'ERR(FLOAT)' );
$this->assertEquals( '-5124095576030431:00:14', TTDate::getTimeUnit( bcmul( bcadd( PHP_INT_MAX, PHP_INT_MAX ), -1 ) ) );
$this->assertEquals( '-9223372036854775807:00:49', TTDate::getTimeUnit( bcmul( bcmul( PHP_INT_MAX, PHP_INT_MAX ), -1 ) ) );
TTDate::setTimeUnitFormat( 23 );
$this->assertEquals( '1.0000', TTDate::getTimeUnit( 3600 ) );
$this->assertEquals( '1.0167', TTDate::getTimeUnit( 3660 ) );
$this->assertEquals( '10.0167', TTDate::getTimeUnit( 36060 ) );
$this->assertEquals( '10.1833', TTDate::getTimeUnit( 36660 ) );
$this->assertEquals( '100.1833', TTDate::getTimeUnit( 360660 ) );
$this->assertEquals( '1,000.1833', TTDate::getTimeUnit( 3600660 ) );
$this->assertEquals( '10,000.1833', TTDate::getTimeUnit( 36000660 ) );
$this->assertEquals( '100,000.1833', TTDate::getTimeUnit( 360000660 ) );
$this->assertEquals( '1,000,000.1833', TTDate::getTimeUnit( 3600000660 ) );
$this->assertEquals( '5,124,095,576,030,431.0000', TTDate::getTimeUnit( ( PHP_INT_MAX + PHP_INT_MAX ) ) ); //This is passing a float that is losing precision.
$this->assertEquals( '5,124,095,576,030,431.0000', TTDate::getTimeUnit( bcadd( PHP_INT_MAX, PHP_INT_MAX ) ) );
$this->assertEquals( '5,124,095,576,030,431.0000', TTDate::getTimeUnit( bcadd( bcadd( PHP_INT_MAX, PHP_INT_MAX ), 660 ) ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( '' ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( '--' ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( 'XYZ' ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( null ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( false ) );
$this->assertEquals( '0.0000', TTDate::getTimeUnit( true ) );
}
function testDate_DMY_1() {
Debug::text( 'Testing Date Format: d-M-y', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'd-M-y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25-Feb-05' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '25-Feb-05 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '25-Feb-05 8:09 AM' ) );
$this->assertEquals( 1109347750, TTDate::parseDateTime( '25-Feb-05 8:09:10 AM' ) );
$this->assertEquals( 1109336950, TTDate::parseDateTime( '25-Feb-05 8:09:10 AM EST' ) );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '25-Feb-05 18:09' ) );
$this->assertEquals( 1109383750, TTDate::parseDateTime( '25-Feb-05 18:09:10' ) );
$this->assertEquals( 1109372950, TTDate::parseDateTime( '25-Feb-05 18:09:10 EST' ) );
//MST7MDT has been deprecated and does not work. Most 3 letter timezones have too.
$this->assertEquals( 1109380150, TTDate::parseDateTime( '25-Feb-05 18:09:10 MST' ) );
$this->assertEquals( 1109380150, TTDate::parseDateTime( '25-Feb-05 18:09:10 America/Edmonton' ) );
//Fails on PHP 5.1.2 due to strtotime()
//TTDate::setDateFormat('d/M/y');
//TTDate::setTimeFormat('g:i A');
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05'), 1109318400 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 8:09PM'), 1109390940 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 8:09 AM'), 1109347740 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 8:09:10 AM'), 1109347750 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 8:09:10 AM EST'), 1109336950 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 18:09'), 1109383740 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 18:09:10'), 1109383750 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/05 18:09:10 EST'), 1109372950 );
TTDate::setDateFormat( 'd-M-Y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25-Feb-2005' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '25-Feb-2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '25-Feb-2005 8:09 AM' ) );
$this->assertEquals( 1109347750, TTDate::parseDateTime( '25-Feb-2005 8:09:10 AM' ) );
$this->assertEquals( 1109336950, TTDate::parseDateTime( '25-Feb-2005 8:09:10 AM EST' ) );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '25-Feb-2005 18:09' ) );
$this->assertEquals( 1109383750, TTDate::parseDateTime( '25-Feb-2005 18:09:10' ) );
$this->assertEquals( 1109372950, TTDate::parseDateTime( '25-Feb-2005 18:09:10 EST' ) );
//Fails on PHP 5.1.2 due to strtotime()
//TTDate::setDateFormat('d/M/Y');
//TTDate::setTimeFormat('g:i A');
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005'), 1109318400 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 8:09PM'), 1109390940 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 8:09 AM'), 1109347740 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 8:09:10 AM'), 1109347750 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 8:09:10 AM EST'), 1109336950 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 18:09'), 1109383740 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 18:09:10'), 1109383750 );
//$this->assertEquals( TTDate::parseDateTime('25/Feb/2005 18:09:10 EST'), 1109372950 );
}
function testDate_DMY_2() {
Debug::text( 'Testing Date Format: dMY', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'dMY' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25Feb2005' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '25Feb2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '25Feb2005 8:09 AM' ) );
$this->assertEquals( 1109347750, TTDate::parseDateTime( '25Feb2005 8:09:10 AM' ) );
$this->assertEquals( 1109336950, TTDate::parseDateTime( '25Feb2005 8:09:10 AM EST' ) );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '25Feb2005 18:09' ) );
$this->assertEquals( 1109383750, TTDate::parseDateTime( '25Feb2005 18:09:10' ) );
$this->assertEquals( 1109372950, TTDate::parseDateTime( '25Feb2005 18:09:10 EST' ) );
}
function testDate_DMY_3() {
Debug::text( 'Testing Date Format: d-m-y', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'd-m-y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25/02/2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25-02-2005' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '25-02-2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '25-02-2005 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '25-02-2005 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '25-02-2005 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '25-02-2005 18:09 EST' ) );
//
// Different separator
//
TTDate::setDateFormat( 'd/m/y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25-02-2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '25/02/2005' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '25/02/2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '25/02/2005 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '25/02/2005 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '25/02/2005 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '25/02/2005 18:09 EST' ) );
}
function testDate_MDY_1() {
Debug::text( 'Testing Date Format: m-d-y', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'm-d-y' );
TTDate::setTimeZone( 'America/Vancouver' ); //Force to non-DST timezone. 'PST' isnt actually valid.
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02-25-2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02/25/2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02-25-05' ) );
$this->assertEquals( 1161932400, TTDate::parseDateTime( '10-27-06' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '02-25-2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '02-25-2005 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '02-25-2005 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '02-25-2005 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '02-25-2005 18:09 EST' ) );
//
// Different separator
//
TTDate::setDateFormat( 'm/d/y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02/25/2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02-25-2005' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '02/25/2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '02/25/2005 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '02/25/2005 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '02/25/2005 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '02/25/2005 18:09 EST' ) );
}
function testDate_MDY_2() {
Debug::text( 'Testing Date Format: M-d-y', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'M-d-y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( 'Feb/25/2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( 'Feb-25-2005' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( 'Feb-25-05' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( 'Feb-25-2005 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( 'Feb-25-2005 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( 'Feb-25-2005 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( 'Feb-25-2005 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( 'Feb-25-2005 18:09 EST' ) );
}
function testDate_MDY_3() {
Debug::text( 'Testing Date Format: m-d-y (two digit year)', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'm-d-y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02/25/05' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '02-25-05' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '02-25-05 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '02-25-05 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '02-25-05 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '02-25-05 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '02-25-05 18:09 EST' ) );
//Try test before 1970, like 1920 - *1920 fails after 2010 has passed, try a different value.
$this->assertEquals( -468604800, TTDate::parseDateTime( '02-25-55' ) );
$this->assertEquals( -468532260, TTDate::parseDateTime( '02-25-55 8:09PM' ) );
$this->assertEquals( -468575460, TTDate::parseDateTime( '02-25-55 8:09 AM' ) );
}
function testDate_YMD_1() {
Debug::text( 'Testing Date Format: Y-m-d', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'Y-m-d' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '2005/02/25' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '2005-02-25' ) );
$this->assertEquals( 1109318400, TTDate::parseDateTime( '05-02-25' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 8:09 AM' ) );
TTDate::setTimeFormat( 'g:i A T' );
$this->assertEquals( 1109336940, TTDate::parseDateTime( '2005-02-25 8:09 AM EST' ) );
TTDate::setTimeFormat( 'G:i' );
$this->assertEquals( 1109383740, TTDate::parseDateTime( '2005-02-25 18:09' ) );
$this->assertEquals( 1109372940, TTDate::parseDateTime( '2005-02-25 18:09 EST' ) );
}
function testTime1() {
Debug::text( 'Testing Date Format: Y-m-d', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'Y-m-d' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09PM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 8:09 AM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 08:09 AM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 08:09 A' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 8:09A' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 8:09A ' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09 P' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09P' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09P ' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 0809 AM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 0809 A' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8:09 PM' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 0809 PM' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 0809 P' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 809 AM' ) );
$this->assertEquals( 1109347740, TTDate::parseDateTime( '2005-02-25 809 A' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 809 PM' ) );
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 809 P' ) );
$this->assertEquals( 1109357100, TTDate::parseDateTime( '2005-02-25 1045 AM' ) );
$this->assertEquals( 1109357100, TTDate::parseDateTime( '2005-02-25 1045 A' ) );
$this->assertEquals( 1109400300, TTDate::parseDateTime( '2005-02-25 1045 PM' ) );
$this->assertEquals( 1109400300, TTDate::parseDateTime( '2005-02-25 1045 P' ) );
$this->assertEquals( 1109357100, TTDate::parseDateTime( '2005-02-25 10:45 A PDT' ) ); //Test with timezone tacked on the end too.
$this->assertEquals( 1109400300, TTDate::parseDateTime( '2005-02-25 10:45 P PDT' ) ); //Test with timezone tacked on the end too.
$this->assertEquals( strtotime( '8:45 AM'), TTDate::parseDateTime( '845 A' ) );
$this->assertEquals( strtotime( '8:45 AM'), TTDate::parseDateTime( '845 AM' ) );
$this->assertEquals( strtotime( '8:45 PM'), TTDate::parseDateTime( '845 P' ) );
$this->assertEquals( strtotime( '8:45 PM'), TTDate::parseDateTime( '845 PM' ) );
$this->assertEquals( strtotime( '8:45 AM'), TTDate::parseDateTime( '0845 A' ) );
$this->assertEquals( strtotime( '8:45 AM'), TTDate::parseDateTime( '0845 AM' ) );
$this->assertEquals( strtotime( '8:45 PM'), TTDate::parseDateTime( '0845 P' ) );
$this->assertEquals( strtotime( '8:45 PM'), TTDate::parseDateTime( '0845 PM' ) );
$this->assertEquals( strtotime( '10:45 AM'), TTDate::parseDateTime( '1045 A' ) );
$this->assertEquals( strtotime( '10:45 AM'), TTDate::parseDateTime( '1045 AM' ) );
$this->assertEquals( strtotime( '10:45 PM'), TTDate::parseDateTime( '1045 P' ) );
$this->assertEquals( strtotime( '10:45 PM'), TTDate::parseDateTime( '1045 PM' ) );
$this->assertEquals( strtotime( '8:00 AM'), TTDate::parseDateTime( '8 A' ) );
$this->assertEquals( strtotime( '8:00 AM'), TTDate::parseDateTime( '8A' ) );
$this->assertEquals( strtotime( '8:00 PM'), TTDate::parseDateTime( '8 P' ) );
$this->assertEquals( strtotime( '8:00 PM'), TTDate::parseDateTime( '8P' ) );
$this->assertEquals( strtotime( '8:00 AM'), TTDate::parseDateTime( '8 a' ) );
$this->assertEquals( strtotime( '8:00 AM'), TTDate::parseDateTime( '8a' ) );
$this->assertEquals( strtotime( '8:00 PM'), TTDate::parseDateTime( '8 p' ) );
$this->assertEquals( strtotime( '8:00 PM'), TTDate::parseDateTime( '8p' ) );
//Obvious typo fixes...
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8;09PM' ) ); //Test with semi-colon, to ensure it gets converted to a colon.
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005-02-25 8?09PM' ) ); //Test with '?', to ensure it gets converted to a colon.
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005=02-25 8;09PM' ) ); //Test with '=' instead of '-'
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005+02-25 8;09PM' ) ); //Test with '+' instead of '-'
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005+02-25 8\'09PM' ) ); //Test with '\'' instead of '-'
$this->assertEquals( 1109390940, TTDate::parseDateTime( '2005+02_25 8"09PM' ) ); //Test with '"' instead of '-'
}
function test_getDayOfNextWeek() {
Debug::text( 'Testing Date Format: Y-m-d', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'Y-m-d' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( TTDate::getDateOfNextDayOfWeek( strtotime( '29-Dec-06' ), strtotime( '27-Dec-06' ) ), strtotime( '03-Jan-07' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfWeek( strtotime( '25-Dec-06' ), strtotime( '28-Dec-06' ) ), strtotime( '28-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfWeek( strtotime( '31-Dec-06' ), strtotime( '25-Dec-06' ) ), strtotime( '01-Jan-07' ) );
}
function test_getDateOfNextDayOfMonth() {
Debug::text( 'Testing Date Format: Y-m-d', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'Y-m-d' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '01-Dec-06' ), strtotime( '02-Dec-06' ) ), strtotime( '02-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06' ), strtotime( '23-Nov-06' ) ), strtotime( '23-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06' ), strtotime( '13-Dec-06' ) ), strtotime( '13-Jan-07' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06' ), strtotime( '14-Dec-06' ) ), strtotime( '14-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06 12:00:00 PM' ), strtotime( '14-Dec-06 12:00:00 PM' ) ), strtotime( '14-Dec-06 12:00:00 AM' ) ); //Always returns beginning of day epoch.
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06 12:00:00 PM' ), strtotime( '14-Dec-06 12:01:00 PM' ) ), strtotime( '14-Dec-06 12:00:00 AM' ) ); //Always returns beginning of day epoch.
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '14-Dec-06 12:01:00 PM' ), strtotime( '14-Dec-06 12:00:00 PM' ) ), strtotime( '14-Dec-06 12:00:00 AM' ) ); //Always returns beginning of day epoch.
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '12-Dec-06' ), strtotime( '01-Dec-04' ) ), strtotime( '01-Jan-07' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '12-Dec-06' ), null, 1 ), strtotime( '01-Jan-07' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '12-Dec-06' ), null, 12 ), strtotime( '12-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '12-Dec-06' ), null, 31 ), strtotime( '31-Dec-06' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '01-Feb-07' ), null, 31 ), strtotime( '28-Feb-07' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '01-Feb-08' ), null, 29 ), strtotime( '29-Feb-08' ) );
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '01-Feb-08' ), null, 31 ), strtotime( '29-Feb-08' ) );
//Anchor Epoch: 09-Apr-04 11:59 PM PDT Day Of Month Epoch: Day Of Month: 24<br>
$this->assertEquals( TTDate::getDateOfNextDayOfMonth( strtotime( '09-Apr-04' ), null, 24 ), strtotime( '24-Apr-04' ) );
}
function test_parseEpoch() {
Debug::text( 'Testing Date Parsing of EPOCH!', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setDateFormat( 'm-d-y' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( TTDate::parseDateTime( 1162670400 ), (int)1162670400 );
TTDate::setDateFormat( 'Y-m-d' );
TTDate::setTimeFormat( 'g:i A' );
$this->assertEquals( TTDate::parseDateTime( 1162670400 ), (int)1162670400 );
$this->assertEquals( 600, TTDate::parseDateTime( 600 ) ); //Test small epochs that may conflict with 24hr time that just has the time and not a date.
$this->assertEquals( 1800, TTDate::parseDateTime( 1800 ) ); //Test small epochs that may conflict with 24hr time that just has the time and not a date.
$this->assertEquals( -600, TTDate::parseDateTime( -600 ) ); //Test small epochs that may conflict with 24hr time that just has the time and not a date.
$this->assertEquals( -1800, TTDate::parseDateTime( -1800 ) ); //Test small epochs that may conflict with 24hr time that just has the time and not a date.
}
function test_roundTime() {
//10 = Down
//20 = Average
//30 = Up
//Test rounding down by 15minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 15 ), 10 ), strtotime( '15-Apr-07 8:00 AM' ) );
//Test rounding down by 5minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 5 ), 10 ), strtotime( '15-Apr-07 8:05 AM' ) );
//Test rounding down by 5minutes when no rounding should occur.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:05 AM' ), ( 60 * 5 ), 10 ), strtotime( '15-Apr-07 8:05 AM' ) );
//Test rounding down by 15minutes with 3minute grace.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 4:58 PM' ), ( 60 * 15 ), 10, ( 60 * 3 ) ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 4:56 PM' ), ( 60 * 15 ), 10, ( 60 * 3 ) ), strtotime( '15-Apr-07 4:45 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:11 PM' ), ( 60 * 15 ), 10, ( 60 * 3 ) ), strtotime( '15-Apr-07 5:00 PM' ) );
//Test rounding down by 5minutes with 2minute grace
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:11 PM' ), ( 60 * 5 ), 10, ( 60 * 2 ) ), strtotime( '15-Apr-07 5:10 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07 PM' ), ( 60 * 5 ), 10, ( 60 * 2 ) ), strtotime( '15-Apr-07 5:05 PM' ) );
//Test rounding avg by 15minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06:59 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:29 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:30 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:59 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:08 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:08:01 AM' ), ( 60 * 15 ), 20 ), strtotime( '15-Apr-07 8:15 AM' ) );
//Test rounding avg by 5minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:05 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:05 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:01 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:05 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:29 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:05 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:30 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:10 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:31 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:10 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:59 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:10 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:08 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:10 AM' ) );
//Test rounding avg by 5minutes when no rounding should occur.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:05 AM' ), ( 60 * 5 ), 20 ), strtotime( '15-Apr-07 8:05 AM' ) );
//Test rounding avg by 1minute -- This is another special case that we have to be exactly proper rounding for.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:00 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:01 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:29 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:30 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:01 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:31 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:01 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:00:59 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:01 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:01:00 AM' ), ( 60 * 1 ), 20 ), strtotime( '15-Apr-07 8:01 AM' ) );
//When doing a 15min average rounding, US law states 7mins and 59 seconds can be rounded down in favor of the employer, and 8mins and 0 seconds must be rounded up. See TTDate::roundTime() for more details.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06:59 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:00 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:29 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:30 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:07:59 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:08 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:08:01 AM' ), ( 60 * 15 ), 27 ), strtotime( '15-Apr-07 8:15 AM' ) );
//When doing a 15min average rounding, US law states 7mins and 59 seconds can be rounded down in favor of the employer, and 8mins and 0 seconds must be rounded up. See TTDate::roundTime() for more details.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:05:01 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:06 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:06:59 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:29 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:30 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:59 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:08 PM' ), ( 60 * 15 ), 25 ), strtotime( '15-Apr-07 5:15 PM' ) );
//When doing a 15min average rounding, US law states 7mins and 59 seconds can be rounded down in favor of the employer, and 8mins and 0 seconds must be rounded up. See TTDate::roundTime() for more details.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:06 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:01 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:29 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:30 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:31 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:07:59 PM' ), ( 60 * 5 ), 25 ), strtotime( '15-Apr-07 5:05 PM' ) );
//Test rounding avg by 1minute -- This is another special case that we have to be exactly proper rounding for.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:00 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:01 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:29 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:30 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:31 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:59 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:01:00 PM' ), ( 60 * 1 ), 27 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:00 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:01 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:29 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:00 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:30 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:31 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:00:59 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:01 PM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 5:01:00 PM' ), ( 60 * 1 ), 25 ), strtotime( '15-Apr-07 5:01 PM' ) );
//Test rounding up by 15minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 15 ), 30 ), strtotime( '15-Apr-07 8:15 AM' ) );
//Test rounding up by 5minutes
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:06 AM' ), ( 60 * 5 ), 30 ), strtotime( '15-Apr-07 8:10 AM' ) );
//Test rounding up by 5minutes when no rounding should occur.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:05 AM' ), ( 60 * 5 ), 30 ), strtotime( '15-Apr-07 8:05 AM' ) );
//Test rounding up by 15minutes with 3minute grace.
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:01 AM' ), ( 60 * 15 ), 30, ( 60 * 3 ) ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:04 AM' ), ( 60 * 15 ), 30, ( 60 * 3 ) ), strtotime( '15-Apr-07 8:15 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:03 AM' ), ( 60 * 15 ), 30, ( 60 * 3 ) ), strtotime( '15-Apr-07 8:00 AM' ) );
//Test rounding up by 5minutes with 2minute grace
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:03 AM' ), ( 60 * 5 ), 30, ( 60 * 2 ) ), strtotime( '15-Apr-07 8:05 AM' ) );
$this->assertEquals( (int)TTDate::roundTime( strtotime( '15-Apr-07 8:01 AM' ), ( 60 * 5 ), 30, ( 60 * 2 ) ), strtotime( '15-Apr-07 8:00 AM' ) );
//Test time units
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '1:05:00' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '1:00' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '1:07:29' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '1:00' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '1:07:30' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '1:15' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '1:07:31' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '1:15' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '1:07:59' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '1:15' ) );
//Test time units with negative values.
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '-1:05:00' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '-1:00' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '-1:07:29' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '-1:00' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '-1:07:30' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '-1:15' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '-1:07:31' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '-1:15' ) );
$this->assertEquals( (int)TTDate::roundTime( TTDate::parseTimeUnit( '-1:07:59' ), ( 60 * 15 ), 20 ), TTDate::parseTimeUnit( '-1:15' ) );
$this->assertEquals( (int)TTDate::roundTime( ( TTDate::parseTimeUnit( '1:05:00' ) * -1 ), ( 60 * 15 ), 20 ), ( TTDate::parseTimeUnit( '1:00' ) * -1 ) );
$this->assertEquals( (int)TTDate::roundTime( ( TTDate::parseTimeUnit( '1:07:29' ) * -1 ), ( 60 * 15 ), 20 ), ( TTDate::parseTimeUnit( '1:00' ) * -1 ) );
$this->assertEquals( (int)TTDate::roundTime( ( TTDate::parseTimeUnit( '1:07:30' ) * -1 ), ( 60 * 15 ), 20 ), ( TTDate::parseTimeUnit( '1:15' ) * -1 ) );
$this->assertEquals( (int)TTDate::roundTime( ( TTDate::parseTimeUnit( '1:07:31' ) * -1 ), ( 60 * 15 ), 20 ), ( TTDate::parseTimeUnit( '1:15' ) * -1 ) );
$this->assertEquals( (int)TTDate::roundTime( ( TTDate::parseTimeUnit( '1:07:59' ) * -1 ), ( 60 * 15 ), 20 ), ( TTDate::parseTimeUnit( '1:15' ) * -1 ) );
$this->assertEquals( TTDate::roundTime( 90.12345, 60, 10 ), (int)60 ); //Make sure partial seconds are stripped off.
$this->assertEquals( TTDate::roundTime( 90.00001, 60, 10 ), (int)60 ); //Make sure partial seconds are stripped off.
$this->assertEquals( TTDate::roundTime( 90.99999, 60, 10 ), (int)60 ); //Make sure partial seconds are stripped off.
//Test rounding with negative grace times.
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 10, 0 ), strtotime( '15-Apr-07 8:00 AM' ) ); //10=Down
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 10, 60 ), strtotime( '15-Apr-07 8:00 AM' ) ); //10=Down
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 10, -60 ), strtotime( '15-Apr-07 7:45 AM' ) ); //10=Down
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 30, 0 ), strtotime( '15-Apr-07 8:00 AM' ) ); //30=Up
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 30, 60 ), strtotime( '15-Apr-07 8:00 AM' ) ); //30=Up
$this->assertEquals( TTDate::roundTime( strtotime( '15-Apr-07 8:00 AM' ), ( 60 * 15 ), 30, -60 ), strtotime( '15-Apr-07 8:15 AM' ) ); //30=Up
}
function test_graceTime() {
$this->assertEquals( (int)TTDate::graceTime( strtotime( '15-Apr-07 7:58 AM' ), ( 60 * 5 ), strtotime( '15-Apr-07 8:00 AM' ) ), strtotime( '15-Apr-07 8:00 AM' ) );
$this->assertEquals( (int)TTDate::graceTime( strtotime( '15-Apr-07 7:58:23 AM' ), ( 60 * 5 ), strtotime( '15-Apr-07 8:00 AM' ) ), strtotime( '15-Apr-07 8:00 AM' ) );
}
function test_calculateTimeOnEachDayBetweenRange() {
$test1_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 8:00AM' ), strtotime( '01-Jan-09 11:30PM' ) );
$this->assertCount( 1, $test1_result );
$this->assertEquals( 55800, $test1_result[1230796800] );
$test2_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 4:00PM' ), strtotime( '02-Jan-09 8:00AM' ) );
$this->assertCount( 2, $test2_result );
$this->assertEquals( 28800, $test2_result[1230796800] );
$this->assertEquals( 28800, $test2_result[1230883200] );
$test3_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 4:00PM' ), strtotime( '03-Jan-09 8:00AM' ) );
$this->assertCount( 3, $test3_result );
$this->assertEquals( 28800, $test3_result[1230796800] );
$this->assertEquals( 86400, $test3_result[1230883200] );
$this->assertEquals( 28800, $test3_result[1230969600] );
$test4_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 4:00PM' ), strtotime( '9-Jan-09 8:00AM' ) );
$this->assertCount( 9, $test4_result );
$this->assertEquals( 28800, $test4_result[1230796800] );
$this->assertEquals( 86400, $test4_result[1230883200] );
$this->assertEquals( 86400, $test4_result[1230969600] );
$this->assertEquals( 86400, $test4_result[1231056000] );
$this->assertEquals( 86400, $test4_result[1231142400] );
$this->assertEquals( 86400, $test4_result[1231228800] );
$this->assertEquals( 86400, $test4_result[1231315200] );
$this->assertEquals( 86400, $test4_result[1231401600] );
$this->assertEquals( 28800, $test4_result[1231488000] );
$test5_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 12:00AM' ), strtotime( '01-Jan-09 12:59:59PM' ) );
$this->assertCount( 1, $test5_result );
$this->assertEquals( 46799, $test5_result[1230796800] );
$test5_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 12:00AM' ), strtotime( '02-Jan-09 12:00AM' ) );
$this->assertCount( 1, $test5_result );
$this->assertEquals( 86400, $test5_result[1230796800] );
$test5_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 12:01AM' ), strtotime( '02-Jan-09 12:01AM' ) );
$this->assertCount( 2, $test5_result );
$this->assertEquals( 86340, $test5_result[1230796800] );
$this->assertEquals( 60, $test5_result[1230883200] );
$test5_result = TTDate::calculateTimeOnEachDayBetweenRange( strtotime( '01-Jan-09 1:53PM' ), strtotime( '03-Jan-09 6:12AM' ) );
$this->assertCount( 3, $test5_result );
$this->assertEquals( 36420, $test5_result[1230796800] );
$this->assertEquals( 86400, $test5_result[1230883200] );
$this->assertEquals( 22320, $test5_result[1230969600] );
}
function test_calculateFiscalYearFromEpoch() {
/*
For example, the United States government fiscal year for 2016 is:
1st quarter: 1 October 2015 – 31 December 2015
2nd quarter: 1 January 2016 – 31 March 2016
3rd quarter: 1 April 2016 – 30 June 2016
4th quarter: 1 July 2016 – 30 September 2016
*/
$this->assertEquals( 2015, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2015 12:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '01-Oct-2015 12:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '01-Jan-2016 8:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '29-Sep-2016 12:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2016 12:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2016 11:59:59PM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '01-Oct-2016 12:00AM' ), 'US' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2016 12:00AM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '01-Oct-2016 12:00AM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '01-Jan-2017 8:00AM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '29-Sep-2017 12:00AM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2017 12:00AM' ), 'US' ) );
$this->assertEquals( 2017, TTDate::getFiscalYearFromEpoch( strtotime( '30-Sep-2017 11:59:59PM' ), 'US' ) );
$this->assertEquals( 2018, TTDate::getFiscalYearFromEpoch( strtotime( '01-Oct-2017 12:00AM' ), 'US' ) );
/*
In Canada,[9] the government's financial year runs from 1 April to 31 March (Example 1 April 2015 to 31 March 2016 for the current financial year).
*/
$this->assertEquals( 2014, TTDate::getFiscalYearFromEpoch( strtotime( '31-Mar-2015 12:00AM' ), 'CA' ) );
$this->assertEquals( 2015, TTDate::getFiscalYearFromEpoch( strtotime( '01-Apr-2015 12:00AM' ), 'CA' ) );
$this->assertEquals( 2015, TTDate::getFiscalYearFromEpoch( strtotime( '31-Dec-2015 8:00AM' ), 'CA' ) );
$this->assertEquals( 2015, TTDate::getFiscalYearFromEpoch( strtotime( '31-Mar-2016 11:59AM' ), 'CA' ) );
$this->assertEquals( 2016, TTDate::getFiscalYearFromEpoch( strtotime( '01-Apr-2016 12:00AM' ), 'CA' ) );
}
function test_getWeek() {
//Match up with PHP's function
$date1 = strtotime( '01-Nov-09 12:00PM' );
$this->assertEquals( 44, date( 'W', $date1 ) );
$this->assertEquals( 44, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '02-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '03-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '04-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '07-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '08-Nov-09 12:00PM' );
$this->assertEquals( 45, date( 'W', $date1 ) );
$this->assertEquals( 45, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '09-Nov-09 12:00PM' );
$this->assertEquals( 46, date( 'W', $date1 ) );
$this->assertEquals( 46, TTDate::getWeek( $date1, 1 ) );
//Test with Sunday as start day of week.
$date1 = strtotime( '01-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '02-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '03-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '04-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '07-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '08-Nov-09 12:00PM' );
$this->assertEquals( 46, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '09-Nov-09 12:00PM' );
$this->assertEquals( 46, TTDate::getWeek( $date1, 0 ) );
//Test with Tuesday as start day of week.
$date1 = strtotime( '01-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '02-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '03-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '04-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '07-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '08-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '09-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '10-Nov-09 12:00PM' );
$this->assertEquals( 46, TTDate::getWeek( $date1, 2 ) );
$date1 = strtotime( '11-Nov-09 12:00PM' );
$this->assertEquals( 46, TTDate::getWeek( $date1, 2 ) );
//Test with Wed as start day of week.
$date1 = strtotime( '03-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 3 ) );
$date1 = strtotime( '04-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 3 ) );
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 3 ) );
//Test with Thu as start day of week.
$date1 = strtotime( '04-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 4 ) );
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 4 ) );
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 4 ) );
//Test with Fri as start day of week.
$date1 = strtotime( '05-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 5 ) );
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 5 ) );
$date1 = strtotime( '07-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 5 ) );
//Test with Sat as start day of week.
$date1 = strtotime( '06-Nov-09 12:00PM' );
$this->assertEquals( 44, TTDate::getWeek( $date1, 6 ) );
$date1 = strtotime( '07-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 6 ) );
$date1 = strtotime( '08-Nov-09 12:00PM' );
$this->assertEquals( 45, TTDate::getWeek( $date1, 6 ) );
//Test with different years
$date1 = strtotime( '31-Dec-09 12:00PM' );
$this->assertEquals( 53, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '01-Jan-10 12:00PM' );
$this->assertEquals( 53, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '04-Jan-10 12:00PM' );
$this->assertEquals( 1, TTDate::getWeek( $date1, 1 ) );
$date1 = strtotime( '03-Jan-10 12:00PM' );
$this->assertEquals( 1, TTDate::getWeek( $date1, 0 ) );
$date1 = strtotime( '09-Jan-10 12:00PM' );
$this->assertEquals( 1, TTDate::getWeek( $date1, 6 ) );
//Start on Monday as thats what PHP uses.
for ( $i = strtotime( '07-Jan-13' ); $i < strtotime( '06-Jan-13' ); $i += ( 86400 * 7 ) ) {
$this->assertEquals( TTDate::getWeek( $i, 1 ), date( 'W', $i ) );
}
//Start on Sunday.
$this->assertEquals( 52, TTDate::getWeek( strtotime( '29-Dec-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '30-Dec-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '31-Dec-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '01-Jan-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '02-Jan-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '03-Jan-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '04-Jan-12' ), 0 ) );
$this->assertEquals( 1, TTDate::getWeek( strtotime( '05-Jan-12' ), 0 ) );
$this->assertEquals( 2, TTDate::getWeek( strtotime( '06-Jan-13' ), 0 ) );
$this->assertEquals( 15, TTDate::getWeek( strtotime( '09-Apr-13' ), 0 ) );
$this->assertEquals( 26, TTDate::getWeek( strtotime( '28-Jun-13' ), 0 ) );
//Start on every other day of the week
$this->assertEquals( 25, TTDate::getWeek( strtotime( '28-Jun-13' ), 6 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '27-Jun-13' ), 5 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '26-Jun-13' ), 4 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '25-Jun-13' ), 3 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '24-Jun-13' ), 2 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '23-Jun-13' ), 1 ) );
$this->assertEquals( 25, TTDate::getWeek( strtotime( '22-Jun-13' ), 0 ) );
}
function test_getNearestWeekDay() {
$date1 = strtotime( '16-Jan-2010 12:00PM' ); //Sat
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 0 ), strtotime( '16-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 1 ), strtotime( '15-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 2 ), strtotime( '18-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 3 ), strtotime( '15-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 10 ), strtotime( '16-Jan-2010 12:00PM' ) ); //Split Sat=Sat, Sun=Mon
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 20 ), strtotime( '15-Jan-2010 12:00PM' ) ); //Split Sat=Fri, Sun=Sun
$date2 = strtotime( '17-Jan-2010 12:00PM' ); //Sun
$this->assertEquals( TTDate::getNearestWeekDay( $date2, 3 ), strtotime( '18-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date2, 10 ), strtotime( '18-Jan-2010 12:00PM' ) ); //Split Sat=Sat, Sun=Mon
$this->assertEquals( TTDate::getNearestWeekDay( $date2, 20 ), strtotime( '17-Jan-2010 12:00PM' ) ); //Split Sat=Fri, Sun=Sun
$holidays = [
TTDate::getBeginDayEpoch( strtotime( '15-Jan-2010' ) ),
];
$date1 = strtotime( '16-Jan-2010 12:00PM' );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 3, $holidays ), strtotime( '14-Jan-2010 12:00PM' ) );
$holidays = [
TTDate::getBeginDayEpoch( strtotime( '15-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '14-Jan-2010' ) ),
];
$date1 = strtotime( '16-Jan-2010 12:00PM' );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 1, $holidays ), strtotime( '13-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 3, $holidays ), strtotime( '18-Jan-2010 12:00PM' ) );
$holidays = [
TTDate::getBeginDayEpoch( strtotime( '15-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '14-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '18-Jan-2010' ) ),
];
$date1 = strtotime( '16-Jan-2010 12:00PM' );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 1, $holidays ), strtotime( '13-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 3, $holidays ), strtotime( '13-Jan-2010 12:00PM' ) );
$holidays = [
TTDate::getBeginDayEpoch( strtotime( '15-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '14-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '13-Jan-2010' ) ),
TTDate::getBeginDayEpoch( strtotime( '18-Jan-2010' ) ),
];
$date1 = strtotime( '16-Jan-2010 12:00PM' );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 1, $holidays ), strtotime( '12-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( $date1, 3, $holidays ), strtotime( '19-Jan-2010 12:00PM' ) );
//Make sure we don't get into any infinite loops if a non-epoch value is passed in.
$this->assertEquals( TTDate::getNearestWeekDay( false, 0 ), false );
$this->assertEquals( TTDate::getNearestWeekDay( true, 0 ), true );
$this->assertEquals( TTDate::getNearestWeekDay( null, 0 ), null );
$this->assertEquals( TTDate::getNearestWeekDay( '', 0 ), '' );
$this->assertEquals( TTDate::getNearestWeekDay( 0, 0 ), 0 );
$this->assertEquals( TTDate::getNearestWeekDay( false, 3 ), false );
$this->assertEquals( TTDate::getNearestWeekDay( true, 3 ), true );
$this->assertEquals( TTDate::getNearestWeekDay( null, 3 ), null );
$this->assertEquals( TTDate::getNearestWeekDay( '', 3 ), '' );
//Test mixing getBeginDayEpoch() and getMiddleDayEpoch()
$this->assertEquals( TTDate::getNearestWeekDay( strtotime( '16-Jan-2010 12:00PM' ), 3, [ TTDate::getBeginDayEpoch( strtotime( '15-Jan-2010' ) ) ] ), strtotime( '14-Jan-2010 12:00PM' ) );
$this->assertEquals( TTDate::getNearestWeekDay( strtotime( '16-Jan-2010 12:00AM' ), 3, [ TTDate::getMiddleDayEpoch( strtotime( '15-Jan-2010' ) ) ] ), strtotime( '14-Jan-2010 12:00AM' ) );
}
function test_timePeriodDates() {
Debug::text( 'Testing Time Period Dates!', __FILE__, __LINE__, __METHOD__, 10 );
TTDate::setTimeZone( 'America/Vancouver' );
$dates = TTDate::getTimePeriodDates( 'custom_date', strtotime( '15-Jul-10 12:00 PM' ), null, [ 'start_date' => strtotime( '10-Jul-10 12:43 PM' ), 'end_date' => strtotime( '12-Jul-10 12:43 PM' ) ] );
$this->assertEquals( $dates['start_date'], (int)1278745200 );
$this->assertEquals( $dates['end_date'], (int)1279004399 );
$dates = TTDate::getTimePeriodDates( 'custom_time', strtotime( '15-Jul-10 12:00 PM' ), null, [ 'start_date' => strtotime( '10-Jul-10 12:43 PM' ), 'end_date' => strtotime( '12-Jul-10 12:53 PM' ) ] );
$this->assertEquals( $dates['start_date'], (int)1278790980 );
$this->assertEquals( $dates['end_date'], (int)1278964380 );
$dates = TTDate::getTimePeriodDates( 'today', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1279177200 );
$this->assertEquals( $dates['end_date'], (int)1279263599 );
$dates = TTDate::getTimePeriodDates( 'yesterday', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1279090800 );
$this->assertEquals( $dates['end_date'], (int)1279177199 );
$dates = TTDate::getTimePeriodDates( 'last_24_hours', strtotime( '15-Jul-10 12:43 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1279136580 );
$this->assertEquals( $dates['end_date'], (int)1279222980 );
$dates = TTDate::getTimePeriodDates( 'this_week', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1278831600 );
$this->assertEquals( $dates['end_date'], (int)1279436399 );
$dates = TTDate::getTimePeriodDates( 'last_week', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1278226800 );
$this->assertEquals( $dates['end_date'], (int)1278831599 );
$dates = TTDate::getTimePeriodDates( 'last_7_days', strtotime( '15-Jul-10 12:43 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1278572400 );
$this->assertEquals( $dates['end_date'], (int)1279177199 );
$dates = TTDate::getTimePeriodDates( 'this_month', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1277967600 );
$this->assertEquals( $dates['end_date'], (int)1280645999 );
$dates = TTDate::getTimePeriodDates( 'last_month', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1275375600 );
$this->assertEquals( $dates['end_date'], (int)1277967599 );
$dates = TTDate::getTimePeriodDates( 'last_month', strtotime( '15-Mar-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1265011200 );
$this->assertEquals( $dates['end_date'], (int)1267430399 );
$dates = TTDate::getTimePeriodDates( 'last_30_days', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1276585200 );
$this->assertEquals( $dates['end_date'], (int)1279177199 );
$dates = TTDate::getTimePeriodDates( 'this_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1277967600 );
$this->assertEquals( $dates['end_date'], (int)1285916399 );
$dates = TTDate::getTimePeriodDates( 'last_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1270105200 );
$this->assertEquals( $dates['end_date'], (int)1277967599 );
$dates = TTDate::getTimePeriodDates( 'last_90_days', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1271401200 );
$this->assertEquals( $dates['end_date'], (int)1279177199 );
$dates = TTDate::getTimePeriodDates( 'this_year_1st_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1262332800 );
$this->assertEquals( $dates['end_date'], (int)1270105199 );
$dates = TTDate::getTimePeriodDates( 'this_year_2nd_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1270105200 );
$this->assertEquals( $dates['end_date'], (int)1277967599 );
$dates = TTDate::getTimePeriodDates( 'this_year_3rd_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1277967600 );
$this->assertEquals( $dates['end_date'], (int)1285916399 );
$dates = TTDate::getTimePeriodDates( 'this_year_4th_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1285916400 );
$this->assertEquals( $dates['end_date'], (int)1293868799 );
$dates = TTDate::getTimePeriodDates( 'last_year_1st_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1230796800 );
$this->assertEquals( $dates['end_date'], (int)1238569199 );
$dates = TTDate::getTimePeriodDates( 'last_year_2nd_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1238569200 );
$this->assertEquals( $dates['end_date'], (int)1246431599 );
$dates = TTDate::getTimePeriodDates( 'last_year_3rd_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1246431600 );
$this->assertEquals( $dates['end_date'], (int)1254380399 );
$dates = TTDate::getTimePeriodDates( 'last_year_4th_quarter', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1254380400 );
$this->assertEquals( $dates['end_date'], (int)1262332799 );
$dates = TTDate::getTimePeriodDates( 'last_3_months', strtotime( '15-May-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1266134400 );
$this->assertEquals( $dates['end_date'], (int)1273906799 );
$dates = TTDate::getTimePeriodDates( 'last_6_months', strtotime( '15-May-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1258185600 );
$this->assertEquals( $dates['end_date'], (int)1273906799 );
$dates = TTDate::getTimePeriodDates( 'last_9_months', strtotime( '15-May-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1250233200 );
$this->assertEquals( $dates['end_date'], (int)1273906799 );
$dates = TTDate::getTimePeriodDates( 'last_12_months', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1247554800 );
$this->assertEquals( $dates['end_date'], (int)1279177199 );
$dates = TTDate::getTimePeriodDates( 'this_year', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1262332800 );
$this->assertEquals( $dates['end_date'], (int)1293868799 );
$dates = TTDate::getTimePeriodDates( 'last_year', strtotime( '15-Jul-10 12:00 PM' ) );
$this->assertEquals( $dates['start_date'], (int)1230796800 );
$this->assertEquals( $dates['end_date'], (int)1262332799 );
}
function test_getEndWeekEpoch() {
TTDate::setTimeZone( 'America/Vancouver' ); //Force to timezone with DST.
$this->assertEquals( strtotime( '11-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '11-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '12-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '13-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '14-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '15-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '16-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '17-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '18-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '18-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '25-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '19-May-2019 12:00AM' ), 0 ) ); //Week starts on Sunday
$this->assertEquals( strtotime( '12-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '12-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '13-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '14-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '15-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '16-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '17-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '18-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '19-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '19-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '26-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '20-May-2019 12:00AM' ), 1 ) ); //Week starts on Monday
$this->assertEquals( strtotime( '13-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '13-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '14-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '15-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '16-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '17-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '18-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '19-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '20-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '20-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '27-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '21-May-2019 12:00AM' ), 2 ) ); //Week starts on Tuesday
$this->assertEquals( strtotime( '14-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '14-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '15-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '16-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '17-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '18-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '19-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '20-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '21-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '21-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '28-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '22-May-2019 12:00AM' ), 3 ) ); //Week starts on Wednesday
$this->assertEquals( strtotime( '17-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '17-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '18-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '19-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '20-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '21-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '22-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '23-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '24-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '24-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
$this->assertEquals( strtotime( '31-May-2019 11:59:59PM' ), TTDate::getEndWeekEpoch( strtotime( '25-May-2019 12:00AM' ), 6 ) ); //Week starts on Saturday
}
function test_getYearQuarters() {
$quarters = TTDate::getYearQuarters( strtotime( '01-Jan-2019' ) );
$this->assertCount( 4, $quarters );
$this->assertEquals( strtotime( '01-Jan-2019 12:00AM' ), $quarters[1]['start'] );
$this->assertEquals( strtotime( '31-Mar-2019 11:59:59PM' ), $quarters[1]['end'] );
$this->assertEquals( strtotime( '01-Apr-2019 12:00AM' ), $quarters[2]['start'] );
$this->assertEquals( strtotime( '30-Jun-2019 11:59:59PM' ), $quarters[2]['end'] );
$this->assertEquals( strtotime( '01-Jul-2019 12:00AM' ), $quarters[3]['start'] );
$this->assertEquals( strtotime( '30-Sep-2019 11:59:59PM' ), $quarters[3]['end'] );
$this->assertEquals( strtotime( '01-Oct-2019 12:00AM' ), $quarters[4]['start'] );
$this->assertEquals( strtotime( '31-Dec-2019 11:59:59PM' ), $quarters[4]['end'] );
$quarters = TTDate::getYearQuarters( strtotime( '01-Jan-2019' ), 1 );
$this->assertCount( 2, $quarters );
$this->assertEquals( strtotime( '01-Jan-2019 12:00AM' ), $quarters['start'] );
$this->assertEquals( strtotime( '31-Mar-2019 11:59:59PM' ), $quarters['end'] );
$quarters = TTDate::getYearQuarters( strtotime( '01-Jan-2019' ), 2 );
$this->assertCount( 2, $quarters );
$this->assertEquals( strtotime( '01-Apr-2019 12:00AM' ), $quarters['start'] );
$this->assertEquals( strtotime( '30-Jun-2019 11:59:59PM' ), $quarters['end'] );
}
function test_DST() {
TTDate::setTimeZone( 'America/Vancouver' ); //Force to timezone with DST.
$this->assertEquals( false, TTDate::doesRangeSpanDST( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 1:59AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 2:00AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 2:01AM' ) ) );
$this->assertEquals( false, TTDate::doesRangeSpanDST( strtotime( '04-Nov-12 12:30AM' ), strtotime( '04-Nov-12 1:59AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '04-Nov-12 12:30AM' ), strtotime( '04-Nov-12 2:00AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '04-Nov-12 1:00AM' ), strtotime( '04-Nov-12 6:30AM' ) ) );
$this->assertEquals( false, TTDate::doesRangeSpanDST( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 1:59AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 2:00AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 2:01AM' ) ) );
$this->assertEquals( false, TTDate::doesRangeSpanDST( strtotime( '10-Mar-13 12:30AM' ), strtotime( '10-Mar-13 1:59AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '10-Mar-13 12:30AM' ), strtotime( '10-Mar-13 2:00AM' ) ) );
$this->assertEquals( true, TTDate::doesRangeSpanDST( strtotime( '10-Mar-13 1:30AM' ), strtotime( '10-Mar-13 6:30AM' ) ) );
$this->assertEquals( 0, TTDate::getDSTOffset( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 1:59AM' ) ) );
$this->assertEquals( -3600, TTDate::getDSTOffset( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 2:00AM' ) ) );
$this->assertEquals( -3600, TTDate::getDSTOffset( strtotime( '03-Nov-12 10:00PM' ), strtotime( '04-Nov-12 2:01AM' ) ) );
$this->assertEquals( 0, TTDate::getDSTOffset( strtotime( '04-Nov-12 12:30AM' ), strtotime( '04-Nov-12 1:59AM' ) ) );
$this->assertEquals( -3600, TTDate::getDSTOffset( strtotime( '04-Nov-12 12:30AM' ), strtotime( '04-Nov-12 2:00AM' ) ) );
$this->assertEquals( -3600, TTDate::getDSTOffset( strtotime( '04-Nov-12 1:00AM' ), strtotime( '04-Nov-12 6:30AM' ) ) );
$this->assertEquals( 0, TTDate::getDSTOffset( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 1:59AM' ) ) );
$this->assertEquals( 3600, TTDate::getDSTOffset( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 2:00AM' ) ) );
$this->assertEquals( 3600, TTDate::getDSTOffset( strtotime( '09-Mar-13 10:00PM' ), strtotime( '10-Mar-13 2:01AM' ) ) );
$this->assertEquals( 0, TTDate::getDSTOffset( strtotime( '10-Mar-13 12:30AM' ), strtotime( '10-Mar-13 1:59AM' ) ) );
$this->assertEquals( 3600, TTDate::getDSTOffset( strtotime( '10-Mar-13 12:30AM' ), strtotime( '10-Mar-13 2:00AM' ) ) );
$this->assertEquals( 3600, TTDate::getDSTOffset( strtotime( '10-Mar-13 1:30AM' ), strtotime( '10-Mar-13 6:30AM' ) ) );
//This is a quirk with PHP assuming that PST/PDT both mean PST8PDT, and since 05-Nov-2016 is the day DST changed, it adds an hour and uses PDT timezone instead.
// Not really testing anything useful here, other than confirming this quirk exists.
$this->assertEquals( '04-Nov-16 6:00 PM PDT', TTDate::getDate( 'DATE+TIME', strtotime( '04-Nov-2016 6:00PM PDT' ) ) );
$this->assertEquals( '04-Nov-16 7:00 PM PDT', TTDate::getDate( 'DATE+TIME', strtotime( '04-Nov-2016 6:00PM PST' ) ) );
$this->assertEquals( '05-Nov-16 7:00 AM PDT', TTDate::getDate( 'DATE+TIME', strtotime( '05-Nov-2016 6:00AM PST' ) ) );
$this->assertEquals( '06-Nov-16 6:00 AM PST', TTDate::getDate( 'DATE+TIME', strtotime( '06-Nov-2016 6:00AM PST' ) ) );
$this->assertEquals( '06-Nov-16 5:00 AM PST', TTDate::getDate( 'DATE+TIME', strtotime( '06-Nov-2016 6:00AM PDT' ) ) );
}
function test_inApplyFrequencyWindow() {
//Annually
$frequency_criteria = [
'month' => 1,
'day_of_month' => 2,
'day_of_week' => 0,
//'quarter' => 0,
'quarter_month' => 0,
'date' => 0,
];
//No range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 20, strtotime( '01-Jan-2010' ), strtotime( '01-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, strtotime( '02-Jan-2010' ), strtotime( '02-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 20, strtotime( '03-Jan-2010' ), strtotime( '03-Jan-2010' ), $frequency_criteria ) );
//Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, strtotime( '01-Jan-2010' ), strtotime( '03-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, strtotime( '02-Jan-2010 12:00PM' ), strtotime( '02-Jan-2010 12:00PM' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, strtotime( '02-Jan-2010 12:00AM' ), strtotime( '02-Jan-2010 11:59PM' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '01-Jan-2010' ), -7, 'day' ), strtotime( '01-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '02-Jan-2010' ), -7, 'day' ), strtotime( '02-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '03-Jan-2010' ), -7, 'day' ), strtotime( '03-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '04-Jan-2010' ), -7, 'day' ), strtotime( '04-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '05-Jan-2010' ), -7, 'day' ), strtotime( '05-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '06-Jan-2010' ), -7, 'day' ), strtotime( '06-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '07-Jan-2010' ), -7, 'day' ), strtotime( '07-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '08-Jan-2010' ), -7, 'day' ), strtotime( '08-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '09-Jan-2010' ), -7, 'day' ), strtotime( '09-Jan-2010' ), $frequency_criteria ) ); //Range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 20, TTDate::incrementDate( strtotime( '10-Jan-2010' ), -7, 'day' ), strtotime( '10-Jan-2010' ), $frequency_criteria ) ); //Range
//Quarterly
$frequency_criteria = [
'month' => 0,
'day_of_month' => 15,
'day_of_week' => 0,
//'quarter' => 3,
'quarter_month' => 2,
'date' => 0,
];
//No range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Feb-2010' ), strtotime( '14-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '15-Feb-2010' ), strtotime( '15-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-Feb-2010' ), strtotime( '16-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-May-2010' ), strtotime( '14-May-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '15-May-2010' ), strtotime( '15-May-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-May-2010' ), strtotime( '16-May-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Aug-2010' ), strtotime( '14-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '15-Aug-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-Aug-2010' ), strtotime( '16-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Nov-2010' ), strtotime( '14-Nov-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '15-Nov-2010' ), strtotime( '15-Nov-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-Nov-2010' ), strtotime( '16-Nov-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Jan-2010' ), strtotime( '14-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Mar-2010' ), strtotime( '14-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Apr-2010' ), strtotime( '14-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Jun-2010' ), strtotime( '14-Jun-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Jul-2010' ), strtotime( '14-Jul-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Sep-2010' ), strtotime( '14-Sep-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Oct-2010' ), strtotime( '14-Oct-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '14-Dec-2010' ), strtotime( '14-Dec-2010' ), $frequency_criteria ) );
//Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-Aug-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '15-Aug-2010' ), strtotime( '20-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-Aug-2010' ), strtotime( '20-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-Jul-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-Jun-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-May-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-Apr-2010' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '01-Apr-2009' ), strtotime( '15-Aug-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '16-Aug-2009' ), strtotime( '14-Dec-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 25, strtotime( '19-Aug-2009' ), strtotime( '14-Nov-2009' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '19-Aug-2009' ), strtotime( '15-Nov-2009' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 25, strtotime( '19-Aug-2009' ), strtotime( '15-Nov-2010' ), $frequency_criteria ) );
//Monthly
$frequency_criteria = [
'month' => 2,
'day_of_month' => 31,
'day_of_week' => 0,
//'quarter' => 0,
'quarter_month' => 0,
'date' => 0,
];
//No range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '27-Feb-2010' ), strtotime( '27-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '28-Feb-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '01-Mar-2010' ), strtotime( '01-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '27-Feb-2011' ), strtotime( '27-Feb-2011' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '28-Feb-2011' ), strtotime( '28-Feb-2011' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '01-Mar-2011' ), strtotime( '01-Mar-2011' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '28-Feb-2012' ), strtotime( '28-Feb-2012' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '29-Feb-2012' ), strtotime( '29-Feb-2012' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '01-Mar-2012' ), strtotime( '01-Mar-2012' ), $frequency_criteria ) );
//Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '28-Feb-2010' ), strtotime( '05-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '22-Feb-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '29-Jan-2010' ), strtotime( '12-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '30-Jan-2010' ), strtotime( '12-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '31-Jan-2010' ), strtotime( '12-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 30, strtotime( '01-Feb-2010' ), strtotime( '12-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '30-Jan-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 30, strtotime( '01-Feb-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
//Semi-Monthly
$frequency_criteria = [
'day_of_month1' => 10,
'day_of_month2' => 31,
'date' => 0,
];
//No range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '10-Feb-2010' ), strtotime( '10-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '10-Mar-2010' ), strtotime( '10-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '27-Feb-2010' ), strtotime( '27-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '28-Feb-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '01-Mar-2010' ), strtotime( '01-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '27-Feb-2011' ), strtotime( '27-Feb-2011' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '28-Feb-2011' ), strtotime( '28-Feb-2011' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '01-Mar-2011' ), strtotime( '01-Mar-2011' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '28-Feb-2012' ), strtotime( '28-Feb-2012' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '29-Feb-2012' ), strtotime( '29-Feb-2012' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '01-Mar-2012' ), strtotime( '01-Mar-2012' ), $frequency_criteria ) );
//Range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '01-Feb-2010' ), strtotime( '10-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 35, strtotime( '11-Feb-2010' ), strtotime( '27-Feb-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '28-Feb-2010' ), strtotime( '05-Mar-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 35, strtotime( '22-Feb-2010' ), strtotime( '28-Feb-2010' ), $frequency_criteria ) );
//Weekly
$frequency_criteria = [
'month' => 0,
'day_of_month' => 0,
'day_of_week' => 2, //Tuesday
//'quarter' => 0,
'quarter_month' => 0,
'date' => 0,
];
//No range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 40, strtotime( '12-Apr-2010' ), strtotime( '12-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '13-Apr-2010' ), strtotime( '13-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 40, strtotime( '14-Apr-2010' ), strtotime( '14-Apr-2010' ), $frequency_criteria ) );
//Range
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 40, strtotime( '07-Apr-2010' ), strtotime( '12-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 40, strtotime( '14-Apr-2010' ), strtotime( '19-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '11-Apr-2010' ), strtotime( '17-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '12-Apr-2010' ), strtotime( '18-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '13-Apr-2010' ), strtotime( '19-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '14-Apr-2010' ), strtotime( '20-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '12-Apr-2010' ), strtotime( '17-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '13-Apr-2010' ), strtotime( '17-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 40, strtotime( '14-Apr-2010' ), strtotime( '17-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '11-Apr-2010' ), strtotime( '18-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '11-Apr-2010' ), strtotime( '19-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '11-Apr-2010' ), strtotime( '24-Apr-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 40, strtotime( '11-Apr-2010' ), strtotime( '25-Apr-2010' ), $frequency_criteria ) );
//Specific date
$frequency_criteria = [
'month' => 0,
'day_of_month' => 0,
'day_of_week' => 0,
//'quarter' => 0,
'quarter_month' => 0,
'date' => strtotime( '01-Jan-2010' ),
];
//No range
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 100, strtotime( '01-Jan-2010' ), strtotime( '01-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 100, strtotime( '31-Dec-2009' ), strtotime( '01-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 100, strtotime( '01-Jan-2010' ), strtotime( '02-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 100, strtotime( '30-Dec-2009' ), strtotime( '31-Dec-2009' ), $frequency_criteria ) );
$this->assertEquals( false, TTDate::inApplyFrequencyWindow( 100, strtotime( '02-Jan-2010' ), strtotime( '03-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 100, strtotime( '01-Jan-2009' ), strtotime( '01-Jan-2010' ), $frequency_criteria ) );
$this->assertEquals( true, TTDate::inApplyFrequencyWindow( 100, strtotime( '01-Jan-2009' ), strtotime( '01-Jan-2011' ), $frequency_criteria ) );
}
//Compare pure PHP implementation of EasterDays to PHP calendar extension.
function test_EasterDays() {
if ( function_exists( 'easter_days' ) ) {
for ( $i = 2000; $i < 2050; $i++ ) {
$this->assertEquals( easter_days( $i ), TTDate::getEasterDays( $i ) );
}
}
}
function testTimeZones() {
$upf = new UserPreferenceFactory();
$zones = $upf->getOptions( 'time_zone' );
foreach ( $zones as $zone => $name ) {
$retval = TTDate::setTimeZone( Misc::trimSortPrefix( $zone ), true, true );
$this->assertEquals( true, $retval, 'Failed TZ: ' . $name );
}
}
function testDeprecatedTimeZones() {
$upf = new UserPreferenceFactory();
$countries = ['CA', 'US', ''];
foreach( $countries as $country ) {
$zones = $upf->getOptions( 'deprecated_timezone', [ 'country' => $country ] );
//Make sure all
foreach ( $zones as $deprecated_zone => $new_zone ) {
if ( strpos( $deprecated_zone, 'AST4ADT' ) !== false || strpos( $deprecated_zone, 'YST9YDT' ) !== false || strpos( $deprecated_zone, 'Canada/East-Saskatchewan' ) !== false || strpos( $deprecated_zone, 'CST5CDT' ) !== false || strpos( $deprecated_zone, 'US/Pacific-New' ) !== false) {
continue;
}
$deprecated_zone_retval = TTDate::setTimeZone( Misc::trimSortPrefix( $deprecated_zone ), true, true );
$this->assertNotFalse( $deprecated_zone_retval );
$deprecated_time = strtotime( '2020-01-01 00:00:00' );
$new_zone_retval = TTDate::setTimeZone( Misc::trimSortPrefix( $new_zone ), true, true );
$this->assertNotFalse( $new_zone_retval );
$new_time = strtotime( '2020-01-01 00:00:00' );
$this->assertEquals( $deprecated_time, $new_time, 'Depcreated Zone: ' . $deprecated_zone . ' New Zone: ' . $new_zone );
}
}
}
function testCheckForDeprecatedTimeZones() {
$countries = ['CA', 'US', ''];
foreach( $countries as $country ) {
$upf = new UserPreferenceFactory();
$zones = $upf->getOptions( 'time_zone' );
$deprecated_zones = $upf->getOptions( 'deprecated_timezone', [ 'country' => $country ] );
$location_zones = $upf->getOptions( 'location_timezone' );
$area_code_zones = $upf->getOptions( 'area_code_timezone' );
//Make sure all
foreach ( $zones as $zone => $name ) {
$this->assertTrue( !isset( $deprecated_zones[$zone] ), 'UserPreference Zone is deprecated: ' . $zone );
if ( isset( $deprecated_zones[$zone] ) ) {
$this->assertTrue( !isset( $zones[$deprecated_zones[$zone]] ), 'Deprecrated Linked Zone does not exist: ' . $deprecated_zones[$zone] );
}
}
foreach ( $deprecated_zones as $deprecated_zone => $new_zone ) {
$this->assertTrue( isset( $zones[$new_zone] ), 'Zone linked to deprecated zone is invalid!: ' . $new_zone );
}
foreach ( $location_zones as $country => $zone_arr ) {
if ( is_array( $zone_arr ) ) {
foreach ( $zone_arr as $zone ) {
if ( !is_array( $zone ) ) {
$zone = [ $zone ];
}
foreach( $zone as $tmp_zone ) {
if ( isset( $deprecated_zones[$tmp_zone] ) ) {
$this->assertTrue( false, 'Location TimeZone Map: Zone is deprecated: ' . $tmp_zone . ' Should be: ' . $deprecated_zones[$tmp_zone] );
}
//Make sure detected timezone are actually valid and in the main timezone list.
if ( $tmp_zone != '' && !isset( $zones[$tmp_zone] ) ) {
$this->assertTrue( false, 'Area Code TimeZone Map: Zone is does not exist in main Time Zone list: ' . $tmp_zone );
}
}
}
} else {
if ( isset( $deprecated_zones[$zone_arr] ) ) {
$this->assertTrue( false, 'Location TimeZone Map: Zone is deprecated: ' . $zone_arr . ' Should be: ' . $deprecated_zones[$zone_arr] );
}
}
}
foreach ( $area_code_zones as $area_code => $arr ) {
$zone = $arr['time_zone'];
if ( $zone != '' && isset( $deprecated_zones[$zone] ) ) {
$this->assertTrue( false, 'Area Code TimeZone Map: Zone is deprecated: ' . $zone . ' Should be: ' . $deprecated_zones[$zone] );
}
//Make sure detected timezone are actually valid and in the main timezone list.
if ( $zone != '' && !isset( $zones[$zone] ) ) {
$this->assertTrue( false, 'Area Code TimeZone Map: Zone is does not exist in main Time Zone list: ' . $zone );
}
}
}
}
function testReportDatesA() {
$uf = TTnew( 'UserFactory' ); /** @var UserFactory $uf */
$uf->getUserPreferenceObject()->setDateFormat( 'm-d-y' );
$pre_process_dates = TTDate::getReportDates( null, strtotime( '03-Mar-2015 08:00AM' ), false, $uf ); //Sortable dates
//var_dump( $pre_process_dates );
$this->assertEquals( '2015-03-03', $pre_process_dates['date_stamp'] );
TTDate::setDateFormat( 'Y-m-d' );
$this->assertEquals( '2015-03-03', TTDate::getReportDates( 'date_stamp', $pre_process_dates['date_stamp'], true, $uf ) );
TTDate::setDateFormat( 'd-m-y' );
$this->assertEquals( '03-03-15', TTDate::getReportDates( 'date_stamp', $pre_process_dates['date_stamp'], true, $uf ) );
}
function testDoesRangeSpanMidnight() {
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 5:00PM' ), false ) );
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 11:59:59PM' ), false ) );
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 12:00:00AM' ), false ) );
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 12:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 1:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '02-Jan-2016 1:00:00AM' ), strtotime( '01-Jan-2016 8:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '03-Jan-2016 1:00:00AM' ), false ) );
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 2:00:00AM' ), strtotime( '01-Jan-2016 2:00:00AM' ), false ) );
$this->assertEquals( false, TTDate::doesRangeSpanMidnight( strtotime( '02-Jan-2016 12:00:00AM' ), strtotime( '02-Jan-2016 1:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 12:00:00AM' ), strtotime( '03-Jan-2016 12:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 12:00AM' ), strtotime( '02-Jan-2016 8:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 12:00AM' ), strtotime( '03-Jan-2016 8:00:00AM' ), false ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '02-Jan-2016 12:00AM' ), strtotime( '02-Jan-2016 1:00:00AM' ), true ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '02-Jan-2016 12:00AM' ), strtotime( '02-Jan-2016 12:00:00AM' ), true ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '02-Jan-2016 12:00AM' ), strtotime( '03-Jan-2016 12:00:00AM' ), true ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 12:00AM' ), strtotime( '03-Jan-2016 8:00:00AM' ), true ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 12:00:00AM' ), true ) );
$this->assertEquals( true, TTDate::doesRangeSpanMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '03-Jan-2016 8:00:00AM' ), true ) );
}
function testsplitDateRange() {
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '02-Jan-2016 8:00AM' ) );
$this->assertCount( 2, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '03-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '03-Jan-2016 8:00AM' ) );
$this->assertCount( 3, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '04-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '04-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '04-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '04-Jan-2016 8:00AM' ) );
$this->assertCount( 4, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 8:00PM' ), strtotime( '01-Jan-2016 7:00AM' ), strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '01-Jan-2016 8:00PM' ) );
$this->assertCount( 2, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 8:00PM' ), strtotime( '01-Jan-2016 3:00PM' ), strtotime( '01-Jan-2016 9:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '01-Jan-2016 8:00PM' ) );
$this->assertCount( 2, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 8:00PM' ), strtotime( '01-Jan-2016 9:00AM' ), strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '01-Jan-2016 8:00PM' ) );
$this->assertCount( 3, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 3:00PM' ), strtotime( '01-Jan-2016 11:00PM' ), strtotime( '01-Jan-2016 12:00AM' ), strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 3:00PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertCount( 1, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 11:00PM' ), strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '02-Jan-2016 8:00AM' ) );
$this->assertCount( 4, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '02-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 11:00PM' ), strtotime( '01-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '02-Jan-2016 8:00AM' ) );
$this->assertCount( 4, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '04-Jan-2016 8:00AM' ), strtotime( '01-Jan-2016 11:00PM' ), strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '02-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '02-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '02-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[5]['start_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[5]['end_time_stamp'], strtotime( '03-Jan-2016 1:00AM' ) );//should be 1am. things are wrong south of here.
$this->assertEquals( $split_range_arr[6]['start_time_stamp'], strtotime( '03-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[6]['end_time_stamp'], strtotime( '03-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[7]['start_time_stamp'], strtotime( '03-Jan-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[7]['end_time_stamp'], strtotime( '04-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[8]['start_time_stamp'], strtotime( '04-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[8]['end_time_stamp'], strtotime( '04-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[9]['start_time_stamp'], strtotime( '04-Jan-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[9]['end_time_stamp'], strtotime( '04-Jan-2016 8:00AM' ) );
$this->assertCount( 10, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-2016 8:00AM' ), strtotime( '03-Jan-2016 8:00PM' ), strtotime( '01-Jan-2016 9:00AM' ), strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '01-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '02-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '02-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '02-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '02-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['start_time_stamp'], strtotime( '02-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['end_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[6]['start_time_stamp'], strtotime( '03-Jan-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[6]['end_time_stamp'], strtotime( '03-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[7]['start_time_stamp'], strtotime( '03-Jan-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[7]['end_time_stamp'], strtotime( '03-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[8]['start_time_stamp'], strtotime( '03-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[8]['end_time_stamp'], strtotime( '03-Jan-2016 8:00PM' ) );
$this->assertCount( 9, $split_range_arr );
//start and end only one day apart
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '10-Mar-2016 8:00AM' ), strtotime( '11-Mar-2016 8:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '10-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '11-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '11-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '11-Mar-2016 8:00PM' ) );
$this->assertCount( 2, $split_range_arr );
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to timezone that observes DST.
//spans daylight savings time in spring
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '13-Mar-2016 8:00AM' ), strtotime( '14-Mar-2016 8:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '13-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '14-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '14-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '14-Mar-2016 8:00PM' ) );
$this->assertCount( 2, $split_range_arr );
//spans daylight savings time in spring with filter
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '13-Mar-2016 8:00AM' ), strtotime( '14-Mar-2016 8:00PM' ), strtotime( '01-Jan-2016 9:00AM' ), strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '13-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '13-Mar-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '13-Mar-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '13-Mar-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '13-Mar-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '14-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '14-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '14-Mar-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '14-Mar-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '14-Mar-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['start_time_stamp'], strtotime( '14-Mar-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['end_time_stamp'], strtotime( '14-Mar-2016 8:00PM' ) );
$this->assertCount( 6, $split_range_arr );
//spans daylight savings time in spring with filter where the filter spans 11-2
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '12-Mar-2016 8:00AM' ), strtotime( '13-Mar-2016 4:00AM' ), strtotime( '12-Mar-2016 11:00PM' ), strtotime( '13-Mar-2016 2:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '12-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '12-Mar-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '12-Mar-2016 11:00PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '13-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '13-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '13-Mar-2016 3:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '13-Mar-2016 3:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '13-Mar-2016 4:00AM' ) );
$this->assertCount( 4, $split_range_arr );
//spans daylight savings time in fall
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '6-Nov-2016 8:00AM' ), strtotime( '7-Nov-2016 8:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '6-Nov-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '7-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '7-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '7-Nov-2016 8:00PM' ) );
$this->assertCount( 2, $split_range_arr );
//spans daylight savings time in fall with filter
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '6-Nov-2016 8:00AM' ), strtotime( '7-Nov-2016 8:00PM' ), strtotime( '01-Jan-2016 9:00AM' ), strtotime( '01-Jan-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '6-Nov-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '6-Nov-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '6-Nov-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '6-Nov-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '6-Nov-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '7-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '7-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '7-Nov-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '7-Nov-2016 9:00AM' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '7-Nov-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['start_time_stamp'], strtotime( '7-Nov-2016 7:00PM' ) );
$this->assertEquals( $split_range_arr[5]['end_time_stamp'], strtotime( '7-Nov-2016 8:00PM' ) );
$this->assertCount( 6, $split_range_arr );
//http://stackoverflow.com/questions/2613338/date-returning-wrong-day-although-the-timestamp-is-correct
//fall daylight savings. illustrating the missing hour
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '6-Nov-2016 8:00AM' ), ( strtotime( '6-Nov-2016 1:00AM' ) + 7200 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '06-Nov-2016 08:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '06-Nov-2016 02:00AM' ) );
$this->assertCount( 1, $split_range_arr );
if ( version_compare( PHP_VERSION, '8.1.0', '>=' ) ) { //Apparently PHP v8.1 handles DST differently in these cases.
//the missing hour shows up in the filter
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '5-Nov-2016 8:00AM PDT' ), ( strtotime( '6-Nov-2016 1:00AM PDT' ) + 7200 ), strtotime( '6-Nov-2016 8:00AM PDT' ), strtotime( '6-Nov-2016 1:00AM PDT' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '5-Nov-2016 8:00AM PDT' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '6-Nov-2016 12:00AM PDT' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '6-Nov-2016 12:00AM PDT' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '6-Nov-2016 1:00AM PST' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '6-Nov-2016 1:00AM PST' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '6-Nov-2016 2:00AM PST' ) );
$this->assertCount( 3, $split_range_arr );
//fall daylight savings. illustrating the missing hour
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '5-Nov-2016 8:00AM PDT' ), ( strtotime( '6-Nov-2016 1:00AM PDT' ) + 7200 ), strtotime( '6-Nov-2016 8:00AM PDT' ), ( strtotime( '6-Nov-2016 1:00AM PDT' ) + 3600 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '05-Nov-2016 8:00AM PDT' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '06-Nov-2016 12:00AM PDT' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '06-Nov-2016 12:00AM PDT' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '06-Nov-2016 1:00AM PST' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '06-Nov-2016 1:00AM PST' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '06-Nov-2016 2:00AM PST' ) );
$this->assertCount( 3, $split_range_arr );
} else {
//the missing hour shows up in the filter
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '5-Nov-2016 8:00AM' ), ( strtotime( '6-Nov-2016 1:00AM' ) + 7200 ), strtotime( '6-Nov-2016 8:00AM' ), strtotime( '6-Nov-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '5-Nov-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '6-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '6-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '6-Nov-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '6-Nov-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '6-Nov-2016 2:00AM' ) );
$this->assertCount( 3, $split_range_arr );
//fall daylight savings. illustrating the missing hour
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '5-Nov-2016 8:00AM' ), ( strtotime( '6-Nov-2016 1:00AM' ) + 7200 ), strtotime( '6-Nov-2016 8:00AM' ), ( strtotime( '6-Nov-2016 1:00AM' ) + 3600 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '05-Nov-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '06-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '06-Nov-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '06-Nov-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '06-Nov-2016 1:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '06-Nov-2016 2:00AM' ) );
$this->assertCount( 3, $split_range_arr );
}
//spring daylight savings. illustrating the extra hour
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '13-Mar-2016 8:00AM' ), ( strtotime( '13-Mar-2016 12:00AM' ) + 7200 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '13-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '13-Mar-2016 3:00AM' ) );
$this->assertCount( 1, $split_range_arr );
//spring daylight savings. illustrating the extra hour
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '11-Mar-2016 8:00AM' ), ( strtotime( '13-Mar-2016 12:00AM' ) + 7200 ), strtotime( '13-Mar-2016 4:00AM' ), ( strtotime( '13-Mar-2016 1:00AM' ) + 7200 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '11-Mar-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '12-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '12-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '12-Mar-2016 4:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '12-Mar-2016 4:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '13-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '13-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '13-Mar-2016 3:00AM' ) );
$this->assertCount( 4, $split_range_arr );
//leap year illustration
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '28-Feb-2016 8:00AM' ), ( strtotime( '1-Mar-2016 12:00AM' ) + 7200 ), strtotime( '28-Feb-2016 4:00AM' ), ( strtotime( '28-Feb-2016 1:00AM' ) + 7200 ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '28-Feb-2016 8:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '29-Feb-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '29-Feb-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '29-Feb-2016 3:00AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '29-Feb-2016 3:00AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '29-Feb-2016 4:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '29-Feb-2016 4:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '01-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '01-Mar-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '01-Mar-2016 2:00AM' ) );
$this->assertCount( 5, $split_range_arr );
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( 'Tue, 03 May 2016 06:00:00 -0600' ), strtotime( 'Thu, 05 May 2016 15:00:00 -0600' ), strtotime( 'Tue, 03 May 2016 08:00:00 -0600' ), strtotime( 'Tue, 03 May 2016 15:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '03 May 2016 06:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '03 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( 'Tue, 03 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '03 May 2016 15:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '03 May 2016 15:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '04-May-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '04-May-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '04 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[4]['start_time_stamp'], strtotime( '04 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[4]['end_time_stamp'], strtotime( '04 May 2016 15:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[5]['start_time_stamp'], strtotime( '04 May 2016 15:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[5]['end_time_stamp'], strtotime( '05-May-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[6]['start_time_stamp'], strtotime( '05-May-2016 12:00AM' ) );
$this->assertEquals( $split_range_arr[6]['end_time_stamp'], strtotime( '05 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[7]['start_time_stamp'], strtotime( '05 May 2016 08:00:00 -0600' ) );
$this->assertEquals( $split_range_arr[7]['end_time_stamp'], strtotime( '05 May 2016 15:00:00 -0600' ) );
$this->assertCount( 8, $split_range_arr );
//multi-year test
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '15-Jun-2010 8:00AM' ), strtotime( '30-Aug-2016 5:00PM' ), strtotime( '25-Jun-2010 2:00AM' ), strtotime( '26-Aug-2016 10:00PM' ) );
//first 3 days
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '2010-06-15 08:00:00am' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '2010-06-15 10:00:00pm' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '2010-06-15 10:00:00pm' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '2010-06-16 12:00:00am' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '2010-06-16 12:00:00am' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '2010-06-16 02:00:00am' ) );
//a few from the middle
$this->assertEquals( $split_range_arr[3000]['start_time_stamp'], strtotime( '2013-03-11 02:00:00am' ) );
$this->assertEquals( $split_range_arr[3000]['end_time_stamp'], strtotime( '2013-03-11 10:00:00pm' ) );
$this->assertEquals( $split_range_arr[3001]['start_time_stamp'], strtotime( '2013-03-11 10:00:00pm' ) );
$this->assertEquals( $split_range_arr[3001]['end_time_stamp'], strtotime( '2013-03-12 12:00:00am' ) );
$this->assertEquals( $split_range_arr[3002]['start_time_stamp'], strtotime( '2013-03-12 12:00:00am' ) );
$this->assertEquals( $split_range_arr[3002]['end_time_stamp'], strtotime( '2013-03-12 02:00:00am' ) );
//last 3 days
$this->assertEquals( $split_range_arr[6802]['start_time_stamp'], strtotime( '2016-08-29 10:00:00pm' ) );
$this->assertEquals( $split_range_arr[6802]['end_time_stamp'], strtotime( '2016-08-30 12:00:00am' ) );
$this->assertEquals( $split_range_arr[6803]['start_time_stamp'], strtotime( '2016-08-30 12:00:00am' ) );
$this->assertEquals( $split_range_arr[6803]['end_time_stamp'], strtotime( '2016-08-30 02:00:00am' ) );
$this->assertEquals( $split_range_arr[6804]['start_time_stamp'], strtotime( '2016-08-30 02:00:00am' ) );
$this->assertEquals( $split_range_arr[6804]['end_time_stamp'], strtotime( '2016-08-30 05:00:00pm' ) );
$this->assertCount( 6805, $split_range_arr );
//#2329 <24 hrs between with midnight filter provided.
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '04-Jul-17 9:55 PM' ), strtotime( '05-Jul-17 1:00 AM' ), strtotime( '04-Jul-17 12:00 AM' ), strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '04-Jul-17 9:55 PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '05-Jul-17 1:00 AM' ) );
$this->assertCount( 3, $split_range_arr );
//same day
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '04-Jul-17 9:55 PM' ), strtotime( '04-Jul-17 11:00 PM' ), strtotime( '04-Jul-17 10:00 PM' ), strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '04-Jul-17 9:55 PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '04-Jul-17 11:00 PM' ) );
$this->assertCount( 3, $split_range_arr );
//next day < 24hrs between
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '04-Jul-17 9:55 PM' ), strtotime( '05-Jul-17 8:00 PM' ), strtotime( '04-Jul-17 10:00 PM' ), strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '04-Jul-17 9:55 PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '05-Jul-17 8:00 PM' ) );
$this->assertCount( 4, $split_range_arr );
//next day < 24hrs between reversed filters (greater, then less.)
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '04-Jul-17 9:55 PM' ), strtotime( '05-Jul-17 8:00 PM' ), strtotime( '04-Jul-17 10:50 PM' ), strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '04-Jul-17 9:55 PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '04-Jul-17 10:00 PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '04-Jul-17 10:50 PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[3]['start_time_stamp'], strtotime( '05-Jul-17 12:00 AM' ) );
$this->assertEquals( $split_range_arr[3]['end_time_stamp'], strtotime( '05-Jul-17 8:00 PM' ) );
$this->assertCount( 4, $split_range_arr );
//very small window
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '04-Jul-17 9:55 PM' ), strtotime( '04-Jul-17 09:58 PM' ), strtotime( '04-Jul-17 09:56 PM' ), strtotime( '04-Jul-17 09:57 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '04-Jul-17 9:55 PM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '04-Jul-17 09:56 PM' ) );
$this->assertEquals( $split_range_arr[1]['start_time_stamp'], strtotime( '04-Jul-17 09:56 PM' ) );
$this->assertEquals( $split_range_arr[1]['end_time_stamp'], strtotime( '04-Jul-17 09:57 PM' ) );
$this->assertEquals( $split_range_arr[2]['start_time_stamp'], strtotime( '04-Jul-17 09:57 PM' ) );
$this->assertEquals( $split_range_arr[2]['end_time_stamp'], strtotime( '04-Jul-17 09:58 PM' ) );
$this->assertCount( 3, $split_range_arr );
//with filter dates after the end time
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-17 08:00AM' ), strtotime( '01-Jan-17 05:00 PM' ), strtotime( '02-Jan-17 06:00 PM' ), strtotime( '02-Jan-17 07:00 PM' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-17 08:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-17 05:00 PM' ) );
$this->assertCount( 1, $split_range_arr );
//with filter dates before the start time.
$split_range_arr = TTDate::splitDateRangeAtMidnight( strtotime( '01-Jan-17 08:00AM' ), strtotime( '01-Jan-17 05:00 PM' ), strtotime( '02-Jan-17 03:00 AM' ), strtotime( '02-Jan-17 05:00 am' ) );
$this->assertEquals( $split_range_arr[0]['start_time_stamp'], strtotime( '01-Jan-17 08:00AM' ) );
$this->assertEquals( $split_range_arr[0]['end_time_stamp'], strtotime( '01-Jan-17 05:00 PM' ) );
$this->assertCount( 1, $split_range_arr );
}
/**
* Magic days and all the problems they leave for us.
*/
function testDSTMagic() {
TTDate::setTimeFormat( 'g:i A T' );
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to timezone that observes DST.
$time_stamp = 1457859600; //13-Mar-2016 1:00AM
$this->assertEquals( strtotime( '13-Mar-2016 1:00AM' ), $time_stamp );
$this->assertEquals( '13-Mar-16 1:00 AM PST', TTDate::getDate( 'DATE+TIME', $time_stamp ) );
$this->assertEquals( strtotime( '13-Mar-2016 2:00AM' ), ( $time_stamp + 3600 ) );
$this->assertEquals( '13-Mar-16 3:00 AM PDT', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 3600 ) ) );
$this->assertEquals( '14-Mar-16 1:00 AM PDT', TTDate::getDate( 'DATE+TIME', TTDate::incrementDate( $time_stamp, 1, 'day' ) ) );
$this->assertEquals( '14-Mar-16 2:00 AM PDT', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 86400 ) ) );
TTDate::setTimeFormat( 'g:i A' );
TTDate::setTimeZone( 'Etc/GMT+8', true ); //Force to timezone that does not observe DST.
$time_stamp = 1457859600; //13-Mar-2016 1:00AM
$this->assertEquals( strtotime( '13-Mar-2016 1:00AM PST' ), $time_stamp );
$this->assertEquals( '13-Mar-16 1:00 AM', TTDate::getDate( 'DATE+TIME', $time_stamp ) ); //Was: GMT+8 - But some versions of PHP return "-08", so just ignore the timezone setting for this case.
$this->assertEquals( strtotime( '13-Mar-2016 2:00AM PST' ), ( $time_stamp + 3600 ) );
$this->assertEquals( '13-Mar-16 2:00 AM', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 3600 ) ) ); //Was: GMT+8
$this->assertEquals( '14-Mar-16 1:00 AM', TTDate::getDate( 'DATE+TIME', TTDate::incrementDate( $time_stamp, 1, 'day' ) ) ); //Was: GMT+8
TTDate::setTimeFormat( 'g:i A T' );
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to timezone that observes DST.
$time_stamp = 1478419200; //13-Mar-2016 1:00AM
$this->assertEquals( strtotime( '06-Nov-2016 1:00AM' ), $time_stamp );
$this->assertEquals( '06-Nov-16 1:00 AM PDT', TTDate::getDate( 'DATE+TIME', $time_stamp ) );
$this->assertEquals( '06-Nov-16 1:00 AM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 3600 ) ) );
$this->assertEquals( strtotime( '06-Nov-2016 2:00AM' ), ( $time_stamp + 7200 ) );
$this->assertEquals( '06-Nov-16 2:00 AM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 7200 ) ) );
$this->assertEquals( '07-Nov-16 1:00 AM PST', TTDate::getDate( 'DATE+TIME', TTDate::incrementDate( $time_stamp, 1, 'day' ) ) );
$this->assertEquals( '07-Nov-16 12:00 AM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp + 86400 ) ) );
//http://stackoverflow.com/questions/2613338/date-returning-wrong-day-although-the-timestamp-is-correct
//illustrating that +86400 will not always give you tomorrow.
$time_stamp = strtotime( '05-Nov-2016 12:00AM' );
$time_stamp += 86400;
$this->assertEquals( '06-Nov-16 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
$time_stamp += 86400;
$this->assertEquals( '06-Nov-16 11:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //extra day!!!
$time_stamp += 86400;
$this->assertEquals( '07-Nov-16 11:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
//and the same for fall daylight savings
$time_stamp = strtotime( '15-Mar-2016 12:00AM' );
$time_stamp -= 86400;
$this->assertEquals( '14-Mar-16 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
$time_stamp -= 86400;
$this->assertEquals( '12-Mar-16 11:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //missing day!!! where is 13th?
$time_stamp -= 86400;
$this->assertEquals( '11-Mar-16 11:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
//illustrating that +86400 will not always give you tomorrow, but the middle day epoch will dodge the issue.
//if we do all the math on the middle of day epoch and continually force it back to noon we can avoid problems with dst
$time_stamp = TTDate::getMiddleDayEpoch( strtotime( '04-Nov-2016 12:00AM' ) );
$time_stamp = TTDate::incrementDate( TTDate::getMiddleDayEpoch( $time_stamp ), 1, 'day' );
$this->assertEquals( '05-Nov-16 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
$time_stamp = TTDate::incrementDate( TTDate::getMiddleDayEpoch( $time_stamp ), 1, 'day' );
$this->assertEquals( '06-Nov-16 12:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
$time_stamp = TTDate::incrementDate( TTDate::getMiddleDayEpoch( $time_stamp ), 1, 'day' );
$this->assertEquals( '07-Nov-16 12:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
$time_stamp = TTDate::incrementDate( TTDate::getMiddleDayEpoch( $time_stamp ), 1, 'day' );
$this->assertEquals( '08-Nov-16 12:00 PM PST', TTDate::getDate( 'DATE+TIME', ( $time_stamp ) ) ); //normal operation
}
function testCalendarArr() {
$calendar_arr = TTDate::getCalendarArray( strtotime( '09-Mar-2019 12:00:00 PM' ), strtotime( '11-Mar-2019 12:00:00 PM' ) );
$match_arr = [
0 =>
[
'epoch' => 1551600000,
'date_stamp' => '2019-03-03',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => true,
],
1 =>
[
'epoch' => 1551686400,
'date_stamp' => '2019-03-04',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
2 =>
[
'epoch' => 1551772800,
'date_stamp' => '2019-03-05',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
3 =>
[
'epoch' => 1551859200,
'date_stamp' => '2019-03-06',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
4 =>
[
'epoch' => 1551945600,
'date_stamp' => '2019-03-07',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
5 =>
[
'epoch' => 1552032000,
'date_stamp' => '2019-03-08',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
6 =>
[
'epoch' => 1552118400,
'date_stamp' => '2019-03-09',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
7 =>
[
'epoch' => 1552204800,
'date_stamp' => '2019-03-10',
'start_day_of_week' => 0,
'day_of_week' => 'Sun',
'day_of_month' => '10',
'month_name' => 'March',
'month_short_name' => 'Mar',
'month' => '3',
'is_new_month' => false,
'is_new_week' => true,
],
8 =>
[
'epoch' => 1552291200,
'date_stamp' => '2019-03-11',
'start_day_of_week' => 0,
'day_of_week' => 'Mon',
'day_of_month' => '11',
'month_name' => 'March',
'month_short_name' => 'Mar',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
9 =>
[
'epoch' => 1552377600,
'date_stamp' => '2019-03-12',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
10 =>
[
'epoch' => 1552464000,
'date_stamp' => '2019-03-13',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
11 =>
[
'epoch' => 1552550400,
'date_stamp' => '2019-03-14',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
12 =>
[
'epoch' => 1552636800,
'date_stamp' => '2019-03-15',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
13 =>
[
'epoch' => 1552723200,
'date_stamp' => '2019-03-16',
'start_day_of_week' => 0,
'day_of_week' => null,
'day_of_month' => null,
'month_name' => null,
'month_short_name' => '',
'month' => '3',
'is_new_month' => false,
'is_new_week' => false,
],
];
$this->assertEquals( $calendar_arr, $match_arr );
}
function testIncrementDate() {
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to timezone that observes DST.
//Increment date across DST switch-over
$this->assertEquals( TTDate::incrementDate( strtotime( '09-Mar-2019 12:00:00 PM' ), 1, 'day' ), strtotime( '10-Mar-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '09-Mar-2019 12:00:00 PM' ), 2, 'day' ), strtotime( '11-Mar-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2019 12:00:00 PM' ), 1, 'day' ), strtotime( '03-Nov-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2019 12:00:00 PM' ), 2, 'day' ), strtotime( '04-Nov-2019 12:00:00 PM' ) );
//General increments
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2019 12:00:00 PM' ), 1, 'week' ), strtotime( '09-Nov-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2019 12:00:00 PM' ), 1, 'month' ), strtotime( '02-Dec-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '15-Nov-2019 12:00:00 PM' ), 1, 'month' ), strtotime( '15-Dec-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Dec-2019 12:00:00 PM' ), -1, 'month' ), strtotime( '30-Nov-2019 12:00:00 PM' ) ); //December has 31 days, and Nov only has 30.
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Jan-2019 12:00:00 PM' ), 1, 'month' ), strtotime( '28-Feb-2019 12:00:00 PM' ) ); //January has 31 days, and Feb 2019 only has 28.
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Mar-2021 12:00:00 PM' ), -1, 'month' ), strtotime( '28-Feb-2021 12:00:00 PM' ) ); //March has 31 days, and Apr 2021 only has 30.
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Mar-2021 12:00:00 PM' ), 1, 'month' ), strtotime( '30-Apr-2021 12:00:00 PM' ) ); //March has 31 days, and Apr 2021 only has 30.
$this->assertEquals( TTDate::incrementDate( strtotime( '28-Feb-2021 12:00:00 PM' ), 1, 'month' ), strtotime( '28-Mar-2021 12:00:00 PM' ) ); //March has 31 days, and Apr 2021 only has 30.
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Dec-2019 12:00:00 PM' ), 1, 'month' ), strtotime( '31-Jan-2020 12:00:00 PM' ) ); //Test crossing year boundary
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), 12, 'month' ), strtotime( '28-Feb-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), -12, 'month' ), strtotime( '28-Feb-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2019 12:00:00 PM' ), 1, 'year' ), strtotime( '02-Nov-2020 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), 1, 'year' ), strtotime( '28-Feb-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), -1, 'year' ), strtotime( '28-Feb-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), 4, 'quarter' ), strtotime( '28-Feb-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '29-Feb-2020 12:00:00 PM' ), -4, 'quarter' ), strtotime( '28-Feb-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '31-Mar-2021 12:00:00 PM' ), 1, 'quarter' ), strtotime( '30-Jun-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '30-Sep-2021 12:00:00 PM' ), 1, 'quarter' ), strtotime( '30-Dec-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '30-Jun-2021 12:00:00 PM' ), -1, 'quarter' ), strtotime( '30-Mar-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '09-Nov-2019 12:00:00 PM' ), -1, 'week' ), strtotime( '02-Nov-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Dec-2019 12:00:00 PM' ), -1, 'month' ), strtotime( '02-Nov-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2020 12:00:00 PM' ), -1, 'year' ), strtotime( '02-Nov-2019 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2020 12:00:00 PM' ), 0.999, 'year' ), strtotime( '02-Nov-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2020 12:00:00 PM' ), 0.5, 'year' ), strtotime( '02-Nov-2021 12:00:00 PM' ) );
$this->assertEquals( TTDate::incrementDate( strtotime( '02-Nov-2020 12:00:00 PM' ), 0.4, 'year' ), strtotime( '02-Nov-2020 12:00:00 PM' ) );
}
function testDatePeriodGenerator() {
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to timezone that observes DST.
//Test original loop code vs. new loop code.
$original_date_arr = $new_date_arr = [];
$x = 0;
for ( $date = TTDate::getMiddleDayEpoch( strtotime( '27-Oct-19 12:00 PM' ) ); $date < strtotime( '28-Oct-19 11:59:59 PM' ); $date += 86400 ) {
switch ( $x ) {
case 0:
$this->assertEquals( '27-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '28-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$original_date_arr[] = $x;
$x++;
}
$this->assertEquals( 2, $x );
$period = TTDate::getDatePeriod( TTDate::getMiddleDayEpoch( strtotime( '27-Oct-19 12:00 PM' ) ), strtotime( '28-Oct-19 11:59:59 PM' ), 'P1D', false );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $x ) {
case 0:
$this->assertEquals( '27-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '28-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$new_date_arr[] = $x;
$x++;
}
$this->assertEquals( 2, $x );
$this->assertEquals( $original_date_arr, $new_date_arr );
//Test original loop code vs. new loop code.
$original_date_arr = $new_date_arr = [];
$x = 0;
for ( $date = TTDate::getMiddleDayEpoch( strtotime( '27-Oct-19 12:00 AM' ) ); $date < strtotime( '28-Oct-19 12:00 PM' ); $date += 86400 ) {
switch ( $x ) {
case 0:
$this->assertEquals( '27-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$original_date_arr[] = $x;
$x++;
}
$this->assertEquals( 1, $x );
$period = TTDate::getDatePeriod( TTDate::getMiddleDayEpoch( strtotime( '27-Oct-19 12:00 AM' ) ), strtotime( '28-Oct-19 12:00 PM' ), 'P1D', false );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $x ) {
case 0:
$this->assertEquals( '27-Oct-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$new_date_arr[] = $x;
$x++;
}
$this->assertEquals( 1, $x );
$this->assertEquals( $original_date_arr, $new_date_arr );
//Test original loop code vs. new loop code.
$original_date_arr = $new_date_arr = [];
$x = 0;
for ( $date = ( TTDate::getMiddleDayEpoch( strtotime( '20-Nov-2018 00:00:00' ) ) - 86400 ); $date <= ( TTDate::getMiddleDayEpoch( strtotime( '20-Nov-2018 23:59:59' ) ) + 86400 ); $date += 86400 ) {
switch ( $x ) {
case 0:
$this->assertEquals( '19-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '20-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '21-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$original_date_arr[] = $x;
$x++;
}
$this->assertEquals( 3, $x );
$period = TTDate::getDatePeriod( ( TTDate::getMiddleDayEpoch( strtotime( '20-Nov-2018 00:00:00' ) ) - 86400 ), ( TTDate::getMiddleDayEpoch( strtotime( '20-Nov-2018 23:59:59' ) ) + 86400 ) );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $x ) {
case 0:
$this->assertEquals( '19-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '20-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '21-Nov-18 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$new_date_arr[] = $x;
$x++;
}
$this->assertEquals( 3, $x );
$this->assertEquals( $original_date_arr, $new_date_arr );
//Test original loop code vs. new loop code across DST(a).
$original_date_arr = $new_date_arr = [];
$x = 0;
for ( $i = ( TTDate::getMiddleDayEpoch( strtotime( '09-Mar-2019 12:00:00 PM' ) ) - 86400 ); $i <= ( TTDate::getMiddleDayEpoch( strtotime( '11-Mar-2019 12:00:00 PM' ) ) + 86400 ); $i += 86400 ) {
$original_date_arr[] = $x;
$x++;
}
$this->assertEquals( 4, $x ); //4 iterations is *incorrect* due to DST
$period = TTDate::getDatePeriod( ( TTDate::getMiddleDayEpoch( strtotime( '09-Mar-2019 12:00:00 PM' ) ) - 86400 ), ( TTDate::getMiddleDayEpoch( strtotime( '11-Mar-2019 12:00:00 PM' ) ) + 86400 ) );
$x = 0;
foreach ( $period as $i => $date ) {
$new_date_arr[] = $x;
$x++;
}
$this->assertEquals( 5, $x ); //5 iterations is correct due to DST
array_pop( $new_date_arr );
$this->assertEquals( $original_date_arr, $new_date_arr );
//Test original loop code vs. new loop code across DST(b).
$original_date_arr = $new_date_arr = [];
$x = 0;
for ( $i = ( TTDate::getMiddleDayEpoch( strtotime( '03-Nov-2013 00:00:00' ) ) - 86400 ); $i <= ( TTDate::getMiddleDayEpoch( strtotime( '03-Nov-2013 10:00:00' ) ) + 86400 ); $i += 86400 ) {
$original_date_arr[] = $x;
$x++;
}
$this->assertEquals( 3, $x ); //3 iterations is *correct* due to DST
//$period = TTDate::getDatePeriod( (TTDate::getMiddleDayEpoch(strtotime('03-Nov-2013 00:00:00')) - 86400), (TTDate::getMiddleDayEpoch( strtotime('03-Nov-2013 10:00:00') ) + 86400) ); //This only returns 2 days.
$period = TTDate::getDatePeriod( TTDate::incrementDate( strtotime( '03-Nov-2013 00:00:00' ), -1, 'day' ), TTDate::incrementDate( strtotime( '03-Nov-2013 10:00:00' ), 1, 'day' ) );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '02-Nov-13 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '03-Nov-13 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '04-Nov-13 12:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$new_date_arr[] = $x;
$x++;
}
$this->assertEquals( 3, $x ); //3 iterations is correct due to DST
$this->assertEquals( $original_date_arr, $new_date_arr );
$period = TTDate::getDatePeriod( strtotime( '09-Mar-2019 12:00:00 PM' ), strtotime( '10-Mar-2019 12:00:00 PM' ) );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '09-Mar-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '10-Mar-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$x++;
}
$this->assertEquals( 2, $x );
$period = TTDate::getDatePeriod( strtotime( '09-Mar-2019 12:00:00 PM' ), strtotime( '10-Mar-2019 12:00:01 PM' ) );
$x = 0;
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '09-Mar-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '10-Mar-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
$x++;
}
$this->assertEquals( 2, $x );
$period = TTDate::getDatePeriod( strtotime( '09-Mar-2019 12:00:00 PM' ), strtotime( '11-Mar-2019 12:00:00 PM' ) );
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '09-Mar-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '10-Mar-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '11-Mar-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
}
$period = TTDate::getDatePeriod( strtotime( '09-Mar-2019 12:00 AM' ), strtotime( '11-Mar-2019 12:00 AM' ) );
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '09-Mar-19 12:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '10-Mar-19 12:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '11-Mar-19 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
}
$period = TTDate::getDatePeriod( strtotime( '02-Nov-2019 12:00:00 PM' ), strtotime( '04-Nov-2019 12:00:00 PM' ) );
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '02-Nov-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '03-Nov-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '04-Nov-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
}
$period = TTDate::getDatePeriod( strtotime( '02-Nov-2019 12:00:00 AM' ), strtotime( '04-Nov-2019 12:00:00 AM' ) );
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '02-Nov-19 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '03-Nov-19 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '04-Nov-19 12:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
}
$period = TTDate::getDatePeriod( strtotime( '02-Nov-2019 12:00:00 PM' ), strtotime( '03-Nov-2019 12:00:00 PM' ), 'PT1H' ); //Every hour.
foreach ( $period as $i => $date ) {
switch ( $i ) {
case 0:
$this->assertEquals( '02-Nov-19 12:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 1:
$this->assertEquals( '02-Nov-19 1:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 2:
$this->assertEquals( '02-Nov-19 2:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 3:
$this->assertEquals( '02-Nov-19 3:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 4:
$this->assertEquals( '02-Nov-19 4:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 5:
$this->assertEquals( '02-Nov-19 5:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 6:
$this->assertEquals( '02-Nov-19 6:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 7:
$this->assertEquals( '02-Nov-19 7:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 8:
$this->assertEquals( '02-Nov-19 8:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 9:
$this->assertEquals( '02-Nov-19 9:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 10:
$this->assertEquals( '02-Nov-19 10:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 11:
$this->assertEquals( '02-Nov-19 11:00 PM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 12:
$this->assertEquals( '03-Nov-19 12:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 13:
$this->assertEquals( '03-Nov-19 1:00 AM PDT', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 14:
$this->assertEquals( '03-Nov-19 2:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 15:
$this->assertEquals( '03-Nov-19 3:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 16:
$this->assertEquals( '03-Nov-19 4:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 17:
$this->assertEquals( '03-Nov-19 5:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 18:
$this->assertEquals( '03-Nov-19 6:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 19:
$this->assertEquals( '03-Nov-19 7:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 20:
$this->assertEquals( '03-Nov-19 8:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 21:
$this->assertEquals( '03-Nov-19 9:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 22:
$this->assertEquals( '03-Nov-19 10:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 23:
$this->assertEquals( '03-Nov-19 11:00 AM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
case 24:
$this->assertEquals( '03-Nov-19 12:00 PM PST', TTDate::getDate( 'DATE+TIME', $date ) );
break;
}
}
}
function testDateOfNextQuarter() {
$this->assertEquals( '01-Jul-19 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '01-Apr-19 12:00:00' ), 1, 1 ) ) );
$this->assertEquals( '03-Oct-81 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '11-Sep-1981 12:00:00' ), 3, 1 ) ) );
$this->assertEquals( '30-Apr-19 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '31-Jan-2019 12:00:00' ), 31, 1 ) ) );
$this->assertEquals( '31-Jul-19 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '30-Apr-2019 12:00:00' ), 31, 1 ) ) );
$this->assertEquals( '31-Oct-19 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '31-Jul-2019 12:00:00' ), 31, 1 ) ) );
$this->assertEquals( '31-Jan-20 12:00 PM -08', TTDate::getDate( 'DATE+TIME', TTDate::getDateOfNextQuarter( strtotime( '31-Oct-2019 12:00:00' ), 31, 1 ) ) );
}
function testGetDateArray() {
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ) ); //No DayOfWeek filter.
$this->assertCount( 31, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), false ); //No DayOfWeek filter.
$this->assertCount( 31, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 0 ); //Filter Sundays
$this->assertCount( 4, $date_arr );
$this->assertEquals( $date_arr[0], strtotime( '04-Dec-2016' ) );
$this->assertEquals( $date_arr[1], strtotime( '11-Dec-2016' ) );
$this->assertEquals( $date_arr[2], strtotime( '18-Dec-2016' ) );
$this->assertEquals( $date_arr[3], strtotime( '25-Dec-2016' ) );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 1 ); //Filter Mondays
$this->assertCount( 4, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 2 ); //Filter Tuesdays
$this->assertCount( 4, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 3 ); //Filter Wednesday
$this->assertCount( 4, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 4 ); //Filter Thursdays
$this->assertCount( 5, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 5 ); //Filter Fridays
$this->assertCount( 5, $date_arr );
$date_arr = TTDate::getDateArray( strtotime( '01-Dec-2016' ), strtotime( '31-Dec-2016' ), 6 ); //Filter Saturdays
$this->assertCount( 5, $date_arr );
$this->assertEquals( $date_arr[0], strtotime( '03-Dec-2016' ) );
$this->assertEquals( $date_arr[1], strtotime( '10-Dec-2016' ) );
$this->assertEquals( $date_arr[2], strtotime( '17-Dec-2016' ) );
$this->assertEquals( $date_arr[3], strtotime( '24-Dec-2016' ) );
$this->assertEquals( $date_arr[4], strtotime( '31-Dec-2016' ) );
}
function testIsConsecutiveDays() {
//Use timezone that observes DST.
TTDate::setTimeZone( 'America/Vancouver', true ); //Due to being a singleton and PHPUnit resetting the state, always force the timezone to be set.
//Spring DST change
$date_array = [
strtotime( 'Fri, 10 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sat, 11 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sun, 12 Mar 2017 00:00:00 -0700' ),
];
$this->assertEquals( true, TTDate::isConsecutiveDays( $date_array ) );
$date_array = [
strtotime( 'Thu, 09 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sat, 10 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sun, 12 Mar 2017 00:00:00 -0700' ),
];
$this->assertEquals( false, TTDate::isConsecutiveDays( $date_array ) );
$date_array = [
strtotime( 'Thu, 09 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sat, 11 Mar 2017 00:00:00 -0800' ),
strtotime( 'Sun, 12 Mar 2017 00:00:00 -0700' ),
];
$this->assertEquals( false, TTDate::isConsecutiveDays( $date_array ) );
//FALL DST change.
$date_array = [
1509692400, //strtotime('Fri, 03 Nov 2017 00:00:00 -0700'), //1509692400=Fri, 03 Nov 2017 00:00:00 -0700
1509778800, //strtotime('Sat, 04 Nov 2017 00:00:00 -0700'), //1509778800=Sat, 04 Nov 2017 00:00:00 -0700
//1509865200, //strtotime('Sun, 05 Nov 2017 00:00:00 -0800'), //1509912000=Sun, 05 Nov 2017 00:00:00 -0800
1509912000, //strtotime('Sun, 05 Nov 2017 00:00:00 -0800'), //1509912000=Sun, 05 Nov 2017 12:00:00 -0800
];
$this->assertEquals( true, TTDate::isConsecutiveDays( $date_array ) );
$date_array = [
1509692400, //strtotime('Fri, 03 Nov 2017 00:00:00 -0700'), //1509692400=Fri, 03 Nov 2017 00:00:00 -0700
1509778800, //strtotime('Sat, 04 Nov 2017 00:00:00 -0700'), //1509778800=Sat, 04 Nov 2017 00:00:00 -0700
1509865200, //strtotime('Sun, 05 Nov 2017 00:00:00 -0800'), //1509912000=Sun, 05 Nov 2017 00:00:00 -0800
//1509912000, //strtotime('Sun, 05 Nov 2017 00:00:00 -0800'), //1509912000=Sun, 05 Nov 2017 12:00:00 -0800
];
$this->assertEquals( true, TTDate::isConsecutiveDays( $date_array ) );
$date_array = [
strtotime( 'Fri, 03 Nov 2017 00:00:00 -0700' ), //1509692400=Fri, 03 Nov 2017 00:00:00 -0700
strtotime( 'Sat, 04 Nov 2017 00:00:00 -0700' ), //1509778800=Sat, 04 Nov 2017 00:00:00 -0700
strtotime( 'Sun, 05 Nov 2017 00:00:00 -0800' ), //1509912000=Sun, 05 Nov 2017 00:00:00 -0800
];
$this->assertEquals( true, TTDate::isConsecutiveDays( $date_array ) );
}
function testLocationTimeZone() {
$upf = TTnew( 'UserPreferenceFactory' ); /** @var UserPreferenceFactory $upf */
$this->assertEquals( 'America/Vancouver', $upf->getLocationTimeZone( 'CA', 'BC' ) );
$this->assertEquals( 'America/Los_Angeles', $upf->getLocationTimeZone( 'US', 'WA' ) );
$this->assertEquals( 'America/Los_Angeles', $upf->getLocationTimeZone( 'US', 'WA', '2065555555' ) );
$this->assertEquals( 'America/New_York', $upf->getLocationTimeZone( 'US', 'NY' ) );
$this->assertEquals( 'America/New_York', $upf->getLocationTimeZone( 'US', 'NY', '2065555555' ) ); //Province doesn't match, so it uses that instead.
$this->assertEquals( 'America/New_York', $upf->getLocationTimeZone( 'US', 'FL' ) ); //Same state with different timezones based on phone number.
$this->assertEquals( 'America/New_York', $upf->getLocationTimeZone( 'US', 'FL', '8135555555' ) ); //Same state with different timezones based on phone number.
$this->assertEquals( 'America/New_York', $upf->getLocationTimeZone( 'US', 'FL', '8505555555' ) ); //Same state with different timezones based on phone number.
$this->assertEquals( 'America/Chicago', $upf->getLocationTimeZone( 'US', 'FL', '8505555555', null, 'America/Chicago' ) ); //Same state with different timezones based on phone number.
$this->assertEquals( 'America/Los_Angeles', $upf->getLocationTimeZone( 'US', 'FL', '8505555555', null, 'America/Los_Angeles' ) ); //Test forcing to a default timezone.
$this->assertEquals( 'America/Antigua', $upf->getLocationTimeZone( 'AG', '' ) );
$this->assertEquals( 'America/Antigua', $upf->getLocationTimeZone( 'AG', '00' ) );
$this->assertEquals( 'America/Nassau', $upf->getLocationTimeZone( 'BS', '' ) );
$this->assertEquals( 'America/Nassau', $upf->getLocationTimeZone( 'BS', '', '2525555555' ) );
$this->assertEquals( 'America/Nassau', $upf->getLocationTimeZone( 'BS', '00', '2525555555' ) );
$this->assertEquals( 'America/Chicago', $upf->getLocationTimeZone( 'US', 'NE', '3085555555', null, 'America/Chicago' ) );
$this->assertEquals( 'America/Denver', $upf->getLocationTimeZone( 'US', 'NE', '3085555555', null, 'America/Denver' ) );
}
function testISODateParsing() {
TTDate::setTimeZone( 'America/New_York', true ); //Due to being a singleton and PHPUnit resetting the state, always force the timezone to be set.
$this->assertEquals( '2019-01-31', TTDate::getISODateStamp( strtotime( '31-Jan-2019' ) ) );
$test_date = strtotime( TTDate::getISODateStamp( strtotime( '31-Jan-2019' ) ) );
$this->assertEquals( '2019-01-31', TTDate::getISODateStamp( $test_date ) );
$test_date = TTDate::getISODateStamp( strtotime( '31-Jan-2019' ) ); //As if we are passing a string date through an API
TTDate::setTimeZone( 'America/Vancouver', true ); //Change timezone to something different as its an API server.
$this->assertEquals( strtotime( $test_date ), strtotime( '31-Jan-2019' ) ); //Parse string date to the same value on the API server.
TTDate::setTimeZone( 'America/New_York', true ); //Due to being a singleton and PHPUnit resetting the state, always force the timezone to be set.
$this->assertEquals( 'Thu, 31 Jan 2019 22:22:22 -0500', TTDate::getISOTimeStamp( strtotime( '31-Jan-2019 22:22:22' ) ) );
$test_date = strtotime( TTDate::getISOTimeStamp( strtotime( '31-Jan-2019 22:22:22' ) ) );
$this->assertEquals( 'Thu, 31 Jan 2019 22:22:22 -0500', TTDate::getISOTimeStamp( $test_date ) );
$test_date = TTDate::getISOTimeStamp( strtotime( '31-Jan-2019 22:22:22' ) ); //As if we are passing a string date through an API
TTDate::setTimeZone( 'America/Vancouver', true ); //Change timezone to something different as its an API server.
$this->assertEquals( strtotime( $test_date ), strtotime( 'Thu, 31 Jan 2019 22:22:22 -0500' ) ); //Parse string date to the same value on the API server.
}
function testHumanTimeSince() {
$this->assertEquals( '0.0 sec', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '2.0 secs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 12:00:02' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '2.0 secs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 11:59:58' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '62.0 secs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 12:01:02' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '3.0 mins', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 11:57:02' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '2.0 hrs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2019 09:57:02' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '48.0 hrs', TTDate::getHumanTimeSince( strtotime( '29-Nov-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '3.0 days', TTDate::getHumanTimeSince( strtotime( '28-Nov-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '3.0 days', TTDate::getHumanTimeSince( strtotime( '04-Dec-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '8.0 days', TTDate::getHumanTimeSince( strtotime( '23-Nov-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '2.1 wks', TTDate::getHumanTimeSince( strtotime( '16-Nov-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '4.3 wks', TTDate::getHumanTimeSince( strtotime( '01-Nov-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '4.0 mths', TTDate::getHumanTimeSince( strtotime( '01-Aug-2019 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '12.0 mths', TTDate::getHumanTimeSince( strtotime( '01-Dec-2018 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '24.0 mths', TTDate::getHumanTimeSince( strtotime( '01-Dec-2017 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '3.0 yrs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2016 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '19.0 yrs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2000 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '114.0 yrs', TTDate::getHumanTimeSince( strtotime( '01-Dec-1905 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( '81.0 yrs', TTDate::getHumanTimeSince( strtotime( '01-Dec-2100 12:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
}
function testTimeStampOverLap() {
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ) ) ); //Exact match
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '02-Dec-2019 8:00:00' ), strtotime( '02-Dec-2019 17:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 17:05:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) ); //Does not overlap, must be able to end one shift and start a new one at the same time.
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ), strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ) ) ); //Does not overlap, must be able to end one shift and start a new one at the same time.
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 08:00:00' ) ) ); //Does not overlap, must be able to end one shift and start a new one at the same time.
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 08:00:00' ), strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ) ) ); //Does not overlap, must be able to end one shift and start a new one at the same time.
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 16:59:59' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 12:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 08:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 07:59:59' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 17:00:01' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 12:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 08:00:00' ) ) ); //Does not overlap, must be able to end one shift and start a new one at the same time.
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 07:59:59' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 01:00:00' ), strtotime( '01-Dec-2019 07:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 17:00:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 20:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 23:00:00' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 23:00:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 8:00:00' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 16:59:59' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 17:00:01' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 22:59:59' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 23:00:00' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '01-Dec-2019 23:00:01' ), strtotime( '01-Dec-2019 23:59:01' ), strtotime( '01-Dec-2019 17:00:00' ), strtotime( '01-Dec-2019 23:00:00' ) ) );
$this->assertEquals( false, TTDate::isTimeOverLap( strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '29-Dec-13 12:00 AM PST' ), strtotime( '04-Jan-14 11:59 PM PST' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '28-Dec-13 11:59 PM PST' ) ) );
$this->assertEquals( true, TTDate::isTimeOverLap( strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '28-Dec-13 11:59 PM PST' ), strtotime( '22-Dec-13 12:00 AM PST' ), strtotime( '22-Dec-13 12:00 AM PST' ) ) );
}
function testConvertTimeZone() {
TTDate::setTimeZone( 'America/Phoenix', true ); //Force to non-DST timezone. 'PST' isnt actually valid, but Arizona doesn't observe DST.
$this->assertEquals( '15-Jan-21 2:00 PM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Jan-2021 11:00:00 AM PST'), 'America/New_York') ) );
$this->assertEquals( '15-Jan-21 1:00 PM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Jan-2021 11:00:00 AM MST'), 'America/New_York') ) );
$this->assertEquals( '15-Jan-21 11:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Jan-2021 2:00:00 PM EST'), 'America/Vancouver') ) );
$this->assertEquals( '15-Jan-21 10:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Jan-2021 10:00:00 AM MST'), 'America/Phoenix') ) );
$this->assertEquals( '15-Jan-21 9:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Jan-2021 10:00:00 AM MDT'), 'America/Phoenix') ) );
$this->assertEquals( '15-Mar-21 2:00 PM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Mar-2021 11:00:00 AM PDT'), 'America/New_York') ) );
$this->assertEquals( '15-Mar-21 1:00 PM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Mar-2021 11:00:00 AM MDT'), 'America/New_York') ) );
$this->assertEquals( '15-Mar-21 11:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Mar-2021 2:00:00 PM EDT'), 'America/Vancouver') ) );
$this->assertEquals( '15-Mar-21 10:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Mar-2021 10:00:00 AM MST'), 'America/Phoenix') ) );
$this->assertEquals( '15-Mar-21 9:00 AM MST', TTDate::getDate( 'DATE+TIME', TTDate::convertTimeZone( strtotime('15-Mar-2021 10:00:00 AM MDT'), 'America/Phoenix') ) );
}
function testDateDifference() {
TTDate::setTimeZone( 'America/Vancouver', true ); //Force to non-DST timezone. 'PST' isnt actually valid.
$this->assertEquals( 0, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('15-Jan-2021 11:00:00 AM PST'), '%a' ) ); //Days
$this->assertEquals( 1, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('16-Jan-2021 11:00:00 AM PST'), '%a' ) ); //Days
$this->assertEquals( 31, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('15-Feb-2021 11:00:00 AM PST'), '%a' ) ); //Days
$this->assertEquals( 0, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('14-Feb-2021 11:00:00 AM PST'), '%m' ) ); //Months
$this->assertEquals( 1, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('15-Feb-2021 11:00:00 AM PST'), '%m' ) ); //Months
$this->assertEquals( 0, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('14-Jan-2022 11:00:00 AM PST'), '%y' ) ); //Years
$this->assertEquals( 1, TTDate::getDateDifference( strtotime('15-Jan-2021 11:00:00 AM PST'), strtotime('15-Jan-2022 11:00:00 AM PST'), '%y' ) ); //Years
$this->assertEquals( 10, TTDate::getDateDifference( strtotime('15-Jan-2010 11:00:00 AM PST'), strtotime('15-Jan-2020 11:00:00 AM PST'), '%y' ) ); //Years
$this->assertEquals( 20, TTDate::getDateDifference( strtotime('15-Jan-2000 11:00:00 AM PST'), strtotime('15-Jan-2020 11:00:00 AM PST'), '%y' ) ); //Years
$this->assertEquals( 100, TTDate::getDateDifference( strtotime('15-Jan-2000 11:00:00 AM PST'), strtotime('15-Jan-2100 11:00:00 AM PST'), '%y' ) ); //Years
}
function testGetISOTimeStampWithMilliseconds() {
$this->assertEquals( '2021-02-19 14:35:37.000000 -0800', TTDate::getISOTimeStampWithMilliseconds(1613774137) );
$this->assertEquals( '2021-02-19 14:35:37.000000 -0800', TTDate::getISOTimeStampWithMilliseconds( (float)1613774137) );
$this->assertEquals( '2021-02-19 14:35:37.000000 -0800', TTDate::getISOTimeStampWithMilliseconds( (float)1613774137.0000) );
$this->assertEquals( '2021-02-19 14:35:37.000001 -0800', TTDate::getISOTimeStampWithMilliseconds( (float)1613774137.000001) );
}
}
?>
Reference in New Issue View Git Blame Copy Permalink