}
    });

    // Pad string to a certain size to format the table. Space is preferred to
    // Tab since it is easier to check the format in the mlir tests.
    auto pad_string = [](StringRef s, int32_t width) -> std::string {
      return llvm::Twine(s).concat(std::string(width - s.size(), ' ')).str();
    };

    // Generate a quantization report.
    size_t name_col_width = 5;

        actions {}

        when:
        visit()

        then:
        2 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file1.txt' })
        1 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file2.txt' })
    }

    def duplicatesExcludedByPerFileConfiguration() {
        given:
        files 'path/file1.txt', 'path/file2.txt', 'path/file1.txt'

		}
	}
	for _, f := range p.Function {
		f.nameX = addString(strings, f.Name)
		f.systemNameX = addString(strings, f.SystemName)
		f.filenameX = addString(strings, f.Filename)
	}

	p.dropFramesX = addString(strings, p.DropFrames)
	p.keepFramesX = addString(strings, p.KeepFrames)

	if pt := p.PeriodType; pt != nil {
		pt.typeX = addString(strings, pt.Type)
		pt.unitX = addString(strings, pt.Unit)
	}

	}
	for _, f := range p.Function {
		f.nameX = addString(strings, f.Name)
		f.systemNameX = addString(strings, f.SystemName)
		f.filenameX = addString(strings, f.Filename)
	}

	p.dropFramesX = addString(strings, p.DropFrames)
	p.keepFramesX = addString(strings, p.KeepFrames)

	if pt := p.PeriodType; pt != nil {
		pt.typeX = addString(strings, pt.Type)
		pt.unitX = addString(strings, pt.Unit)
	}

	p.commentX = nil

        return roots.mapNotNull { path ->
            val pathString = FileUtil.toSystemIndependentName(path.toAbsolutePath().toString())
            when {
                pathString.endsWith(JAR_PROTOCOL) || pathString.endsWith(KLIB_FILE_EXTENSION) -> {
                    environment.environment.jarFileSystem.findFileByPath(pathString + JAR_SEPARATOR)
                }

                pathString.contains(JAR_SEPARATOR) -> {

		// left padding
		f.writePadding(width)
		f.buf.write(b)
	} else {
		// right padding
		f.buf.write(b)
		f.writePadding(width)
	}
}

// padString appends s to f.buf, padded on left (!f.minus) or right (f.minus).
func (f *fmt) padString(s string) {
	if !f.widPresent || f.wid == 0 {
		f.buf.writeString(s)
		return
	}
	width := f.wid - utf8.RuneCountInString(s)
	if !f.minus {
		// left padding

            Decoder decoder = new InputStreamBackedDecoder(inputStream);
            String pidString = decoder.readNullableString();
            String uid = decoder.readString();
            Long pid = pidString == null ? null : Long.parseLong(pidString);
            Address address = new MultiChoiceAddressSerializer().read(decoder);
            File daemonLog = new File(decoder.readString());

    def modelDsl

    def setup() {
        modelDsl = new NonTransformedModelDslBacking(getRegistry())
    }

    void register(String pathString, Object element) {
        registry.register(ModelRegistrations.bridgedInstance(ModelReference.of(pathString, element.class), element).descriptor("register").build())
    }

    def "can add rules via dsl"() {
        given:
        register("foo", [])

        when:

        def path = path(':foo:bar')

        expect:
        path.takeFirstSegments(42) === path
    }

    def "segments"(pathString) {
        given:
        def path = path(pathString)

        expect:
        path.segments() == segments

        where:
        pathString    | segments
        ':foo:bar'    | ["foo", "bar"]
        'foo:bar'     | ["foo", "bar"]
        'foo:bar:zzz' | ["foo", "bar", "zzz"]

    // Define a domain object set to hold strings
    val myStrings: DomainObjectSet<String> = project.objects.domainObjectSet(String::class)

    // Add some strings to the domain object set
    fun addString(value: String) {
        myStrings.add(value)
    }
}
// end::dos[]

// tag::ndos[]
// tag::ndol[]
// tag::ndoc[]
abstract class Person(val name: String)
// end::ndol[]
// end::ndoc[]