implab/ImplabNet Commit - r188:3071220371f8

Updated VS project

cin -

r188:3071220371f8 ref20160224

parent child

Context file:

r188:3071220371f8

Collapse all files

.hgignore +1 0

             syntax: glob
             Implab.Test/bin/
             *.user
             Implab.Test/obj/
             *.userprefs
             Implab/bin/
             Implab/obj/
             TestResults/
             Implab.Fx/obj/
             Implab.Fx/bin/
             Implab.Fx.Test/bin/
             Implab.Fx.Test/obj/
             _ReSharper.Implab/
             Implab.Diagnostics.Interactive/bin/
             Implab.Diagnostics.Interactive/obj/
             MonoPlay/bin/
             MonoPlay/obj/
             Implab.Test/Implab.Format.Test/bin/
             Implab.Test/Implab.Format.Test/obj/
+            *.suo

Implab.Test/Implab.Test.csproj +2 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{63F92C0C-61BF-48C0-A377-8D67C3C661D0}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <AppDesignerFolder>Properties</AppDesignerFolder>
                 <RootNamespace>Implab.Test</RootNamespace>
                 <AssemblyName>Implab.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <FileAlignment>512</FileAlignment>
                 <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
                 <TargetFrameworkProfile />
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug\</OutputPath>
                 <DefineConstants>DEBUG;TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>pdbonly</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release\</OutputPath>
                 <DefineConstants>TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug\</OutputPath>
                 <DefineConstants>DEBUG;TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <DebugType>pdbonly</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release\</OutputPath>
                 <DefineConstants>TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
                 <Reference Include="System" />
                 <Reference Include="System.Core">
                   <RequiredTargetFramework>3.5</RequiredTargetFramework>
                 </Reference>
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="AsyncTests.cs" />
+                <Compile Include="CancelationTests.cs" />
                 <Compile Include="PromiseHelper.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
+                <Compile Include="RunnableComponentTests.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
                    Other similar extension points exist, see Microsoft.Common.targets.
               <Target Name="BeforeBuild">
               </Target>
               <Target Name="AfterBuild">
               </Target>
               -->
             </Project>

Implab.Test/RunnableComponentTests.cs +7 -6

             using System;
             using System.Reflection;
             using System.Threading;
             using Implab.Parallels;
             using Implab.Components;
             #if MONO
             using NUnit.Framework;
             using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
             using TestMethodAttribute = NUnit.Framework.TestAttribute;
+            using AssertFailedException = NUnit.Framework.AssertionException;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class RunnableComponentTests {
                     static void ShouldThrow(Action action) {
                         try {
                             action();
                             Assert.Fail();
-                        } catch(AssertionException) {
+                        } catch (AssertFailedException) {
                             throw;
                         } catch {
                         }
                     }
                     class Runnable : RunnableComponent {
                         public Runnable(bool initialized) : base(initialized) {
                         }
                         public Action MockInit {
                             get;
                             set;
                         }
                         public Func<IPromise> MockStart {
                             get;
                             set;
                         }
                         public Func<IPromise> MockStop {
                             get;
                             set;
                         }
                         protected override IPromise OnStart() {
                             return MockStart != null ? MockStart() : base.OnStart();
                         }
                         protected override IPromise OnStop() {
                             return MockStop != null ? MockStop() : base.OnStart();
                         }
                         protected override void OnInitialize() {
                             if (MockInit != null)
                                 MockInit();
                         }
                     }
                     [TestMethod]
                     public void NormalFlowTest() {
                         var comp = new Runnable(false);
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         comp.Init();
                         Assert.AreEqual(ExecutionState.Ready, comp.State);
                         comp.Start().Join(1000);
                         Assert.AreEqual(ExecutionState.Running, comp.State);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void InitFailTest() {
                         var comp = new Runnable(false) {
                             MockInit = () => {
                                 throw new Exception("BAD");
                             }
                         };
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         comp.Dispose();
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void DisposedTest() {
                         var comp = new Runnable(false);
                         comp.Dispose();
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartCancelTest() {
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0)
                         };
                         var p = comp.Start();
                         Assert.AreEqual(ExecutionState.Starting, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
-                        Assert.IsInstanceOfType(typeof(OperationCanceledException), comp.LastError);
+                        Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
                         comp.Dispose();
                     }
                     [TestMethod]
                     public void StartStopTest() {
                         var stop = new Signal();
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0),
                             MockStop = () => AsyncPool.RunThread(stop.Wait)
                         };
                         var p1 = comp.Start();
                         var p2 = comp.Stop();
                         // should enter stopping state
                         ShouldThrow(p1.Join);
                         Assert.IsTrue(p1.IsCancelled);
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         stop.Set();
                         p2.Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartStopFailTest() {
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
                         };
                         comp.Start();
                         var p = comp.Stop();
                         // if Start fails to cancel, should fail to stop
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsNotNull(comp.LastError);
                         Assert.AreEqual("I'm dead", comp.LastError.Message);
                     }
                     [TestMethod]
                     public void StopCancelTest() {
                         var comp = new Runnable(true) {
                             MockStop = () => PromiseHelper.Sleep(100000, 0)
                         };
                         comp.Start();
                         var p = comp.Stop();
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
-                        Assert.IsInstanceOfType(typeof(OperationCanceledException), comp.LastError);
+                        Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
                         comp.Dispose();
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages