if (!requestSemaphore.tryAcquire()) {
                totalBackpressureRejections.incrementAndGet();
                throw new CIFSException("Circuit breaker '" + name + "' rejected request due to backpressure");
            }
        }

        long startTime = System.nanoTime();
        boolean semaphoreAcquired = backpressureEnabled && requestSemaphore != null;

        try {

   * and returns {@code null} if non-ASCII digits are present in the string.
   *
   * <p>Note that strings prefixed with ASCII {@code '+'} are rejected, even though {@link
   * Integer#parseInt(String)} accepts them.
   *
   * @param string the string representation of an integer value

        when(nameFilter.accept(parent, acceptedName)).thenReturn(true);

        FileEntry initial = entry("first");
        FileEntry[] page1 = new FileEntry[] { entry("."), entry(".."), entry("rejected"), entry(acceptedName) };
        TestIterator it = TestIterator.create(tree, parent, "*", nameFilter, 0, initial, List.of(new FileEntry[][] { page1 }));

        // Act
        assertTrue(it.hasNext());

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class DefaultToolchainManagerTest {
    // Mocks to inject into toolchainManager
    @Mock
    private Logger logger;

    private ToolchainManagerFactory.DefaultToolchainManagerV3 toolchainManager;

    @Mock
    private ToolchainFactory toolchainFactoryBasicType;

You can create your own custom response class, inheriting from `Response` and using it.

For example, let's say that you want to use [`orjson`](https://github.com/ijl/orjson) with some settings.

Let's say you want it to return indented and formatted JSON, so you want to use the orjson option `orjson.OPT_INDENT_2`.

    implements Serializable {

  /**
   * Creates a new, empty multiset, sorted according to the elements' natural order. All elements
   * inserted into the multiset must implement the {@code Comparable} interface. Furthermore, all
   * such elements must be <i>mutually comparable</i>: {@code e1.compareTo(e2)} must not throw a

        val versionsToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
        JavaParser().parse(sourceFile).getResult().get().run {
            solver.inject(this)
            findAllIncubating()
                .map { node ->
                    toVersionIncubating(sourceFile, node) }
                .forEach { (version, incubating) ->

	"errors"
	"fmt"
	"hash/maphash"
	"reflect"
	"strings"

	"gorm.io/gorm/clause"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

// Create inserts value, returning the inserted data's primary key in value's id
func (db *DB) Create(value interface{}) (tx *DB) {
	if db.CreateBatchSize > 0 {
		return db.CreateInBatches(value, db.CreateBatchSize)
	}

	tx = db.getInstance()

020B          ; valid                                  # 1.1  LATIN SMALL LETTER I WITH INVERTED BREVE
020C          ; mapped                 ; 020D          # 1.1  LATIN CAPITAL LETTER O WITH DOUBLE GRAVE
020D          ; valid                                  # 1.1  LATIN SMALL LETTER O WITH DOUBLE GRAVE
020E          ; mapped                 ; 020F          # 1.1  LATIN CAPITAL LETTER O WITH INVERTED BREVE

        // This requires Mockito 3.4.0+ for MockedStatic
        // For simplicity, we'll assume Crypto.getMD5() is static and mock it.
        // If it's not static, we'd need to inject it or mock the class that provides it.
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
        }
    }

    @Test