public class DbContext1 : DbContext
{
    public DbContext1(string connectionString)
    {
    }
}

public class Program
{
    private static readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);

    public async Task Run()
    {
        await _lock.WaitAsync();
        try
        {
            await InsertDbRow();
        }
        finally
        {
            _lock.Release();
        }
    }

    private static async Task InsertDbRow()
    {
        await RetryWrapperAsync(async () =>
        {
            using DbContext1 dbContext = new DbContext1("con str");
            await dbContext.SaveChangesAsync();
        });
    }

    public static async Task RetryWrapperAsync(Func<Task> operation)
    {
        for (int i = 0; i < 3; i++)
        {
            try
            {
                await operation();
                break;
            }
            catch (Exception)
            {
                await Task.Delay(100);
            }
        };
    }
}

[TestClass]
public class ProgramTest
{
    private readonly DbContext1 mockContext1 = Mock.Create<DbContext1>();

    [TestInitialize]
    public void SetUp()
    {
        Mock.Arrange(() => new DbContext1("con str")).Returns(mockContext1);
    }

    [TestMethod]
    public async Task TestMethod()
    {
        // Arrange
        Program program = new Program();

        // Act
        await program.Run(); // <-- at this point the test hangs
    }
}

[TestMethod]
public void TestMethod()
{
    var cultureInfo = Mock.Create<CultureInfo>();
    var thisThrowsAnException = cultureInfo.Name;
}

One of the possible workarounds is to create a mock like this:

readonly string cultureName = CultureInfo.InvariantCulture.Name;
...
var cultureInfo = Mock.Create(() => new CultureInfo(cultureName));

000000CD7CE038D0 00007ffafb22d3b6 [GCFrame: 000000cd7ce038d0]
000000CD7CE03A40 00007ffafb22d3b6 [GCFrame: 000000cd7ce03a40]
000000CD7CE0A530 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7ce0a530] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CE0A988 00007ffafb22d3b6 [GCFrame: 000000cd7ce0a988]
000000CD7CE0E3C0 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7ce0e3c0]  System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)

... (omitted for brevity)

000000CD7CF72548 00007ffafb22d3b6 [GCFrame: 000000cd7cf72548]
000000CD7CF75F80 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf75f80] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CF763D8 00007ffafb22d3b6 [GCFrame: 000000cd7cf763d8]
000000CD7CF79E10 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf79e10] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CF7A268 00007ffafb22d3b6 [GCFrame: 000000cd7cf7a268]
000000CD7CF7DCA0 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf7dca0] System.Collections.Generic.Dictionary`2[[System.__Canon, System.Private.CoreLib],[System.__Canon, System.Private.CoreLib]]..ctor()
000000CD7CF7DF10 00007FFA9B787B2A System.AppContext..cctor() [/_/src/System.Private.CoreLib/shared/System/AppContext.cs @ 16]
000000CD7CF7E340 00007ffafb2b6c93 [GCFrame: 000000cd7cf7e340]
000000CD7CF7ED18 00007ffafb2b6c93 [HelperMethodFrame: 000000cd7cf7ed18]
000000CD7CF7EE20 00007FFA9B7876B9 System.AppContext.Setup(Char**, Char**, Int32)

public interface IMyInterface
{
    int IntProperty { get => 0; }
}


[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void TestMethod1()
    {
        var mock = Mock.Create<IMyInterface>();
        Mock.Arrange(() => mock.IntProperty).Returns(1);

        Assert.AreEqual(1, mock.IntProperty);
    }
}

public class Class1
{
	private string arg1;

	public Class1(string arg1)
	{
		this.arg1 = arg1;
	}

	public Class3 Method(string arg)
	{
		throw new NotImplementedException();
	}
}

public class Class2
{
	static Class3 class3Instance; 

	public static void StaticMethod(string arg1, string arg2)
	{
		Class1 class1Instance = new Class1(arg1);
		class3Instance = class1Instance.Method(arg2);
	}
}

public class Class3
{

}

[TestClass]
public class Class2Test
{
	static Class1 mockClass1 = Mock.Create<Class1>();
	Class3 mockClass3 = Mock.Create<Class3>();

	[TestInitialize]
	public void SetUp()
	{
		Mock.Arrange(() => new Class1("arg1")).Returns(mockClass1);
		Mock.Arrange(() => mockClass1.Method("arg2")).Returns(mockClass3);
	}

	[TestMethod]
	public void TestB()
	{
		Class2.StaticMethod("arg1", "arg2");
	}
}

The test passes, but the debug trace output contains the warning message: "Calling one test method from another could result in unexpected behavior and must be avoided. Extract common mocking logic to a non-test method." even there is no call to the other test methods.

Telerik.JustMock.Core.MockException : Abstract type 'IPool' is not accessible for inheritance.
   In Telerik.JustMock.Core.MocksRepository.Create(Type type, MockCreationSettings settings)
   In Telerik.JustMock.Mock.<>c__39`1.<Create>b__39_0()
   In Telerik.JustMock.Core.ProfilerInterceptor.GuardInternal[T](Func`1 guardedAction) 

    {
        object GetItem(in Struct a, out Class b);
    }