import java.util.HashMap;
import java.util.Map;
import org.jspecify.annotations.NullUnmarked;

/** Benchmarks for memory consumption of map implementations. */
@NullUnmarked
public class MapsMemoryBenchmark {
  static final Map<String, MapsImplEnum> mapEnums =
      uniqueIndex(
          Iterables.<MapsImplEnum>concat(
              asList(MapImpl.values()), asList(SortedMapImpl.values()), asList(BiMapImpl.values())),
          toStringFunction());

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Slf4jMavenTransferListener
 */
public class Slf4jMavenTransferListener extends AbstractTransferListener {

    protected final Logger out;

    public Slf4jMavenTransferListener() {
        this.out = LoggerFactory.getLogger(Slf4jMavenTransferListener.class);
    }

    // TODO should we deprecate?

import gradlebuild.docs.dsl.docbook.model.ClassDoc;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class ClassDescriptionRenderer {
    private final ElementWarningsRenderer warningsRenderer = new ElementWarningsRenderer();

    public void renderTo(ClassDoc classDoc, Element parent) {
        Document document = parent.getOwnerDocument();

     * .
     */
    @Test
    public void testToBinary() {
        assertThat(BinaryConversionUtil.toBinary(null), nullValue());
        final byte[] b = { 0x00, 0x01 };
        assertThat(BinaryConversionUtil.toBinary(b), is(b));
        assertThat(BinaryConversionUtil.toBinary("hoge"), is("hoge".getBytes()));
    }

    /**
     * Test method for

import org.apache.maven.artifact.Artifact;

/**
 * Common elements of artifact metadata.
 *
 */
@Deprecated
public abstract class AbstractArtifactMetadata implements ArtifactMetadata {
    private static final String LS = System.lineSeparator();

    protected Artifact artifact;

    protected AbstractArtifactMetadata(Artifact artifact) {
        this.artifact = artifact;
    }

    @Override

    setDefault(SubscriberExceptionContext.class, dummySubscriber.toContext());
    setDefault(Dispatcher.class, Dispatcher.immediate());
  }

  private static class DummySubscriber {

    private final EventBus eventBus = new EventBus();

    @Subscribe
    public void handle(@Nullable Object unused) {}

    Subscriber toSubscriber() throws Exception {
      return Subscriber.create(eventBus, this, subscriberMethod());

    /**
     * The CSS file to style Javadocs with
     */
    public abstract RegularFileProperty getJavadocCss();

    /**
     * A collection of the final rendered Javaodcs
     */
    public abstract ConfigurableFileCollection getRenderedDocumentation();

        return UserDbm.getInstance();
    }

    @Override
    protected <RESULT extends User> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setBusinessCategory(DfTypeUtil.toString(source.get("businessCategory")));
            result.setCarLicense(DfTypeUtil.toString(source.get("carLicense")));

import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;

@ExtendWith(MockitoExtension.class)
class DefaultToolchainsBuilderTest {
    private static final String LS = System.lineSeparator();

    @Spy
    private DefaultToolchainsReader toolchainsReader;

    @Spy
    private DefaultToolchainsWriter toolchainsWriter;

    @InjectMocks

/**
 * Tests {@link SequentialExecutor}.
 *
 * @author JJ Furman
 */
@NullUnmarked
public class SequentialExecutorTest extends TestCase {

  private static class FakeExecutor implements Executor {
    final Queue<Runnable> tasks = new ArrayDeque<>();

    @Override
    public void execute(Runnable command) {
      tasks.add(command);
    }

    boolean hasNext() {
      return !tasks.isEmpty();
    }