// See the License for the specific language governing permissions and
// limitations under the License.

package ipset

import (
	"net/netip"

	"github.com/stretchr/testify/mock"
)

type MockedIpsetDeps struct {
	mock.Mock
}

func FakeNLDeps() *MockedIpsetDeps {
	return &MockedIpsetDeps{}
}

func (m *MockedIpsetDeps) ipsetIPHashCreate(name string, v6 bool) error {
	args := m.Called(name, v6)

Xiaopeng Han <******@****.***> 1686841337 +0800

Xiaopeng Han <******@****.***> 1709887099 +0800

     * the type is irrelevant at runtime.
     */
    mock = mock(LoadingCache.class);
    forward =
        new ForwardingLoadingCache<String, Boolean>() {
          @Override
          protected LoadingCache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGet() throws ExecutionException {
    when(mock.get("key")).thenReturn(Boolean.TRUE);

     * the type is irrelevant at runtime.
     */
    mock = mock(LoadingCache.class);
    forward =
        new ForwardingLoadingCache<String, Boolean>() {
          @Override
          protected LoadingCache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGet() throws ExecutionException {
    when(mock.get("key")).thenReturn(Boolean.TRUE);

     * the type is irrelevant at runtime.
     */
    mock = mock(Cache.class);
    forward =
        new ForwardingCache<String, Boolean>() {
          @Override
          protected Cache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGetIfPresent() throws ExecutionException {
    when(mock.getIfPresent("key")).thenReturn(Boolean.TRUE);

              public T apply(Object delegate) {
                T mock = mock(forwarderClass, CALLS_REAL_METHODS);
                try {
                  T stubber = doReturn(delegate).when(mock);
                  DELEGATE_METHOD.invoke(stubber);
                } catch (Exception e) {
                  throw new RuntimeException(e);
                }
                return mock;
              }
            });
  }

     * the type is irrelevant at runtime.
     */
    mock = mock(Cache.class);
    forward =
        new ForwardingCache<String, Boolean>() {
          @Override
          protected Cache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGetIfPresent() throws ExecutionException {
    when(mock.getIfPresent("key")).thenReturn(Boolean.TRUE);

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

    @InjectMocks
    private DefaultToolchainManagerPrivate toolchainManager;

    @Mock
    private ToolchainFactory toolchainFactory_basicType;

    @Mock
    private ToolchainFactory toolchainFactory_rareType;

    @BeforeEach
    void setUp() {

        RepositorySystemSession session = mock(RepositorySystemSession.class);
        when(session.getLocalRepository()).thenReturn(localRepository);

        Artifact localRepositoryArtifact = mock(Artifact.class);
        when(localRepositoryArtifact.getFile()).thenReturn(new File(baseDir, "some/path/within"));

        Artifact nonLocalReposioryArtifact = mock(Artifact.class);