h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2026-05-21 18:10:40 +08:00
Code Issues Releases Wiki Activity

Fix tests

Browse Source 
- Move them to the correct class. They were exercising filter matching,
  not parsing.
- Remove a bunch of unreadable tuple stuff that was mostly obfuscating
  the readability without actually improving test coverage.
- Make tests fail everywhere rather than on CI only. They were failing
  because they were written in a way that was implicitly dependent on
  the local computer's timezone.
This commit is contained in:
Bartłomiej Dach
2025-08-13 11:25:14 +02:00
Unverified
parent bd90ef1bf4
commit e31b2c08fd
2 changed files with 161 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files
osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
+161
View File
@@ -1,7 +1,9 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using osu.Framework.Bindables;
using osu.Game.Beatmaps;
@@ -361,6 +363,165 @@ namespace osu.Game.Tests.NonVisual.Filtering
Assert.AreEqual(matchCustomCriteria == false, carouselItem.Filtered.Value);
}
[TestCase("title!=Title", new[] { 2, 4, 6 })]
[TestCase("title!=\"Title1\"", new[] { 2, 3, 4, 5, 6 })]
[TestCase("title!=\"Title1\"!", new[] { 2, 3, 4, 5, 6 })]
public void TestNotEqualSearchForTextFilters(string query, int[] expectedBeatmapIndexes)
{
string[] titles =
[
"Title1",
"Title1",
"My[Favourite]Song",
"Title",
"Another One",
"Diff in title",
"a",
];
var carouselBeatmaps = titles.Select(title => new CarouselBeatmap(new BeatmapInfo
{
Metadata = new BeatmapMetadata
{
Title = title,
},
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
public void TestNotEqualSearchForNumberFilters()
{
double[] starRatings =
[
2.78,
1.78,
1.55,
3.78,
1.78,
1.55,
2.78
];
var carouselBeatmaps = starRatings.Select(starRating => new CarouselBeatmap(new BeatmapInfo
{
StarRating = starRating,
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, "star!=1.78");
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(new int[] { 0, 2, 3, 5, 6 }));
}
[TestCase("status!=ranked", new[] { 1, 2, 4, 5 })]
[TestCase("status!=r", new[] { 1, 2, 4, 5 })]
[TestCase("status!=loved", new[] { 0, 1, 2, 3, 4, 6 })]
[TestCase("status!=l", new[] { 0, 1, 2, 3, 4, 6 })]
public void TestNotEqualSearchForEnumFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = new[]
{
BeatmapOnlineStatus.Ranked,
BeatmapOnlineStatus.Qualified,
BeatmapOnlineStatus.Approved,
BeatmapOnlineStatus.Ranked,
BeatmapOnlineStatus.Approved,
BeatmapOnlineStatus.Loved,
BeatmapOnlineStatus.Ranked
}.Select(info => new CarouselBeatmap(new BeatmapInfo
{
Status = info
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[TestCase("played!=1", new[] { 1, 4, 5 })]
[TestCase("played!=0", new[] { 0, 2, 3, 6, 7 })]
public void TestNotEqualSearchForBooleanFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = (new DateTimeOffset?[]
{
new DateTimeOffset(2012, 10, 21, 12, 13, 24, TimeSpan.Zero),
null,
new DateTimeOffset(2012, 11, 12, 23, 10, 13, TimeSpan.Zero),
new DateTimeOffset(2013, 2, 13, 11, 43, 23, TimeSpan.Zero),
null,
null,
new DateTimeOffset(2014, 1, 15, 20, 13, 24, TimeSpan.Zero),
new DateTimeOffset(2014, 11, 16, 0, 13, 23, TimeSpan.Zero),
}).Select(lastPlayed => new CarouselBeatmap(new BeatmapInfo
{
LastPlayed = lastPlayed
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[TestCase("ranked!=2012", new[] { 3, 4, 5, 6, 7 })]
[TestCase("ranked!=2012.11", new[] { 0, 1, 3, 4, 5, 6, 7 })]
[TestCase("ranked!=2012.10.21", new[] { 1, 2, 3, 4, 5, 6, 7 })]
public void TestNotEqualSearchForDateFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = new[]
{
new DateTimeOffset(2012, 10, 21, 13, 42, 13, TimeSpan.Zero),
new DateTimeOffset(2012, 10, 11, 2, 33, 43, TimeSpan.Zero),
new DateTimeOffset(2012, 11, 12, 10, 22, 32, TimeSpan.Zero),
new DateTimeOffset(2013, 2, 13, 5, 19, 0, TimeSpan.Zero),
new DateTimeOffset(2013, 2, 13, 11, 23, 35, TimeSpan.Zero),
new DateTimeOffset(2013, 3, 14, 9, 9, 1, TimeSpan.Zero),
new DateTimeOffset(2014, 1, 15, 10, 5, 0, TimeSpan.Zero),
new DateTimeOffset(2014, 11, 16, 23, 27, 0, TimeSpan.Zero),
}.Select(dateRanked => new CarouselBeatmap(new BeatmapInfo
{
BeatmapSet = new BeatmapSetInfo
{
DateRanked = dateRanked,
}
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
private class CustomCriteria : IRulesetFilterCriteria
{
private readonly bool match;
osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
-185
View File
@@ -521,191 +521,6 @@ namespace osu.Game.Tests.NonVisual.Filtering
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[TestCase("title!=Title", new[] { 2, 4, 6 })]
[TestCase("title!=\"Title1\"", new[] { 2, 3, 4, 5, 6 })]
[TestCase("title!=\"Title1\"!", new[] { 2, 3, 4, 5, 6 })]
[TestCase("artist!=artist", new int[] { })]
[TestCase("artist!=\"artist2\"", new[] { 1, 2, 4, 6 })]
[TestCase("artist!=\"artist2\"!", new[] { 1, 2, 4, 6 })]
[TestCase("diff!=Diff", new[] { 2, 5 })]
[TestCase("diff!=\"Diff1\"", new[] { 1, 2, 3, 4, 5, 6 })]
[TestCase("diff!=\"Diff1\"!", new[] { 1, 2, 3, 4, 5, 6 })]
public void TestNotEqualSearchForTextFilters(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = (((string title, string difficultyName, string artist)[])new[]
{
("Title1", "Diff1", "artist2"),
("Title1", "Diff2", "artist1"),
("My[Favourite]Song", "Expert", "artist1"),
("Title", "My Favourite Diff", "artist2"),
("Another One", "diff ]with [[ brackets]]]", "artist3"),
("Diff in title", "a", "artist2"),
("a", "Diff in diff", "artist3")
}).Select(info => new CarouselBeatmap(new BeatmapInfo
{
Metadata = new BeatmapMetadata
{
Title = info.title,
Artist = info.artist
},
DifficultyName = info.difficultyName
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[TestCase("ar!=5", new[] { 0, 2, 3, 5 })]
[TestCase("cs!=7", new[] { 0, 2, 3, 6 })]
[TestCase("od!=3", new[] { 0, 2, 4, 6 })]
[TestCase("hp!=6", new[] { 0, 1, 3, 5, 6 })]
[TestCase("star!=1.78", new[] { 0, 2, 3, 5, 6 })]
[TestCase("bpm!=144", new[] { 0, 1, 3, 5 })]
[TestCase("length!=120", new[] { 2, 3, 4, 6 })]
public void TestNotEqualSearchForNumberFilters(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = (((float ar, float cs, float od, float hp, double star, double bpm, double length)[])new[]
{
(10.0f, 5.0f, 1.0f, 6.5f, 2.78, 100.0, 120000.0),
(5.0f, 7.0f, 3.0f, 8.0f, 1.78, 244.0, 120000.0),
(5.5f, 7.5f, 4.0f, 6.0f, 1.55, 144.0, 60000.0),
(6.0f, 2.0f, 3.0f, 7.0f, 3.78, 774.0, 440000.0),
(5.0f, 7.0f, 4.0f, 6.0f, 1.78, 144.0, 310000.0),
(5.8f, 7.0f, 3.0f, 6.5f, 1.55, 344.0, 120000.0),
(5.0f, 3.0f, 7.0f, 10.0f, 2.78, 144.0, 260000.0)
}).Select(info => new CarouselBeatmap(new BeatmapInfo
{
Difficulty = new BeatmapDifficulty
{
ApproachRate = info.ar,
OverallDifficulty = info.od,
DrainRate = info.hp,
CircleSize = info.cs
},
BPM = info.bpm,
StarRating = info.star,
Length = info.length
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[TestCase("status!=ranked", new[] { 1, 2, 4, 5 })]
[TestCase("status!=r", new[] { 1, 2, 4, 5 })]
[TestCase("status!=loved", new[] { 0, 1, 2, 3, 4, 6 })]
[TestCase("status!=l", new[] { 0, 1, 2, 3, 4, 6 })]
public void TestNotEqualSearchForEnumFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = new[]
{
BeatmapOnlineStatus.Ranked,
BeatmapOnlineStatus.Qualified,
BeatmapOnlineStatus.Approved,
BeatmapOnlineStatus.Ranked,
BeatmapOnlineStatus.Approved,
BeatmapOnlineStatus.Loved,
BeatmapOnlineStatus.Ranked
}.Select(info => new CarouselBeatmap(new BeatmapInfo
{
Status = info
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
//played
[TestCase("played!=1", new[] { 1, 4, 5 })]
[TestCase("played!=0", new[] { 0, 2, 3, 6, 7 })]
public void TestNotEqualSearchForBooleanFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = (new DateTimeOffset?[]
{
new DateTime(2012, 10, 21),
null,
new DateTime(2012, 11, 12),
new DateTime(2013, 2, 13),
null,
null,
new DateTime(2014, 1, 15),
new DateTime(2014, 11, 16),
}).Select(info => new CarouselBeatmap(new BeatmapInfo
{
LastPlayed = info
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
//submitted, ranked
[TestCase("ranked!=2012", new[] { 3, 4, 5, 6, 7 })]
[TestCase("ranked!=2012.11", new[] { 0, 1, 3, 4, 5, 6, 7 })]
[TestCase("ranked!=2012.10.21", new[] { 1, 2, 3, 4, 5, 6, 7 })]
[TestCase("submitted!=2012", new[] { 3, 4, 5, 6, 7 })]
[TestCase("submitted!=2012.11", new[] { 0, 1, 3, 4, 5, 6, 7 })]
[TestCase("submitted!=2012.10.21", new[] { 1, 2, 3, 4, 5, 6, 7 })]
public void TestNotEqualSearchForDateFilter(string query, int[] expectedBeatmapIndexes)
{
var carouselBeatmaps = new[]
{
new DateTime(2012, 10, 21),
new DateTime(2012, 10, 11),
new DateTime(2012, 11, 12),
new DateTime(2013, 2, 13),
new DateTime(2013, 2, 13),
new DateTime(2013, 3, 14),
new DateTime(2014, 1, 15),
new DateTime(2014, 11, 16),
}.Select(info => new CarouselBeatmap(new BeatmapInfo
{
BeatmapSet = new BeatmapSetInfo
{
DateRanked = new DateTimeOffset(info),
DateSubmitted = new DateTimeOffset(info),
}
})).ToList();
var criteria = new FilterCriteria();
FilterQueryParser.ApplyQueries(criteria, query);
carouselBeatmaps.ForEach(b => b.Filter(criteria));
int[] visibleBeatmaps = carouselBeatmaps
.Where(b => !b.Filtered.Value)
.Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
}
[Test]
public void TestApplySourceQueries()
{