Files
SpotiFLAC-Mobile/test/equalizer_test.dart
T
zarzet 962e582acc chore(flutter): move to Flutter 3.50.0 and the material_ui packages
Flutter 3.50 deprecates its built-in Material and Cupertino libraries in
favour of the material_ui and cupertino_ui packages. The imports move
with the official fix (dart fix, migrate_design_widgets); the app's old
two-library theme bridge collapses into one Theme type.

- MaterialExpressiveScope keeps the complete host theme nearest its
  child. The reduced copy made for the expressive widgets now shares the
  app's Theme type and would hide component themes and extensions.
- LegacyThemeBrightness hands the brightness to the glass package, which
  still reads Flutter's built-in theme.
- appLocalizationsDelegates lists the material_ui localization delegates;
  the generated list still names the built-in ones.
- Tests: findByTooltip and pageBack replace the flutter_test helpers that
  only know the built-in widgets, and several tests that had gone stale
  against earlier app changes are repaired.
2026-11-15 23:33:29 +07:00

436 lines
16 KiB
Dart
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import 'dart:convert';
import 'package:material_ui/material_ui.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:material_3_expressive/material_3_expressive.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:mornye/l10n/l10n.dart';
import 'package:mornye/models/equalizer_settings.dart';
import 'package:mornye/providers/equalizer_provider.dart';
import 'package:mornye/screens/equalizer_screen.dart';
import 'package:mornye/services/playback_equalizer.dart';
import 'package:mornye/theme/app_theme.dart';
import 'package:mornye/theme/mornye_theme.dart';
import 'package:mornye/widgets/app_slider.dart';
import 'package:mornye/widgets/mornye_chrome.dart';
import 'package:mornye/widgets/mornye_level_slider.dart';
import 'package:mornye/widgets/slider_value_header.dart';
class _CountedSettings extends EqualizerSettings {
_CountedSettings(double preamp, this.serialized) : super(preamp: preamp);
final VoidCallback serialized;
@override
Map<String, dynamic> toJson() {
serialized();
return super.toJson();
}
}
void main() {
setUp(() {
SharedPreferences.setMockInitialValues({});
playbackEqualizer.value = const EqualizerSettings();
playbackEqualizerError.value = null;
});
testWidgets('slider bursts serialize only the final persisted snapshot', (
tester,
) async {
final container = ProviderContainer();
final notifier = container.read(equalizerProvider.notifier);
await tester.pump();
var serializations = 0;
final presets = container.read(equalizerProvider).presets;
for (var i = 0; i < 100; i++) {
notifier.update(_CountedSettings(-i / 10, () => serializations++));
}
expect(serializations, 0);
expect(container.read(equalizerProvider).presets, same(presets));
expect(playbackEqualizer.value.preamp, -9.9);
await tester.pump(const Duration(milliseconds: 350));
await tester.runAsync(() async => Future<void>.delayed(Duration.zero));
await tester.pump();
expect(serializations, 1);
final prefs = await SharedPreferences.getInstance();
Object? savedPreamp() {
final stored =
jsonDecode(prefs.getString(EqualizerController.storageKey)!)
as Map<String, dynamic>;
return (stored['settings'] as Map<String, dynamic>)['preamp'];
}
expect(savedPreamp(), -9.9);
notifier.update(_CountedSettings(-5, () => serializations++));
container.dispose();
await tester.runAsync(() async => Future<void>.delayed(Duration.zero));
await tester.pump();
expect(serializations, 2);
expect(savedPreamp(), -5);
});
for (final mornye in [false, true]) {
testWidgets(
'EQ drags retain unrelated controls and current edits ($mornye)',
(tester) async {
tester.view.physicalSize = const Size(1200, 3000);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
final container = ProviderContainer();
addTearDown(container.dispose);
await tester.pumpWidget(
UncontrolledProviderScope(
container: container,
child: MaterialApp(
theme: mornye
? MornyeTheme.build(Brightness.dark)
: AppTheme.light(),
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
home: const EqualizerScreen(),
),
),
);
await tester.pumpAndSettle();
final notifier = container.read(equalizerProvider.notifier);
notifier.update(
container.read(equalizerProvider).settings.copyWith(preamp: -1),
);
await tester.pumpAndSettle();
final page = tester.widget<Scaffold>(find.byType(Scaffold));
final picker = find.byType(
mornye ? MornyeSegmentedControl : M3EButtonGroup,
);
final bandPicker = tester.widget(picker);
Widget bass() => mornye
? tester
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
.firstWhere((slider) => slider.semanticLabel == 'Bass')
: tester
.widgetList<AppSlider>(find.byType(AppSlider))
.firstWhere((slider) => slider.semanticLabel == 'Bass');
final bassSlider = bass();
final gainSlider = mornye
? tester
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
.first
: tester.widgetList<AppSlider>(find.byType(AppSlider)).first;
for (var i = 1; i <= 20; i++) {
notifier.update(
container.read(equalizerProvider).settings.copyWith(preamp: -i / 2),
);
await tester.pump(const Duration(milliseconds: 16));
expect(tester.widget<Scaffold>(find.byType(Scaffold)), same(page));
expect(tester.widget(picker), same(bandPicker));
expect(bass(), same(bassSlider));
}
if (gainSlider is MornyeLevelSlider) {
gainSlider.onChanged!(5);
} else {
(gainSlider as AppSlider).onChanged!(5);
}
await tester.pump();
if (bassSlider is MornyeLevelSlider) {
bassSlider.onChanged!(3);
} else {
(bassSlider as AppSlider).onChanged!(3);
}
await tester.pump();
final settings = container.read(equalizerProvider).settings;
expect(settings.preamp, -10);
expect(settings.gains.first, 5);
expect(settings.bass, 3);
expect(playbackEqualizer.value, same(settings));
notifier.update(const EqualizerSettings());
await tester.pumpAndSettle();
notifier.importPreset(
jsonEncode({
'format': 'mornye-equalizer',
'version': 1,
'name': 'Signed zero',
'settings': EqualizerSettings(
gains: List.filled(10, -0.0),
preamp: -0.0,
bass: -0.0,
treble: -0.0,
balance: -0.0,
).toJson(),
}),
);
await tester.pumpAndSettle();
final headers = tester.widgetList<SliderValueHeader>(
find.byType(SliderValueHeader),
);
for (final title in ['Preamp', 'Bass', 'Treble', 'Balance']) {
expect(
headers.firstWhere((header) => header.title == title).value,
title == 'Balance' ? '−0%' : '−0.0 dB',
);
}
final bandValue = mornye
? tester
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
.first
.value
: tester.widgetList<AppSlider>(find.byType(AppSlider)).first.value;
expect(bandValue.isNegative, isTrue);
expect(tester.takeException(), isNull);
await tester.pumpWidget(const SizedBox.shrink());
await tester.pump(const Duration(milliseconds: 350));
},
);
}
test('band resampling preserves flat curves and center gains', () {
for (final count in EqualizerSettings.bandCounts) {
final settings = const EqualizerSettings().withBandCount(count);
expect(settings.gains, everyElement(0));
expect(settings.frequencies.length, count);
final raised = settings.copyWith(gains: List.filled(count, 6));
for (final hz in raised.frequencies) {
expect(raised.gainAt(hz), closeTo(6, 1e-9));
}
expect(raised.withBandCount(31).gains, everyElement(closeTo(6, 1e-9)));
}
expect(const EqualizerSettings().withBandCount(31).frequencies.take(3), [
20,
25,
31.5,
]);
expect(
() => const EqualizerSettings().withBandCount(32),
throwsFormatException,
);
});
test('tone controls and automatic headroom reach the native payload', () {
const settings = EqualizerSettings(
enabled: true,
bass: 6,
treble: -3,
preamp: -2,
);
final payload = settings.toNative();
expect(settings.effectiveGains.first, greaterThan(5));
expect(settings.effectiveGains.last, lessThan(-2));
expect(payload['inputGain'], lessThan(-7));
expect(payload['gains'], settings.effectiveGains);
expect(settings.copyWith(autoHeadroom: false).inputGain, -2);
});
test('presets change the sound but keep output safety choices', () {
final container = ProviderContainer();
addTearDown(container.dispose);
final notifier = container.read(equalizerProvider.notifier);
notifier.update(
const EqualizerSettings(
enabled: true,
balance: 0.25,
autoHeadroom: false,
limiter: false,
compressor: true,
ratio: 6,
),
);
final bassBoost = EqualizerPreset.builtIn.firstWhere(
(preset) => preset.name == 'Bass boost',
);
notifier.applyPreset(bassBoost);
final settings = container.read(equalizerProvider).settings;
expect(settings.gains, bassBoost.settings.gains);
expect(settings.enabled, isTrue);
expect(settings.balance, 0.25);
expect(settings.autoHeadroom, isFalse);
expect(settings.limiter, isFalse);
expect(settings.compressor, isTrue);
expect(settings.ratio, 6);
expect(settings.inputGain, 0);
});
test(
'malformed and nonfinite imports cannot create unsafe native settings',
() {
final json = const EqualizerSettings().toJson();
expect(
() => EqualizerSettings.fromJson({
...json,
'gains': [1, 2],
}),
throwsFormatException,
);
expect(
() => EqualizerSettings.fromJson({
...json,
'gains': List.filled(10, double.nan),
}),
throwsFormatException,
);
final bounded = EqualizerSettings.fromJson({
...json,
'gains': List.filled(10, 100),
'preamp': 1000,
'balance': -100,
'ratio': double.infinity,
});
expect(bounded.gains, everyElement(15));
expect(bounded.preamp, 12);
expect(bounded.balance, -1);
expect(bounded.ratio, 3);
},
);
testWidgets('presets survive fast edits during startup and reload', (
tester,
) async {
SharedPreferences.setMockInitialValues({
EqualizerController.storageKey: jsonEncode({
'settings': const EqualizerSettings(preamp: -4).toJson(),
'presets': [
const EqualizerPreset(
'Headphones',
EqualizerSettings(bass: 3),
).toJson(),
],
}),
});
final container = ProviderContainer();
container.read(equalizerProvider);
container
.read(equalizerProvider.notifier)
.update(const EqualizerSettings(enabled: true, treble: 2));
await tester.pump(const Duration(milliseconds: 500));
await tester.runAsync(() async {
await Future<void>.delayed(Duration.zero);
});
await tester.pump(const Duration(milliseconds: 500));
expect(container.read(equalizerProvider).settings.treble, 2);
expect(container.read(equalizerProvider).presets.single.name, 'Headphones');
final notifier = container.read(equalizerProvider.notifier);
notifier.savePreset('Desk');
notifier.update(const EqualizerSettings(enabled: true, preamp: -8));
final export = notifier.exportPreset('Portable');
expect(
(jsonDecode(export) as Map<String, dynamic>)['format'],
'mornye-equalizer',
);
notifier.importPreset(export);
notifier.importPreset(
export.replaceFirst('mornye-equalizer', 'spotiflac-equalizer'),
);
expect(container.read(equalizerProvider).presets.map((v) => v.name), [
'Headphones',
'Desk',
'Portable',
]);
expect(container.read(equalizerProvider).settings.enabled, isTrue);
expect(() => notifier.importPreset('{}'), throwsFormatException);
expect(() => notifier.importPreset('x' * 65537), throwsFormatException);
await tester.pump(const Duration(milliseconds: 500));
await tester.runAsync(() async {
await Future<void>.delayed(Duration.zero);
});
container.dispose();
final restored = ProviderContainer();
addTearDown(restored.dispose);
restored.read(equalizerProvider);
await tester.runAsync(() async {
await Future<void>.delayed(Duration.zero);
});
await tester.pump();
expect(restored.read(equalizerProvider).settings.preamp, -8);
expect(restored.read(equalizerProvider).presets.length, 3);
});
for (final mornye in [false, true]) {
testWidgets(
'EQ editing and dialogs fit a narrow screen with large text ($mornye)',
(tester) async {
tester.view.physicalSize = const Size(320, 720);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
final container = ProviderContainer();
addTearDown(container.dispose);
await tester.pumpWidget(
UncontrolledProviderScope(
container: container,
child: MaterialApp(
theme: mornye
? MornyeTheme.build(Brightness.dark)
: AppTheme.light(),
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
builder: (context, child) => MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: const TextScaler.linear(1.8)),
child: child!,
),
home: const EqualizerScreen(),
),
),
);
await tester.pumpAndSettle();
final picker = find.byType(
mornye ? MornyeSegmentedControl : M3EButtonGroup,
);
await tester.scrollUntilVisible(
picker,
150,
scrollable: find.byType(Scrollable).first,
);
await tester.pumpAndSettle();
// The picker sits on an opaque group card.
expect(
find.descendant(of: picker, matching: find.byType(BackdropFilter)),
findsNothing,
);
await tester.tap(
find.descendant(of: picker, matching: find.text('31')).first,
);
await tester.pumpAndSettle();
expect(container.read(equalizerProvider).settings.gains.length, 31);
expect(tester.takeException(), isNull);
// The first slider on the page is the lowest band's fader.
final onChanged = mornye
? tester
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
.first
.onChanged
: tester
.widgetList<AppSlider>(find.byType(AppSlider))
.first
.onChanged;
onChanged!(5);
await tester.pump();
expect(container.read(equalizerProvider).settings.gains.first, 5);
// Drags over the vertical faders adjust gains instead of scrolling.
tester
.state<ScrollableState>(find.byType(Scrollable).first)
.position
.jumpTo(0);
await tester.pumpAndSettle();
final save = find.text('Save preset');
await tester.scrollUntilVisible(
save,
150,
scrollable: find.byType(Scrollable).first,
);
await tester.pumpAndSettle();
await tester.tap(save);
await tester.pumpAndSettle();
await tester.enterText(find.byType(EditableText), 'My headphones');
await tester.tap(find.text('Save').last);
await tester.pumpAndSettle();
expect(
container.read(equalizerProvider).presets.single.name,
'My headphones',
);
expect(tester.takeException(), isNull);
await tester.pumpWidget(const SizedBox.shrink());
},
);
}
}