public TestSuite(Type type)
        {
            this.name = type.Name;
            this.fullName = type.FullName;

            object[] attrs = type.GetCustomAttributes( typeof(PropertyAttribute), true);
            foreach (PropertyAttribute attr in attrs)
                this.Properties[attr.Name] = attr.Value;

            IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(type, typeof(IgnoreAttribute));
            if (ignore != null)
            {
                this.runState = RunState.Ignored;
                this.ignoreReason = ignore.Reason;
            }

            if ( !InvalidTestSuite(type) )
            {
                foreach (MethodInfo method in type.GetMethods())
                {
                    if (IsTestMethod(method))
                        this.AddTest(HasValidSignature(method)
                            ? Reflect.ConstructTestCase(method)
                            : new InvalidTestCase(method.Name,
                                "Test methods must have signature void MethodName()"));
                }
            }
        }

        private void Initialize(MethodInfo method, object fixture)
        {
            this.name = method.Name;
            this.method = method;
            this.fullName = method.ReflectedType.FullName + "." + name;
            this.fixture = fixture;
            if ( fixture == null )
                this.fixture = Reflect.Construct(method.ReflectedType, null);

            if (!HasValidSignature(method))
            {
                this.runState = RunState.NotRunnable;
                this.ignoreReason = "Test methods must have signature void MethodName()";
            }
            else
            {
                IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(this.method, typeof(IgnoreAttribute));
                if (ignore != null)
                {
                    this.runState = RunState.Ignored;
                    this.ignoreReason = ignore.Reason;
                }
            }

            foreach (MethodInfo m in method.ReflectedType.GetMethods())
            {
                if (Reflect.HasAttribute(m, typeof(SetUpAttribute)))
                    this.setup = m;

                if (Reflect.HasAttribute(m, typeof(TearDownAttribute)))
                    this.teardown = m;
            }
        }

        public TestSuite(Type type)
        {
            this.name = type.Name;
            this.fullName = type.FullName;

            object[] attrs = type.GetCustomAttributes( typeof(PropertyAttribute), true);
            foreach (PropertyAttribute attr in attrs)
                foreach( DictionaryEntry entry in attr.Properties )
                    this.Properties[entry.Key] = entry.Value;

            IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(type, typeof(IgnoreAttribute));
            if (ignore != null)
            {
                this.runState = RunState.Ignored;
                this.ignoreReason = ignore.Reason;
            }

            if ( !InvalidTestSuite(type) )
            {
                foreach (MethodInfo method in type.GetMethods())
                {
                    if (TestCase.IsTestMethod(method))
                        this.AddTest(new TestCase(method));
                    //{
                    //    ITest test = TestCase.HasValidSignature(method)
                    //        ? (ITest)new TestCase(method)
                    //        : (ITest)new InvalidTestCase(method.Name,
                    //            "Test methods must have signature void MethodName()");

                    //    this.AddTest(test);
                    //}
                }
            }
        }

		public void AsyncTests(MethodInfo method, RunState state)
		{
			var built = _sut.BuildFrom(method);

			Assert.That(built, Is.InstanceOf<NUnitAsyncTestMethod>());
			Assert.That(built.RunState, Is.EqualTo(state));
		}

 public void TryApplyRunState(RunState state, string reason)
 {
     if (_runStatePriorities[state] < _runStatePriorities[_test.RunState])
     {
         _test.RunState = state;
         _test.IgnoreReason = reason;
     }
 }

 private void OnTestClassStarting(object sender, TestClassStartingEventArgs e)
 {
     if (!IsRunning)
     {
         IsRunning = true;
         runState = new RunState();
     }
 }

        /// <summary>
        /// Construct a TestCaseAttribute with a list of arguments.
        /// This constructor is not CLS-Compliant
        /// </summary>
        /// <param name="arguments"></param>
        public TestCaseAttribute(params object[] arguments)
        {
			this.runState = RunState.Runnable;
			
         	if (arguments == null)
         		this.arguments = new object[] { null };
         	else
 	        	this.arguments = arguments;
        }

        public void runCalculation(Object o)
        {
            DataResponse r = (DataResponse)o;
            Thread.Sleep(1000 * 20);
            r.data = MakeArrayetest(r.row, r.col);
            sendRequest(r, null);

            myState = RunState.IDLE;
        }

 public VirtualHardware(int boardLayoutWidth, int boardLayoutHeight, int ledSize, Color ledColor, int dotPitch)
 {
     this.m_display = null;
     this.m_state = RunState.Stopped;
     this.m_boardLayout = new Size(boardLayoutWidth, boardLayoutHeight);
     this.m_ledSize = ledSize;
     this.m_ledColor = ledColor;
     this.m_dotPitch = dotPitch;
 }

        public void Match_returns_true_if_run_state_is_not_explicit(RunState runState)
        {
            test.Stub(t => t.TestName).Return(testName);
            test.RunState = runState;

            var result = testFilter.Match(test);

            Assert.That(result, Is.True());
        }

		/// <summary>
		/// Constructs a test given its name
		/// </summary>
		/// <param name="name">The name of the test</param>
		protected Test( string name )
		{
			this.testName = new TestName();
			this.testName.FullName = name;
			this.testName.Name = name;
			this.testName.TestID = new TestID();

            this.runState = RunState.Runnable;
		}

		private void ChangeState(RunState newState)
		{
			RunState = newState;			
			
			if (RunStateChanged != null)
			{
				RunStateChanged(this, EventArgs.Empty);
			}
		}

        private void btnGo_Click(object sender, EventArgs e)
        {
            myState = RunState.RUN;
            r = new DataResponse();
            r.row = Int32.Parse( this.txtRow.Text);
            r.col = Int32.Parse(this.txtCol.Text);

            ThreadPool.QueueUserWorkItem(this.runCalculation, r);
            //this.Close();
        }

        /// <summary>
        /// Constructs a test given the path through the
        /// test hierarchy to its parent and a name.
        /// </summary>
        /// <param name="pathName">The parent tests full name</param>
        /// <param name="name">The name of the test</param>
        protected Test( string pathName, string name )
        {
            this.testName = new TestName();
            this.testName.FullName = pathName == null || pathName == string.Empty
                ? name : pathName + "." + name;
            this.testName.Name = name;
            this.testName.TestID = new TestID();

            this.runState = RunState.Runnable;
        }

 public ThreadBLL()
 {
     this._workerThread = null;
     this._connected = false;
     this._task = null;
     this._runState = RunState.idle;
     this._connString = String.Empty;///////////////////////important
     this.Connection = new SQLiteConnection();
     this.Adapt = new SQLiteDataAdapter();
 }

 public Run( Profiler p, ProjectInfo pi )
 {
     _p = p;
     _dtStart = DateTime.Now;
     _dtEnd = DateTime.MaxValue;
     _rs = RunState.Initializing;
     _tic = new ThreadInfoCollection();
     _pi = pi;
     _rmcMessages = new RunMessageCollection();
     _bSuccess = false;
 }

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this)
            {
                PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8
            };
            //graphicsDevice = new GraphicsDevice();
            Content.RootDirectory = "Content";

            runState = RunState.MainMenu;

            graphics.IsFullScreen = false;
            graphics.PreferredBackBufferWidth = 1280;
            graphics.PreferredBackBufferHeight = 720;

            loadPercentage = 0;
        }

 private void Initialize(string name, object fixture)
 {
     this.name = name;
     this.fixture = fixture;
     this.fullName = this.fixture.GetType().FullName + "." + name;
     this.method = Reflect.GetMethod(this.fixture.GetType(), name);
     if (this.method == null)
         this.runState = RunState.NotRunnable;
     else 
     {
         IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(this.method, typeof(IgnoreAttribute));
         if (ignore != null)
         {
             this.runState = RunState.Ignored;
             this.ignoreReason = ignore.Reason;
         }
     }
 }

        public TestSuite(Type type)
        {
            TestObject = Reflect.Construct(type, null);

            this.name = type.Name;
            this.fullName = type.FullName;

            object[] attrs = type.GetCustomAttributes( typeof(PropertyAttribute), true);
            foreach (PropertyAttribute attr in attrs)
            {
                foreach( DictionaryEntry entry in attr.Properties )
                {
                    this.Properties[entry.Key] = entry.Value;
                }
            }

            IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(type, typeof(IgnoreAttribute));
            if (ignore != null)
            {
                this.runState = RunState.Ignored;
                this.ignoreReason = ignore.Reason;
            }

            if ( !InvalidTestSuite(type) )
            {
                foreach (MethodInfo method in type.GetMethods())
                {
                    if (TestCase.IsTestMethod(method))
                    {
                        this.AddTest(new TestCase(method, TestObject));
                    }
                    else if (IsTestFixtureSetup(method))
                    {
                        TestFixtureSetUpMethod = method;

                    }else if (IsTestFixtureTearDownAttribute(method))
                    {
                        TestFixtureTearDownMethod = method;
                    }
                }
            }
        }

		/// <summary>
		/// Construct from an ITest
		/// </summary>
		/// <param name="test">Test from which a TestNode is to be constructed</param>
		public TestInfo( ITest test )
		{
			this.testName = (TestName)test.TestName.Clone();
			this.testType = test.TestType;

            this.runState = test.RunState;
			this.ignoreReason = test.IgnoreReason;
			this.description = test.Description;
			this.isSuite = test.IsSuite;

			if (test.Categories != null) 
				this.categories.AddRange(test.Categories);
			if (test.Properties != null)
			{
				this.properties = new ListDictionary();
				foreach( DictionaryEntry entry in test.Properties )
					this.properties.Add( entry.Key, entry.Value );
			}

			this.testCaseCount = test.TestCount;
		}