Add base Version class to start support versioning in pub.

utils/tests/pub/version_test.dart

Index: utils/tests/pub/version_test.dart
diff --git a/utils/tests/pub/version_test.dart b/utils/tests/pub/version_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f2875639efad8687cc220e2414892531f8741814
--- /dev/null
+++ b/utils/tests/pub/version_test.dart
@@ -0,0 +1,193 @@
+// Copyright (c) 2012, 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.
+
+#library('version_test');
+
+#import('../../../lib/unittest/unittest.dart');
+#import('../../pub/version.dart');
+
+main() {
+  group('Version', () {
+    group('constructor', () {
+      test('throws on negative numbers', () {
+        throwsIllegalArg(() => new Version(-1, 1, 1));
+        throwsIllegalArg(() => new Version(1, -1, 1));
+        throwsIllegalArg(() => new Version(1, 1, -1));
+      });
+    });
+
+    group('comparison', () {
+      // A correctly sorted list of versions.
+      var versions = [
+        '1.0.0-alpha',
+        '1.0.0-alpha.1',
+        '1.0.0-beta.2',
+        '1.0.0-beta.11',
+        '1.0.0-rc.1',
+        '1.0.0-rc.1+build.1',
+        '1.0.0',
+        '1.0.0+0.3.7',
+        '1.3.7+build',
+        '1.3.7+build.2.b8f12d7',
+        '1.3.7+build.11.e0f985a',
+        '2.0.0',
+        '2.1.0',
+        '2.2.0',
+        '2.11.0',
+        '2.11.1'
+      ];
+
+      test('compareTo()', () {
+        // Ensure that every pair of versions compares in the order that it
+        // appears in the list.
+        for (var i = 0; i < versions.length; i++) {
+          for (var j = 0; j < versions.length; j++) {
+            var a = Version.parse(versions[i]);
+            var b = Version.parse(versions[j]);
+            var expectation = i.compareTo(j);
+            expect(a.compareTo(b)).equals(expectation);
+          }
+        }
+      });
+
+      test('operators', () {
+        for (var i = 0; i < versions.length; i++) {
+          for (var j = 0; j < versions.length; j++) {
+            var a = Version.parse(versions[i]);
+            var b = Version.parse(versions[j]);
+            expect(a < b).equals(i < j);
+            expect(a > b).equals(i > j);
+            expect(a <= b).equals(i <= j);
+            expect(a >= b).equals(i >= j);
+            expect(a == b).equals(i == j);
+            expect(a != b).equals(i != j);
+          }
+        }
+      });
+    });
+
+    test('allows()', () {
+      expect(Version.parse('1.2.3').allows(Version.parse('1.2.3'))).isTrue();
+      expect(Version.parse('1.2.3').allows(Version.parse('1.1.4'))).isFalse();
+      expect(Version.parse('1.2.3').allows(Version.parse('1.2.4'))).isFalse();
+    });
+
+    test('parse()', () {
+      expect(Version.parse('0.0.0')).equals(new Version(0, 0, 0));
+      expect(Version.parse('12.34.56')).equals(new Version(12, 34, 56));
+
+      expect(Version.parse('1.2.3-alpha.1')).equals(
+          new Version(1, 2, 3, pre: 'alpha.1'));
+      expect(Version.parse('1.2.3-x.7.z-92')).equals(
+          new Version(1, 2, 3, pre: 'x.7.z-92'));
+
+      expect(Version.parse('1.2.3+build.1')).equals(
+          new Version(1, 2, 3, build: 'build.1'));
+      expect(Version.parse('1.2.3+x.7.z-92')).equals(
+          new Version(1, 2, 3, build: 'x.7.z-92'));
+
+      expect(Version.parse('1.0.0-rc-1+build-1')).equals(
+          new Version(1, 0, 0, pre: 'rc-1', build: 'build-1'));
+
+      throwsBadFormat(() => Version.parse('1.0'));
+      throwsBadFormat(() => Version.parse('1.2.3.4'));
+      throwsBadFormat(() => Version.parse('1234'));
+      throwsBadFormat(() => Version.parse('-2.3.4'));
+      throwsBadFormat(() => Version.parse('1.3-pre'));
+      throwsBadFormat(() => Version.parse('1.3+build'));
+      throwsBadFormat(() => Version.parse('1.3+bu?!3ild'));
+    });
+
+    test('toString()', () {
+      expect(new Version(0, 0, 0).toString()).equals('0.0.0');
+      expect(new Version(12, 34, 56).toString()).equals('12.34.56');
+
+      expect(new Version(1, 2, 3, pre: 'alpha.1').toString()).equals(
+          '1.2.3-alpha.1');
+      expect(new Version(1, 2, 3, pre: 'x.7.z-92').toString()).equals(
+          '1.2.3-x.7.z-92');
+
+      expect(new Version(1, 2, 3, build: 'build.1').toString()).equals(
+          '1.2.3+build.1');
+      expect(new Version(1, 2, 3, pre: 'pre', build: 'bui').toString()).equals(
+          '1.2.3-pre+bui');
+    });
+  });
+
+  group('VersionRange', () {
+    group('constructor', () {
+      test('takes a min and max', () {
+        var min = Version.parse('1.2.3');
+        var max = Version.parse('1.3.5');
+        var range = new VersionRange(min, max);
+        expect(range.min).equals(min);
+        expect(range.max).equals(max);
+      });
+
+      test('allows omitting max', () {

[nweiz, 2012/05/15 23:12:19]

What about "allows omitting min"?

[Bob Nystrom, 2012/05/16 18:39:52]

Done.

+        var min = Version.parse('1.2.3');
+        var range = new VersionRange(min);
+        expect(range.min).equals(min);
+        expect(range.max).isNull();
+      });
+
+      test('allows omitting min and max', () {
+        var range = new VersionRange();

[nweiz, 2012/05/15 23:12:19]

Why is this allowed?

[Bob Nystrom, 2012/05/16 00:27:27]

My plan is that once we start solving for version constraints, I'll add
intersect to VersionRange (and Version). Dependencies where a version constraint
isn't specified will just be new VersionRange();

Also, min and max are named and optional, so it would have to do *something*
here. This seemed like a consistent semantic.

+        expect(range.min).isNull();
+        expect(range.max).isNull();
+      });
+
+      test('throws if min > max', () {
+        var min = Version.parse('1.2.3');
+        var max = Version.parse('1.0.0');
+
+        throwsIllegalArg(() => new VersionRange(min, max));
+      });
+    });
+
+    group('allows()', () {
+      test('version must be min or greater', () {
+        var range = new VersionRange(
+            Version.parse('1.2.3'), Version.parse('2.3.4'));
+
+        expect(range.allows(Version.parse('1.2.2'))).isFalse();
+        expect(range.allows(Version.parse('1.2.3'))).isTrue();
+        expect(range.allows(Version.parse('1.3.3'))).isTrue();
+        expect(range.allows(Version.parse('2.3.3'))).isTrue();
+      });
+
+      test('version must be less than max', () {
+        var range = new VersionRange(
+            Version.parse('1.2.3'), Version.parse('2.3.4'));
+
+        expect(range.allows(Version.parse('2.3.3'))).isTrue();
+        expect(range.allows(Version.parse('2.3.4'))).isFalse();
+        expect(range.allows(Version.parse('2.4.3'))).isFalse();
+      });
+
+      test('has no max if one was not set', () {

[nweiz, 2012/05/15 23:12:19]

What about "has no min if one was not set"?

[Bob Nystrom, 2012/05/16 00:27:27]

Done.

+        var range = new VersionRange(Version.parse('1.2.3'));
+
+        expect(range.allows(Version.parse('1.2.3'))).isTrue();
+        expect(range.allows(Version.parse('1.3.3'))).isTrue();
+        expect(range.allows(Version.parse('999.3.3'))).isTrue();
+      });
+
+      test('allows any version if there is no min or max', () {

[nweiz, 2012/05/15 23:12:19]

It seems like this might be cleaner to represent as a special AnyVersion
constraint.

[Bob Nystrom, 2012/05/16 00:27:27]

min and max are optional args, and open either end of the range when omitted so
it made sense to me to allow omitting both and just open the whole range.

Once I start doing intersection of VersionConstraints, it will be simpler if I
have fewer classes I need to double-dispatch on.

[nweiz, 2012/05/16 18:28:05]

It seems like what you're planning to do with versions has all
VersionConstraints providing basically the same semantics as VersionRange does
now. Maybe a better architecture would be having all the classes just inherit
from VersionRange?

Alternately, if you do want the full power of an arbitrary allows() method,
maybe intersection() would be better represented as an IntersectedVersion class
that just checks v1.allows(...) && v2.allows(...).

[Bob Nystrom, 2012/05/16 18:39:52]

Maybe. I kind of sketched this stuff in just for kicks. Once I start actually
using version ranges in later patches, I'll have a clearer idea of what I need
here.

+        var range = new VersionRange();
+
+        expect(range.allows(Version.parse('0.0.0'))).isTrue();
+        expect(range.allows(Version.parse('999.99.9'))).isTrue();
+      });
+    });
+  });
+}
+
+throwsIllegalArg(function) {
+  expectThrow(function, (e) => e is IllegalArgumentException);
+}
+
+throwsBadFormat(function) {
+  expectThrow(function, (e) => e is FormatException);
+}