1043 lines
33 KiB
PHP
Executable File
1043 lines
33 KiB
PHP
Executable File
<?php
|
|
|
|
/*
|
|
* This file is part of the Carbon package.
|
|
*
|
|
* (c) Brian Nesbitt <brian@nesbot.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
use Carbon\Carbon;
|
|
use Carbon\CarbonInterval;
|
|
|
|
class DiffTest extends TestFixture
|
|
{
|
|
public function testDiffInYearsPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInYears($dt->copy()->addYear()));
|
|
}
|
|
|
|
public function testDiffInYearsNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-1, $dt->diffInYears($dt->copy()->subYear(), false));
|
|
}
|
|
|
|
public function testDiffInYearsNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInYears($dt->copy()->subYear()));
|
|
}
|
|
|
|
public function testDiffInYearsVsDefaultNow()
|
|
{
|
|
$this->assertSame(1, Carbon::now()->subYear()->diffInYears());
|
|
}
|
|
|
|
public function testDiffInYearsEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInYears($dt->copy()->addYear()->addMonths(7)));
|
|
}
|
|
|
|
public function testDiffInMonthsPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(13, $dt->diffInMonths($dt->copy()->addYear()->addMonth()));
|
|
}
|
|
|
|
public function testDiffInMonthsNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-11, $dt->diffInMonths($dt->copy()->subYear()->addMonth(), false));
|
|
}
|
|
|
|
public function testDiffInMonthsNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(11, $dt->diffInMonths($dt->copy()->subYear()->addMonth()));
|
|
}
|
|
|
|
public function testDiffInMonthsVsDefaultNow()
|
|
{
|
|
$this->assertSame(12, Carbon::now()->subYear()->diffInMonths());
|
|
}
|
|
|
|
public function testDiffInMonthsEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInMonths($dt->copy()->addMonth()->addDays(16)));
|
|
}
|
|
|
|
public function testDiffInDaysPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(366, $dt->diffInDays($dt->copy()->addYear()));
|
|
}
|
|
|
|
public function testDiffInDaysNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-365, $dt->diffInDays($dt->copy()->subYear(), false));
|
|
}
|
|
|
|
public function testDiffInDaysNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(365, $dt->diffInDays($dt->copy()->subYear()));
|
|
}
|
|
|
|
public function testDiffInDaysVsDefaultNow()
|
|
{
|
|
$this->assertSame(7, Carbon::now()->subWeek()->diffInDays());
|
|
}
|
|
|
|
public function testDiffInDaysEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInDays($dt->copy()->addDay()->addHours(13)));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredPositiveWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(5, $dt->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === 1;
|
|
}, $dt->copy()->endOfMonth()));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredPositiveWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 1);
|
|
$dt2 = Carbon::createFromDate(2000, 1, 31);
|
|
|
|
$this->assertSame(5, $dt1->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === Carbon::SUNDAY;
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredNegativeNoSignWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(5, $dt->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === Carbon::SUNDAY;
|
|
}, $dt->copy()->startOfMonth()));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredNegativeNoSignWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 31);
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1);
|
|
|
|
$this->assertSame(5, $dt1->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === Carbon::SUNDAY;
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredNegativeWithSignWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(-5, $dt->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === 1;
|
|
}, $dt->copy()->startOfMonth(), false));
|
|
}
|
|
|
|
public function testDiffInDaysFilteredNegativeWithSignWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 31);
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1);
|
|
|
|
$this->assertSame(-5, $dt1->diffInDaysFiltered(function (Carbon $date) {
|
|
return $date->dayOfWeek === Carbon::SUNDAY;
|
|
}, $dt2, false));
|
|
}
|
|
|
|
public function testDiffInHoursFiltered()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 31)->endOfDay();
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1)->startOfDay();
|
|
|
|
$this->assertSame(31, $dt1->diffInHoursFiltered(function (Carbon $date)
|
|
{
|
|
return $date->hour === 9;
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffInHoursFilteredNegative()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 31)->endOfDay();
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1)->startOfDay();
|
|
|
|
$this->assertSame(-31, $dt1->diffInHoursFiltered(function (Carbon $date)
|
|
{
|
|
return $date->hour === 9;
|
|
}, $dt2, false));
|
|
}
|
|
|
|
public function testDiffInHoursFilteredWorkHoursPerWeek()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2000, 1, 5)->endOfDay();
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1)->startOfDay();
|
|
|
|
$this->assertSame(40, $dt1->diffInHoursFiltered(function (Carbon $date)
|
|
{
|
|
return ($date->hour > 8 && $date->hour < 17);
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffFilteredUsingMinutesPositiveWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1)->startOfDay();
|
|
$this->assertSame(60, $dt->diffFiltered(CarbonInterval::minute(), function (Carbon $date) {
|
|
return $date->hour === 12;
|
|
}, Carbon::createFromDate(2000, 1, 1)->endOfDay()));
|
|
}
|
|
|
|
public function testDiffFilteredPositiveWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::create(2000, 1, 1);
|
|
$dt2 = $dt1->copy()->addSeconds(80);
|
|
|
|
$this->assertSame(40, $dt1->diffFiltered(CarbonInterval::second(), function (Carbon $date) {
|
|
return $date->second % 2 === 0;
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffFilteredNegativeNoSignWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
|
|
$this->assertSame(2, $dt->diffFiltered(CarbonInterval::days(2), function (Carbon $date) {
|
|
return $date->dayOfWeek === Carbon::SUNDAY;
|
|
}, $dt->copy()->startOfMonth()));
|
|
}
|
|
|
|
public function testDiffFilteredNegativeNoSignWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2006, 1, 31);
|
|
$dt2 = Carbon::createFromDate(2000, 1, 1);
|
|
|
|
$this->assertSame(7, $dt1->diffFiltered(CarbonInterval::year(), function (Carbon $date) {
|
|
return $date->month === 1;
|
|
}, $dt2));
|
|
}
|
|
|
|
public function testDiffFilteredNegativeWithSignWithMutated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(-4, $dt->diffFiltered(CarbonInterval::week(), function (Carbon $date) {
|
|
return $date->month === 12;
|
|
}, $dt->copy()->subMonths(3), false));
|
|
}
|
|
|
|
public function testDiffFilteredNegativeWithSignWithSecondObject()
|
|
{
|
|
$dt1 = Carbon::createFromDate(2001, 1, 31);
|
|
$dt2 = Carbon::createFromDate(1999, 1, 1);
|
|
|
|
$this->assertSame(-12, $dt1->diffFiltered(CarbonInterval::month(), function (Carbon $date) {
|
|
return $date->year === 2000;
|
|
}, $dt2, false));
|
|
}
|
|
|
|
public function testBug188DiffWithSameDates()
|
|
{
|
|
$start = Carbon::create(2014, 10, 8, 15, 20, 0);
|
|
$end = $start->copy();
|
|
|
|
$this->assertSame(0, $start->diffInDays($end));
|
|
$this->assertSame(0, $start->diffInWeekdays($end));
|
|
}
|
|
|
|
public function testBug188DiffWithDatesOnlyHoursApart()
|
|
{
|
|
$start = Carbon::create(2014, 10, 8, 15, 20, 0);
|
|
$end = $start->copy();
|
|
|
|
$this->assertSame(0, $start->diffInDays($end));
|
|
$this->assertSame(0, $start->diffInWeekdays($end));
|
|
}
|
|
|
|
public function testBug188DiffWithSameDates1DayApart()
|
|
{
|
|
$start = Carbon::create(2014, 10, 8, 15, 20, 0);
|
|
$end = $start->copy()->addDay();
|
|
|
|
$this->assertSame(1, $start->diffInDays($end));
|
|
$this->assertSame(1, $start->diffInWeekdays($end));
|
|
}
|
|
|
|
public function testBug188DiffWithDatesOnTheWeekend()
|
|
{
|
|
$start = Carbon::create(2014, 1, 1, 0, 0, 0);
|
|
$start->next(Carbon::SATURDAY);
|
|
$end = $start->copy()->addDay();
|
|
|
|
$this->assertSame(1, $start->diffInDays($end));
|
|
$this->assertSame(0, $start->diffInWeekdays($end));
|
|
}
|
|
|
|
public function testDiffInWeekdaysPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(21, $dt->diffInWeekdays($dt->copy()->endOfMonth()));
|
|
}
|
|
|
|
public function testDiffInWeekdaysNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(21, $dt->diffInWeekdays($dt->copy()->startOfMonth()));
|
|
}
|
|
|
|
public function testDiffInWeekdaysNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(-21, $dt->diffInWeekdays($dt->copy()->startOfMonth(), false));
|
|
}
|
|
|
|
public function testDiffInWeekendDaysPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(10, $dt->diffInWeekendDays($dt->copy()->endOfMonth()));
|
|
}
|
|
|
|
public function testDiffInWeekendDaysNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(10, $dt->diffInWeekendDays($dt->copy()->startOfMonth()));
|
|
}
|
|
|
|
public function testDiffInWeekendDaysNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 31);
|
|
$this->assertSame(-10, $dt->diffInWeekendDays($dt->copy()->startOfMonth(), false));
|
|
}
|
|
|
|
public function testDiffInWeeksPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(52, $dt->diffInWeeks($dt->copy()->addYear()));
|
|
}
|
|
|
|
public function testDiffInWeeksNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-52, $dt->diffInWeeks($dt->copy()->subYear(), false));
|
|
}
|
|
|
|
public function testDiffInWeeksNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(52, $dt->diffInWeeks($dt->copy()->subYear()));
|
|
}
|
|
|
|
public function testDiffInWeeksVsDefaultNow()
|
|
{
|
|
$this->assertSame(1, Carbon::now()->subWeek()->diffInWeeks());
|
|
}
|
|
|
|
public function testDiffInWeeksEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(0, $dt->diffInWeeks($dt->copy()->addWeek()->subDay()));
|
|
}
|
|
|
|
public function testDiffInHoursPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(26, $dt->diffInHours($dt->copy()->addDay()->addHours(2)));
|
|
}
|
|
|
|
public function testDiffInHoursNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-22, $dt->diffInHours($dt->copy()->subDay()->addHours(2), false));
|
|
}
|
|
|
|
public function testDiffInHoursNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(22, $dt->diffInHours($dt->copy()->subDay()->addHours(2)));
|
|
}
|
|
|
|
public function testDiffInHoursVsDefaultNow()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 15));
|
|
$this->assertSame(48, Carbon::now()->subDays(2)->diffInHours());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffInHoursEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInHours($dt->copy()->addHour()->addMinutes(31)));
|
|
}
|
|
|
|
public function testDiffInMinutesPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(62, $dt->diffInMinutes($dt->copy()->addHour()->addMinutes(2)));
|
|
}
|
|
|
|
public function testDiffInMinutesPositiveAlot()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1502, $dt->diffInMinutes($dt->copy()->addHours(25)->addMinutes(2)));
|
|
}
|
|
|
|
public function testDiffInMinutesNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-58, $dt->diffInMinutes($dt->copy()->subHour()->addMinutes(2), false));
|
|
}
|
|
|
|
public function testDiffInMinutesNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(58, $dt->diffInMinutes($dt->copy()->subHour()->addMinutes(2)));
|
|
}
|
|
|
|
public function testDiffInMinutesVsDefaultNow()
|
|
{
|
|
$this->assertSame(60, Carbon::now()->subHour()->diffInMinutes());
|
|
}
|
|
|
|
public function testDiffInMinutesEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInMinutes($dt->copy()->addMinute()->addSeconds(31)));
|
|
}
|
|
|
|
public function testDiffInSecondsPositive()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(62, $dt->diffInSeconds($dt->copy()->addMinute()->addSeconds(2)));
|
|
}
|
|
|
|
public function testDiffInSecondsPositiveAlot()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(7202, $dt->diffInSeconds($dt->copy()->addHours(2)->addSeconds(2)));
|
|
}
|
|
|
|
public function testDiffInSecondsNegativeWithSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(-58, $dt->diffInSeconds($dt->copy()->subMinute()->addSeconds(2), false));
|
|
}
|
|
|
|
public function testDiffInSecondsNegativeNoSign()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(58, $dt->diffInSeconds($dt->copy()->subMinute()->addSeconds(2)));
|
|
}
|
|
|
|
public function testDiffInSecondsVsDefaultNow()
|
|
{
|
|
$this->assertSame(3600, Carbon::now()->subHour()->diffInSeconds());
|
|
}
|
|
|
|
public function testDiffInSecondsEnsureIsTruncated()
|
|
{
|
|
$dt = Carbon::createFromDate(2000, 1, 1);
|
|
$this->assertSame(1, $dt->diffInSeconds($dt->copy()->addSeconds(1.9)));
|
|
}
|
|
|
|
public function testDiffInSecondsWithTimezones()
|
|
{
|
|
$dtOttawa = Carbon::createFromDate(2000, 1, 1, 'America/Toronto');
|
|
$dtVancouver = Carbon::createFromDate(2000, 1, 1, 'America/Vancouver');
|
|
$this->assertSame(3 * 60 * 60, $dtOttawa->diffInSeconds($dtVancouver));
|
|
}
|
|
|
|
public function testDiffInSecondsWithTimezonesAndVsDefault()
|
|
{
|
|
$dt = Carbon::now('America/Vancouver');
|
|
$this->assertSame(0, $dt->diffInSeconds());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndSecond()
|
|
{
|
|
$d = Carbon::now();
|
|
$this->assertSame('1 second ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndSecondWithTimezone()
|
|
{
|
|
$d = Carbon::now('America/Vancouver');
|
|
$this->assertSame('1 second ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndSeconds()
|
|
{
|
|
$d = Carbon::now()->subSeconds(2);
|
|
$this->assertSame('2 seconds ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyMinute()
|
|
{
|
|
$d = Carbon::now()->subSeconds(59);
|
|
$this->assertSame('59 seconds ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndMinute()
|
|
{
|
|
$d = Carbon::now()->subMinute();
|
|
$this->assertSame('1 minute ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndMinutes()
|
|
{
|
|
$d = Carbon::now()->subMinutes(2);
|
|
$this->assertSame('2 minutes ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyHour()
|
|
{
|
|
$d = Carbon::now()->subMinutes(59);
|
|
$this->assertSame('59 minutes ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndHour()
|
|
{
|
|
$d = Carbon::now()->subHour();
|
|
$this->assertSame('1 hour ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndHours()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 15));
|
|
$d = Carbon::now()->subHours(2);
|
|
$this->assertSame('2 hours ago', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyDay()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 15));
|
|
$d = Carbon::now()->subHours(23);
|
|
$this->assertSame('23 hours ago', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndDay()
|
|
{
|
|
$d = Carbon::now()->subDay();
|
|
$this->assertSame('1 day ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndDays()
|
|
{
|
|
$d = Carbon::now()->subDays(2);
|
|
$this->assertSame('2 days ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyWeek()
|
|
{
|
|
$d = Carbon::now()->subDays(6);
|
|
$this->assertSame('6 days ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndWeek()
|
|
{
|
|
$d = Carbon::now()->subWeek();
|
|
$this->assertSame('1 week ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndWeeks()
|
|
{
|
|
$d = Carbon::now()->subWeeks(2);
|
|
$this->assertSame('2 weeks ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyMonth()
|
|
{
|
|
$d = Carbon::now()->subWeeks(3);
|
|
$this->assertSame('3 weeks ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndMonth()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->subWeeks(4);
|
|
$this->assertSame('4 weeks ago', $d->diffForHumans());
|
|
$d = Carbon::now()->subMonth();
|
|
$this->assertSame('1 month ago', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndMonths()
|
|
{
|
|
$d = Carbon::now()->subMonths(2);
|
|
$this->assertSame('2 months ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyYear()
|
|
{
|
|
$d = Carbon::now()->subMonths(11);
|
|
$this->assertSame('11 months ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndYear()
|
|
{
|
|
$d = Carbon::now()->subYear();
|
|
$this->assertSame('1 year ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndYears()
|
|
{
|
|
$d = Carbon::now()->subYears(2);
|
|
$this->assertSame('2 years ago', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureSecond()
|
|
{
|
|
$d = Carbon::now()->addSecond();
|
|
$this->assertSame('1 second from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureSeconds()
|
|
{
|
|
$d = Carbon::now()->addSeconds(2);
|
|
$this->assertSame('2 seconds from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureMinute()
|
|
{
|
|
$d = Carbon::now()->addSeconds(59);
|
|
$this->assertSame('59 seconds from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureMinute()
|
|
{
|
|
$d = Carbon::now()->addMinute();
|
|
$this->assertSame('1 minute from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureMinutes()
|
|
{
|
|
$d = Carbon::now()->addMinutes(2);
|
|
$this->assertSame('2 minutes from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureHour()
|
|
{
|
|
$d = Carbon::now()->addMinutes(59);
|
|
$this->assertSame('59 minutes from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureHour()
|
|
{
|
|
$d = Carbon::now()->addHour();
|
|
$this->assertSame('1 hour from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureHours()
|
|
{
|
|
$d = Carbon::now()->addHours(2);
|
|
$this->assertSame('2 hours from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureDay()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addHours(23);
|
|
$this->assertSame('23 hours from now', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureDay()
|
|
{
|
|
$d = Carbon::now()->addDay();
|
|
$this->assertSame('1 day from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureDays()
|
|
{
|
|
$d = Carbon::now()->addDays(2);
|
|
$this->assertSame('2 days from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureWeek()
|
|
{
|
|
$d = Carbon::now()->addDays(6);
|
|
$this->assertSame('6 days from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureWeek()
|
|
{
|
|
$d = Carbon::now()->addWeek();
|
|
$this->assertSame('1 week from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureWeeks()
|
|
{
|
|
$d = Carbon::now()->addWeeks(2);
|
|
$this->assertSame('2 weeks from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureMonth()
|
|
{
|
|
$d = Carbon::now()->addWeeks(3);
|
|
$this->assertSame('3 weeks from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureMonth()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addWeeks(4);
|
|
$this->assertSame('4 weeks from now', $d->diffForHumans());
|
|
$d = Carbon::now()->addMonth();
|
|
$this->assertSame('1 month from now', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureMonths()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addMonths(2);
|
|
$this->assertSame('2 months from now', $d->diffForHumans());
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansNowAndNearlyFutureYear()
|
|
{
|
|
$d = Carbon::now()->addMonths(11);
|
|
$this->assertSame('11 months from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureYear()
|
|
{
|
|
$d = Carbon::now()->addYear();
|
|
$this->assertSame('1 year from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansNowAndFutureYears()
|
|
{
|
|
$d = Carbon::now()->addYears(2);
|
|
$this->assertSame('2 years from now', $d->diffForHumans());
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndSecond()
|
|
{
|
|
$d = Carbon::now()->addSecond();
|
|
$this->assertSame('1 second before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndSeconds()
|
|
{
|
|
$d = Carbon::now()->addSeconds(2);
|
|
$this->assertSame('2 seconds before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyMinute()
|
|
{
|
|
$d = Carbon::now()->addSeconds(59);
|
|
$this->assertSame('59 seconds before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndMinute()
|
|
{
|
|
$d = Carbon::now()->addMinute();
|
|
$this->assertSame('1 minute before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndMinutes()
|
|
{
|
|
$d = Carbon::now()->addMinutes(2);
|
|
$this->assertSame('2 minutes before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyHour()
|
|
{
|
|
$d = Carbon::now()->addMinutes(59);
|
|
$this->assertSame('59 minutes before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndHour()
|
|
{
|
|
$d = Carbon::now()->addHour();
|
|
$this->assertSame('1 hour before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndHours()
|
|
{
|
|
$d = Carbon::now()->addHours(2);
|
|
$this->assertSame('2 hours before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyDay()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addHours(23);
|
|
$this->assertSame('23 hours before', Carbon::now()->diffForHumans($d));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndDay()
|
|
{
|
|
$d = Carbon::now()->addDay();
|
|
$this->assertSame('1 day before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndDays()
|
|
{
|
|
$d = Carbon::now()->addDays(2);
|
|
$this->assertSame('2 days before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyWeek()
|
|
{
|
|
$d = Carbon::now()->addDays(6);
|
|
$this->assertSame('6 days before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndWeek()
|
|
{
|
|
$d = Carbon::now()->addWeek();
|
|
$this->assertSame('1 week before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndWeeks()
|
|
{
|
|
$d = Carbon::now()->addWeeks(2);
|
|
$this->assertSame('2 weeks before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyMonth()
|
|
{
|
|
$d = Carbon::now()->addWeeks(3);
|
|
$this->assertSame('3 weeks before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndMonth()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addWeeks(4);
|
|
$this->assertSame('4 weeks before', Carbon::now()->diffForHumans($d));
|
|
$d = Carbon::now()->addMonth();
|
|
$this->assertSame('1 month before', Carbon::now()->diffForHumans($d));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndMonths()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->addMonths(2);
|
|
$this->assertSame('2 months before', Carbon::now()->diffForHumans($d));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyYear()
|
|
{
|
|
$d = Carbon::now()->addMonths(11);
|
|
$this->assertSame('11 months before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndYear()
|
|
{
|
|
$d = Carbon::now()->addYear();
|
|
$this->assertSame('1 year before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndYears()
|
|
{
|
|
$d = Carbon::now()->addYears(2);
|
|
$this->assertSame('2 years before', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureSecond()
|
|
{
|
|
$d = Carbon::now()->subSecond();
|
|
$this->assertSame('1 second after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureSeconds()
|
|
{
|
|
$d = Carbon::now()->subSeconds(2);
|
|
$this->assertSame('2 seconds after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureMinute()
|
|
{
|
|
$d = Carbon::now()->subSeconds(59);
|
|
$this->assertSame('59 seconds after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureMinute()
|
|
{
|
|
$d = Carbon::now()->subMinute();
|
|
$this->assertSame('1 minute after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureMinutes()
|
|
{
|
|
$d = Carbon::now()->subMinutes(2);
|
|
$this->assertSame('2 minutes after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureHour()
|
|
{
|
|
$d = Carbon::now()->subMinutes(59);
|
|
$this->assertSame('59 minutes after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureHour()
|
|
{
|
|
$d = Carbon::now()->subHour();
|
|
$this->assertSame('1 hour after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureHours()
|
|
{
|
|
$d = Carbon::now()->subHours(2);
|
|
$this->assertSame('2 hours after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureDay()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 15));
|
|
$d = Carbon::now()->subHours(23);
|
|
$this->assertSame('23 hours after', Carbon::now()->diffForHumans($d));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureDay()
|
|
{
|
|
$d = Carbon::now()->subDay();
|
|
$this->assertSame('1 day after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureDays()
|
|
{
|
|
$d = Carbon::now()->subDays(2);
|
|
$this->assertSame('2 days after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureWeek()
|
|
{
|
|
$d = Carbon::now()->subDays(6);
|
|
$this->assertSame('6 days after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureWeek()
|
|
{
|
|
$d = Carbon::now()->subWeek();
|
|
$this->assertSame('1 week after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureWeeks()
|
|
{
|
|
$d = Carbon::now()->subWeeks(2);
|
|
$this->assertSame('2 weeks after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureMonth()
|
|
{
|
|
$d = Carbon::now()->subWeeks(3);
|
|
$this->assertSame('3 weeks after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureMonth()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->subWeeks(4);
|
|
$this->assertSame('4 weeks after', Carbon::now()->diffForHumans($d));
|
|
$d = Carbon::now()->subMonth();
|
|
$this->assertSame('1 month after', Carbon::now()->diffForHumans($d));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureMonths()
|
|
{
|
|
$d = Carbon::now()->subMonths(2);
|
|
$this->assertSame('2 months after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndNearlyFutureYear()
|
|
{
|
|
$d = Carbon::now()->subMonths(11);
|
|
$this->assertSame('11 months after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureYear()
|
|
{
|
|
$d = Carbon::now()->subYear();
|
|
$this->assertSame('1 year after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansOtherAndFutureYears()
|
|
{
|
|
$d = Carbon::now()->subYears(2);
|
|
$this->assertSame('2 years after', Carbon::now()->diffForHumans($d));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteSeconds()
|
|
{
|
|
$d = Carbon::now()->subSeconds(59);
|
|
$this->assertSame('59 seconds', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addSeconds(59);
|
|
$this->assertSame('59 seconds', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteMinutes()
|
|
{
|
|
$d = Carbon::now()->subMinutes(30);
|
|
$this->assertSame('30 minutes', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addMinutes(30);
|
|
$this->assertSame('30 minutes', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteHours()
|
|
{
|
|
$d = Carbon::now()->subHours(3);
|
|
$this->assertSame('3 hours', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addHours(3);
|
|
$this->assertSame('3 hours', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteDays()
|
|
{
|
|
$d = Carbon::now()->subDays(2);
|
|
$this->assertSame('2 days', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addDays(2);
|
|
$this->assertSame('2 days', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteWeeks()
|
|
{
|
|
$d = Carbon::now()->subWeeks(2);
|
|
$this->assertSame('2 weeks', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addWeeks(2);
|
|
$this->assertSame('2 weeks', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteMonths()
|
|
{
|
|
Carbon::setTestNow(Carbon::create(2012, 1, 1));
|
|
$d = Carbon::now()->subMonths(2);
|
|
$this->assertSame('2 months', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addMonths(2);
|
|
$this->assertSame('2 months', Carbon::now()->diffForHumans($d, true));
|
|
Carbon::setTestNow();
|
|
}
|
|
|
|
public function testDiffForHumansAbsoluteYears()
|
|
{
|
|
$d = Carbon::now()->subYears(1);
|
|
$this->assertSame('1 year', Carbon::now()->diffForHumans($d, true));
|
|
$d = Carbon::now()->addYears(1);
|
|
$this->assertSame('1 year', Carbon::now()->diffForHumans($d, true));
|
|
}
|
|
|
|
public function testDiffForHumansWithShorterMonthShouldStillBeAMonth()
|
|
{
|
|
$feb15 = Carbon::parse('2015-02-15');
|
|
$mar15 = Carbon::parse('2015-03-15');
|
|
$this->assertSame('1 month after', $mar15->diffForHumans($feb15));
|
|
}
|
|
}
|