private record Plugin(String groupId, String artifactId, String version) {}

    private record Property(String name, String value) {}

            return parent;
        }

        @Override
        public String getQuery() {
            return parent.getQuery();
        }

        @Override
        public Map<String, String[]> getFields() {
            return parent.getFields();
        }

        @Override
        public Map<String, String[]> getConditions() {
            return parent.getConditions();
        }

        FloatBuffer.class,
        DoubleBuffer.class,
        String[].class,
        Object[].class,
        int[].class);
  }

  public void testStringArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generateFresh(String[].class);
    String[] a2 = generator.generateFresh(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }

	typedef struct {
		[string] wchar_t *entry_path;
	} DfsInfo1;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo1 *s;
	} DfsEnumArray1;

	typedef struct {
		uint32_t state;
		[string] wchar_t *server_name;
		[string] wchar_t *share_name;
	} DfsStorageInfo;

	typedef struct {
		[string] wchar_t *path;
		[string] wchar_t *comment;
		uint32_t state;

package mountinfo

// mountInfo - This represents a single line in /proc/mounts.
type mountInfo struct {
	Device  string
	Path    string
	FSType  string
	Options []string
	Freq    string
	Pass    string
}

func (m mountInfo) String() string {
	return m.Path
}

// mountInfos - This represents the entire /proc/mounts.

     * @param index the index of the value to retrieve
     * @return the cleaned value at the specified index, or empty string if index is out of bounds
     */
    static String getValue(final List<String> list, final int index) {
        if (index >= list.size()) {
            return StringUtil.EMPTY;
        }
        String item = list.get(index).trim();
        if (StringUtil.isBlank(item)) {
            return StringUtil.EMPTY;

         */
        private static final String RELEASE_VERSION_INDEX = String.valueOf(QUALIFIERS.indexOf(""));

        private final String value;

        StringItem(String value, boolean followedByDigit) {
            if (followedByDigit && value.length() == 1) {
                // a1 = alpha-1, b1 = beta-1, m1 = milestone-1
                switch (value.charAt(0)) {
                    case 'a':

      };
    }
  }

  @Override
  protected Map<String, String> makeEmptyMap() {
    Map<String, Integer> underlying = new HashMap<>();
    return transformValues(
        new UnmodifiableIteratorMap<String, Integer>(underlying), Functions.toStringFunction());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);

        }

        @Override
        public String getDisplayName() {
            return String.format("%s{}", name);
        }
    }

    private static class PropertyLinkMetaData extends MethodLinkMetaData {
        private final String propertyName;

        private PropertyLinkMetaData(String propertyName, String methodName, String signature) {

	Preload(association string, query func(db PreloadBuilder) error) ChainInterface[T]
	Select(query string, args ...interface{}) CreateInterface[T]
	Omit(columns ...string) CreateInterface[T]
	MapColumns(m map[string]string) ChainInterface[T]
	Distinct(args ...interface{}) ChainInterface[T]
	Group(name string) ChainInterface[T]
	Having(query interface{}, args ...interface{}) ChainInterface[T]