[BACK]Return to tools_test.go CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / pkgsrc / pkgtools / pkglint / files

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>