← Back to branch summary

~chipaca/+junk/arylex

« back to all changes in this revision

Viewing changes to parse_test.go

  • Committer: john.lenton at canonical
  • Date: 2012-06-25 20:41:28 UTC
  • Revision ID: john.lenton@canonical.com-20120625204128-pmk213yxrjzke1oa
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
parse_test.go
 
1
package arylex
 
2
 
 
3
import (
 
4
        "testing"
 
5
)
 
6
 
 
7
func TestEmpty(t *testing.T) {
 
8
        a, err := Parse("{}")
 
9
        failIfError(t, err)
 
10
        failUnlessEqual(t, [](interface{}){}, a, "slice")
 
11
}
 
12
 
 
13
func TestTwoEmpties(t *testing.T) {
 
14
        a, err := Parse("{,}")
 
15
        failUnlessError(t, err, a)
 
16
}
 
17
 
 
18
func TestTwoQuotedEmpties(t *testing.T) {
 
19
        a, err := Parse("{\"\",\"\"}")
 
20
        failIfError(t, err)
 
21
        failUnlessEqual(t, [](interface{}){"", ""}, a, "slice")
 
22
}
 
23
 
 
24
func TestWhitespace(t *testing.T) {
 
25
        a, err := Parse("{ a }")
 
26
        failUnlessError(t, err, a)
 
27
}
 
28
 
 
29
func TestQuotedWhitespace(t *testing.T) {
 
30
        a, err := Parse("{\" a \"}")
 
31
        failIfError(t, err)
 
32
        failUnlessEqual(t, [](interface{}){" a "}, a, "slice")
 
33
}
 
34
 
 
35
func TestEmpty2D(t *testing.T) {
 
36
        a, err := Parse("{{}}")
 
37
        failIfError(t, err)
 
38
        failUnlessEqual(t, [](interface{}){[](interface{}){}}, a, "slice")
 
39
}
 
40
 
 
41
func TestErrorEndBrace(t *testing.T) {
 
42
        a, err := Parse("{}}")
 
43
        failUnlessError(t, err, a)
 
44
}
 
45
 
 
46
func TestErrorEndJustABrace(t *testing.T) {
 
47
        a, err := Parse("}")
 
48
        failUnlessError(t, err, a)
 
49
}
 
50
 
 
51
func TestOne(t *testing.T) {
 
52
        a, err := Parse("{42}")
 
53
        failIfError(t, err)
 
54
        failUnlessEqual(t, [](interface{}){"42"}, a, "slice")
 
55
}
 
56
 
 
57
func TestQuoted(t *testing.T) {
 
58
        a, err := Parse("{\"NULL\"}")
 
59
        failIfError(t, err)
 
60
        failUnlessEqual(t, [](interface{}){"NULL"}, a, "slice")
 
61
}
 
62
 
 
63
func TestQuotedQuote(t *testing.T) {
 
64
        a, err := Parse("{\"a\\\"b\"}")
 
65
        failIfError(t, err)
 
66
        failUnlessEqual(t, [](interface{}){"a\"b"}, a, "slice")
 
67
}
 
68
 
 
69
func TestTwoItems(t *testing.T) {
 
70
        a, err := Parse("{a,\"b\"}")
 
71
        failIfError(t, err)
 
72
        failUnlessEqual(t, [](interface{}){"a", "b"}, a, "slice")
 
73
}
 
74
 
 
75
func TestTwoArys(t *testing.T) {
 
76
        a, err := Parse("{{a},{b}}")
 
77
        failIfError(t, err)
 
78
        failUnlessEqual(t, [](interface{}){
 
79
                [](interface{}){"a"},
 
80
                [](interface{}){"b"}}, a, "slice")
 
81
}
 
82
 
 
83
func TestDeepishAry(t *testing.T) {
 
84
        // note this is not actually a valid psql array
 
85
        a, err := Parse("{0,{0,{0,{0,{0,{0,{0,{0}}}}}}}}")
 
86
        failIfError(t, err)
 
87
        failUnlessEqual(t,
 
88
                [](interface{}){"0", [](interface{}){"0",
 
89
                        [](interface{}){"0", [](interface{}){"0",
 
90
                                [](interface{}){"0", [](interface{}){"0",
 
91
                                        [](interface{}){"0", [](interface{}){"0"}}}}}}}},
 
92
                a, "slice")
 
93
}