Exemple #1
0
    public static void ThreadPoolTest()
    {
        Thread[]      threads = new Thread[Test.nThreads];
        IGen <double> obj     = new GenDouble();

        for (int i = 0; i < Test.nThreads; i++)
        {
            threads[i] = new Thread(new ThreadStart(obj.Target));
            threads[i].Start();
        }

        for (int i = 0; i < Test.nThreads; i++)
        {
            threads[i].Join();
        }

        Test.Eval(Test.Xcounter == Test.nThreads);
        Test.Xcounter = 0;
    }
Exemple #2
0
    public static int Main()
    {
        GenInt.ThreadPoolTest();
        GenDouble.ThreadPoolTest();
        GenString.ThreadPoolTest();
        GenObject.ThreadPoolTest();
        GenGuid.ThreadPoolTest();

        if (result)
        {
            Console.WriteLine("Test Passed");
            return(100);
        }
        else
        {
            Console.WriteLine("Test Failed");
            return(1);
        }
    }
Exemple #3
0
    public static void ThreadPoolTest()
    {
        ManualResetEvent[] evts = new ManualResetEvent[Test_thread13.nThreads];
        WaitHandle[]       hdls = new WaitHandle[Test_thread13.nThreads];

        for (int i = 0; i < Test_thread13.nThreads; i++)
        {
            evts[i] = new ManualResetEvent(false);
            hdls[i] = (WaitHandle)evts[i];
        }

        IGen <double> obj = new GenDouble();

        for (int i = 0; i < Test_thread13.nThreads; i++)
        {
            WaitCallback cb = new WaitCallback(obj.Target);
            ThreadPool.QueueUserWorkItem(cb, evts[i]);
        }

        WaitHandle.WaitAll(hdls);
        Test_thread13.Eval(Test_thread13.Xcounter == Test_thread13.nThreads);
        Test_thread13.Xcounter = 0;
    }
Exemple #4
0
    public static int Main()
    {
        IGen <int> IGenInt = new GenInt();

        IGenInt._Init(new int());
        Eval(IGenInt.InstVerify(typeof(int)));

        IGen <double> IGenDouble = new GenDouble();

        IGenDouble._Init(new double());
        Eval(IGenDouble.InstVerify(typeof(double)));

        IGen <string> IGenString = new GenString();

        IGenString._Init("string");
        Eval(IGenString.InstVerify(typeof(string)));

        IGen <object> IGenObject = new GenObject();

        IGenObject._Init(new object());
        Eval(IGenObject.InstVerify(typeof(object)));

        IGen <Guid> IGenGuid = new GenGuid();

        IGenGuid._Init(new Guid());
        Eval(IGenGuid.InstVerify(typeof(Guid)));

        IGen <RefX1 <int> > IGenConstructedReference = new GenConstructedReference();

        IGenConstructedReference._Init(new RefX1 <int>());
        Eval(IGenConstructedReference.InstVerify(typeof(RefX1 <int>)));

        IGen <ValX1 <string> > IGenConstructedValue = new GenConstructedValue();

        IGenConstructedValue._Init(new ValX1 <string>());
        Eval(IGenConstructedValue.InstVerify(typeof(ValX1 <string>)));

        IGen <int[]> IGen1DIntArray = new Gen1DIntArray();

        IGen1DIntArray._Init(new int[1]);
        Eval(IGen1DIntArray.InstVerify(typeof(int[])));

        IGen <string[, ]> IGen2DStringArray = new Gen2DStringArray();

        IGen2DStringArray._Init(new string[1, 1]);
        Eval(IGen2DStringArray.InstVerify(typeof(string[, ])));

        IGen <object[][]> IGenJaggedObjectArray = new GenJaggedObjectArray();

        IGenJaggedObjectArray._Init(new object[1][]);
        Eval(IGenJaggedObjectArray.InstVerify(typeof(object[][])));

        if (result)
        {
            Console.WriteLine("Test Passed");
            return(100);
        }
        else
        {
            Console.WriteLine("Test Failed");
            return(1);
        }
    }