Example #1
0
def test_interval_generate_grid():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.generate_grid(Duration.seconds(1.0)) is not None
Example #2
0
def test_interval_generate_grid ():

    interval = Interval(Instant.J2000(), Instant.J2000() + Duration.minutes(1.0), Interval.Type.Closed)

    grid = interval.generate_grid(Duration.seconds(1.0))

    assert grid is not None
    assert isinstance(grid, list)
    assert isinstance(grid[0], Instant)
Example #3
0
def test_interval_intersects():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.intersects(interval) is not None
Example #4
0
def test_interval_is_degenerate():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.is_degenerate() is not None
Example #5
0
def test_interval_get_center():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.get_center() is not None
Example #6
0
def test_interval_contains_instant():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.contains_instant(Instant.J2000()) is not None
Example #7
0
def test_interval_operators():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert (interval == interval) is not None
    assert (interval != interval) is not None
Example #8
0
def test_interval_to_string():

    interval = Interval(Instant.J2000(),
                        Instant.J2000() + Duration.minutes(1.0),
                        Interval.Type.Closed)

    assert interval.to_string() is not None
    assert interval.to_string(Scale.UTC) is not None
Example #9
0
def test_instant_operators ():

    instant = Instant.J2000()

    assert (instant == instant) is not None
    assert (instant != instant) is not None


    assert (instant < instant) is not None
    assert (instant <= instant) is not None
    assert (instant > instant) is not None
    assert (instant >= instant) is not None

    assert (instant + Duration.seconds(1.0)) is not None
    assert (instant - Duration.seconds(1.0)) is not None

    assert (instant - instant) is not None

    instant += Duration.seconds(1.0)
    instant -= Duration.seconds(1.0)
def test_duration_operators():

    duration_A = Duration.seconds(123.0)
    duration_B = Duration.seconds(456.0)

    assert (duration_A == duration_B) is not None
    assert (duration_A != duration_B) is not None

    assert (duration_A < duration_B) is not None
    assert (duration_A <= duration_B) is not None
    assert (duration_A > duration_B) is not None
    assert (duration_A >= duration_B) is not None

    assert (duration_A + duration_B) is not None
    assert (duration_A - duration_B) is not None

    assert (duration_A * 2.0) is not None
    assert (duration_A / 2.0) is not None

    duration_A += duration_B
    duration_A -= duration_B

    duration_A *= 2.0
    duration_A /= 2.0
def test_duration_parse():

    ## Using python strings

    # Testing with default format argument (Duration::Format::Undefined)
    duration: Duration = Duration.parse('02:03.456.000.000')

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True

    # Testing with Duration.Format.Standard
    duration: Duration = Duration.parse('02:03.456.000.000',
                                        Duration.Format.Standard)

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True

    # Testing with Duration.Format.ISO8601
    duration: Duration = Duration.parse('PT2M3.456S', Duration.Format.ISO8601)

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True

    ## Using String

    # Testing with default format argument (Duration::Format::Undefined)
    duration: Duration = Duration.parse(String('02:03.456.000.000'))

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True

    # Testing with Duration.Format.Standard
    duration: Duration = Duration.parse(String('02:03.456.000.000'),
                                        Duration.Format.Standard)

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True

    # Testing with Duration.Format.ISO8601
    duration: Duration = Duration.parse(String('PT2M3.456S'),
                                        Duration.Format.ISO8601)

    assert duration is not None
    assert isinstance(duration, Duration)
    assert duration.is_defined() is True
def test_duration_to_string():

    assert Duration.seconds(123.0).to_string() is not None
    assert Duration.seconds(123.0).to_string(Duration.Format.Standard)
    assert Duration.seconds(123.0).to_string(Duration.Format.ISO8601)
def test_duration_get_absolute():

    assert Duration.seconds(123.0).get_absolute() is not None
def test_duration_in_unit():

    assert Duration.seconds(123.0).in_unit(Time.Unit.Second) is not None
def test_duration_in_weeks():

    assert Duration.seconds(123.0).in_weeks() is not None
def test_duration_get_days():

    assert Duration.seconds(123.0).get_days() is not None
def test_duration_zero():

    assert Duration.zero() is not None
def test_duration_is_near():

    assert Duration.seconds(123.0).is_near(Duration.seconds(123.0),
                                           Duration.zero()) is not None
def test_duration_is_strictly_positive():

    assert Duration.seconds(123.0).is_strictly_positive() is not None
Example #20
0
def test_interval_closed():

    assert Interval.closed(Instant.J2000(),
                           Instant.J2000() + Duration.minutes(1.0)) is not None
def test_duration_days():

    assert Duration.days(123.456) is not None
def test_duration_minutes():

    assert Duration.minutes(123.456) is not None
def test_duration_milliseconds():

    assert Duration.milliseconds(123.456) is not None
def test_duration_between():

    assert Duration.between(Instant.now(), Instant.now()) is not None
def test_duration_seconds():

    assert Duration.seconds(123.456) is not None
def test_duration_is_defined():

    assert Duration.seconds(123.0).is_defined() is not None
def test_duration_hours():

    assert Duration.hours(123.456) is not None
def test_duration_undefined():

    assert Duration.undefined() is not None
def test_duration_weeks():

    assert Duration.weeks(123.456) is not None
def test_duration_is_zero():

    assert Duration.seconds(123.0).is_zero() is not None