long newValue = random.nextInt(MAX_ADDEND);
    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      assertFalse(map.replace(key, before + 1, newValue + 1));
      assertFalse(map.replace(key, before - 1, newValue - 1));
      assertTrue(map.replace(key, before, newValue));
      long after = map.get(key);
      assertEquals(newValue, after);
      newValue += newValue;
    }

	if u.detail == "" {
		if u.msg != "" {
			return u.msg
		}
		return "<nil>"
	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string) Err {
	e := u.Clone()
	e.msg = m
	return e
}

// Msgf - Replace the current error's message
func (u Err) Msgf(m string, args ...interface{}) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {

            element.setTextContent(normalise(element.getTextContent()))
        }
    }

    static String normalise(String content) {
        content.replace('\t', '    ').stripIndent().replace('\r\n', '\n')
    }

    def transformApiLinks(Document doc) {
        ClassMetaDataRepository<ClassLinkMetaData> linkRepository = new SimpleClassMetaDataRepository<ClassLinkMetaData>()

    /**
     * Artifact type name for a JAR file containing test classes. If the main artifact is placed on the class-path
     * ({@value #JAR} or {@value #CLASSPATH_JAR} types), then the test artifact will also be placed on the class-path.
     * Otherwise, if the main artifact is placed on the module-path ({@value #JAR} or {@value #MODULAR_JAR} types),

                        const value = line.replace(promptLiteralStart, "").trimEnd();
                        useLines.push({
                            type: "input",
                            value: value
                        });
                    } else if (line.startsWith("// ")) {
                        saveBuffer();
                        const value = "💬 " + line.replace("// ", "").trimEnd();

				callMethod(v, "After", c.after)
			}

			if c.match != nil {
				callMethod(v, "Match", c.match)
			}

			if c.remove {
				callMethod(v, "Remove", c.name)
			} else if c.replace {
				callMethod(v, "Replace", c.name, c.h)
			} else {
				callMethod(v, "Register", c.name, c.h)
			}

			if e, ok := v.(error); !ok || e != nil {
				err = e
			}
		}

     * <h4>Context-sensitive interpretation</h4>
     * A dependency with this path type will not necessarily be placed on the class-path.
     * There are two circumstances where the dependency may nevertheless be placed somewhere else:
     *
     * <ul>
     *   <li>If {@link #MODULES} path type is also set, then the dependency can be placed either on the
     *       class-path or on the module-path, but only one of those. The choice is up to the plugin,

}

// Raw - returns the underlying data with format info.
func (r *Record) Raw() (sql.SelectObjectFormat, interface{}) {
	return sql.SelectFmtCSV, r
}

// Replace - is not supported for CSV
func (r *Record) Replace(_ interface{}) error {
	return errors.New("Replace is not supported for CSV")
}

// NewRecord - creates new CSV record.
func NewRecord() *Record {
	return &Record{}

    }

    @Override
    public String alignToBaseDirectory(String path, Path basedir) {
        String result = path;

        if (path != null && basedir != null) {
            path = path.replace('\\', File.separatorChar).replace('/', File.separatorChar);

            File file = new File(path);
            if (file.isAbsolute()) {
                // path was already absolute, just normalize file separator and we're done

        return new PathSource(path.resolve(relative));
    }

    @Override
    public ModelSource resolve(ModelLocator locator, String relative) {
        String norm = relative.replace('\\', File.separatorChar).replace('/', File.separatorChar);
        Path path = getPath().getParent().resolve(norm);
        Path relatedPom = locator.locateExistingPom(path);
        if (relatedPom != null) {