Merge pull request #14 from Innmind/fix-elapsed-period-precision

Fix precision of elapsed periods

CHANGELOG.md

@@ -20,6 +20,8 @@
 - `Innmind\TimeContinuum\Clock::ofFormat()`
 - `Innmind\TimeContinuum\Offset::plus()`
 - `Innmind\TimeContinuum\Offset::minus()`
+- `Innmind\TimeContinuum\ElapsedPeriod::asPeriod()`
+- `Innmind\TimeContinuum\Period\Value::seconds()`
 
 ### Changed
 
@@ -72,6 +74,9 @@
 - `Innmind\TimeContinuum\ElapsedPeriod::ofPeriod()`
 - `Innmind\TimeContinuum\PointInTime::milliseconds()`
 - `Innmind\TimeContinuum\Offset::of()`
+- `Innmind\TimeContinuum\ElapsedPeriod::milliseconds()`
+- `Innmind\TimeContinuum\Period\Value::second`
+- `Innmind\TimeContinuum\Period\Value::milliseconds()`
 
 ## 3.4.1 - 2023-09-17
 

blackbox.php

@@ -23,6 +23,7 @@
                     ->dumpTo('coverage.clover')
                     ->enableWhen(true),
             )
+            ->scenariiPerProof(1_000),
     )
     ->tryToProve(static function() {
         yield from Load::everythingIn(__DIR__.'/proofs/')();

proofs/elapsedPeriod.php

@@ -0,0 +1,149 @@
+<?php
+declare(strict_types = 1);
+
+use Innmind\TimeContinuum\{
+    PointInTime\HighResolution,
+    Period,
+};
+use Fixtures\Innmind\TimeContinuum as Fixtures;
+use Innmind\BlackBox\Set;
+
+return static function() {
+    yield proof(
+        'High resolution elapsed period',
+        given(
+            Set\Integers::above(0),
+            Set\Integers::above(0),
+            Set\Integers::between(0, 999_999_999),
+            Set\Integers::between(0, 999_999_999),
+        )->filter(static fn($start, $end) => $end > $start),
+        static function(
+            $assert,
+            $startSeconds,
+            $endSeconds,
+            $startNanoseconds,
+            $endNanoseconds,
+        ) {
+            $start = HighResolution::of($startSeconds, $startNanoseconds);
+            $end = HighResolution::of($endSeconds, $endNanoseconds);
+
+            $assert->true(
+                $start
+                    ->elapsedSince($start)
+                    ->equals(
+                        Period::microsecond(0)->asElapsedPeriod(),
+                    ),
+            );
+            $assert->true(
+                $end
+                    ->elapsedSince($start)
+                    ->longerThan(
+                        Period::microsecond(1)->asElapsedPeriod(),
+                    ),
+            );
+        },
+    );
+
+    yield proof(
+        'High resolution elapsed period within same second',
+        given(
+            Set\Integers::between(0, 999_999_999),
+            Set\Integers::between(0, 999_999_999),
+        )->filter(static fn($start, $end) => $end > $start),
+        static function(
+            $assert,
+            $startNanoseconds,
+            $endNanoseconds,
+        ) {
+            $start = HighResolution::of(0, $startNanoseconds);
+            $end = HighResolution::of(0, $endNanoseconds);
+
+            $assert->true(
+                $start
+                    ->elapsedSince($start)
+                    ->equals(
+                        Period::microsecond(0)->asElapsedPeriod(),
+                    ),
+            );
+            $assert->true(
+                $end
+                    ->elapsedSince($start)
+                    ->longerThan(
+                        Period::microsecond(1)->asElapsedPeriod(),
+                    ),
+            );
+        },
+    );
+
+    yield proof(
+        'Elapsed period',
+        given(
+            Fixtures\PointInTime::any(),
+            Set\Integers::above(1),
+        ),
+        static function($assert, $start, $microsecond) {
+            $assert->true(
+                $start
+                    ->elapsedSince($start)
+                    ->equals(
+                        Period::microsecond(0)->asElapsedPeriod(),
+                    ),
+            );
+            $assert->true(
+                $start
+                    ->goForward(Period::microsecond($microsecond))
+                    ->elapsedSince($start)
+                    ->equals(
+                        Period::microsecond($microsecond)->asElapsedPeriod(),
+                    ),
+            );
+            $assert->true(
+                $start
+                    ->goForward(Period::microsecond($microsecond))
+                    ->elapsedSince($start)
+                    ->longerThan(
+                        Period::microsecond(0)->asElapsedPeriod(),
+                    ),
+            );
+        },
+    );
+
+    yield proof(
+        'Negative elapsed periods throws',
+        given(
+            Fixtures\PointInTime::any(),
+            Set\Integers::above(1),
+        ),
+        static function($assert, $start, $microsecond) {
+            $assert->throws(
+                static fn() => $start
+                    ->goBack(Period::microsecond($microsecond))
+                    ->elapsedSince($start),
+            );
+        },
+    );
+
+    yield proof(
+        'Negative high resolution elapsed periods throws',
+        given(
+            Set\Integers::above(0),
+            Set\Integers::above(0),
+            Set\Integers::between(0, 999_999_999),
+            Set\Integers::between(0, 999_999_999),
+        )->filter(static fn($start, $end) => $end > $start),
+        static function(
+            $assert,
+            $startSeconds,
+            $endSeconds,
+            $startNanoseconds,
+            $endNanoseconds,
+        ) {
+            $start = HighResolution::of($startSeconds, $startNanoseconds);
+            $end = HighResolution::of($endSeconds, $endNanoseconds);
+
+            $assert->throws(
+                static fn() => $start->elapsedSince($end),
+            );
+        },
+    );
+};

src/ElapsedPeriod.php

@@ -9,52 +9,67 @@
 final class ElapsedPeriod
 {
     /** @var int<0, max> */
+    private int $seconds;
+    /** @var int<0, 999> */
+    private int $milliseconds;
+    /** @var int<0, 999> */
     private int $microseconds;
 
-    private function __construct(int $microseconds)
-    {
-        if ($microseconds < 0) {
-            throw new \RuntimeException((string) $microseconds);
-        }
-
+    /**
+     * @param int<0, max> $seconds
+     * @param int<0, 999> $milliseconds
+     * @param int<0, 999> $microseconds
+     */
+    private function __construct(
+        int $seconds,
+        int $milliseconds,
+        int $microseconds,
+    ) {
+        $this->seconds = $seconds;
+        $this->milliseconds = $milliseconds;
         $this->microseconds = $microseconds;
     }
 
     /**
      * @psalm-pure
      * @internal
      *
-     * @throws \RuntimeException
+     * @param int<0, max> $seconds
+     * @param int<0, 999> $milliseconds
+     * @param int<0, 999> $microseconds
      */
-    public static function of(int $microseconds): self
-    {
-        return new self($microseconds);
+    public static function of(
+        int $seconds,
+        int $milliseconds,
+        int $microseconds,
+    ): self {
+        return new self($seconds, $milliseconds, $microseconds);
     }
 
-    /**
-     * @return int<0, max>
-     */
-    public function milliseconds(): int
+    public function longerThan(self $period): bool
     {
-        /** @var int<0, max> */
-        return (int) ($this->microseconds / 1_000);
-    }
+        if ($this->seconds > $period->seconds) {
+            return true;
+        }
 
-    /**
-     * @return int<0, max>
-     */
-    public function microseconds(): int
-    {
-        return $this->microseconds;
-    }
+        if ($this->milliseconds > $period->milliseconds) {
+            return true;
+        }
 
-    public function longerThan(self $period): bool
-    {
         return $this->microseconds > $period->microseconds;
     }
 
     public function equals(self $period): bool
     {
-        return $this->microseconds === $period->microseconds;
+        return $this->seconds === $period->seconds &&
+            $this->milliseconds === $period->milliseconds &&
+            $this->microseconds === $period->microseconds;
+    }
+
+    public function asPeriod(): Period
+    {
+        return Period::second($this->seconds)
+            ->add(Period::millisecond($this->milliseconds))
+            ->add(Period::microsecond($this->microseconds));
     }
 }

src/Period.php

@@ -458,13 +458,15 @@ public function asElapsedPeriod(): ElapsedPeriod
             throw new \LogicException('Months and years can not be converted to microseconds');
         }
 
-        $milliseconds = Period\Value::day->milliseconds($this->days()) +
-            Period\Value::hour->milliseconds($this->hours()) +
-            Period\Value::minute->milliseconds($this->minutes()) +
-            Period\Value::second->milliseconds($this->seconds()) +
-            $this->milliseconds();
-        $milliseconds *= 1_000;
-
-        return ElapsedPeriod::of($milliseconds + $this->microseconds());
+        $seconds = Period\Value::day->seconds($this->days()) +
+            Period\Value::hour->seconds($this->hours()) +
+            Period\Value::minute->seconds($this->minutes()) +
+            $this->second;
+
+        return ElapsedPeriod::of(
+            $seconds,
+            $this->millisecond,
+            $this->microsecond,
+        );
     }
 }

src/Period/Value.php

@@ -8,22 +8,24 @@
  */
 enum Value
 {
-    case second;
     case minute;
     case hour;
     case day;
 
     /**
-     * Returns the number of milliseconds contained in the number of seconds,
-     * minutes, hours and days
+     * Returns the number of seconds contained in the number of  minutes, hours
+     * and days
+     *
+     * @param int<0, max> $number
+     *
+     * @return int<0, max>
      */
-    public function milliseconds(int $number): int
+    public function seconds(int $number): int
     {
         return match ($this) {
-            self::second => $number * 1000,
-            self::minute => $number * self::second->milliseconds(60),
-            self::hour => $number * self::minute->milliseconds(60),
-            self::day => $number * self::hour->milliseconds(24),
+            self::minute => $number * 60,
+            self::hour => $number * self::minute->seconds(60),
+            self::day => $number * self::hour->seconds(24),
         };
     }
 }

src/PointInTime.php

@@ -143,14 +143,44 @@ public function elapsedSince(self $point): ElapsedPeriod
         }
 
         $seconds = ((int) $this->date->format('U')) - ((int) $point->date->format('U'));
