type args struct {
		yamlStr string
	}
	type PrefixTemp struct {
		Prefix BatchJobPrefix `yaml:"prefix"`
	}
	tests := []struct {
		name    string
		b       PrefixTemp
		args    args
		want    []string
		wantErr bool
	}{
		{
			name: "test1",
			b:    PrefixTemp{},
			args: args{
				yamlStr: `
prefix: "foo"
`,
			},
			want:    []string{"foo"},
			wantErr: false,
		},
		{

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {

    private final Map<String, ClassDoc> extensionClasses = [:]
    private final String pluginId
    final ClassDoc targetClass
    final List<PropertyDoc> extraProperties = []
    final List<BlockDoc> extraBlocks = []

    ClassExtensionDoc(String pluginId, ClassDoc targetClass) {
        this.pluginId = pluginId
        this.targetClass = targetClass
    }

    String getPluginId() {
        return pluginId

    }

    /**
     * Removes delimiters.
     *
     * @param value
     *            String value
     * @param locale
     *            Locale
     * @return String result with delimiters removed
     */
    public static String removeDelimeter(String value, final Locale locale) {
        final String groupingSeparator = findGroupingSeparator(locale);
        if (groupingSeparator != null) {

    }

    /**
     * Splits the given string into an array of substrings based on the specified regular expression
     * and returns a stream of those substrings.
     *
     * @param value the string to be split; if {@code null}, the method returns an empty stream
     * @param regex the regular expression to use for splitting the string

            when(dc.toString()).thenReturn("LARGEDC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);
            String result = nc.toString();

            // Should contain hex representation of 0-15
            assertTrue(result.contains("0x"));
            assertTrue(result.contains("dc=LARGEDC"));
            // The hex string should be 32 chars long (16 bytes * 2)

          <type>String</type>
          <required>true</required>
        </field>
        <field>
          <version>1.0.0</version>
          <name>description</name>
          <description>The description of what this expression references, and what it's generally used for.</description>
          <type>String</type>
          <required>true</required>
        </field>

    suite.addTest(
        ListTestSuiteBuilder.using(
                new TestStringListGenerator() {

                  @Override
                  protected List<String> create(String[] elements) {
                    return new StandardImplForwardingList<>(Lists.newArrayList(elements));
                  }
                })

 */
public class PluginManagerException extends Exception {

    private final String pluginGroupId;

    private final String pluginArtifactId;

    private final String pluginVersion;

    private String goal;

    private MavenProject project;

    protected PluginManagerException(Plugin plugin, String message, MavenProject project, Throwable cause) {
        super(message, cause);

/**
 * Microbenchmark for {@link Splitter#on} with char vs String with length == 1.
 *
 * @author Paul Lindner
 */
@NullUnmarked
public class SplitterBenchmark {
  // overall size of string
  @Param({"1", "10", "100", "1000"})
  int length;

  // Number of matching strings
  @Param({"xxxx", "xxXx", "xXxX", "XXXX"})
  String text;

  private String input;