1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
package main
import (
check "gopkg.in/check.v1"
)
func (s *Suite) TestParser_PkgbasePattern(c *check.C) {
test := func(pattern, expected, rest string) {
parser := NewParser(pattern)
actual := parser.PkgbasePattern()
c.Check(actual, equals, expected)
c.Check(parser.Rest(), equals, rest)
}
test("fltk", "fltk", "")
test("fltk|", "fltk", "|")
test("boost-build-1.59.*", "boost-build", "-1.59.*")
test("${PHP_PKG_PREFIX}-pdo-5.*", "${PHP_PKG_PREFIX}-pdo", "-5.*")
test("${PYPKGPREFIX}-metakit-[0-9]*", "${PYPKGPREFIX}-metakit", "-[0-9]*")
}
func (s *Suite) TestParser_Dependency(c *check.C) {
testDependencyRest := func(pattern string, expected DependencyPattern, rest string) {
parser := NewParser(pattern)
dp := parser.Dependency()
if c.Check(dp, check.NotNil) {
c.Check(*dp, equals, expected)
c.Check(parser.Rest(), equals, rest)
}
}
testDependency := func(pattern string, expected DependencyPattern) {
testDependencyRest(pattern, expected, "")
}
testDependency("fltk>=1.1.5rc1<1.3", DependencyPattern{"fltk", ">=", "1.1.5rc1", "<", "1.3", ""})
testDependency("libwcalc-1.0*", DependencyPattern{"libwcalc", "", "", "", "", "1.0*"})
testDependency("${PHP_PKG_PREFIX}-pdo-5.*", DependencyPattern{"${PHP_PKG_PREFIX}-pdo", "", "", "", "", "5.*"})
testDependency("${PYPKGPREFIX}-metakit-[0-9]*", DependencyPattern{"${PYPKGPREFIX}-metakit", "", "", "", "", "[0-9]*"})
testDependency("boost-build-1.59.*", DependencyPattern{"boost-build", "", "", "", "", "1.59.*"})
testDependency("${_EMACS_REQD}", DependencyPattern{"${_EMACS_REQD}", "", "", "", "", ""})
testDependency("{gcc46,gcc46-libs}>=4.6.0", DependencyPattern{"{gcc46,gcc46-libs}", ">=", "4.6.0", "", "", ""})
testDependency("perl5-*", DependencyPattern{"perl5", "", "", "", "", "*"})
testDependency("verilog{,-current}-[0-9]*", DependencyPattern{"verilog{,-current}", "", "", "", "", "[0-9]*"})
testDependency("mpg123{,-esound,-nas}>=0.59.18", DependencyPattern{"mpg123{,-esound,-nas}", ">=", "0.59.18", "", "", ""})
testDependency("mysql*-{client,server}-[0-9]*", DependencyPattern{"mysql*-{client,server}", "", "", "", "", "[0-9]*"})
testDependency("postgresql8[0-35-9]-${module}-[0-9]*", DependencyPattern{"postgresql8[0-35-9]-${module}", "", "", "", "", "[0-9]*"})
testDependency("ncurses-${NC_VERS}{,nb*}", DependencyPattern{"ncurses", "", "", "", "", "${NC_VERS}{,nb*}"})
testDependency("xulrunner10>=${MOZ_BRANCH}${MOZ_BRANCH_MINOR}", DependencyPattern{"xulrunner10", ">=", "${MOZ_BRANCH}${MOZ_BRANCH_MINOR}", "", "", ""})
testDependencyRest("gnome-control-center>=2.20.1{,nb*}", DependencyPattern{"gnome-control-center", ">=", "2.20.1", "", "", ""}, "{,nb*}")
// "{ssh{,6}-[0-9]*,openssh-[0-9]*}" is not representable using the current data structure
}
func (s *Suite) TestParser_MkTokens(c *check.C) {
parse := func(input string, expectedTokens []*MkToken, expectedRest string) {
p := NewParser(input)
actualTokens := p.MkTokens()
c.Check(actualTokens, deepEquals, expectedTokens)
for i, expectedToken := range expectedTokens {
if i < len(actualTokens) {
c.Check(*actualTokens[i], deepEquals, *expectedToken)
}
}
c.Check(p.Rest(), equals, expectedRest)
}
token := func(input string, expectedToken MkToken) {
parse(input, []*MkToken{&expectedToken}, "")
}
literal := func(literal string) MkToken {
return MkToken{literal: literal}
}
varuse := func(varname string, modifiers ...string) MkToken {
return MkToken{varuse: MkVarUse{varname: varname, modifiers: modifiers}}
}
token("literal", literal("literal"))
token("\\/share\\/ { print \"share directory\" }", literal("\\/share\\/ { print \"share directory\" }"))
token("find . -name \\*.orig -o -name \\*.pre", literal("find . -name \\*.orig -o -name \\*.pre"))
token("-e 's|\\$${EC2_HOME.*}|EC2_HOME}|g'", literal("-e 's|\\${EC2_HOME.*}|EC2_HOME}|g'"))
token("${VARIABLE}", varuse("VARIABLE"))
token("${VARIABLE.param}", varuse("VARIABLE.param"))
token("${VARIABLE.${param}}", varuse("VARIABLE.${param}"))
token("${VARIABLE.hicolor-icon-theme}", varuse("VARIABLE.hicolor-icon-theme"))
token("${VARIABLE.gtk+extra}", varuse("VARIABLE.gtk+extra"))
token("${VARIABLE:S/old/new/}", varuse("VARIABLE", "S/old/new/"))
token("${GNUSTEP_LFLAGS:S/-L//g}", varuse("GNUSTEP_LFLAGS", "S/-L//g"))
token("${SUSE_VERSION:S/.//}", varuse("SUSE_VERSION", "S/.//"))
token("${MASTER_SITE_GNOME:=sources/alacarte/0.13/}", varuse("MASTER_SITE_GNOME", "=sources/alacarte/0.13/"))
token("${INCLUDE_DIRS:H:T}", varuse("INCLUDE_DIRS", "H", "T"))
token("${A.${B.${C.${D}}}}", varuse("A.${B.${C.${D}}}"))
token("${RUBY_VERSION:C/([0-9]+)\\.([0-9]+)\\.([0-9]+)/\\1/}", varuse("RUBY_VERSION", "C/([0-9]+)\\.([0-9]+)\\.([0-9]+)/\\1/"))
token("${PERL5_${_var_}:Q}", varuse("PERL5_${_var_}", "Q"))
token("${PKGNAME_REQD:C/(^.*-|^)py([0-9][0-9])-.*/\\2/}", varuse("PKGNAME_REQD", "C/(^.*-|^)py([0-9][0-9])-.*/\\2/"))
token("${PYLIB:S|/|\\\\/|g}", varuse("PYLIB", "S|/|\\\\/|g"))
token("${PKGNAME_REQD:C/ruby([0-9][0-9]+)-.*/\\1/}", varuse("PKGNAME_REQD", "C/ruby([0-9][0-9]+)-.*/\\1/"))
token("${RUBY_SHLIBALIAS:S/\\//\\\\\\//}", varuse("RUBY_SHLIBALIAS", "S/\\//\\\\\\//"))
token("${RUBY_VER_MAP.${RUBY_VER}:U${RUBY_VER}}", varuse("RUBY_VER_MAP.${RUBY_VER}", "U${RUBY_VER}"))
token("${RUBY_VER_MAP.${RUBY_VER}:U18}", varuse("RUBY_VER_MAP.${RUBY_VER}", "U18"))
token("${CONFIGURE_ARGS:S/ENABLE_OSS=no/ENABLE_OSS=yes/g}", varuse("CONFIGURE_ARGS", "S/ENABLE_OSS=no/ENABLE_OSS=yes/g"))
token("${PLIST_RUBY_DIRS:S,DIR=\"PREFIX/,DIR=\",}", varuse("PLIST_RUBY_DIRS", "S,DIR=\"PREFIX/,DIR=\","))
token("${LDFLAGS:S/-Wl,//g:Q}", varuse("LDFLAGS", "S/-Wl,//g", "Q"))
token("${_PERL5_REAL_PACKLIST:S/^/${DESTDIR}/}", varuse("_PERL5_REAL_PACKLIST", "S/^/${DESTDIR}/"))
token("${_PYTHON_VERSION:C/^([0-9])/\\1./1}", varuse("_PYTHON_VERSION", "C/^([0-9])/\\1./1"))
token("${PKGNAME:S/py${_PYTHON_VERSION}/py${i}/}", varuse("PKGNAME", "S/py${_PYTHON_VERSION}/py${i}/"))
token("${PKGNAME:C/-[0-9].*$/-[0-9]*/}", varuse("PKGNAME", "C/-[0-9].*$/-[0-9]*/"))
token("${PKGNAME:S/py${_PYTHON_VERSION}/py${i}/:C/-[0-9].*$/-[0-9]*/}", varuse("PKGNAME", "S/py${_PYTHON_VERSION}/py${i}/", "C/-[0-9].*$/-[0-9]*/"))
token("${_PERL5_VARS:tl:S/^/-V:/}", varuse("_PERL5_VARS", "tl", "S/^/-V:/"))
token("${_PERL5_VARS_OUT:M${_var_:tl}=*:S/^${_var_:tl}=${_PERL5_PREFIX:=/}//}", varuse("_PERL5_VARS_OUT", "M${_var_:tl}=*", "S/^${_var_:tl}=${_PERL5_PREFIX:=/}//"))
token("${RUBY${RUBY_VER}_PATCHLEVEL}", varuse("RUBY${RUBY_VER}_PATCHLEVEL"))
token("${DISTFILES:M*.gem}", varuse("DISTFILES", "M*.gem"))
token("$(GNUSTEP_USER_ROOT)", varuse("GNUSTEP_USER_ROOT"))
token("${LOCALBASE:S^/^_^}", varuse("LOCALBASE", "S^/^_^"))
token("${SOURCES:%.c=%.o}", varuse("SOURCES", "%.c=%.o"))
token("${GIT_TEMPLATES:@.t.@ ${EGDIR}/${GIT_TEMPLATEDIR}/${.t.} ${PREFIX}/${GIT_CORE_TEMPLATEDIR}/${.t.} @:M*}",
varuse("GIT_TEMPLATES", "@.t.@ ${EGDIR}/${GIT_TEMPLATEDIR}/${.t.} ${PREFIX}/${GIT_CORE_TEMPLATEDIR}/${.t.} @", "M*"))
token("${DISTNAME:C:_:-:}", varuse("DISTNAME", "C:_:-:"))
token("${CF_FILES:H:O:u:S@^@${PKG_SYSCONFDIR}/@}", varuse("CF_FILES", "H", "O", "u", "S@^@${PKG_SYSCONFDIR}/@"))
token("${ALT_GCC_RTS:S%${LOCALBASE}%%:S%/%%}", varuse("ALT_GCC_RTS", "S%${LOCALBASE}%%", "S%/%%"))
token("${PREFIX:C;///*;/;g:C;/$;;}", varuse("PREFIX", "C;///*;/;g", "C;/$;;"))
token("${GZIP_CMD:[1]:Q}", varuse("GZIP_CMD", "[1]", "Q"))
token("${DISTNAME:C/-[0-9]+$$//:C/_/-/}", varuse("DISTNAME", "C/-[0-9]+$$//", "C/_/-/"))
token("${DISTNAME:slang%=slang2%}", varuse("DISTNAME", "slang%=slang2%"))
token("${OSMAP_SUBSTVARS:@v@-e 's,\\@${v}\\@,${${v}},g' @}", varuse("OSMAP_SUBSTVARS", "@v@-e 's,\\@${v}\\@,${${v}},g' @"))
/* weird features */
token("${${EMACS_VERSION_MAJOR}>22:?@comment :}", varuse("${EMACS_VERSION_MAJOR}>22", "?@comment :"))
token("${${XKBBASE}/xkbcomp:L:Q}", varuse("${XKBBASE}/xkbcomp", "L", "Q"))
token("${${PKGBASE} ${PKGVERSION}:L}", varuse("${PKGBASE} ${PKGVERSION}", "L"))
token("${empty(CFLAGS):?:-cflags ${CFLAGS:Q}}", varuse("empty(CFLAGS)", "?:-cflags ${CFLAGS:Q}"))
token("${${${PKG_INFO} -E ${d} || echo:L:sh}:L:C/[^[0-9]]*/ /g:[1..3]:ts.}",
varuse("${${PKG_INFO} -E ${d} || echo:L:sh}", "L", "C/[^[0-9]]*/ /g", "[1..3]", "ts."))
token("${VAR:S/-//S/.//}", varuse("VAR", "S/-//", "S/.//")) // For :S and :C, the colon can be left out.
token("${VAR:ts}", varuse("VAR", "ts")) // The separator character can be left out.
token("${VAR:ts\\000012}", varuse("VAR", "ts\\000012")) // The separator character can be a long octal number.
token("${VAR:ts\\124}", varuse("VAR", "ts\\124")) // Or even decimal.
parse("${VAR)", nil, "${VAR)") // Opening brace, closing parenthesis
parse("$(VAR}", nil, "$(VAR}") // Opening parenthesis, closing brace
}
func (s *Suite) TestParser_MkCond_Basics(c *check.C) {
condrest := func(input string, expectedTree *Tree, expectedRest string) {
p := NewParser(input)
actualTree := p.MkCond()
c.Check(actualTree, deepEquals, expectedTree)
c.Check(p.Rest(), equals, expectedRest)
}
cond := func(input string, expectedTree *Tree) {
condrest(input, expectedTree, "")
}
literal := func(literal string) MkToken {
return MkToken{literal: literal}
}
varuse := func(varname string, modifiers ...string) MkVarUse {
return MkVarUse{varname: varname, modifiers: modifiers}
}
_, _ = literal, varuse
cond("${OPSYS:MNetBSD}",
NewTree("not", NewTree("empty", varuse("OPSYS", "MNetBSD"))))
cond("defined(VARNAME)",
NewTree("defined", "VARNAME"))
cond("empty(VARNAME)",
NewTree("empty", varuse("VARNAME")))
cond("!empty(VARNAME)",
NewTree("not", NewTree("empty", varuse("VARNAME"))))
cond("!empty(VARNAME:M[yY][eE][sS])",
NewTree("not", NewTree("empty", varuse("VARNAME", "M[yY][eE][sS]"))))
cond("${VARNAME} != \"Value\"",
NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
cond("${VARNAME:Mi386} != \"Value\"",
NewTree("compareVarStr", varuse("VARNAME", "Mi386"), "!=", "Value"))
cond("${VARNAME} != Value",
NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
cond("\"${VARNAME}\" != Value",
NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
cond("(defined(VARNAME))",
NewTree("defined", "VARNAME"))
cond("exists(/etc/hosts)",
NewTree("exists", "/etc/hosts"))
cond("exists(${PREFIX}/var)",
NewTree("exists", "${PREFIX}/var"))
cond("${OPSYS} == \"NetBSD\" || ${OPSYS} == \"OpenBSD\"",
NewTree("or",
NewTree("compareVarStr", varuse("OPSYS"), "==", "NetBSD"),
NewTree("compareVarStr", varuse("OPSYS"), "==", "OpenBSD")))
cond("${OPSYS} == \"NetBSD\" && ${MACHINE_ARCH} == \"i386\"",
NewTree("and",
NewTree("compareVarStr", varuse("OPSYS"), "==", "NetBSD"),
NewTree("compareVarStr", varuse("MACHINE_ARCH"), "==", "i386")))
cond("defined(A) && defined(B) || defined(C) && defined(D)",
NewTree("or",
NewTree("and",
NewTree("defined", "A"),
NewTree("defined", "B")),
NewTree("and",
NewTree("defined", "C"),
NewTree("defined", "D"))))
// Exotic cases
cond("0",
NewTree("literalNum", "0"))
cond("! ( defined(A) && empty(VARNAME) )",
NewTree("not", NewTree("and", NewTree("defined", "A"), NewTree("empty", varuse("VARNAME")))))
cond("${REQD_MAJOR} > ${MAJOR}",
NewTree("compareVarVar", varuse("REQD_MAJOR"), ">", varuse("MAJOR")))
cond("${OS_VERSION} >= 6.5",
NewTree("compareVarNum", varuse("OS_VERSION"), ">=", "6.5"))
cond("${OS_VERSION} == 5.3",
NewTree("compareVarNum", varuse("OS_VERSION"), "==", "5.3"))
// Errors
condrest("!empty(PKG_OPTIONS:Msndfile) || defined(PKG_OPTIONS:Msamplerate)",
NewTree("not", NewTree("empty", varuse("PKG_OPTIONS", "Msndfile"))),
" || defined(PKG_OPTIONS:Msamplerate)")
}
|