-        $milliseconds = $seconds * 1_000;
-        $milliseconds += $this->millisecond()->toInt();
-        $milliseconds -= $point->millisecond()->toInt();
-        $microseconds = $milliseconds * 1_000;
-        $microseconds += $this->microsecond()->toInt();
-        $microseconds -= $point->microsecond()->toInt();
-
-        return ElapsedPeriod::of($microseconds);
+        $milliseconds = $this->millisecond()->toInt() - $point->millisecond()->toInt();
+        $microseconds = $this->microsecond()->toInt() - $point->microsecond()->toInt();
+
+        if ($milliseconds < 0) {
+            $seconds -= 1;
+            $milliseconds += 1_000;
+        }
+
+        if ($microseconds < 0) {
+            $milliseconds -= 1;
+            $microseconds += 1_000;
+        }
+
+        if ($milliseconds < 0) {
+            // This handles the case where any second diff is positive, but zero
+            // milliseconds and any microsecond diff.
+            // Duplication could be avoided by switching the 2 previous if but
+            // it would require to compute the number of seconds to subtract.
+            // The duplication seems more obvious to understand (at least for
+            // now).
+            $seconds -= 1;
+            $milliseconds += 1_000;
+        }
+
+        if ($seconds < 0) {
+            throw new \RuntimeException(\sprintf(
+                'Negative period : %ss, %smillis, %smicros',
+                $seconds,
+                $milliseconds,
+                $microseconds,
+            ));
+        }
+
+        return ElapsedPeriod::of(
+            $seconds,
+            $milliseconds,
+            $microseconds,
+        );
     }
 
     public function goBack(Period $period): self