Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

The Super Pool Framework

, 31 Aug 2010 CPOL
The Super Pool is a framework for decoupled communication and management of components. The Super Pool introduces a natural asynchronous communication environment into your solution that can be fluently spread over different components, threads, processes, or even computers or networks.
Matrix_SuperPool_Standalone.zip
Lib
PowerCollections.dll
Matrix.Framework.SuperPool.Standalone
bin
Debug
Release
Common.Sockets
Common
Core
Matrix.Common.Core
Collections
Identification
Results
Serialization
Matrix.Common.Extended
FastSerialization
Operationals
ThreadPools
Matrix.Common.Sockets
Common
Core
Matrix.Framework.MessageBus
Client
Clients
ExecutionStrategies
Core
Net
Messages
Matrix.Framework.SuperPool
Call
Clients
Core
DynamicProxy
Subscription
Matrix.Framework.SuperPool.Standalone.csproj.user
Properties
Tests
Lib
log4net.dll
Matrix.Common.Core.dll
Matrix.Common.Diagnostics.dll
Matrix.Common.Diagnostics.FrontEnd.dll
Matrix.Common.Extended.dll
Matrix.Common.FrontEnd.dll
Matrix.Common.Sockets.dll
Matrix.Framework.TestFramework.dll
nunit.framework.dll
Matrix.Framework.SuperPool.Demonstration
bin
Debug
Release
FormServer.cs.bak
Properties
Matrix.Framework.SuperPool.Test
bin
Debug
Release
Matrix.Framework.SuperPool.Test.vshost.exe.manifest
MultiThreadTests
Properties
Settings.settings
SpeedTests
Matrix.Framework.SuperPool.UnitTest
bin
Debug
Release
Matrix.Framework.SuperPool.UnitTest.csproj.user
Properties
// -----
// Copyright 2010 Deyan Timnev
// This file is part of the Matrix Platform (www.matrixplatform.com).
// The Matrix Platform is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version. The Matrix Platform is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
// You should have received a copy of the GNU Lesser General Public License along with the Matrix Platform. If not, see http://www.gnu.org/licenses/lgpl.html
// -----
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using NUnit.Framework;
using Matrix.Framework.SuperPool.Core;
using Matrix.Framework.SuperPool.Clients;
using Matrix.Framework.MessageBus.Core;

namespace Matrix.Framework.SuperPool.UnitTest
{
    /// <summary>
    /// Helper delegate used for the testing of events.
    /// </summary>
    public delegate void HelperDelegate(int a, string b, EventArgs c);
    public delegate string HelperDelegateWithReturn(int a, string b, EventArgs c);

    /// <summary>
    /// Helper interface.
    /// </summary>
    [SuperPoolInterface]
    public interface ITestInterface
    {
        event HelperDelegate EventA;
        event HelperDelegateWithReturn EventB;

        /// <summary>
        /// Simple call.
        /// </summary>
        void SimpleMethod(int a, string b, EventArgs c);

        /// <summary>
        /// Async result call, will cause some delay to test sync/async result operation.
        /// </summary>
        string AsyncResultMethod(int requestedDelayMs);

        /// <summary>
        /// Variable parameters call.
        /// </summary>
        void VariableParametersTest(params object[] parameters);

        /// <summary>
        /// This "ref" parameter is not supported and must generate a NotImplementedException().
        /// </summary>
        void RefMethod(ref int a);

        /// <summary>
        /// This "out" parameter is not supported and must generate a NotImplementedException().
        /// </summary>
        void OutMethod(out int a);

        /// <summary>
        /// This method throws an exception.
        /// </summary>
        void ExceptionMethod();

        /// <summary>
        /// Handles a direct call, returns this.
        /// </summary>
        /// <returns></returns>
        ITestInterface DirectCall(string parameter1);
    }

    /// <summary>
    /// Implements the interface.
    /// </summary>
    public class InterfaceImplementor : ITestInterface
    {
        public delegate void StringDelegate(string value);

        public event StringDelegate MethodInvokedEvent;

        #region ITestInterface Members

        public event HelperDelegate EventA;

        public event HelperDelegateWithReturn EventB;

