from datetime import datetime

import pendulum
import pytest


def test_diff_in_years_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(years=1)).in_years()


def test_diff_in_years_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -1 == dt.diff(dt.subtract(years=1), False).in_years()


def test_diff_in_years_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.subtract(years=1)).in_years()


def test_diff_in_years_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 1 == pendulum.now().subtract(years=1).diff().in_years()


def test_diff_in_years_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(years=1).add(months=7)).in_years()


def test_diff_in_months_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 13 == dt.diff(dt.add(years=1).add(months=1)).in_months()


def test_diff_in_months_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -11 == dt.diff(dt.subtract(years=1).add(months=1), False).in_months()


def test_diff_in_months_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 11 == dt.diff(dt.subtract(years=1).add(months=1)).in_months()


def test_diff_in_months_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 12 == pendulum.now().subtract(years=1).diff().in_months()


def test_diff_in_months_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(months=1).add(days=16)).in_months()


def test_diff_in_days_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 366 == dt.diff(dt.add(years=1)).in_days()


def test_diff_in_days_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -365 == dt.diff(dt.subtract(years=1), False).in_days()


def test_diff_in_days_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 365 == dt.diff(dt.subtract(years=1)).in_days()


def test_diff_in_days_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 7 == pendulum.now().subtract(weeks=1).diff().in_days()


def test_diff_in_days_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(days=1).add(hours=13)).in_days()


def test_diff_in_weeks_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 52 == dt.diff(dt.add(years=1)).in_weeks()


def test_diff_in_weeks_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -52 == dt.diff(dt.subtract(years=1), False).in_weeks()


def test_diff_in_weeks_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 52 == dt.diff(dt.subtract(years=1)).in_weeks()


def test_diff_in_weeks_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 1 == pendulum.now().subtract(weeks=1).diff().in_weeks()


def test_diff_in_weeks_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 0 == dt.diff(dt.add(weeks=1).subtract(days=1)).in_weeks()


def test_diff_in_hours_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 26 == dt.diff(dt.add(days=1).add(hours=2)).in_hours()


def test_diff_in_hours_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -22 == dt.diff(dt.subtract(days=1).add(hours=2), False).in_hours()


def test_diff_in_hours_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 22 == dt.diff(dt.subtract(days=1).add(hours=2)).in_hours()


def test_diff_in_hours_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 15)):
        assert 48 == pendulum.now().subtract(days=2).diff().in_hours()


def test_diff_in_hours_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(hours=1).add(minutes=31)).in_hours()


def test_diff_in_minutes_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 62 == dt.diff(dt.add(hours=1).add(minutes=2)).in_minutes()


def test_diff_in_minutes_positive_big():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1502 == dt.diff(dt.add(hours=25).add(minutes=2)).in_minutes()


def test_diff_in_minutes_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -58 == dt.diff(dt.subtract(hours=1).add(minutes=2), False).in_minutes()


def test_diff_in_minutes_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 58 == dt.diff(dt.subtract(hours=1).add(minutes=2)).in_minutes()


def test_diff_in_minutes_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 60 == pendulum.now().subtract(hours=1).diff().in_minutes()


def test_diff_in_minutes_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(minutes=1).add(seconds=59)).in_minutes()


def test_diff_in_seconds_positive():
    dt = pendulum.datetime(2000, 1, 1)
    assert 62 == dt.diff(dt.add(minutes=1).add(seconds=2)).in_seconds()


def test_diff_in_seconds_positive_big():
    dt = pendulum.datetime(2000, 1, 1)
    assert 7202 == dt.diff(dt.add(hours=2).add(seconds=2)).in_seconds()


def test_diff_in_seconds_negative_with_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert -58 == dt.diff(dt.subtract(minutes=1).add(seconds=2), False).in_seconds()


def test_diff_in_seconds_negative_no_sign():
    dt = pendulum.datetime(2000, 1, 1)
    assert 58 == dt.diff(dt.subtract(minutes=1).add(seconds=2)).in_seconds()


def test_diff_in_seconds_vs_default_now():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert 3600 == pendulum.now().subtract(hours=1).diff().in_seconds()


def test_diff_in_seconds_ensure_is_truncated():
    dt = pendulum.datetime(2000, 1, 1)
    assert 1 == dt.diff(dt.add(seconds=1.9)).in_seconds()


def test_diff_in_seconds_with_timezones():
    dt_ottawa = pendulum.datetime(2000, 1, 1, 13, tz="America/Toronto")
    dt_vancouver = pendulum.datetime(2000, 1, 1, 13, tz="America/Vancouver")
    assert 3 * 60 * 60 == dt_ottawa.diff(dt_vancouver).in_seconds()


