import org.junit.jupiter.api.Test;

/**
 * Tests <code>NearestConflictResolver</code>.
 *
 * @see NearestConflictResolver
 */
@Deprecated
class NearestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    NearestConflictResolverTest() throws Exception {
        super("nearest");
    }

import org.junit.jupiter.api.Test;

/**
 * Tests <code>OldestConflictResolver</code>.
 *
 * @see OldestConflictResolver
 */
@Deprecated
class OldestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    OldestConflictResolverTest() throws Exception {
        super("oldest");
    }

    Matcher matcher = pattern.matcher(expected.getMessage());
    assertThat(matcher.matches()).isTrue();
    assertThat(matcher.group(1)).isNotEqualTo(matcher.group(2));
  }

  public void testOf() {
    assertMapEquals(ImmutableMap.of("one", 1), "one", 1);
    assertMapEquals(ImmutableMap.of("one", 1, "two", 2), "one", 1, "two", 2);
    assertMapEquals(

import org.junit.jupiter.params.provider.ValueSource;

import jcifs.Address;
import jcifs.CIFSContext;

class UniAddressTest {

    @Nested
    @DisplayName("isDotQuadIP method tests")
    class IsDotQuadIPTests {

        @ParameterizedTest(name = "should return true for valid IP address: {0}")
        @ValueSource(strings = { "192.168.1.1", "10.0.0.255", "0.0.0.0", "255.255.255.255" })

import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.Test;

/**
 * Tests for the Trans2QueryFSInformationResponse class.
 */
class Trans2QueryFSInformationResponseTest {

    /**
     * Tests the constructor to ensure it sets up the command and subcommand correctly.
     */
    @Test
    void testConstructor() {

    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        testMessage = new TestServerMessageBlock2(mockConfig);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create with configuration only")
        void testConstructorWithConfig() {

You don't want the original dependency to run (nor any of the sub-dependencies it might have).

Instead, you want to provide a different dependency that will be used only during tests (possibly only some specific tests), and will provide a value that can be used where the value of the original dependency was used.

### Use cases: external service { #use-cases-external-service }

        description = "Run all flaky tests skipped multiple times"

        applyDefaultSettings(os = os, arch = arch, buildJvm = BuildToolBuildJvm, timeout = 180)

        if (os == Os.LINUX) {
            steps {
                script {
                    // Because we exclude tests in `distributions-integ-tests` below, `@Flaky` won't work in that subproject.

#!/bin/bash

trap 'cleanup $LINENO' ERR

# shellcheck disable=SC2120
cleanup() {
	MINIO_VERSION=dev /tmp/gopath/bin/docker-compose \
		-f "buildscripts/upgrade-tests/compose.yml" \
		down || true

	MINIO_VERSION=dev /tmp/gopath/bin/docker-compose \
		-f "buildscripts/upgrade-tests/compose.yml" \
		rm || true

	for volume in $(docker volume ls -q | grep upgrade); do
		docker volume rm ${volume} || true
	done

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

var db, _ = gorm.Open(tests.DummyDialector{}, nil)

func checkBuildClauses(t *testing.T, clauses []clause.Interface, result string, vars []interface{}) {
	var (
		buildNames    []string
		buildNamesMap = map[string]bool{}
		user, _       = schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)