if len(functionNodes) == 0 {
		return fmt.Errorf("no matches found for regexp: %s", o.Symbol)
	}

	sourcePath := o.SourcePath
	if sourcePath == "" {
		wd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("could not stat current dir: %v", err)
		}
		sourcePath = wd
	}
	reader := newSourceReader(sourcePath, o.TrimPath)

	fmt.Fprintf(w, "Total: %s\n", rpt.formatValue(rpt.total))
	for _, fn := range functions {

    prettyPrint(
        "KotlinBuildScriptModel",
        sequenceOf(
            "classPath" to compactStringFor(classPath),
            "sourcePath" to compactStringFor(sourcePath),
            "implicitImports" to compactStringFor(implicitImports, '.'),
            "editorReports" to editorReports.toString(),
            "exceptions" to stringForExceptions(exceptions, indentation)

        then:
        new WbResource(rootNode.'wb-resource'[0]) == createWbResource()
    }

    def equality() {
        WbResource wbResource = createWbResource()
        wbResource.sourcePath += 'x'

        expect:
        wbResource != createWbResource()
    }

    private WbResource createWbResource() {
        return new WbResource("/", "src/main/webapp")
    }

                <td><literal>eclipse.project.name</literal></td>
            </tr>
            <tr>
                <td>resources</td>
                <td><literal>[deployPath: '/', sourcePath: project.webAppDirName]</literal></td>
                <td><literal>[]</literal></td>
            </tr>
            <tr>
                <td>properties</td>
                <td><literal>[]</literal></td>

        }


        Container_Boundary(tapiBuilder, "IDE ToolingAPI Models") {

            Component(tapiModels, "TAPI Models", "classpath, sourcepath, implicit imports, user reports")
            Component(tapiModelBuilders, "TAPI Model Builders", "On-demand source distro download, Calculates editor warnings and errors")

            final List<String> tags = parseTags(fileDeclaration);
            final String sourceSyntax = getSourceSyntax(sourceRelativeLocation);
            String sourcePath = String.format("%s/%s/%s", sampleBaseDir, sampleDir, sourceRelativeLocation);
            String source = getContent(sourcePath);
            source = filterByTags(source, sourceSyntax, tags);
            source = trimIndent(source);

    public Variable(Node node, FileReferenceFactory fileReferenceFactory) {
        super(node, fileReferenceFactory);
        setSourcePath(fileReferenceFactory.fromVariablePath((String) node.attribute("sourcepath")));
    }

    public Variable(FileReference library) {
        super(library);
    }

    @Override
    public String getKind() {
        return "var";
    }

    @Override

                        sorted.add(productPath.relativize(sourceFile.toPath()).toString());
                    }
                    for (String sourcePath : sorted) {
                        writer.print("                \"");
                        writer.print(sourcePath);
                        writer.println("\",");
                    }
                    writer.print("            ]");

                            def lib = classpath.entries.find { it.path.contains('example-lib') }
                            lib.javadocPath = fileReference('$customJavadocPath')
                            lib.sourcePath  = fileReference('$customSourcePath')
                        }
                    }
                }
            }
        """

        when:
        def project = loadToolingModel(EclipseProject)

        Lists.newArrayList(args) == ["-J-Xmx256m", "@$argsFile"]
        println argsFile.text

        and: "args file contains remaining arguments (one per line, quoted)"
        argsFile.readLines() == ["-g", "-sourcepath", quote(""), "-proc:none", USE_UNSHARED_COMPILER_TABLE_OPTION, "-classpath", quote("${spec.compileClasspath.join(File.pathSeparator)}"), *(spec.sourceFiles*.path.collect { quote(it) })]
    }