def test_diff_for_humans_now_and_second():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "a few seconds ago" == pendulum.now().diff_for_humans()


def test_diff_for_humans_now_and_second_with_timezone():
    van_now = pendulum.now("America/Vancouver")
    here_now = van_now.in_timezone(pendulum.now().timezone)

    with pendulum.test(here_now):
        assert "a few seconds ago" == here_now.diff_for_humans()


def test_diff_for_humans_now_and_seconds():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert (
            "a few seconds ago" == pendulum.now().subtract(seconds=2).diff_for_humans()
        )


def test_diff_for_humans_now_and_nearly_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 seconds ago" == pendulum.now().subtract(seconds=59).diff_for_humans()


def test_diff_for_humans_now_and_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 minute ago" == pendulum.now().subtract(minutes=1).diff_for_humans()


def test_diff_for_humans_now_and_minutes():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 minutes ago" == pendulum.now().subtract(minutes=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 minutes ago" == pendulum.now().subtract(minutes=59).diff_for_humans()


def test_diff_for_humans_now_and_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 hour ago" == pendulum.now().subtract(hours=1).diff_for_humans()


def test_diff_for_humans_now_and_hours():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 hours ago" == pendulum.now().subtract(hours=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "23 hours ago" == pendulum.now().subtract(hours=23).diff_for_humans()


def test_diff_for_humans_now_and_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 day ago" == pendulum.now().subtract(days=1).diff_for_humans()


def test_diff_for_humans_now_and_days():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 days ago" == pendulum.now().subtract(days=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "6 days ago" == pendulum.now().subtract(days=6).diff_for_humans()


def test_diff_for_humans_now_and_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 week ago" == pendulum.now().subtract(weeks=1).diff_for_humans()


def test_diff_for_humans_now_and_weeks():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 weeks ago" == pendulum.now().subtract(weeks=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "3 weeks ago" == pendulum.now().subtract(weeks=3).diff_for_humans()


def test_diff_for_humans_now_and_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "4 weeks ago" == pendulum.now().subtract(weeks=4).diff_for_humans()
        assert "1 month ago" == pendulum.now().subtract(months=1).diff_for_humans()


def test_diff_for_humans_now_and_months():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 months ago" == pendulum.now().subtract(months=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "11 months ago" == pendulum.now().subtract(months=11).diff_for_humans()


def test_diff_for_humans_now_and_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 year ago" == pendulum.now().subtract(years=1).diff_for_humans()


def test_diff_for_humans_now_and_years():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 years ago" == pendulum.now().subtract(years=2).diff_for_humans()


def test_diff_for_humans_now_and_future_second():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in a few seconds" == pendulum.now().add(seconds=1).diff_for_humans()


def test_diff_for_humans_now_and_future_seconds():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in a few seconds" == pendulum.now().add(seconds=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 59 seconds" == pendulum.now().add(seconds=59).diff_for_humans()


def test_diff_for_humans_now_and_future_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 1 minute" == pendulum.now().add(minutes=1).diff_for_humans()


def test_diff_for_humans_now_and_future_minutes():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 minutes" == pendulum.now().add(minutes=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 59 minutes" == pendulum.now().add(minutes=59).diff_for_humans()


def test_diff_for_humans_now_and_future_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 1 hour" == pendulum.now().add(hours=1).diff_for_humans()


def test_diff_for_humans_now_and_future_hours():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 hours" == pendulum.now().add(hours=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 23 hours" == pendulum.now().add(hours=23).diff_for_humans()


def test_diff_for_humans_now_and_future_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 1 day" == pendulum.now().add(days=1).diff_for_humans()


def test_diff_for_humans_now_and_future_days():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 days" == pendulum.now().add(days=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 6 days" == pendulum.now().add(days=6).diff_for_humans()


def test_diff_for_humans_now_and_future_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 1 week" == pendulum.now().add(weeks=1).diff_for_humans()


def test_diff_for_humans_now_and_future_weeks():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 weeks" == pendulum.now().add(weeks=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 3 weeks" == pendulum.now().add(weeks=3).diff_for_humans()


def test_diff_for_humans_now_and_future_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 4 weeks" == pendulum.now().add(weeks=4).diff_for_humans()
        assert "in 1 month" == pendulum.now().add(months=1).diff_for_humans()


def test_diff_for_humans_now_and_future_months():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 months" == pendulum.now().add(months=2).diff_for_humans()


