← Back to branch summary

~rogpeppe/juju-core/438-local-instance-Addresses

« back to all changes in this revision

Viewing changes to testing/checkers/file_test.go

  • Committer: John Arbash Meinel
  • Date: 2013-09-15 07:36:52 UTC
  • mfrom: (1817 juju-core)
  • mto: This revision was merged to the branch mainline in revision 1882.
  • Revision ID: john@arbash-meinel.com-20130915073652-80jnupeguvr1klea
Merge trunk, resolve conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/checkers/file_test.go
9
9
        "path/filepath"
10
10
 
11
11
        gc "launchpad.net/gocheck"
12
 
        . "launchpad.net/juju-core/testing/checkers"
 
12
 
 
13
        jc "launchpad.net/juju-core/testing/checkers"
13
14
)
14
15
 
15
16
type FileSuite struct{}
22
23
        fmt.Fprintf(file, "something")
23
24
        file.Close()
24
25
 
25
 
        c.Assert(file.Name(), IsNonEmptyFile)
 
26
        c.Assert(file.Name(), jc.IsNonEmptyFile)
26
27
}
27
28
 
28
29
func (s *FileSuite) TestIsNonEmptyFileWithEmptyFile(c *gc.C) {
30
31
        c.Assert(err, gc.IsNil)
31
32
        file.Close()
32
33
 
33
 
        result, message := IsNonEmptyFile.Check([]interface{}{file.Name()}, nil)
34
 
        c.Assert(result, IsFalse)
 
34
        result, message := jc.IsNonEmptyFile.Check([]interface{}{file.Name()}, nil)
 
35
        c.Assert(result, jc.IsFalse)
35
36
        c.Assert(message, gc.Equals, file.Name()+" is empty")
36
37
}
37
38
 
38
39
func (s *FileSuite) TestIsNonEmptyFileWithMissingFile(c *gc.C) {
39
40
        name := filepath.Join(c.MkDir(), "missing")
40
41
 
41
 
        result, message := IsNonEmptyFile.Check([]interface{}{name}, nil)
42
 
        c.Assert(result, IsFalse)
 
42
        result, message := jc.IsNonEmptyFile.Check([]interface{}{name}, nil)
 
43
        c.Assert(result, jc.IsFalse)
43
44
        c.Assert(message, gc.Equals, name+" does not exist")
44
45
}
45
46
 
46
47
func (s *FileSuite) TestIsNonEmptyFileWithNumber(c *gc.C) {
47
 
        result, message := IsNonEmptyFile.Check([]interface{}{42}, nil)
48
 
        c.Assert(result, IsFalse)
 
48
        result, message := jc.IsNonEmptyFile.Check([]interface{}{42}, nil)
 
49
        c.Assert(result, jc.IsFalse)
49
50
        c.Assert(message, gc.Equals, "obtained value is not a string and has no .String(), int:42")
50
51
}
51
52
 
52
53
func (s *FileSuite) TestIsDirectory(c *gc.C) {
53
54
        dir := c.MkDir()
54
 
        c.Assert(dir, IsDirectory)
 
55
        c.Assert(dir, jc.IsDirectory)
55
56
}
56
57
 
57
58
func (s *FileSuite) TestIsDirectoryMissing(c *gc.C) {
58
59
        absentDir := filepath.Join(c.MkDir(), "foo")
59
60
 
60
 
        result, message := IsDirectory.Check([]interface{}{absentDir}, nil)
61
 
        c.Assert(result, IsFalse)
 
61
        result, message := jc.IsDirectory.Check([]interface{}{absentDir}, nil)
 
62
        c.Assert(result, jc.IsFalse)
62
63
        c.Assert(message, gc.Equals, absentDir+" does not exist")
63
64
}
64
65
 
67
68
        c.Assert(err, gc.IsNil)
68
69
        file.Close()
69
70
 
70
 
        result, message := IsDirectory.Check([]interface{}{file.Name()}, nil)
71
 
        c.Assert(result, IsFalse)
 
71
        result, message := jc.IsDirectory.Check([]interface{}{file.Name()}, nil)
 
72
        c.Assert(result, jc.IsFalse)
72
73
        c.Assert(message, gc.Equals, file.Name()+" is not a directory")
73
74
}
74
75
 
75
76
func (s *FileSuite) TestIsDirectoryWithNumber(c *gc.C) {
76
 
        result, message := IsDirectory.Check([]interface{}{42}, nil)
77
 
        c.Assert(result, IsFalse)
 
77
        result, message := jc.IsDirectory.Check([]interface{}{42}, nil)
 
78
        c.Assert(result, jc.IsFalse)
78
79
        c.Assert(message, gc.Equals, "obtained value is not a string and has no .String(), int:42")
79
80
}
80
81
 
81
82
func (s *FileSuite) TestDoesNotExist(c *gc.C) {
82
83
        absentDir := filepath.Join(c.MkDir(), "foo")
83
 
        c.Assert(absentDir, DoesNotExist)
 
84
        c.Assert(absentDir, jc.DoesNotExist)
84
85
}
85
86
 
86
87
func (s *FileSuite) TestDoesNotExistWithPath(c *gc.C) {
87
88
        dir := c.MkDir()
88
 
        result, message := DoesNotExist.Check([]interface{}{dir}, nil)
89
 
        c.Assert(result, IsFalse)
 
89
        result, message := jc.DoesNotExist.Check([]interface{}{dir}, nil)
 
90
        c.Assert(result, jc.IsFalse)
90
91
        c.Assert(message, gc.Equals, dir+" exists")
91
92
}
92
93
 
93
94
func (s *FileSuite) TestDoesNotExistWithNumber(c *gc.C) {
94
 
        result, message := DoesNotExist.Check([]interface{}{42}, nil)
95
 
        c.Assert(result, IsFalse)
 
95
        result, message := jc.DoesNotExist.Check([]interface{}{42}, nil)
 
96
        c.Assert(result, jc.IsFalse)
96
97
        c.Assert(message, gc.Equals, "obtained value is not a string and has no .String(), int:42")
97
98
}