Annotation of pkgsrc/pkgtools/pkglint/files/tools_test.go, Revision 1.13
1.10 rillig 1: package pkglint
1.1 rillig 2:
3: import "gopkg.in/check.v1"
4:
1.6 rillig 5: func (s *Suite) Test_Tool_UsableAtLoadTime(c *check.C) {
6:
7: nowhere := Tool{"nowhere", "", false, Nowhere}
8: c.Check(nowhere.UsableAtLoadTime(false), equals, false)
9: c.Check(nowhere.UsableAtLoadTime(true), equals, false)
10:
11: load := Tool{"load", "", false, AfterPrefsMk}
12: c.Check(load.UsableAtLoadTime(false), equals, false)
13: c.Check(load.UsableAtLoadTime(true), equals, true)
14:
15: run := Tool{"run", "", false, AtRunTime}
16: c.Check(run.UsableAtLoadTime(false), equals, false)
17: c.Check(run.UsableAtLoadTime(true), equals, false)
18: }
19:
20: func (s *Suite) Test_Tool_UsableAtRunTime(c *check.C) {
21:
22: nowhere := Tool{"nowhere", "", false, Nowhere}
23: c.Check(nowhere.UsableAtRunTime(), equals, false)
24:
25: load := Tool{"load", "", false, AfterPrefsMk}
26: c.Check(load.UsableAtRunTime(), equals, true)
27:
28: run := Tool{"run", "", false, AtRunTime}
29: c.Check(run.UsableAtRunTime(), equals, true)
30: }
31:
1.7 rillig 32: // USE_TOOLS is an operating-system-dependent variable.
33: // Many other tool variables have the form VARNAME.${tool},
34: // which confused an earlier version of pkglint into
35: // thinking that the below definition was about a tool
36: // called "NetBSD".
1.4 rillig 37: func (s *Suite) Test_Tools_ParseToolLine(c *check.C) {
1.1 rillig 38: t := s.Init(c)
39:
1.12 rillig 40: t.SetUpTool("tool1", "", Nowhere)
41: t.SetUpVartypes()
1.5 rillig 42: t.CreateFileLines("Makefile",
1.1 rillig 43: MkRcsID,
44: "",
45: "USE_TOOLS.NetBSD+=\ttool1")
46:
1.2 rillig 47: CheckdirToplevel(t.File("."))
1.1 rillig 48:
49: // No error about "Unknown tool \"NetBSD\"."
50: t.CheckOutputEmpty()
51: }
1.3 rillig 52:
1.6 rillig 53: func (s *Suite) Test_Tools_Define__invalid_tool_name(c *check.C) {
1.3 rillig 54: t := s.Init(c)
55:
1.8 rillig 56: mkline := t.NewMkLine("dummy.mk", 123, "DUMMY=\tvalue")
1.12 rillig 57: reg := NewTools()
1.3 rillig 58:
1.8 rillig 59: reg.Define("tool_name", "", mkline)
60: reg.Define("tool:dependency", "", mkline)
61: reg.Define("tool:build", "", mkline)
1.3 rillig 62:
1.7 rillig 63: // As of October 2018, the underscore is not used in any tool name.
1.4 rillig 64: // If there should ever be such a case, just use a different character for testing.
1.3 rillig 65: t.CheckOutputLines(
1.8 rillig 66: "ERROR: dummy.mk:123: Invalid tool name \"tool_name\".",
67: "ERROR: dummy.mk:123: Invalid tool name \"tool:dependency\".",
68: "ERROR: dummy.mk:123: Invalid tool name \"tool:build\".")
1.4 rillig 69: }
70:
71: func (s *Suite) Test_Tools_Trace__coverage(c *check.C) {
72: t := s.Init(c)
73:
74: t.DisableTracing()
75:
1.12 rillig 76: reg := NewTools()
1.4 rillig 77: reg.Trace()
78:
79: t.CheckOutputEmpty()
80: }
81:
82: func (s *Suite) Test_Tools__USE_TOOLS_predefined_sed(c *check.C) {
83: t := s.Init(c)
84:
1.12 rillig 85: t.SetUpPkgsrc()
1.4 rillig 86: t.CreateFileLines("mk/bsd.prefs.mk",
87: "USE_TOOLS+=\tsed:pkgsrc")
88: t.CreateFileLines("mk/tools/defaults.mk",
89: "_TOOLS_VARNAME.sed=\tSED")
1.5 rillig 90: t.CreateFileLines("module.mk",
1.4 rillig 91: MkRcsID,
92: "",
93: "do-build:",
94: "\t${SED} < input > output",
95: "\t${AWK} < input > output")
96:
97: G.Main("pkglint", "-Wall", t.File("module.mk"))
98:
1.7 rillig 99: // Since this test doesn't load the usual tool definitions via
100: // G.Pkgsrc.loadTools, AWK is not known at all.
1.4 rillig 101: t.CheckOutputLines(
102: "WARN: ~/module.mk:5: Unknown shell command \"${AWK}\".",
1.6 rillig 103: "WARN: ~/module.mk:5: AWK is used but not defined.",
104: "0 errors and 2 warnings found.",
1.4 rillig 105: "(Run \"pkglint -e\" to show explanations.)")
106: }
107:
1.7 rillig 108: // It may happen that a tool is first defined without knowing its
109: // variable name. When trying to define the tool with its variable name
110: // later, the existing definition is amended.
1.4 rillig 111: func (s *Suite) Test_Tools__add_varname_later(c *check.C) {
1.8 rillig 112: t := s.Init(c)
1.4 rillig 113:
1.8 rillig 114: mkline := t.NewMkLine("dummy.mk", 123, "DUMMY=\tvalue")
1.12 rillig 115: tools := NewTools()
1.8 rillig 116: tool := tools.Define("tool", "", mkline)
1.4 rillig 117:
118: c.Check(tool.Name, equals, "tool")
119: c.Check(tool.Varname, equals, "")
120:
1.7 rillig 121: // Updates the existing tool definition.
1.8 rillig 122: tools.Define("tool", "TOOL", mkline)
1.4 rillig 123:
124: c.Check(tool.Name, equals, "tool")
125: c.Check(tool.Varname, equals, "TOOL")
126: }
127:
128: func (s *Suite) Test_Tools__load_from_infrastructure(c *check.C) {
129: t := s.Init(c)
130:
1.12 rillig 131: tools := NewTools()
1.4 rillig 132:
1.6 rillig 133: tools.ParseToolLine(t.NewMkLine("create.mk", 2, "TOOLS_CREATE+= load"), true, false)
134: tools.ParseToolLine(t.NewMkLine("create.mk", 3, "TOOLS_CREATE+= run"), true, false)
135: tools.ParseToolLine(t.NewMkLine("create.mk", 4, "TOOLS_CREATE+= nowhere"), true, false)
1.4 rillig 136:
137: // The references to the tools are stable,
138: // the lookup methods always return the same objects.
139: load := tools.ByName("load")
140: run := tools.ByName("run")
141: nowhere := tools.ByName("nowhere")
142:
143: // All tools are defined by name, but their variable names are not yet known.
144: // At this point they may not be used, neither by the pkgsrc infrastructure nor by a package.
1.13 ! rillig 145: c.Check(load.String(), equals, "load:::AtRunTime")
! 146: c.Check(run.String(), equals, "run:::AtRunTime")
! 147: c.Check(nowhere.String(), equals, "nowhere:::AtRunTime")
1.4 rillig 148:
1.13 ! rillig 149: // The variable name RUN is reserved by pkgsrc, therefore RUN_CMD.
1.6 rillig 150: tools.ParseToolLine(t.NewMkLine("varnames.mk", 2, "_TOOLS_VARNAME.load= LOAD"), true, false)
151: tools.ParseToolLine(t.NewMkLine("varnames.mk", 3, "_TOOLS_VARNAME.run= RUN_CMD"), true, false)
152: tools.ParseToolLine(t.NewMkLine("varnames.mk", 4, "_TOOLS_VARNAME.nowhere= NOWHERE"), true, false)
1.4 rillig 153:
154: // At this point the tools can be found by their variable names, too.
155: // They still may not be used.
1.13 ! rillig 156: c.Check(load.String(), equals, "load:LOAD::AtRunTime")
! 157: c.Check(run.String(), equals, "run:RUN_CMD::AtRunTime")
! 158: c.Check(nowhere.String(), equals, "nowhere:NOWHERE::AtRunTime")
1.4 rillig 159: c.Check(tools.ByVarname("LOAD"), equals, load)
160: c.Check(tools.ByVarname("RUN_CMD"), equals, run)
161: c.Check(tools.ByVarname("NOWHERE"), equals, nowhere)
1.13 ! rillig 162: c.Check(load.String(), equals, "load:LOAD::AtRunTime")
! 163: c.Check(run.String(), equals, "run:RUN_CMD::AtRunTime")
! 164: c.Check(nowhere.String(), equals, "nowhere:NOWHERE::AtRunTime")
1.4 rillig 165:
1.6 rillig 166: tools.ParseToolLine(t.NewMkLine("bsd.prefs.mk", 2, "USE_TOOLS+= load"), true, true)
1.4 rillig 167:
168: // Tools that are added to USE_TOOLS in bsd.prefs.mk may be used afterwards.
169: // By variable name, they may be used both at load time as well as run time.
170: // By plain name, they may be used only in {pre,do,post}-* targets.
1.7 rillig 171: c.Check(load.String(), equals, "load:LOAD::AfterPrefsMk")
1.4 rillig 172:
1.6 rillig 173: tools.ParseToolLine(t.NewMkLine("bsd.pkg.mk", 2, "USE_TOOLS+= run"), true, true)
1.4 rillig 174:
175: // Tools that are added to USE_TOOLS in bsd.pkg.mk may be used afterwards at run time.
176: // The {pre,do,post}-* targets may use both forms (${CAT} and cat).
177: // All other targets must use the variable form (${CAT}).
1.7 rillig 178: c.Check(run.String(), equals, "run:RUN_CMD::AtRunTime")
1.4 rillig 179:
180: // That's all for parsing tool definitions from the pkgsrc infrastructure.
181: // See Test_Tools__package_Makefile for a continuation.
182: }
183:
184: func (s *Suite) Test_Tools__package_Makefile(c *check.C) {
185: t := s.Init(c)
186:
1.12 rillig 187: t.SetUpPkgsrc()
1.4 rillig 188: t.CreateFileLines("mk/tools/defaults.mk",
189: "TOOLS_CREATE+= load",
190: "TOOLS_CREATE+= run",
191: "TOOLS_CREATE+= nowhere",
192: "TOOLS_CREATE+= pkg-before-prefs",
193: "TOOLS_CREATE+= pkg-after-prefs",
194: "_TOOLS_VARNAME.load= LOAD",
195: "_TOOLS_VARNAME.run= RUN_CMD",
196: "_TOOLS_VARNAME.nowhere= NOWHERE",
197: "_TOOLS_VARNAME.pkg-before-prefs= PKG_BEFORE_PREFS",
198: "_TOOLS_VARNAME.pkg-after-prefs= PKG_AFTER_PREFS")
199: t.CreateFileLines("mk/bsd.prefs.mk",
200: "USE_TOOLS+= load")
201: t.CreateFileLines("mk/bsd.pkg.mk",
202: "USE_TOOLS+= run")
203: G.Pkgsrc.LoadInfrastructure()
204:
1.12 rillig 205: tools := NewTools()
1.6 rillig 206: tools.Fallback(G.Pkgsrc.Tools)
1.4 rillig 207:
208: load := tools.ByName("load")
209: run := tools.ByName("run")
210: nowhere := tools.ByName("nowhere")
211: before := tools.ByName("pkg-before-prefs")
212: after := tools.ByName("pkg-after-prefs")
213:
214: c.Check(load.UsableAtRunTime(), equals, true)
215: c.Check(run.UsableAtRunTime(), equals, true)
1.13 ! rillig 216: c.Check(nowhere.UsableAtRunTime(), equals, true)
1.4 rillig 217:
218: // The seenPrefs variable is only relevant for the package Makefile.
219: // All other files must not use the tools at load time.
1.7 rillig 220: // For them, seenPrefs can be thought of as being true from the beginning.
1.4 rillig 221:
1.6 rillig 222: tools.ParseToolLine(t.NewMkLine("Makefile", 2, "USE_TOOLS+= pkg-before-prefs"), false, true)
1.4 rillig 223:
224: c.Check(before.Validity, equals, AfterPrefsMk)
225: c.Check(tools.SeenPrefs, equals, false)
226:
1.6 rillig 227: tools.ParseToolLine(t.NewMkLine("Makefile", 3, ".include \"../../mk/bsd.prefs.mk\""), false, true)
1.4 rillig 228:
229: c.Check(tools.SeenPrefs, equals, true)
230:
1.6 rillig 231: tools.ParseToolLine(t.NewMkLine("Makefile", 4, "USE_TOOLS+= pkg-after-prefs"), false, true)
1.4 rillig 232:
233: c.Check(after.Validity, equals, AtRunTime)
234: }
235:
236: func (s *Suite) Test_Tools__builtin_mk(c *check.C) {
237: t := s.Init(c)
238:
1.12 rillig 239: t.SetUpPkgsrc()
240: t.SetUpCommandLine("-Wall,no-space")
1.4 rillig 241: t.CreateFileLines("mk/tools/defaults.mk",
242: "TOOLS_CREATE+= load",
243: "TOOLS_CREATE+= run",
244: "TOOLS_CREATE+= nowhere",
245: "_TOOLS_VARNAME.load= LOAD",
246: "_TOOLS_VARNAME.run= RUN_CMD",
247: "_TOOLS_VARNAME.nowhere= NOWHERE")
248: t.CreateFileLines("mk/bsd.prefs.mk",
249: "USE_TOOLS+= load")
250: t.CreateFileLines("mk/bsd.pkg.mk",
251: "USE_TOOLS+= run")
252: t.CreateFileLines("mk/buildlink3/bsd.builtin.mk")
253: G.Pkgsrc.LoadInfrastructure()
254:
255: // Tools that are defined by pkgsrc as load-time tools
256: // may be used in any file at load time.
257:
1.12 rillig 258: mklines := t.SetUpFileMkLines("category/package/builtin.mk",
1.4 rillig 259: MkRcsID,
260: "",
261: "VAR!= ${ECHO} 'too early'",
262: "VAR!= ${LOAD} 'too early'",
263: "VAR!= ${RUN_CMD} 'never allowed'",
264: "VAR!= ${NOWHERE} 'never allowed'",
265: "",
266: ".include \"../../mk/buildlink3/bsd.builtin.mk\"",
267: "",
268: "VAR!= ${ECHO} 'valid'",
269: "VAR!= ${LOAD} 'valid'",
270: "VAR!= ${RUN_CMD} 'never allowed'",
271: "VAR!= ${NOWHERE} 'never allowed'",
272: "",
273: "VAR!= ${VAR}")
274:
275: mklines.Check()
276:
277: t.CheckOutputLines(
1.9 rillig 278: "WARN: ~/category/package/builtin.mk:3: To use the tool ${ECHO} at load time, bsd.prefs.mk has to be included before.",
279: "WARN: ~/category/package/builtin.mk:4: To use the tool ${LOAD} at load time, bsd.prefs.mk has to be included before.",
280: "WARN: ~/category/package/builtin.mk:5: The tool ${RUN_CMD} cannot be used at load time.",
281: "WARN: ~/category/package/builtin.mk:6: The tool ${NOWHERE} cannot be used at load time.",
282: "WARN: ~/category/package/builtin.mk:12: The tool ${RUN_CMD} cannot be used at load time.",
283: "WARN: ~/category/package/builtin.mk:13: The tool ${NOWHERE} cannot be used at load time.")
1.4 rillig 284: }
285:
286: func (s *Suite) Test_Tools__implicit_definition_in_bsd_pkg_mk(c *check.C) {
287: t := s.Init(c)
288:
1.12 rillig 289: t.SetUpPkgsrc()
290: t.SetUpCommandLine("-Wall,no-space")
1.4 rillig 291: t.CreateFileLines("mk/tools/defaults.mk",
292: MkRcsID) // None
293: t.CreateFileLines("mk/bsd.prefs.mk",
294: "USE_TOOLS+= load")
295: t.CreateFileLines("mk/bsd.pkg.mk",
296: "USE_TOOLS+= run")
297:
298: // It's practically impossible that a tool is added to USE_TOOLS in
299: // bsd.pkg.mk and not defined earlier in mk/tools/defaults.mk, but
300: // the pkglint code is even prepared for these rare cases.
301: // In other words, this test is only there for the code coverage.
302: G.Pkgsrc.LoadInfrastructure()
303:
1.7 rillig 304: c.Check(G.Pkgsrc.Tools.ByName("run").String(), equals, "run:::AtRunTime")
1.4 rillig 305: }
306:
307: func (s *Suite) Test_Tools__both_prefs_and_pkg_mk(c *check.C) {
308: t := s.Init(c)
309:
1.12 rillig 310: t.SetUpPkgsrc()
311: t.SetUpCommandLine("-Wall,no-space")
1.4 rillig 312: t.CreateFileLines("mk/tools/defaults.mk",
313: MkRcsID)
314: t.CreateFileLines("mk/bsd.prefs.mk",
315: "USE_TOOLS+= both")
316: t.CreateFileLines("mk/bsd.pkg.mk",
317: "USE_TOOLS+= both")
318:
319: // The echo tool is mentioned in both files. The file bsd.prefs.mk
320: // grants more use cases (load time + run time), therefore it wins.
321: G.Pkgsrc.LoadInfrastructure()
322:
323: c.Check(G.Pkgsrc.Tools.ByName("both").Validity, equals, AfterPrefsMk)
324: }
325:
326: func (s *Suite) Test_Tools__tools_having_the_same_variable_name(c *check.C) {
327: t := s.Init(c)
328:
1.12 rillig 329: t.SetUpPkgsrc()
330: t.SetUpCommandLine("-Wall,no-space")
1.4 rillig 331: t.CreateFileLines("mk/tools/defaults.mk",
332: "_TOOLS_VARNAME.awk= AWK",
333: "_TOOLS_VARNAME.gawk= AWK",
334: "_TOOLS_VARNAME.gsed= SED",
335: "_TOOLS_VARNAME.sed= SED")
336: t.CreateFileLines("mk/bsd.prefs.mk",
337: "USE_TOOLS+= awk sed")
338:
339: G.Pkgsrc.LoadInfrastructure()
340:
341: c.Check(G.Pkgsrc.Tools.ByName("awk").Validity, equals, AfterPrefsMk)
342: c.Check(G.Pkgsrc.Tools.ByName("sed").Validity, equals, AfterPrefsMk)
343: c.Check(G.Pkgsrc.Tools.ByName("gawk").Validity, equals, Nowhere)
344: c.Check(G.Pkgsrc.Tools.ByName("gsed").Validity, equals, Nowhere)
345:
346: t.EnableTracingToLog()
347: G.Pkgsrc.Tools.Trace()
348: t.DisableTracing()
349:
350: t.CheckOutputLines(
1.12 rillig 351: "TRACE: + (*Tools).Trace()",
1.6 rillig 352: "TRACE: 1 tool awk:AWK::AfterPrefsMk",
353: "TRACE: 1 tool echo:ECHO:var:AfterPrefsMk",
354: "TRACE: 1 tool echo -n:ECHO_N:var:AfterPrefsMk",
355: "TRACE: 1 tool false:FALSE:var:AtRunTime",
356: "TRACE: 1 tool gawk:AWK::Nowhere",
357: "TRACE: 1 tool gsed:SED::Nowhere",
358: "TRACE: 1 tool sed:SED::AfterPrefsMk",
359: "TRACE: 1 tool test:TEST:var:AfterPrefsMk",
360: "TRACE: 1 tool true:TRUE:var:AfterPrefsMk",
1.12 rillig 361: "TRACE: - (*Tools).Trace()")
1.4 rillig 362:
1.12 rillig 363: tools := NewTools()
1.6 rillig 364: tools.Fallback(G.Pkgsrc.Tools)
1.4 rillig 365:
366: t.EnableTracingToLog()
367: tools.Trace()
368: t.DisableTracing()
369:
370: t.CheckOutputLines(
1.12 rillig 371: "TRACE: + (*Tools).Trace()",
372: "TRACE: 1 + (*Tools).Trace()",
1.6 rillig 373: "TRACE: 1 2 tool awk:AWK::AfterPrefsMk",
374: "TRACE: 1 2 tool echo:ECHO:var:AfterPrefsMk",
375: "TRACE: 1 2 tool echo -n:ECHO_N:var:AfterPrefsMk",
376: "TRACE: 1 2 tool false:FALSE:var:AtRunTime",
377: "TRACE: 1 2 tool gawk:AWK::Nowhere",
378: "TRACE: 1 2 tool gsed:SED::Nowhere",
379: "TRACE: 1 2 tool sed:SED::AfterPrefsMk",
380: "TRACE: 1 2 tool test:TEST:var:AfterPrefsMk",
381: "TRACE: 1 2 tool true:TRUE:var:AfterPrefsMk",
1.12 rillig 382: "TRACE: 1 - (*Tools).Trace()",
383: "TRACE: - (*Tools).Trace()")
1.4 rillig 384: }
385:
386: func (s *Suite) Test_ToolTime_String(c *check.C) {
387: c.Check(LoadTime.String(), equals, "LoadTime")
388: c.Check(RunTime.String(), equals, "RunTime")
389: }
390:
391: func (s *Suite) Test_Tools__var(c *check.C) {
392: t := s.Init(c)
393:
1.12 rillig 394: t.SetUpPkgsrc()
1.4 rillig 395: t.CreateFileLines("mk/tools/defaults.mk",
396: "TOOLS_CREATE+= ln",
397: "_TOOLS_VARNAME.ln= LN")
398: t.CreateFileLines("mk/bsd.pkg.mk",
399: "USE_TOOLS+= ln")
400: G.Pkgsrc.LoadInfrastructure()
401:
402: mklines := t.NewMkLines("module.mk",
403: MkRcsID,
404: "",
405: "pre-configure:",
406: "\t${LN} from to")
407:
408: mklines.Check()
409:
410: t.CheckOutputEmpty()
411: }
412:
1.6 rillig 413: // Demonstrates how the Tools type handles tools that share the same
1.4 rillig 414: // variable name. Of these tools, the GNU variant is preferred.
415: //
1.6 rillig 416: // In this realistic variant, the non-GNU tool is defined in bsd.prefs.mk
417: // and the GNU tool is only defined but not made available.
418: //
1.4 rillig 419: // See also Pkglint.Tool.
1.6 rillig 420: func (s *Suite) Test_Tools_Fallback__tools_having_the_same_variable_name_realistic(c *check.C) {
1.12 rillig 421: nonGnu := NewTools()
1.7 rillig 422: nonGnu.def("sed", "SED", false, AfterPrefsMk)
1.4 rillig 423:
1.12 rillig 424: gnu := NewTools()
1.7 rillig 425: gnu.def("gsed", "SED", false, Nowhere)
1.4 rillig 426:
1.12 rillig 427: local1 := NewTools()
1.7 rillig 428: local1.def("sed", "SED", false, AfterPrefsMk)
1.6 rillig 429: local1.Fallback(gnu)
1.4 rillig 430:
431: c.Check(local1.ByName("sed").Validity, equals, AfterPrefsMk)
432: c.Check(local1.ByName("gsed").Validity, equals, Nowhere)
433:
1.12 rillig 434: local2 := NewTools()
1.7 rillig 435: local2.def("gsed", "SED", false, Nowhere)
1.6 rillig 436: local2.Fallback(nonGnu)
1.4 rillig 437:
438: c.Check(local2.ByName("sed").Validity, equals, AfterPrefsMk)
439: c.Check(local2.ByName("gsed").Validity, equals, Nowhere)
440:
1.6 rillig 441: // No matter in which order the tool definitions are encountered,
442: // the non-GNU version is always chosen since the GNU version is
443: // not available at all.
444: c.Check(local1.ByVarname("SED").String(), equals, "sed:SED::AfterPrefsMk")
445: c.Check(local2.ByVarname("SED").String(), equals, "sed:SED::AfterPrefsMk")
446: }
1.4 rillig 447:
1.6 rillig 448: // Demonstrates how the Tools type handles tools that share the same
449: // variable name. Of these tools, the GNU variant is preferred.
450: //
451: // In this unrealistic variant, the GNU tool is defined in bsd.prefs.mk
452: // and the non-GNU tool is only defined but not made available.
453: //
454: // See also Pkglint.Tool.
455: func (s *Suite) Test_Tools_Fallback__tools_having_the_same_variable_name_unrealistic(c *check.C) {
1.12 rillig 456: nonGnu := NewTools()
1.7 rillig 457: nonGnu.def("sed", "SED", false, Nowhere)
1.6 rillig 458:
1.12 rillig 459: gnu := NewTools()
1.7 rillig 460: gnu.def("gsed", "SED", false, AfterPrefsMk)
1.6 rillig 461:
1.12 rillig 462: local1 := NewTools()
1.7 rillig 463: local1.def("sed", "SED", false, Nowhere)
1.6 rillig 464: local1.Fallback(gnu)
465:
466: c.Check(local1.ByName("sed").Validity, equals, Nowhere)
467: c.Check(local1.ByName("gsed").Validity, equals, AfterPrefsMk)
468:
1.12 rillig 469: local2 := NewTools()
1.7 rillig 470: local2.def("gsed", "SED", false, AfterPrefsMk)
1.6 rillig 471: local2.Fallback(nonGnu)
472:
473: c.Check(local2.ByName("sed").Validity, equals, Nowhere)
474: c.Check(local2.ByName("gsed").Validity, equals, AfterPrefsMk)
475:
476: // FIXME: Must both be gsed:SED::AfterPrefsMk
477: c.Check(local1.ByVarname("SED").String(), equals, "sed:SED::Nowhere")
478: c.Check(local2.ByVarname("SED").String(), equals, "sed:SED::Nowhere")
479: }
480:
481: // The cmake tool is included conditionally. The condition is so simple that
482: // pkglint could parse it but it depends on the particular package.
483: // This is something that pkglint cannot do right now, since the global tools
484: // are loaded once for all packages.
485: //
486: // Therefore there is a workaround for USE_CMAKE.
487: //
488: // See mk/tools/cmake.mk.
489: func (s *Suite) Test_Tools__cmake(c *check.C) {
490: t := s.Init(c)
491:
1.12 rillig 492: t.SetUpPackage("category/package",
1.6 rillig 493: "USE_CMAKE=\tyes",
494: "",
495: "do-test:",
496: "\tcd ${WRKSRC} && cmake")
497: t.CreateFileLines("mk/tools/defaults.mk",
498: ".if defined(USE_CMAKE)",
499: "USE_TOOLS+=\tcmake cpack",
500: ".endif")
501: G.Pkgsrc.LoadInfrastructure()
502:
1.11 rillig 503: G.Check(t.File("category/package"))
1.4 rillig 504:
1.6 rillig 505: t.CheckOutputEmpty()
1.3 rillig 506: }
1.13 ! rillig 507:
! 508: func (s *Suite) Test_Tools__gmake(c *check.C) {
! 509: t := s.Init(c)
! 510:
! 511: t.SetUpPackage("category/package",
! 512: "USE_TOOLS=\tgmake",
! 513: "",
! 514: "do-test:",
! 515: "\tcd ${WRKSRC} && make tests")
! 516: t.CreateFileLines("mk/tools/bsd.tools.mk",
! 517: ".include \"defaults.mk\"",
! 518: ".include \"replace.mk\"",
! 519: ".include \"make.mk\"")
! 520: t.CreateFileLines("mk/tools/make.mk",
! 521: "TOOLS_CREATE+=\tmake",
! 522: "TOOLS_PATH.make=\t/usr/bin/make")
! 523: t.CreateFileLines("mk/tools/replace.mk",
! 524: "TOOLS_CREATE+=\tgmake",
! 525: "TOOLS_PATH.gmake=\t/usr/bin/gnu-make")
! 526:
! 527: G.Pkgsrc.LoadInfrastructure()
! 528:
! 529: G.Check(t.File("category/package"))
! 530:
! 531: t.CheckOutputEmpty()
! 532: }
CVSweb <webmaster@jp.NetBSD.org>