Add more tests

lib/src/core/buffer/range_line.dart

@@ -14,37 +14,34 @@ class BufferRangeLine extends BufferRange {
 
   @override
   Iterable<BufferSegment> toSegments() sync* {
-    var begin = this.begin;
-    var end = this.end;
-
-    if (!isNormalized) {
-      end = this.begin;
-      begin = this.end;
-    }
-
-    for (var i = begin.y; i <= end.y; i++) {
-      var startX = i == begin.y ? begin.x : null;
-      var endX = i == end.y ? end.x : null;
+    final self = normalized;
+    for (var i = self.begin.y; i <= self.end.y; i++) {
+      var startX = i == self.begin.y ? self.begin.x : null;
+      var endX = i == self.end.y ? self.end.x : null;
       yield BufferSegment(this, i, startX, endX);
     }
   }
 
   @override
   bool contains(CellOffset position) {
-    return begin.isBeforeOrSame(position) && end.isAfterOrSame(position);
+    final self = normalized;
+    return self.begin.isBeforeOrSame(position) &&
+        self.end.isAfterOrSame(position);
   }
 
   @override
   BufferRangeLine merge(BufferRange range) {
-    final begin = this.begin.isBefore(range.begin) ? this.begin : range.begin;
-    final end = this.end.isAfter(range.end) ? this.end : range.end;
+    final self = normalized;
+    final begin = self.begin.isBefore(range.begin) ? self.begin : range.begin;
+    final end = self.end.isAfter(range.end) ? self.end : range.end;
     return BufferRangeLine(begin, end);
   }
 
   @override
   BufferRangeLine extend(CellOffset position) {
-    final begin = this.begin.isBefore(position) ? position : this.begin;
-    final end = this.end.isAfter(position) ? position : this.end;
+    final self = normalized;
+    final begin = self.begin.isAfter(position) ? position : self.begin;
+    final end = self.end.isBefore(position) ? position : self.end;
     return BufferRangeLine(begin, end);
   }
 

lib/src/core/buffer/segment.dart

@@ -8,13 +8,15 @@ class BufferSegment {
   /// The line that this segment resides on.
   final int line;
 
-  /// The start position of this segment.
+  /// The start position of this segment. [null] means the start of the line.
   final int? start;
 
-  /// The end position of this segment. [null] if this segment is not closed.
+  /// The end position of this segment. [null] means the end of the line.
+  /// Should be greater than or equal to [start].
   final int? end;
 
-  const BufferSegment(this.range, this.line, this.start, this.end);
+  const BufferSegment(this.range, this.line, this.start, this.end)
+      : assert((start != null && end != null) ? start <= end : true);
 
   bool isWithin(CellOffset position) {
     if (position.y != line) {
@@ -33,7 +35,11 @@ class BufferSegment {
   }
 
   @override
-  String toString() => 'Segment($line, $start, $end)';
+  String toString() {
+    final start = this.start != null ? this.start.toString() : 'start';
+    final end = this.end != null ? this.end.toString() : 'end';
+    return 'Segment($line, $start -> $end)';
+  }
 
   @override
   int get hashCode =>

test/src/core/buffer/range_block_test.dart

@@ -0,0 +1,107 @@
+import 'package:test/test.dart';
+import 'package:xterm/xterm.dart';
+
+void main() {
+  group('BufferLineRange', () {
+    test('toSegments() works', () {
+      final range = BufferRangeBlock(CellOffset(10, 10), CellOffset(12, 12));
+      final segments = range.toSegments().toList();
+
+      expect(segments, hasLength(3));
+
+      expect(segments[0].start, equals(10));
+      expect(segments[0].end, equals(12));
+
+      expect(segments[1].start, equals(10));
+      expect(segments[1].end, equals(12));
+
+      expect(segments[2].start, equals(10));
+      expect(segments[2].end, 12);
+    });
+
+    test('toSegments() works with reversed range', () {
+      final range = BufferRangeBlock(CellOffset(12, 12), CellOffset(10, 10));
+      final segments = range.toSegments().toList();
+
+      expect(segments, hasLength(3));
+
+      expect(segments[0].start, equals(10));
+      expect(segments[0].end, equals(12));
+
+      expect(segments[1].start, equals(10));
+      expect(segments[1].end, equals(12));
+
+      expect(segments[2].start, equals(10));
+      expect(segments[2].end, 12);
+    });
+
+    test('contains() works', () {
+      final range = BufferRangeBlock(CellOffset(10, 10), CellOffset(10, 12));
+
+      expect(range.contains(CellOffset(10, 10)), isTrue);
+      expect(range.contains(CellOffset(10, 11)), isTrue);
+      expect(range.contains(CellOffset(10, 12)), isTrue);
+
+      expect(range.contains(CellOffset(10, 9)), isFalse);
+      expect(range.contains(CellOffset(10, 13)), isFalse);
+    });
+
+    test('contains() works with reversed range', () {
+      final range = BufferRangeBlock(CellOffset(10, 12), CellOffset(10, 10));
+
+      expect(range.contains(CellOffset(10, 10)), isTrue);
+      expect(range.contains(CellOffset(10, 11)), isTrue);
+      expect(range.contains(CellOffset(10, 12)), isTrue);
+
+      expect(range.contains(CellOffset(10, 9)), isFalse);
+      expect(range.contains(CellOffset(10, 13)), isFalse);
+    });
+
+    test('merge() works', () {
+      final range1 = BufferRangeBlock(CellOffset(10, 10), CellOffset(10, 12));
+      final range2 = BufferRangeBlock(CellOffset(10, 13), CellOffset(10, 15));
+
+      final merged = range1.merge(range2);
+
+      expect(merged.begin, equals(CellOffset(10, 10)));
+      expect(merged.end, equals(CellOffset(10, 15)));
+    });
+
+    test('merge() works with reversed range', () {
+      final range1 = BufferRangeBlock(CellOffset(10, 12), CellOffset(10, 10));
+      final range2 = BufferRangeBlock(CellOffset(10, 13), CellOffset(10, 15));
+
+      final merged = range1.merge(range2);
+
+      expect(merged.begin, equals(CellOffset(10, 10)));
+      expect(merged.end, equals(CellOffset(10, 15)));
+    });
+
+    test('extend() works', () {
+      final range = BufferRangeBlock(CellOffset(10, 10), CellOffset(10, 12));
+
+      final extended = range.extend(CellOffset(10, 13));
+
+      expect(extended.begin, equals(CellOffset(10, 10)));
+      expect(extended.end, equals(CellOffset(10, 13)));
+    });
+
+    test('extend() works with reversed range', () {
+      final range = BufferRangeBlock(CellOffset(10, 12), CellOffset(10, 10));
+
+      final extended = range.extend(CellOffset(10, 13));
+
+      expect(extended.begin, equals(CellOffset(10, 10)));
+      expect(extended.end, equals(CellOffset(10, 13)));
+    });
+
+    test('extend() works with reversed range and reversed extend', () {
+      final range = BufferRangeBlock(CellOffset(10, 12), CellOffset(10, 10));
+
+      final extended = range.extend(CellOffset(10, 9));
+
+      expect(extended.begin, equals(CellOffset(10, 9)));
+      expect(extended.end, equals(CellOffset(10, 12)));
+    });
+  });
+}

test/src/core/buffer/range_line_test.dart

@@ -0,0 +1,107 @@
+import 'package:test/test.dart';
+import 'package:xterm/xterm.dart';
+
+void main() {
+  group('BufferRangeLine', () {
+    test('toSegments() works', () {
+      final range = BufferRangeLine(CellOffset(10, 10), CellOffset(10, 12));
+      final segments = range.toSegments().toList();
+
+      expect(segments, hasLength(3));
+
+      expect(segments[0].start, equals(10));
+      expect(segments[0].end, null);
+
+      expect(segments[1].start, null);
+      expect(segments[1].end, null);
+
+      expect(segments[2].start, null);
+      expect(segments[2].end, 10);
+    });
+
+    test('toSegments() works with reversed range', () {
+      final range = BufferRangeLine(CellOffset(10, 12), CellOffset(10, 10));
+      final segments = range.toSegments().toList();
+
+      expect(segments, hasLength(3));
+
+      expect(segments[0].start, 10);
+      expect(segments[0].end, null);
+
+      expect(segments[1].start, null);
+      expect(segments[1].end, null);
+
+      expect(segments[2].start, null);
+      expect(segments[2].end, 10);
+    });
+
+    test('contains() works', () {
+      final range = BufferRangeLine(CellOffset(10, 10), CellOffset(10, 12));
+
+      expect(range.contains(CellOffset(10, 10)), isTrue);
+      expect(range.contains(CellOffset(10, 11)), isTrue);
+      expect(range.contains(CellOffset(10, 12)), isTrue);
+
+      expect(range.contains(CellOffset(10, 9)), isFalse);
+      expect(range.contains(CellOffset(10, 13)), isFalse);
+    });
+
+    test('contains() works with reversed range', () {
+      final range = BufferRangeLine(CellOffset(10, 12), CellOffset(10, 10));
+
+      expect(range.contains(CellOffset(10, 10)), isTrue);
+      expect(range.contains(CellOffset(10, 11)), isTrue);
+      expect(range.contains(CellOffset(10, 12)), isTrue);
+
+      expect(range.contains(CellOffset(10, 9)), isFalse);
+      expect(range.contains(CellOffset(10, 13)), isFalse);
+    });
+
+    test('merge() works', () {
+      final range1 = BufferRangeLine(CellOffset(10, 10), CellOffset(10, 12));
+      final range2 = BufferRangeLine(CellOffset(10, 13), CellOffset(10, 15));
+
+      final merged = range1.merge(range2);
+
+      expect(merged.begin, equals(CellOffset(10, 10)));
+      expect(merged.end, equals(CellOffset(10, 15)));
+    });
+
+    test('merge() works with reversed range', () {
+      final range1 = BufferRangeLine(CellOffset(10, 12), CellOffset(10, 10));
+      final range2 = BufferRangeLine(CellOffset(10, 13), CellOffset(10, 15));
+
+      final merged = range1.merge(range2);
+
+      expect(merged.begin, equals(CellOffset(10, 10)));
+      expect(merged.end, equals(CellOffset(10, 15)));
+    });
+
+    test('extend() works', () {
+      final range = BufferRangeLine(CellOffset(10, 10), CellOffset(10, 12));
+
+      final extended = range.extend(CellOffset(10, 13));
+
+      expect(extended.begin, equals(CellOffset(10, 10)));
+      expect(extended.end, equals(CellOffset(10, 13)));
+    });
+
+    test('extend() works with reversed range', () {
+      final range = BufferRangeLine(CellOffset(10, 12), CellOffset(10, 10));
+
+      final extended = range.extend(CellOffset(10, 13));
+
+      expect(extended.begin, equals(CellOffset(10, 10)));
+      expect(extended.end, equals(CellOffset(10, 13)));
+    });
+
+    test('extend() works with reversed range and reversed extend', () {
+      final range = BufferRangeLine(CellOffset(10, 12), CellOffset(10, 10));
+
+      final extended = range.extend(CellOffset(10, 9));
+
+      expect(extended.begin, equals(CellOffset(10, 9)));
+      expect(extended.end, equals(CellOffset(10, 12)));
+    });
+  });
+}

test/src/core/buffer/segment_test.dart

@@ -0,0 +1,32 @@
+import 'package:test/test.dart';
+import 'package:xterm/xterm.dart';
+
+void main() {
+  group('BufferSegment', () {
+    test('isWithin() works', () {
+      final segments = BufferRangeLine(CellOffset(10, 10), CellOffset(10, 12))
+          .toSegments()
+          .toList();
+
+      expect(segments[0].start, equals(10));
+      expect(segments[0].end, null);
+      expect(segments[0].isWithin(CellOffset(10, 10)), isTrue);
+      expect(segments[0].isWithin(CellOffset(11, 10)), isTrue);
+      expect(segments[0].isWithin(CellOffset(100, 10)), isTrue);
+      expect(segments[0].isWithin(CellOffset(9, 10)), isFalse);
+
+      expect(segments[1].start, null);
+      expect(segments[1].end, null);
+      expect(segments[1].isWithin(CellOffset(10, 11)), isTrue);
+      expect(segments[1].isWithin(CellOffset(11, 11)), isTrue);
+      expect(segments[1].isWithin(CellOffset(100, 11)), isTrue);
+      expect(segments[1].isWithin(CellOffset(0, 11)), isTrue);
+
+      expect(segments[2].start, null);
+      expect(segments[2].end, 10);
+      expect(segments[2].isWithin(CellOffset(0, 12)), isTrue);
+      expect(segments[2].isWithin(CellOffset(10, 12)), isTrue);
+      expect(segments[2].isWithin(CellOffset(11, 12)), isFalse);
+    });
+  });
+}