Why is AutoFixture executed more than once?

Question

I've been using AutoFixture / AutoMoqData / Nunit for several months now, quite happily so far.

But I'm getting stuck on something weird:

If I want to run a single test in a test suite (using TestDriven), it seems that the AutoMoqData attribute is launched several times (between 5 and 9, but I don't really know why, and what decides how many times it runs).

The problem is that if I try to freeze an object instance in AutoFixture customizations, it'll end up freezing 5 to 9 objects, using this many fixture instances, and will have no clue which one is injected in my test.

Is there a way to avoid this ? Why does it happen in the first place ?

Sample code :

public class AutoMoqDataAttribute : AutoDataAttribute
{
    public AutoMoqDataAttribute()
        : base(new Fixture()
            .Customize(new AutoMoqCustomization())
            .Customize(new FrozenFooCustomization()) // freezing an object
            .Customize(new FrozenFixtureCustomization()) // freezing the passed fixture to have the fixture instance available in the test body
            .Customize(new StaticBindingCustomization()) // binding the frozen object to a static reference
            )
    {
    }
}

public class FrozenFooCustomization : ICustomization
{
    public void Customize(IFixture fixture)
    {
        fixture.Freeze<Foo>();
    }
}

public class Foo { }

public class FrozenFixtureCustomization : ICustomization
{
    public void Customize(IFixture fixture)
    {
        fixture.Inject(fixture);
    }
}

public class StaticBindingCustomization : ICustomization
{
    public void Customize(IFixture fixture)
    {
        fixture.Freeze<Mock<ISomeUtilities>>();
        var someUtilities = fixture.Create<Mock<ISomeUtilities>>();
        someUtilities.Setup(x => x.GetStuff()).Returns(fixture.Create<Foo>());
        // this is executed several times, each time with a different instance of fixture, returning a different instance of Foo
        SomeExtensions.Factory = x => someUtilities.Object;
        // so the last "someUtilities.Object" is bound to the factory, but the test relies on a frozen version generated by one of the previous fixture instances
    }
}

[TestFixture]
public class Test
{
    [Test, AutoMoqData]
    public void SomeTest(
        [Frozen]Mock<ISomeUtilities> objMock,
        SomeObjectToTest sut)
    {
        Assert.IsTrue(ReferenceEquals(objMock.Object.GetStuff(), sut.GetStuff()));
    }
}

public class SomeObjectToTest { }

public static class SomeExtensions
{
    public static Func<object, ISomeUtilities> Factory { get; set; } = x => new SomeUtilities(x);

    public static object GetStuff(this object obj)
    {
        return Factory(obj).GetStuff();
    }
}

public class SomeUtilities : ISomeUtilities
{
    private readonly object _obj;

    public SomeUtilities(object obj)
    {
        _obj = obj;
    }

    public object GetStuff()
    {
        return _obj; // whatever
    }
}

public interface ISomeUtilities
{
    object GetStuff();
}

EDIT: SomeExtensions.Factory is a factory used to make extensions mockable, based on Daniel Cazzulino's approach.

I'm not a big fan of those extensions and hope to refactor them at some point, but this is for another time. The question here is why are there several fixture instances, making the frozen SomeUtilities mock used in the factory different than the one used in the test, and thus the test to fail.

EDIT2: Following @MarkSeemann's advice, I reported an issue on Autofixture repo.