Fix pkg/glob tests on Windows.

pkg/glob/test/list_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 'dart:async';
 import 'dart:io';
 
 import 'package:glob/glob.dart';
 import 'package:glob/src/utils.dart';
 import 'package:path/path.dart' as p;
@@ skipping 37 matching lines @@
       schedule(() {
         expect(new Glob("non/existent/**").listSync,
             throwsA(new isInstanceOf<FileSystemException>()));
       });
     });
   });
 
   syncAndAsync((list) {
     group("literals", () {
       test("lists a single literal", () {
-        expect(list("foo/baz/qux"), completion(equals(["foo/baz/qux"])));
+        expect(list("foo/baz/qux"),
+            completion(equals([p.join("foo", "baz", "qux")])));
       });
 
       test("lists a non-matching literal", () {
         expect(list("foo/baz/nothing"), completion(isEmpty));
       });
     });
 
     group("star", () {
       test("lists within filenames but not across directories", () {
-        expect(list("foo/b*"),
-            completion(unorderedEquals(["foo/bar", "foo/baz"])));
+        expect(list("foo/b*"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz")
+        ])));
       });
 
       test("lists the empy string", () {
-        expect(list("foo/bar*"), completion(equals(["foo/bar"])));
+        expect(list("foo/bar*"), completion(equals([p.join("foo", "bar")])));
       });
     });
 
     group("double star", () {
       test("lists within filenames", () {
-        expect(list("foo/baz/**"),
-            completion(unorderedEquals(["foo/baz/qux", "foo/baz/bang"])));
+        expect(list("foo/baz/**"), completion(unorderedEquals([
+          p.join("foo", "baz", "qux"),
+          p.join("foo", "baz", "bang")
+        ])));
       });
 
       test("lists the empty string", () {
-        expect(list("foo/bar**"), completion(equals(["foo/bar"])));
+        expect(list("foo/bar**"), completion(equals([p.join("foo", "bar")])));
       });
 
       test("lists recursively", () {
-        expect(list("foo/**"), completion(unorderedEquals(
-            ["foo/bar", "foo/baz", "foo/baz/qux", "foo/baz/bang"])));
+        expect(list("foo/**"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz"),
+          p.join("foo", "baz", "qux"),
+          p.join("foo", "baz", "bang")
+        ])));
       });
 
       test("combines with literals", () {
-        expect(list("foo/ba**"), completion(unorderedEquals(
-            ["foo/bar", "foo/baz", "foo/baz/qux", "foo/baz/bang"])));
+        expect(list("foo/ba**"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz"),
+          p.join("foo", "baz", "qux"),
+          p.join("foo", "baz", "bang")
+        ])));
       });
 
       test("lists recursively in the middle of a glob", () {
         d.dir("deep", [
           d.dir("a", [
             d.dir("b", [
               d.dir("c", [
                 d.file("d"),
                 d.file("long-file")
               ]),
               d.dir("long-dir", [d.file("x")])
             ])
           ])
         ]).create();
 
-        expect(list("deep/**/?/?"),
-            completion(unorderedEquals(["deep/a/b/c", "deep/a/b/c/d"])));
+        expect(list("deep/**/?/?"), completion(unorderedEquals([
+          p.join("deep", "a", "b", "c"),
+          p.join("deep", "a", "b", "c", "d")
+        ])));
       });
     });
 
     group("any char", () {
       test("matches a character", () {
-        expect(list("foo/ba?"),
-            completion(unorderedEquals(["foo/bar", "foo/baz"])));
+        expect(list("foo/ba?"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz")
+        ])));
       });
 
       test("doesn't match a separator", () {
         expect(list("foo?bar"), completion(isEmpty));
       });
     });
 
     group("range", () {
       test("matches a range of characters", () {
-        expect(list("foo/ba[a-z]"),
-            completion(unorderedEquals(["foo/bar", "foo/baz"])));
+        expect(list("foo/ba[a-z]"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz")
+        ])));
       });
 
       test("matches a specific list of characters", () {
-        expect(list("foo/ba[rz]"),
-            completion(unorderedEquals(["foo/bar", "foo/baz"])));
+        expect(list("foo/ba[rz]"), completion(unorderedEquals([
+          p.join("foo", "bar"),
+          p.join("foo", "baz")
+        ])));
       });
 
       test("doesn't match outside its range", () {
         expect(list("foo/ba[a-x]"),
-            completion(unorderedEquals(["foo/bar"])));
+            completion(unorderedEquals([p.join("foo", "bar")])));
       });
 
       test("doesn't match outside its specific list", () {
         expect(list("foo/ba[rx]"),
-            completion(unorderedEquals(["foo/bar"])));
+            completion(unorderedEquals([p.join("foo", "bar")])));
       });
     });
 
     test("the same file shouldn't be non-recursively listed multiple times",
         () {
       d.dir("multi", [
         d.dir("start-end", [d.file("file")])
       ]).create();
 
       expect(list("multi/{start-*/f*,*-end/*e}"),
-          completion(equals(["multi/start-end/file"])));
+          completion(equals([p.join("multi", "start-end", "file")])));
     });
 
     test("the same file shouldn't be recursively listed multiple times", () {
       d.dir("multi", [
         d.dir("a", [
           d.dir("b", [
             d.file("file"),
             d.dir("c", [
               d.file("file")
             ])
           ]),
           d.dir("x", [
             d.dir("y", [
               d.file("file")
             ])
           ])
         ])
       ]).create();
 
       expect(list("multi/{*/*/*/file,a/**/file}"), completion(unorderedEquals([
-        "multi/a/b/file", "multi/a/b/c/file", "multi/a/x/y/file"
+        p.join("multi", "a", "b", "file"),
+        p.join("multi", "a", "b", "c", "file"),
+        p.join("multi", "a", "x", "y", "file")
       ])));
     });
 
     group("with symlinks", () {
       setUp(() {
         schedule(() {
           return new Link(p.join(sandbox, "dir", "link"))
               .create(p.join(sandbox, "foo", "baz"), recursive: true);
         }, "symlink foo/baz to dir/link");
       });
 
       test("follows symlinks by default", () {
         expect(list("dir/**"), completion(unorderedEquals([
-          "dir/link", "dir/link/bang", "dir/link/qux"
+          p.join("dir", "link"),
+          p.join("dir", "link", "bang"),
+          p.join("dir", "link", "qux")
         ])));
       });
 
       test("doesn't follow symlinks with followLinks: false", () {
         expect(list("dir/**", followLinks: false),
-            completion(equals(["dir/link"])));
+            completion(equals([p.join("dir", "link")])));
       });
 
       test("shouldn't crash on broken symlinks", () {
         schedule(() {
           return new Directory(p.join(sandbox, "foo")).delete(recursive: true);
         });
 
-        expect(list("dir/**"), completion(equals(["dir/link"])));
+        expect(list("dir/**"), completion(equals([p.join("dir", "link")])));
       });
     });
 
     test("always lists recursively with recursive: true", () {
-      expect(list("foo", recursive: true), completion(unorderedEquals(
-          ["foo", "foo/bar", "foo/baz", "foo/baz/qux", "foo/baz/bang"])));
+      expect(list("foo", recursive: true), completion(unorderedEquals([
+        "foo",
+        p.join("foo", "bar"),
+        p.join("foo", "baz"),
+        p.join("foo", "baz", "qux"),
+        p.join("foo", "baz", "bang")
+      ])));
     });
 
     test("lists an absolute glob", () {
       expect(schedule(() {
         var pattern = separatorToForwardSlash(
             p.absolute(p.join(sandbox, 'foo/baz/**')));
 
         return list(pattern);
-      }), completion(unorderedEquals(["foo/baz/bang", "foo/baz/qux"])));
+      }), completion(unorderedEquals([
+        p.join("foo", "baz", "bang"),
+        p.join("foo", "baz", "qux")
+      ])));
     });
   });
 }
 
 typedef Future<List<String>> ListFn(String glob,
     {bool recursive, bool followLinks});
 
 /// Runs [callback] in two groups with two values of [listFn]: one that uses
 /// [Glob.list], one that uses [Glob.listSync].
 void syncAndAsync(callback(ListFn listFn)) {
@@ skipping 33 matching lines @@
   }, 'creating sandbox');
 
   currentSchedule.onComplete.schedule(() {
     d.defaultRoot = null;
     if (sandbox == null) return null;
     var oldSandbox = sandbox;
     sandbox = null;
     return new Directory(oldSandbox).delete(recursive: true);
   });
 }