        public string Name { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        public InterfaceImplementor(string name)
        {
            Name = name;
        }

        public void RaiseEventA(int a, string b, EventArgs c)
        {
            HelperDelegate delegateInstance = EventA;
            if (delegateInstance != null)
            {
                delegateInstance(a, b, c);
            }
        }

        public void RaiseEventB(int a, string b, EventArgs c)
        {
            HelperDelegateWithReturn delegateInstance = EventB;
            if (delegateInstance != null)
            {
                delegateInstance(a, b, c);
            }
        }

        public void VariableParametersTest(params object[] parameters)
        {
            // Method invoked.
            StringDelegate delegateInstance = MethodInvokedEvent;
            if (delegateInstance != null)
            {
                delegateInstance("VariableParametersTest");
            }
        }

        public void SimpleMethod(int a, string b, EventArgs c)
        {
            // Method invoked.
            StringDelegate delegateInstance = MethodInvokedEvent;
            if (delegateInstance != null)
            {
                delegateInstance("SimpleMethod");
            }
        }

        public void RefMethod(ref int a)
        {
            // Method invoked.
            StringDelegate delegateInstance = MethodInvokedEvent;
            if (delegateInstance != null)
            {
                delegateInstance("RefMethod");
            }
        }

        public string AsyncResultMethod(int requestedDelayMs)
        {
            Thread.Sleep(requestedDelayMs);
            return "async call completed";
        }

        public void OutMethod(out int a)
        {
            a = -1;
        }

        public void ExceptionMethod()
        {
            throw new NotImplementedException();
        }

        public ITestInterface DirectCall(string parameter1)
        {
            return this;
        }

        #endregion
    }

    /// <summary>
    /// Implements the operation of the Call test.
    /// </summary>
    internal class CallTestImplementor
    {
        internal SuperPoolClient Client1 { get; set; }
        internal SuperPoolClient Client2 { get; set; }

        InterfaceImplementor _implementor1;
        InterfaceImplementor _implementor2;

        /// <summary>
        /// List of items to be disposed at test end.
        /// </summary>
        internal List<IDisposable> Disposables = new List<IDisposable>();

        #region Default Parameters

        int a = 12;
        string b = "string b";
        EventArgs c = new EventArgs();

        #endregion


        /// <summary>
        /// Constructor.
        /// </summary>
        internal CallTestImplementor()
        {
            _implementor1 = new InterfaceImplementor("Implementor1");
            _implementor2 = new InterfaceImplementor("Implementor2");

            Client1 = new SuperPoolClient("client1", _implementor1);
            Client2 = new SuperPoolClient("client2", _implementor2);
        }

        internal void Initialize()
        {
        }

        internal void Uninit()
        {
            foreach (IDisposable disposable in Disposables)
            {
                disposable.Dispose();
            }

            // If we do this, following tests will fail.
            //ApplicationLifetimeHelper.SetApplicationClosing();
        }

        internal void SimpleCallTest(int length)
        {
            for (int i = 0; i < length; i++)
            {
                Client1.Call<ITestInterface>(Client2.Id).SimpleMethod(a, b, c);
            }
        }

        
        internal void VariableCallTest(int length)
        {
            for (int i = 0; i < length; i++)
            {
                Client1.Call<ITestInterface>(Client2.Id).VariableParametersTest(new object[] { a, b, c });
            }
        }

        
        internal void RefCallTest()
        {
            try
            {
                int d = 0;
                Client1.Call<ITestInterface>(Client2.Id).RefMethod(ref d);
                throw new Exception("Invalid call did not generate expected exception.");
            }
            catch (NotImplementedException)
            {
                // Test succeded only if exception is thrown.
            }
        }

        internal void ConfirmedCallTest()
        {
            CallOutcome outcome;
            Client1.CallConfirmed<ITestInterface>(Client2.Id, TimeSpan.FromSeconds(2), out outcome).SimpleMethod(2, "some param", EventArgs.Empty);

            if (outcome == null || outcome.Result != Outcomes.Success)
            {
                Assert.Fail("Failed to perform confirmed call.");
            }

            ClientId dummyId = new ClientId("dummyId");
            CallOutcome outcome2;
            Client1.CallConfirmed<ITestInterface>(dummyId, TimeSpan.FromSeconds(2), out outcome2).SimpleMethod(2, "some param", EventArgs.Empty);

            if (outcome2 != null && outcome2.Result == Outcomes.Success)
            {
                Assert.Fail("Failed to verify invalid outcome.");
            }
        }
        
