import static com.google.common.util.concurrent.Internal.toNanosSaturated;
import static com.google.common.util.concurrent.SneakyThrows.sneakyThrow;
import static java.util.Objects.requireNonNull;
import static java.util.concurrent.Executors.defaultThreadFactory;
import static java.util.concurrent.Executors.unconfigurableExecutorService;

import org.jspecify.annotations.Nullable;

@GwtCompatible
@NullMarked
public class Helpers {
  // Clone of Objects.equals
  static boolean equal(@Nullable Object a, @Nullable Object b) {
    return a == b || (a != null && a.equals(b));
  }

  // Clone of Lists.newArrayList
  public static <E extends @Nullable Object> List<E> copyToList(Iterable<? extends E> elements) {
    List<E> list = new ArrayList<>();
    addAll(list, elements);

 * test with reference to the same "lock-like object", and then their interactions with that object
 * are choreographed via the various methods on this class.
 *
 * <p>A "lock-like object" is really any object that may be used for concurrency control. If the
 * {@link #callAndAssertBlocks} method is ever called in a test, the lock-like object must have a

            }
        },
        "components": {
            "schemas": {
                "Item": {
                    "title": "Item",
                    "required": ["name", "price"],
                    "type": "object",
                    "properties": {
                        "name": {"title": "Name", "type": "string"},
                        "description": {
                            "title": "Description",

     * Serializes an object using Kryo serialization.
     * <p>
     * Uses the thread-local Kryo instance to serialize the object along with
     * its class information. The serialized data is written to a byte array
     * output stream.
     * </p>
     *
     * @param obj the object to serialize
     * @return the serialized object as a byte array
     * @throws IORuntimeException if an I/O error occurs during serialization

 *
 * @author Hayward Chan
 */
final class Platform {
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {

        String resourceId = resourceManager.registerResource(resource);

        assertNotNull(resourceId);
        assertTrue(resourceId.contains("TestResource"));

        Map<String, Object> stats = resourceManager.getStatistics();
        assertTrue((long) stats.get("totalAllocated") > 0);
    }

    @Test
    @DisplayName("Test resource close tracking")

				console.Debugln("error refreshing", m.id, time.Now().Format(time.RFC3339))
			}
		}
	}
}

// baseDirFromPrefix will return the base directory given an object path.
// For example an object with name prefix/folder/object.ext will return `prefix/folder/`.
func baseDirFromPrefix(prefix string) string {
	b := path.Dir(prefix)
	if b == "." || b == "./" || b == "/" {
		b = ""
	}

        return clazz;
    }

    /**
     * Returns a {@link Constructor} object that reflects the specified {@code public} constructor of the class represented by the {@link Class} object.
     *
     * @param <T>
     *            The class represented by the {@link Class} object
     * @param clazz
     *            The {@link Class} object representing the class. Must not be {@literal null}.
     * @param argTypes

 * </ul>
 *
 * <h2>Usage Example:</h2>
 * <pre>
 * {@code
 * String escapedXml = XmlUtil.escapeXml("<tag>value</tag>");
 * Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
 * }
 * </pre>
 *
 * <h2>Thread Safety:</h2>
 * <p>
 * This class is thread-safe as it does not maintain any state.
 * </p>
 *
 * <h2>Dependencies:</h2>