singrdk/base/Kernel/Singularity.Stress/KPTestBase.sg

////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   KPTestBase.sg
//
//  Note:   Tests the kernel-process boundary.
//
//  Warning: this file is compiled in two separate places:
//    - Applications/Tests/KPTest
//    - Kernel/Singularity.Stress
//
//  Feel free to add more commands to this file.

using System;
using System.Threading;
using Microsoft.SingSharp;
using Microsoft.Singularity;
using Microsoft.Singularity.V1.Services;

namespace Microsoft.Singularity.Stress
{
    public class KPTestBase
    {
        public virtual uint Go(string[]! args, int i)
        {
            if (i >= args.Length) return 0xdeafbead;
            string! arg = (!) (args[i]);
            if (arg == "print") {
                DebugStub.WriteLine("{0}", __arglist(args[i + 1]));
                return Go(args, i + 2);
            }
            else if (arg == "print-") {
                uint r = Go(args, i + 2);
                DebugStub.WriteLine("{0} (print-after) {1:x}", __arglist(args[i + 1], r));
                return r;
            }
            else if (arg == "print^") {
                DebugStub.WriteLine(args[i + 1] + " (print-before)");
                uint r = Go(args, i + 2);
                DebugStub.WriteLine("{0} (print-after) {1:x}", __arglist(args[i + 1], r));
                return r;
            }
            else if (arg == "catch" || arg == "_catch") {
                try {
                    return Go(args, i + 2);
                }
                catch (Exception) {
                    if (arg == "catch") {
                        DebugStub.WriteLine("{0} (catch)", __arglist(args[i + 1]));
                    }
                }
                return 0xdeadbeef;
            }
            else if (arg == "finally" || arg == "_finally") {
                try {
                    return Go(args, i + 2);
                }
                finally {
                    if (arg == "finally") {
                        DebugStub.WriteLine(" (finally)", __arglist(args[i + 1]));
                    }
                }
            }
            else if (arg == "throw") {
                throw new ArgumentException("ArgumentException");
            }
            else if (arg == "break" || arg == "_break") {
                if (arg == "break") {
                    DebugStub.WriteLine("break-before");
                }
                DebugService.Break();
                uint r = Go(args, i + 1);
                if (arg == "break") {
                    DebugStub.WriteLine("break-after");
                }
                DebugService.Break();
                return r;
            }
            else if (arg == "frames") {
                return RecN(Int32.Parse(args[i + 1]), args, i + 2);
            }
            else if (arg == "delay") {
                int n = Int32.Parse(args[i + 1]);
                uint dummy = 100;
                for (int k = 0; k < n; k++) {
                    for (int j = 0; j < 10000000; j++) {
                        dummy = dummy % 100;
                    }
                }
                return (dummy % 100) + Go(args, i + 2);
            }
            else if (arg == "sleep") {
                int n = Int32.Parse(args[i + 1]);
                Thread.Sleep(n);
                return Go(args, i + 2);
            }
            else if (arg == "yield") {
                Thread.Yield();
                return Go(args, i + 1);
            }
            else if (arg == "wall" || arg == "_wall") {
                if (arg == "wall") {
                    DebugStub.WriteLine("wall");
                }
                new AutoResetEvent(false).WaitOne();
                return 0;
            }
            else if (arg == "(*") {
                int n = Int32.Parse(args[i + 1]);
                int rParen = FindClosingRParen(args, i + 2);
                string[] before = new string[rParen - (i + 2)];
                Array.Copy(args, i + 2, before, 0, before.Length);
                string[] after = new string[args.Length - (rParen + 1)];
                Array.Copy(args, rParen + 1, after, 0, after.Length);
                for (int j = 0; j < n; j++) {
                    Go(before, 0);
                }
                return Go(after, 0);
            }
            else {
                DebugStub.WriteLine("unknown command: {0}", __arglist(arg));
                return 0;
            }
        }

        public virtual uint RecN(int n, String[]! args, int i)
        {
            if (n == 0) return Go(args, i);
            else return RecN(n - 1, args, i);
        }

        public int FindClosingRParen(string[]! args, int i)
        {
            int count = 1;
            for (; i < args.Length; i++) {
                if (((!) (args[i]))[0] == '(') count++;
                else if (args[i] == ")") count--;
                if (count == 0) return i;
            }
            return i;
        }
    }
}