Mocking complex scenario

Hi, I'm trying to use TypeMock to mock a complex scenario that includes Singleton, Static , Interfaces and inner classes combined.

I'm trying to mock the return value of DataManager.Raw.CurrentStudy.GetRunByFrame(frame) which is a dependancy in a class I'm testing.
Here is the stripped down version:

using NUnit.Framework;
using TypeMock;

public class TesterClass
{
    public void TestGetRun()
    {
        FrameEntity frame = new FrameEntity();
        Run run = DataManager.Raw.CurrentStudy.GetRunByFrame(frame);
    }
}

[TestFixture]
public class Test
{
    [Test]
    public void TestMe()
    {
        MockManager.Init();
        Mock dataManager = MockManager.Mock(typeof(DataManager));
        Mock rawDataManager = MockManager.Mock(typeof(RawDataManager));
        Mock rawFacade = MockManager.Mock(typeof(DataManager.RawFacade));
        Mock iRawDataManager = MockManager.MockObject(typeof(IRawDataManager));
        Mock study = MockManager.Mock(typeof(StudyEntity));
        Mock Run = MockManager.Mock(typeof(Run));
        TesterClass tester = new TesterClass();
        dataManager.ExpectGet("Raw", rawDataManager.MockedInstance);
        iRawDataManager.ExpectGet("CurrentStudy", study.MockedInstance);
        rawDataManager.ExpectGet("CurrentStudy", study.MockedInstance);
        rawFacade.ExpectGet("CurrentStudy", study.MockedInstance);
        study.ExpectAndReturn("GetRunByFrame", Run.MockedInstance, null);

        tester.TestGetRun();
    }
}

public sealed class DataManager
{
    private RawDataManager rawDataManager;
    private RawFacade rawFacade;

    public static readonly DataManager Instance = new DataManager();

    public static IRawDataManager Raw
    {
        get
        {
            return Instance.rawFacade;
        }
    }

    private DataManager()
    {
        rawFacade = new RawFacade(this);
        rawDataManager = new RawDataManager();
    }

    private StudyEntity CurrentStudy
    {
        get
        {
            return rawDataManager.CurrentStudy;
        }
    }

    private void SetStudy(StudyEntity newStudy)
    {
        rawDataManager.SetStudy(newStudy);
    }

    internal class RawFacade : IRawDataManager
    {
        DataManager currentDM;

        public RawFacade(DataManager currentParent)
        {
            currentDM = currentParent;
        }

        public StudyEntity CurrentStudy
        {
            get
            {
                return currentDM.CurrentStudy;
            }
        }

        public void SetStudy(StudyEntity newStudy)
        {
            currentDM.SetStudy(newStudy);
        }
    }
}

public interface IRawDataManager
{
    StudyEntity CurrentStudy { get; }
    void SetStudy(StudyEntity newStudy);
}

public class RawDataManager : IRawDataManager
{

    private StudyEntity study;

    public RawDataManager()
    {
    }

    public StudyEntity CurrentStudy
    {
        get
        {
            return study;
        }
        set
        {
            study = value;
        }
    }

    public void SetStudy(StudyEntity newStudy)
    {
        study = newStudy;
    }
}

public class StudyEntity
{
    public StudyEntity(Run run)
    {
        this.run = run;
    }
   
    private Run run;

    public Run GetRunByFrame(FrameEntity frame)
    {
        return run;
    }
}

public class FrameEntity
{
}

public class Run
{
    public Run()
    {

    }
}

How do I mock this using reflective type mock (the community edition)?
If this is not testable using the community edition but is using Professional Standard, is there way for me to test this pior to purchasing a license (When trying to use demo I get an exception that says:

*** You are using the Demo version that allows only one Mock, to enable please enter license key.