def test_diff_for_humans_now_and_nearly_future_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 11 months" == pendulum.now().add(months=11).diff_for_humans()


def test_diff_for_humans_now_and_future_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 1 year" == pendulum.now().add(years=1).diff_for_humans()


def test_diff_for_humans_now_and_future_years():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "in 2 years" == pendulum.now().add(years=2).diff_for_humans()


def test_diff_for_humans_other_and_second():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "a few seconds before" == pendulum.now().diff_for_humans(
            pendulum.now().add(seconds=1)
        )


def test_diff_for_humans_other_and_seconds():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "a few seconds before" == pendulum.now().diff_for_humans(
            pendulum.now().add(seconds=2)
        )


def test_diff_for_humans_other_and_nearly_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 seconds before" == pendulum.now().diff_for_humans(
            pendulum.now().add(seconds=59)
        )


def test_diff_for_humans_other_and_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 minute before" == pendulum.now().diff_for_humans(
            pendulum.now().add(minutes=1)
        )


def test_diff_for_humans_other_and_minutes():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 minutes before" == pendulum.now().diff_for_humans(
            pendulum.now().add(minutes=2)
        )


def test_diff_for_humans_other_and_nearly_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 minutes before" == pendulum.now().diff_for_humans(
            pendulum.now().add(minutes=59)
        )


def test_diff_for_humans_other_and_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 hour before" == pendulum.now().diff_for_humans(
            pendulum.now().add(hours=1)
        )


def test_diff_for_humans_other_and_hours():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 hours before" == pendulum.now().diff_for_humans(
            pendulum.now().add(hours=2)
        )


def test_diff_for_humans_other_and_nearly_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "23 hours before" == pendulum.now().diff_for_humans(
            pendulum.now().add(hours=23)
        )


def test_diff_for_humans_other_and_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 day before" == pendulum.now().diff_for_humans(
            pendulum.now().add(days=1)
        )


def test_diff_for_humans_other_and_days():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 days before" == pendulum.now().diff_for_humans(
            pendulum.now().add(days=2)
        )


def test_diff_for_humans_other_and_nearly_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "6 days before" == pendulum.now().diff_for_humans(
            pendulum.now().add(days=6)
        )


def test_diff_for_humans_other_and_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 week before" == pendulum.now().diff_for_humans(
            pendulum.now().add(weeks=1)
        )


def test_diff_for_humans_other_and_weeks():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 weeks before" == pendulum.now().diff_for_humans(
            pendulum.now().add(weeks=2)
        )


def test_diff_for_humans_other_and_nearly_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "3 weeks before" == pendulum.now().diff_for_humans(
            pendulum.now().add(weeks=3)
        )


def test_diff_for_humans_other_and_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "4 weeks before" == pendulum.now().diff_for_humans(
            pendulum.now().add(weeks=4)
        )
        assert "1 month before" == pendulum.now().diff_for_humans(
            pendulum.now().add(months=1)
        )


def test_diff_for_humans_other_and_months():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 months before" == pendulum.now().diff_for_humans(
            pendulum.now().add(months=2)
        )


def test_diff_for_humans_other_and_nearly_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "11 months before" == pendulum.now().diff_for_humans(
            pendulum.now().add(months=11)
        )


def test_diff_for_humans_other_and_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 year before" == pendulum.now().diff_for_humans(
            pendulum.now().add(years=1)
        )


def test_diff_for_humans_other_and_years():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 years before" == pendulum.now().diff_for_humans(
            pendulum.now().add(years=2)
        )


def test_diff_for_humans_other_and_future_second():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "a few seconds after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(seconds=1)
        )


def test_diff_for_humans_other_and_future_seconds():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "a few seconds after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(seconds=2)
        )


def test_diff_for_humans_other_and_nearly_future_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 seconds after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(seconds=59)
        )


def test_diff_for_humans_other_and_future_minute():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 minute after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(minutes=1)
        )


def test_diff_for_humans_other_and_future_minutes():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 minutes after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(minutes=2)
        )


def test_diff_for_humans_other_and_nearly_future_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 minutes after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(minutes=59)
        )


def test_diff_for_humans_other_and_future_hour():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 hour after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(hours=1)
        )


def test_diff_for_humans_other_and_future_hours():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 hours after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(hours=2)
        )


def test_diff_for_humans_other_and_nearly_future_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "23 hours after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(hours=23)
        )


def test_diff_for_humans_other_and_future_day():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 day after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(days=1)
        )


def test_diff_for_humans_other_and_future_days():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 days after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(days=2)
        )


