Add VersionConstraint.difference().

test/version_range_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:test/test.dart';
 
 import 'package:pub_semver/pub_semver.dart';
 
 import 'utils.dart';
 
@@ skipping 322 matching lines @@
       expect(intersect.includeMax, isFalse);
     });
 
     test('a non-overlapping range allows no versions', () {
       var a = new VersionRange(min: v114, max: v124);
       var b = new VersionRange(min: v200, max: v250);
       expect(a.intersect(b).isEmpty, isTrue);
     });
 
     test('adjacent ranges allow no versions if exclusive', () {
-      var a = new VersionRange(min: v114, max: v124, includeMax: false);
-      var b = new VersionRange(min: v124, max: v200, includeMin: true);
+      var a = new VersionRange(min: v114, max: v124);
+      var b = new VersionRange(min: v124, max: v200);
       expect(a.intersect(b).isEmpty, isTrue);
     });
 
     test('adjacent ranges allow version if inclusive', () {
       var a = new VersionRange(min: v114, max: v124, includeMax: true);
       var b = new VersionRange(min: v124, max: v200, includeMin: true);
       expect(a.intersect(b), equals(v124));
     });
 
     test('with an open range', () {
@@ skipping 79 matching lines @@
     });
 
     test("includes edges if either range does", () {
       var result = new VersionRange(min: v003, max: v114, includeMin: true)
           .union(new VersionRange(min: v003, max: v114, includeMax: true));
       expect(result, equals(new VersionRange(
           min: v003, max: v114, includeMin: true, includeMax: true)));
     });
   });
 
