}
	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 ...any) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {
		e.msg = fmt.Sprintf(m, args...)
	}
	return e
}

// Hint - Replace the current error's message

        }

        @Test
        @DisplayName("Should replace entry in cache map")
        void testReplaceCacheWithMap() {
            String key = "test-key";

            // Setup concrete implementation
            concreteImplementation.setKey(key);
            concreteImplementation.setCacheMap(cacheMap);

            // Execute replace
            concreteImplementation.replaceCache();

    when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(existingZero);
    // since the putIfAbsent returned a zero, we'll try to replace...
    when(backingMap.replace(eq(KEY), eq(existingZero), isA(AtomicInteger.class))).thenReturn(false);
    // ...and then putIfAbsent. Simulate failure on both

    @Override
    public String alignToBaseDirectory(String path, File 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

   * result from the user invoking {@link Cache#put}, {@link LoadingCache#refresh}, {@link Map#put},
   * {@link Map#putAll}, {@link ConcurrentMap#replace(Object, Object)}, or {@link
   * ConcurrentMap#replace(Object, Object, Object)}.
   */
  REPLACED {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

  /**

     */
    @Deprecated
    public File getPomFile() {
        return getFile();
    }

    @Override
    public ModelSource2 getRelatedSource(String relPath) {
        relPath = relPath.replace('\\', File.separatorChar).replace('/', File.separatorChar);

        Path relatedPom = getPath().getParent().resolve(relPath);

        if (Files.isDirectory(relatedPom)) {

        for (final JarEntry entry : iterable(jarFile.entries())) {
            final String entryName = entry.getName().replace('\\', '/');
            if (entryName.startsWith(prefix) && entryName.endsWith(CLASS_SUFFIX)) {
                final String className = entryName.substring(startPos, entryName.length() - CLASS_SUFFIX.length()).replace('/', '.');
                final int pos = className.lastIndexOf('.');

			for i, val := range v {
				tmpRec := input.Clone(nil)
				if err = tmpRec.Replace(val); err != nil {
					return nil, err
				}
				recs[i] = &tmpRec
			}
			return recs, nil

		default:
			kvs = jstream.KVS{jstream.KV{Key: "_1", Value: v}}
		}

		if err = input.Replace(kvs); err != nil {
			return nil, err
		}

		return []*Record{&input}, nil
	case simdjson.Object:

                    // we're going to parse this back in as XML so we need to escape XML markup
                    value = value.toString()
                            .replace("&", "&")
                            .replace("<", "&lt;")
                            .replace(">", "&gt;");
                    return value;
                }
                return null;
            }
        });

        try {

	if err != nil {
		return err
	}
	if n != len(b) {
		return io.ErrShortWrite
	}
	return nil
}

// Replace the underlying buffer of json data.
func (r *Record) Replace(k any) error {
	v, ok := k.(simdjson.Object)
	if !ok {
		return fmt.Errorf("cannot replace internal data in simd json record with type %T", k)
	}
	r.object = v
	return nil
}

// NewRecord - creates new empty JSON record.