def test_diff_for_humans_other_and_nearly_future_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "6 days after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(days=6)
        )


def test_diff_for_humans_other_and_future_week():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 week after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(weeks=1)
        )


def test_diff_for_humans_other_and_future_weeks():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 weeks after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(weeks=2)
        )


def test_diff_for_humans_other_and_nearly_future_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "3 weeks after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(weeks=3)
        )


def test_diff_for_humans_other_and_future_month():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "4 weeks after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(weeks=4)
        )
        assert "1 month after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(months=1)
        )


def test_diff_for_humans_other_and_future_months():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 months after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(months=2)
        )


def test_diff_for_humans_other_and_nearly_future_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "11 months after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(months=11)
        )


def test_diff_for_humans_other_and_future_year():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 year after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(years=1)
        )


def test_diff_for_humans_other_and_future_years():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 years after" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(years=2)
        )


def test_diff_for_humans_absolute_seconds():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "59 seconds" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(seconds=59), True
        )
        assert "59 seconds" == pendulum.now().diff_for_humans(
            pendulum.now().add(seconds=59), True
        )


def test_diff_for_humans_absolute_minutes():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "30 minutes" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(minutes=30), True
        )
        assert "30 minutes" == pendulum.now().diff_for_humans(
            pendulum.now().add(minutes=30), True
        )


def test_diff_for_humans_absolute_hours():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "3 hours" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(hours=3), True
        )
        assert "3 hours" == pendulum.now().diff_for_humans(
            pendulum.now().add(hours=3), True
        )


def test_diff_for_humans_absolute_days():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 days" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(days=2), True
        )
        assert "2 days" == pendulum.now().diff_for_humans(
            pendulum.now().add(days=2), True
        )


def test_diff_for_humans_absolute_weeks():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 weeks" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(weeks=2), True
        )
        assert "2 weeks" == pendulum.now().diff_for_humans(
            pendulum.now().add(weeks=2), True
        )


def test_diff_for_humans_absolute_months():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "2 months" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(months=2), True
        )
        assert "2 months" == pendulum.now().diff_for_humans(
            pendulum.now().add(months=2), True
        )


def test_diff_for_humans_absolute_years():
    with pendulum.test(pendulum.datetime(2012, 1, 1, 1, 2, 3)):
        assert "1 year" == pendulum.now().diff_for_humans(
            pendulum.now().subtract(years=1), True
        )
        assert "1 year" == pendulum.now().diff_for_humans(
            pendulum.now().add(years=1), True
        )


def test_diff_for_humans_accuracy():
    now = pendulum.now("utc")

    with pendulum.test(now.add(microseconds=200)):
        assert "1 year" == now.add(years=1).diff_for_humans(absolute=True)
        assert "11 months" == now.add(months=11).diff_for_humans(absolute=True)
        assert "4 weeks" == now.add(days=27).diff_for_humans(absolute=True)
        assert "1 year" == now.add(years=1, months=3).diff_for_humans(absolute=True)
        assert "2 years" == now.add(years=1, months=8).diff_for_humans(absolute=True)

    # DST
    now = pendulum.datetime(2017, 3, 7, tz="America/Toronto")
    with pendulum.test(now):
        assert "6 days" == now.add(days=6).diff_for_humans(absolute=True)


def test_subtraction():
    d = pendulum.naive(2016, 7, 5, 12, 32, 25, 0)
    future_dt = datetime(2016, 7, 5, 13, 32, 25, 0)
    future = d.add(hours=1)

    assert 3600 == (future - d).total_seconds()
    assert 3600 == (future_dt - d).total_seconds()


def test_subtraction_aware_naive():
    dt = pendulum.datetime(2016, 7, 5, 12, 32, 25, 0)
    future_dt = datetime(2016, 7, 5, 13, 32, 25, 0)

    with pytest.raises(TypeError):
        future_dt - dt

    future_dt = pendulum.naive(2016, 7, 5, 13, 32, 25, 0)

    with pytest.raises(TypeError):
        future_dt - dt


def test_subtraction_with_timezone():
    dt = pendulum.datetime(2013, 3, 31, 1, 59, 59, 999999, tz="Europe/Paris")
    post = dt.add(microseconds=1)

    assert (post - dt).total_seconds() == 1e-06

    dt = pendulum.datetime(
        2013,
        10,
        27,
        2,
        59,
        59,
        999999,
        tz="Europe/Paris",
        dst_rule=pendulum.PRE_TRANSITION,
    )
    post = dt.add(microseconds=1)

    assert (post - dt).total_seconds() == 1e-06