        internal void OutCallTest()
        {
            try
            {
                int d = 0;
                Client1.Call<ITestInterface>(Client2.Id).OutMethod(out d);
                throw new Exception("Invalid call did not generate expected exception.");
            }
            catch (NotImplementedException)
            {
                // Test succeded only if exception is thrown.
            }
        }

        
        internal void AsyncResultCallTest()
        {
            ManualResetEvent eventa = new ManualResetEvent(false);

            AsyncCallResultDelegate delegateInstance =
                delegate(ISuperPoolClient client, AsyncResultParams parameters)
                {
                    if ((parameters.State is int == false) ||
                        (int)parameters.State != 152)
                    {
                        Assert.Fail("Parameter fail.");
                    }

                    if (parameters.Result != null)
                    {
                        // Do something with result.
                        string resultString = parameters.Result.ToString();
                    }

                    eventa.Set();
                };

            Client1.Call<ITestInterface>(Client2.Id, delegateInstance, 152).AsyncResultMethod(1500);

            if (eventa.WaitOne(60000) == false)
            {
                Assert.Fail("Failed to receive async result.");
            }
        }

        
        internal void AsyncTimeoutResultCallTest()
        {
            ManualResetEvent eventa = new ManualResetEvent(false);

            DateTime start = DateTime.Now;

            AsyncCallResultDelegate delegateInstance =
                delegate(ISuperPoolClient client, AsyncResultParams parameters)
                {
                    TimeSpan time = DateTime.Now - start;
                    Console.WriteLine("Async call result received in " + time.TotalMilliseconds + "ms.");
                    eventa.Set();
                    string p = parameters.Result as string;
                };

            Client1.CallAll<ITestInterface>(delegateInstance, 152, TimeSpan.FromSeconds(2)).AsyncResultMethod(500);

            eventa.WaitOne(60000);

            if (Client1.PendingSyncCallsCount != 1)
            {
                throw new Exception("Pending sync calls count not 1.");
            }

            // Allow time for the client GC to gather the call.
            Thread.Sleep(SuperPoolClient.GarbageCollectorIntervalMs * 3);

            if (Client1.PendingSyncCallsCount != 0)
            {
                throw new Exception("Pending sync calls count not 0.");
            }
        }

        internal void DirectCallTest(int length)
        {
            ITestInterface result = null;
            for (int i = 0; i < length; i++)
            {
                result = Client1.CallDirectLocal<ITestInterface>(Client2.Id).DirectCall("some data");   
            }
            
            Assert.AreEqual(result == Client2.Source, true, "Result failed.");
        }

        internal void CallFirst()
        {
            Client1.CallFirst<ITestInterface>().AsyncResultMethod(100);
        }

        internal void AsyncTimeoutResultCallTestException()
        {
            ManualResetEvent eventa = new ManualResetEvent(false);

            AsyncCallResultDelegate delegateInstance =
                delegate(ISuperPoolClient client, AsyncResultParams parameters)
                {
                    if (parameters.Exception == null)
                    {// No exception was received, this is not expected.
                    }
                    else
                    {
                        eventa.Set();
                    }
                };

            Client1.CallAll<ITestInterface>(delegateInstance, 152, TimeSpan.FromSeconds(2)).ExceptionMethod();

            if (eventa.WaitOne(20000) == false)
            {
                throw new Exception("Test failed due to no exception received.");
            }
        }
    }

}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Deyan Timnev
Product Manager Ingenious Ltd, Bulgaria
Bulgaria Bulgaria
I worked for a few years as a C++/Win32 developer and software architect, and then moved on to the .NET environment where I was able to discover the beauty of managed programming.
 
I am currently involved in the development and management of Open Forex Platform (www.openforexplatform.com) and the Matrix Platform (www.matrixplatform.com).

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.150327.1 | Last Updated 31 Aug 2010
Article Copyright 2010 by Deyan Timnev
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid