Sever isolate package's dependency on client/internal.

client/isolate/format_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package isolate
 
 import (
         "encoding/json"
         "errors"
         "fmt"
         "io/ioutil"
         "os"
         "path/filepath"
         "sort"
         "strings"
         "testing"
 
-        "github.com/luci/luci-go/client/internal/common"
         "github.com/luci/luci-go/common/isolated"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestReadOnlyValue(t *testing.T) {
         t.Parallel()
         Convey(`Isolate should properly support read-only values.`, t, func() {
                 So(NotSet.ToIsolated(), ShouldBeNil)
                 So(ReadOnlyValue(100).ToIsolated(), ShouldBeNil)
@@ skipping 351 matching lines @@
                 vars, ok = getSortedVarValues(p.varsValsSet, "bit")
                 So(ok, ShouldBeTrue)
                 So(vvToStr(vars), ShouldResemble, vvToStr(makeVVs("32", "64")))
         })
 }
 
 func TestLoadIsolateAsConfig(t *testing.T) {
         t.Parallel()
         Convey(`Isolate should properly load a config from a isolate file.`, t, func() {
                 root := "/dir"
-                if common.IsWindows() {
+                if IsWindows() {
                         root = "x:\\dir"
                 }
                 isolate, err := LoadIsolateAsConfig(root, []byte(sampleIsolateData))
                 So(err, ShouldBeNil)
                 So(isolate.ConfigVariables, ShouldResemble, []string{"OS", "bit"})
         })
 }
 
 func TestLoadIsolateForConfigMissingVars(t *testing.T) {
         t.Parallel()
         Convey(`Isolate should properly handle missing variables when loading a config.`, t, func() {
                 isoData := []byte(sampleIsolateData)
                 root := "/dir"
-                if common.IsWindows() {
+                if IsWindows() {
                         root = "x:\\dir"
                 }
                 _, _, _, _, err := LoadIsolateForConfig(root, isoData, nil)
                 So(err, ShouldNotBeNil)
                 Convey(fmt.Sprintf("Verify error message: %s", err), func() {
                         So(err.Error(), ShouldContainSubstring, "variables were missing")
                         So(err.Error(), ShouldContainSubstring, "bit")
                         So(err.Error(), ShouldContainSubstring, "OS")
                         _, _, _, _, err = LoadIsolateForConfig(root, isoData, map[string]string{"bit": "32"})
                         So(err, ShouldNotBeNil)
                         So(err.Error(), ShouldContainSubstring, "variables were missing")
                         So(err.Error(), ShouldContainSubstring, "OS")
                 })
         })
 }
 
 func TestLoadIsolateForConfig(t *testing.T) {
         t.Parallel()
         Convey(`Isolate should properly load and return config data from a isolate file.`, t, func() {
                 // Case linux64, matches first condition.
                 root := "/dir"
-                if common.IsWindows() {
+                if IsWindows() {
                         root = "x:\\dir"
                 }
                 vars := map[string]string{"bit": "64", "OS": "linux"}
                 cmd, deps, ro, dir, err := LoadIsolateForConfig(root, []byte(sampleIsolateData), vars)
                 So(err, ShouldBeNil)
                 So(dir, ShouldResemble, root)
                 So(ro, ShouldResemble, NotSet) // first condition has no read_only specified.
                 So(cmd, ShouldResemble, []string{"python", "64linuxOrWin"})
                 So(deps, ShouldResemble, []string{"64linuxOrWin", filepath.Join("<(PRODUCT_DIR)", "unittest<(EXECUTABLE_SUFFIX)")})
 
@@ skipping 114 matching lines @@
                 So(out.IsolateDir, ShouldResemble, right.IsolateDir)
                 So(right.IsolateDir, ShouldResemble, absToOS("/var/lib"))
                 So(out.Files, ShouldResemble, []string{"../../le/f/t", "../../tmp/bar/foo/", "../ri/g/ht", "bar/"})
         })
 }
 
 // Helper functions.
 
 // absToOS converts a POSIX path to OS specific format.
 func absToOS(p string) string {
-        if common.IsWindows() {
+        if IsWindows() {
                 return "e:" + strings.Replace(p, "/", "\\", -1)
         }
         return p
 }
 
 // makeVVs simplifies creating variableValue:
 // "unbound" => unbound
 // "123" => int(123)
 // "s123" => string("123")
 func makeVVs(ss ...string) []variableValue {
@@ skipping 58 matching lines @@
         for key := range valueSet {
                 keys = append(keys, string(key))
         }
         sort.Strings(keys)
         values := make([]variableValue, len(valueSet))
         for i, key := range keys {
                 values[i] = valueSet[variableValueKey(key)]
         }
         return values, true
 }