rodydavis/packages.dart
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

update versions

Browse Source
This commit is contained in:
Rody Davis
2026-02-16 10:48:25 -08:00
parent 3f8c930d48
commit ee78f04d33
3 changed files with 185 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/undo/test/undo_test.dart
+175 -177
View File
@@ -1,197 +1,195 @@
import 'dart:async';
import 'package:test/test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:undo/undo.dart';
void main() {
group('initial state', () {
test('is correct', () {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.state, 0);
});
group('initial state', () {
test('is correct', () {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.state, 0);
});
});
group('canUndo', () {
test('is false when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.canUndo, isFalse);
});
group('canUndo', () {
test('is false when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.canUndo, isFalse);
});
test('is true when a single state change has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
expect(testObject.canUndo, isTrue);
});
test('is false when undos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(testObject.canUndo, isFalse);
});
test('is true when a single state change has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
expect(testObject.canUndo, isTrue);
});
group('canRedo', () {
test('is false when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.canRedo, isFalse);
});
test('is false when undos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
test('is true when a single undo has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(testObject.canRedo, isTrue);
});
expect(testObject.canUndo, isFalse);
});
});
test('is false when redos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(testObject.canRedo, isFalse);
});
group('canRedo', () {
test('is false when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
expect(testObject.canRedo, isFalse);
});
group('clearHistory', () {
test('clears history and redos on new testObject', () async {
final testObject = SimpleStack(0)..clearHistory();
expect(testObject.canRedo, isFalse);
expect(testObject.canUndo, isFalse);
});
test('is true when a single undo has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(testObject.canRedo, isTrue);
});
group('undo', () {
test('does nothing when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(Duration.zero, testObject.undo);
test('is false when redos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(testObject.canRedo, isFalse);
});
});
expect(states, [0]);
});
group('clearHistory', () {
test('clears history and redos on new testObject', () async {
final testObject = SimpleStack(0)..clearHistory();
expect(testObject.canRedo, isFalse);
expect(testObject.canUndo, isFalse);
});
});
test('does nothing when limit is 0', () async {
final states = <int>[];
final testObject = SimpleStack(0, limit: 0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
group('undo', () {
test('does nothing when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 0]);
});
test('loses history outside of limit', () async {
final states = <int>[];
final testObject = SimpleStack(0, limit: 1, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 2, 1, 0]);
});
test('reverts to initial state', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 0]);
});
test('reverts to previous state with multiple state changes ', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 2, 1]);
});
expect(states, [0]);
});
group('redo', () {
test('does nothing when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(Duration.zero, testObject.redo);
test('does nothing when limit is 0', () async {
final states = <int>[];
final testObject = SimpleStack(0, limit: 0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0]);
});
test('does nothing when no undos have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2]);
});
test('works when one undo has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 2]);
});
test('does nothing when undos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 2]);
});
test(
'does nothing when undos has occurred '
'followed by a new state change', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state - 1));
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 0]);
});
expect(states, [0, 1, 0]);
});
}
test('loses history outside of limit', () async {
final states = <int>[];
final testObject = SimpleStack(0, limit: 1, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 2, 1, 0]);
});
test('reverts to initial state', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 0]);
});
test('reverts to previous state with multiple state changes ', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
expect(states, [0, 1, 2, 1]);
});
});
group('redo', () {
test('does nothing when no state changes have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0]);
});
test('does nothing when no undos have occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2]);
});
test('works when one undo has occurred', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 2]);
});
test('does nothing when undos have been exhausted', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(Duration.zero, testObject.redo);
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 2]);
});
test(
'does nothing when undos has occurred '
'followed by a new state change', () async {
final states = <int>[];
final testObject = SimpleStack(0, onUpdate: states.add);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state + 1));
await Future<void>.delayed(Duration.zero, testObject.undo);
await Future<void>.delayed(
Duration.zero, () => testObject.modify(testObject.state - 1));
await Future<void>.delayed(Duration.zero, testObject.redo);
expect(states, [0, 1, 2, 1, 0]);
});
});
}