Add test coverage ensuring offsets are correct before and after legacy replay encode

osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs

@@ -8,6 +8,7 @@
 using NUnit.Framework;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Replays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
@@ -64,6 +65,55 @@ public void TestDecodeManiaReplay()
             }
         }
 
+        [TestCase(3)]
+        [TestCase(6)]
+        [TestCase(LegacyBeatmapDecoder.LATEST_VERSION)]
+        public void TestLegacyBeatmapReplayOffsets(int beatmapVersion)
+        {
+            const double first_frame_time = 2000;
+            const double second_frame_time = 3000;
+
+            var ruleset = new OsuRuleset().RulesetInfo;
+            var scoreInfo = TestResources.CreateTestScoreInfo(ruleset);
+            var beatmap = new TestBeatmap(ruleset)
+            {
+                BeatmapInfo =
+                {
+                    BeatmapVersion = beatmapVersion
+                }
+            };
+
+            var score = new Score
+            {
+                ScoreInfo = scoreInfo,
+                Replay = new Replay
+                {
+                    Frames = new List<ReplayFrame>
+                    {
+                        new OsuReplayFrame(first_frame_time, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton),
+                        new OsuReplayFrame(second_frame_time, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton)
+                    }
+                }
+            };
+
+            // the "se" culture is used here, as it encodes the negative number sign as U+2212 MINUS SIGN,
+            // rather than the classic ASCII U+002D HYPHEN-MINUS.
+            CultureInfo.CurrentCulture = new CultureInfo("se");
+
+            var encodeStream = new MemoryStream();
+
+            var encoder = new LegacyScoreEncoder(score, beatmap);
+            encoder.Encode(encodeStream);
+
+            var decodeStream = new MemoryStream(encodeStream.GetBuffer());
+
+            var decoder = new TestLegacyScoreDecoder(beatmapVersion);
+            var decodedAfterEncode = decoder.Parse(decodeStream);
+
+            Assert.That(decodedAfterEncode.Replay.Frames[0].Time, Is.EqualTo(first_frame_time));
+            Assert.That(decodedAfterEncode.Replay.Frames[1].Time, Is.EqualTo(second_frame_time));
+        }
+
         [Test]
         public void TestCultureInvariance()
         {
@@ -118,6 +168,8 @@ public void TearDown()
 
         private class TestLegacyScoreDecoder : LegacyScoreDecoder
         {
+            private readonly int beatmapVersion;
+
             private static readonly Dictionary<int, Ruleset> rulesets = new Ruleset[]
             {
                 new OsuRuleset(),
@@ -126,6 +178,11 @@ private class TestLegacyScoreDecoder : LegacyScoreDecoder
                 new ManiaRuleset()
             }.ToDictionary(ruleset => ((ILegacyRuleset)ruleset).LegacyID);
 
+            public TestLegacyScoreDecoder(int beatmapVersion = LegacyBeatmapDecoder.LATEST_VERSION)
+            {
+                this.beatmapVersion = beatmapVersion;
+            }
+
             protected override Ruleset GetRuleset(int rulesetId) => rulesets[rulesetId];
 
             protected override WorkingBeatmap GetBeatmap(string md5Hash) => new TestWorkingBeatmap(new Beatmap
@@ -134,7 +191,8 @@ private class TestLegacyScoreDecoder : LegacyScoreDecoder
                 {
                     MD5Hash = md5Hash,
                     Ruleset = new OsuRuleset().RulesetInfo,
-                    Difficulty = new BeatmapDifficulty()
+                    Difficulty = new BeatmapDifficulty(),
+                    BeatmapVersion = beatmapVersion,
                 }
             });
         }