println "setStrings: " + ($.setStrings as List)
                  }
                }
              }
            }
        '''

        then:
        succeeds "print"

        and:
        output.contains "mapThings: [[a, b], [a]]"
        output.contains "setThings: [[Thing 'setThings.0.0']]"
        output.contains "setStrings: [[a], [b]]"
    }

        schema.getProperty('parent').schema == schema
    }

    @Managed
    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @Managed
    interface Person {
        Person getParent()
    }

	// In that case, we don't remove the final entry.
	if numLMS > 1 {
		sa[lastB] = 0
	}
	return numLMS
}

// induceSubL_8_32 inserts the L-type text indexes of LMS-substrings
// into sa, assuming that the final characters of the LMS-substrings
// are already inserted into sa, sorted by final character, and at the
// right (not left) end of the corresponding character bucket.
// Each LMS-substring has the form (as a regexp) /S+L+S/:

        schema.properties.isEmpty()
    }

    static abstract class SomeRules extends RuleSource {
        abstract String getReadOnlyString()
        abstract List<String> getStrings()
        abstract void setStrings(List<String> strings)
    }

    def "assembles schema for RuleSource subtype"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeRules))
        schema instanceof RuleSourceSchema

    public static class TestClass4 {
        @Option(option = 'stringValue', description = "string value")
        public void setStrings(String value1, String value2) {
        }
    }

    public static class TestClass5 {
        @Option(option = 'fileValue', description = "file value")
        public void setStrings(File file) {
        }
    }

    public static class TestClassWithOptionNameClashing {

        schema.getProperty('parent').schema == schema
    }

    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @UnmanagedStruct
    interface SomeStruct {
        String getReadOnlyString()
    }

    interface Person {
        Person getParent()
    }

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import javax.annotation.CheckForNull;

/**
 * Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
 * a <i>separator</i> sequence. This separator can be specified as a single {@linkplain #on(char)

import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.annotation.CheckForNull;

/**
 * Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
 * a <i>separator</i> sequence. This separator can be specified as a single {@linkplain #on(char)

//	// s: ["", "b", "b", "c", "cadaaae"]
//
// The count determines the number of substrings to return:
//
//	n > 0: at most n substrings; the last substring will be the unsplit remainder.
//	n == 0: the result is nil (zero substrings)
//	n < 0: all substrings
func (re *Regexp) Split(s string, n int) []string {

	if n == 0 {
		return nil
	}

		// The input must have more than N/3 LMS-substrings,
		// which we arrange by repeating an SLSLSLSLSLSL pattern
		// like ababab... above, but then we must also arrange
		// for a large number of distinct LMS-substrings.
		// We use this pattern:
		// 1 255 1 254 1 253 1 ... 1 2 1 255 2 254 2 253 2 252 2 ...
		// This gives approximately 2¹⁵ distinct LMS-substrings.
		// We need to repeat at least one substring, though,