+  group('difference()', () {
+    test("with an empty range returns the original range", () {
+      expect(
+          new VersionRange(min: v003, max: v114)
+              .difference(VersionConstraint.empty),
+          equals(new VersionRange(min: v003, max: v114)));
+    });
+
+    test("with a version outside the range returns the original range", () {
+      expect(
+          new VersionRange(min: v003, max: v114).difference(v200),
+          equals(new VersionRange(min: v003, max: v114)));
+    });
+
+    test("with a version in the range splits the range", () {
+      expect(
+          new VersionRange(min: v003, max: v114).difference(v072),
+          equals(new VersionConstraint.unionOf([
+            new VersionRange(min: v003, max: v072),
+            new VersionRange(min: v072, max: v114)
+          ])));
+    });
+
+    test("with the max version makes the max exclusive", () {
+      expect(
+          new VersionRange(min: v003, max: v114, includeMax: true)
+              .difference(v114),
+          equals(new VersionRange(min: v003, max: v114)));
+    });
+
+    test("with the min version makes the min exclusive", () {
+      expect(
+          new VersionRange(min: v003, max: v114, includeMin: true)
+              .difference(v003),
+          equals(new VersionRange(min: v003, max: v114)));
+    });
+
+    test("with a disjoint range returns the original", () {
+      expect(
+          new VersionRange(min: v003, max: v114)
+              .difference(new VersionRange(min: v123, max: v140)),
+          equals(new VersionRange(min: v003, max: v114)));
+    });
+
+    test("with an adjacent range returns the original", () {
+      expect(
+          new VersionRange(min: v003, max: v114, includeMax: true)
+              .difference(new VersionRange(min: v114, max: v140)),
+          equals(new VersionRange(min: v003, max: v114, includeMax: true)));
+    });
+
+    test("with a range at the beginning cuts off the beginning of the range",
+        () {
+      expect(
+          new VersionRange(min: v080, max: v130)
+              .difference(new VersionRange(min: v010, max: v114)),
+          equals(new VersionRange(min: v114, max: v130, includeMin: true)));
+      expect(
+          new VersionRange(min: v080, max: v130)
+              .difference(new VersionRange(max: v114)),
+          equals(new VersionRange(min: v114, max: v130, includeMin: true)));
+      expect(
+          new VersionRange(min: v080, max: v130).difference(
+              new VersionRange(min: v010, max: v114, includeMax: true)),
+          equals(new VersionRange(min: v114, max: v130)));
+      expect(
+          new VersionRange(min: v080, max: v130, includeMin: true).difference(
+              new VersionRange(min: v010, max: v080, includeMax: true)),
+          equals(new VersionRange(min: v080, max: v130)));
+      expect(
+          new VersionRange(min: v080, max: v130, includeMax: true)
+              .difference(new VersionRange(min: v080, max: v130)),
+          equals(v130));
+    });
+
+    test("with a range at the end cuts off the end of the range",
+        () {
+      expect(
+          new VersionRange(min: v080, max: v130)
+              .difference(new VersionRange(min: v114, max: v140)),
+          equals(new VersionRange(min: v080, max: v114, includeMax: true)));
+      expect(
+          new VersionRange(min: v080, max: v130)
+              .difference(new VersionRange(min: v114)),
+          equals(new VersionRange(min: v080, max: v114, includeMax: true)));
+      expect(
+          new VersionRange(min: v080, max: v130).difference(
+              new VersionRange(min: v114, max: v140, includeMin: true)),
+          equals(new VersionRange(min: v080, max: v114)));
+      expect(
+          new VersionRange(min: v080, max: v130, includeMax: true).difference(
+              new VersionRange(min: v130, max: v140, includeMin: true)),
+          equals(new VersionRange(min: v080, max: v130)));
+      expect(
+          new VersionRange(min: v080, max: v130, includeMin: true)
+              .difference(new VersionRange(min: v080, max: v130)),
+          equals(v080));
+    });
+
+    test("with a range in the middle cuts the range in half", () {
+      expect(
+          new VersionRange(min: v003, max: v130)
+              .difference(new VersionRange(min: v072, max: v114)),
+          equals(new VersionConstraint.unionOf([
+            new VersionRange(min: v003, max: v072, includeMax: true),
+            new VersionRange(min: v114, max: v130, includeMin: true)
+          ])));
+    });
+
+    test("with a totally covering range returns empty", () {
+      expect(
+          new VersionRange(min: v114, max: v200)
+              .difference(new VersionRange(min: v072, max: v300)),
+          isEmpty);
+      expect(
+          new VersionRange(min: v003, max: v114)
+              .difference(new VersionRange(min: v003, max: v114)),
+          isEmpty);
+      expect(
+          new VersionRange(
+                  min: v003, max: v114, includeMin: true, includeMax: true)
+              .difference(new VersionRange(
+                  min: v003, max: v114, includeMin: true, includeMax: true)),
+          isEmpty);
+    });
+
+    test("with a version union that doesn't cover the range, returns the "
+        "original", () {
+      expect(
+          new VersionRange(min: v114, max: v140)
+              .difference(new VersionConstraint.unionOf([v010, v200])),
+          equals(new VersionRange(min: v114, max: v140)));
+    });
+
+    test("with a version union that intersects the ends, chops them off", () {
+      expect(
+          new VersionRange(min: v114, max: v140)
+              .difference(new VersionConstraint.unionOf([
+                new VersionRange(min: v080, max: v123),
+                new VersionRange(min: v130, max: v200)
+              ])),
+          equals(new VersionRange(
+              min: v123, max: v130, includeMin: true, includeMax: true)));
+    });
+
+    test("with a version union that intersects the middle, chops it up", () {
+      expect(
+          new VersionRange(min: v114, max: v140)
+              .difference(new VersionConstraint.unionOf([v123, v124, v130])),
+          equals(new VersionConstraint.unionOf([
+            new VersionRange(min: v114, max: v123),
+            new VersionRange(min: v123, max: v124),
+            new VersionRange(min: v124, max: v130),
+            new VersionRange(min: v130, max: v140)
+          ])));
+    });
+  });
+
   test('isEmpty', () {
     expect(new VersionRange().isEmpty, isFalse);
     expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse);
   });
 
   group('compareTo()', () {
     test("orders by minimum first", () {
       _expectComparesSmaller(
           new VersionRange(min: v003, max: v080),
           new VersionRange(min: v010, max: v072));
@@ skipping 42 matching lines @@
     });
   });
 }
 
 void _expectComparesSmaller(VersionRange smaller, VersionRange larger) {
   expect(smaller.compareTo(larger), lessThan(0),
       reason: "expected $smaller to sort below $larger");
   expect(larger.compareTo(smaller), greaterThan(0),
       reason: "expected $larger to sort above $smaller");
 }