Free cookie consent management tool by TermsFeed Policy Generator

Changeset 9777


Ignore:
Timestamp:
07/26/13 13:25:19 (11 years ago)
Author:
abeham
Message:

#2088: Added test attributes and cleaned up tests of the encodings

Location:
trunk/sources/HeuristicLab.Tests
Files:
51 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/Auxiliary.cs

    r9764 r9777  
    2020#endregion
    2121
    22 
    2322namespace HeuristicLab.Encodings.BinaryVectorEncoding.Tests {
    2423  public static class Auxiliary {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs

    r9765 r9777  
    2626
    2727namespace HeuristicLab.Encodings.BinaryVectorEncoding.Tests {
    28 
    29 
    3028  /// <summary>
    3129  ///This is a test class for SinglePointCrossoverTest and is intended
    … …  
    3432  [TestClass()]
    3533  public class NPointCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8334    /// <summary>
    8435    ///A test for Cross
    8536    ///</summary>
    8637    [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.BinaryVectorEncoding-3.3.dll")]
     38    [TestCategory("Encodings.BinaryVector")]
     39    [TestProperty("Time", "short")]
    8840    public void NPointCrossoverCrossTest() {
    8941      NPointCrossover_Accessor target = new NPointCrossover_Accessor(new PrivateObject(typeof(NPointCrossover)));
    … …  
    11971    ///</summary>
    12072    [TestMethod]
     73    [TestCategory("Encodings.BinaryVector")]
     74    [TestProperty("Time", "short")]
    12175    public void NPointCrossoverApplyTest() {
    12276      TestRandom random = new TestRandom();
    … …  
    167121      Assert.IsTrue(exceptionFired);
    168122    }
    169 
    170     /// <summary>
    171     ///A test for SinglePointCrossover Constructor
    172     ///</summary>
    173     [TestMethod]
    174     public void NPointCrossoverConstructorTest() {
    175       NPointCrossover target = new NPointCrossover();
    176     }
    177123  }
    178124}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r9765 r9777  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.BinaryVectorEncoding;
    2424using HeuristicLab.Tests;
    2525using Microsoft.VisualStudio.TestTools.UnitTesting;
    2626
    2727namespace HeuristicLab.Encodings.BinaryVectorEncoding.Tests {
    28 
    29 
    3028  /// <summary>
    3129  ///This is a test class for SinglePointCrossoverTest and is intended
    … …  
    3432  [TestClass()]
    3533  public class SinglePointCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8334    /// <summary>
    8435    ///A test for Cross
    8536    ///</summary>
    8637    [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.BinaryVectorEncoding-3.3.dll")]
     38    [TestCategory("Encodings.BinaryVector")]
     39    [TestProperty("Time", "short")]
    8840    public void SinglePointCrossoverCrossTest() {
    8941      SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
    … …  
    9850        BinaryVector actual;
    9951        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     52      } catch (ArgumentException) {
    10253        exceptionFired = true;
    10354      }
    … …  
    11061        BinaryVector actual;
    11162        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     63      } catch (ArgumentException) {
    11464        exceptionFired = true;
    11565      }
    11666      Assert.IsTrue(exceptionFired);
    11767    }
    118 
    119     /// <summary>
    120     ///A test for SinglePointCrossover Constructor
    121     ///</summary>
    122     [TestMethod]
    123     public void SinglePointCrossoverConstructorTest() {
    124       SinglePointCrossover target = new SinglePointCrossover();
    125     }
    12668  }
    12769}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/SinglePositionBitflipManipulatorTest.cs

    r9765 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.BinaryVectorEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class SinglePositionBitflipManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.BinaryVector")]
     37    [TestProperty("Time", "short")]
    8538    public void SinglePositionBitflipManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();
    … …  
    9649      Assert.IsTrue(Auxiliary.BinaryVectorIsEqualByPosition(expected, parent));
    9750    }
    98 
    99     /// <summary>
    100     ///A test for SinglePositionBitflipManipulator Constructor
    101     ///</summary>
    102     [TestMethod]
    103     public void SinglePositionBitflipManipulatorConstructorTest() {
    104       SinglePositionBitflipManipulator target = new SinglePositionBitflipManipulator();
    105     }
    10651  }
    10752}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/SomePositionsBitflipManipulatorTest.cs

    r9765 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.BinaryVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class SomePositionsBitflipManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    8536    [TestMethod]
     37    [TestCategory("Encodings.BinaryVector")]
     38    [TestProperty("Time", "short")]
    8639    public void SomePositionsBitflipManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    9750      Assert.IsTrue(Auxiliary.BinaryVectorIsEqualByPosition(expected, parent));
    9851    }
    99 
    100     /// <summary>
    101     ///A test for SomePositionsBitflipManipulator Constructor
    102     ///</summary>
    103     [TestMethod]
    104     public void SomePositionsBitflipManipulatorConstructorTest() {
    105       SomePositionsBitflipManipulator target = new SomePositionsBitflipManipulator();
    106     }
    10752  }
    10853}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs

    r9765 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.BinaryVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.BinaryVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for SinglePointCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class UniformCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    8636    [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.BinaryVectorEncoding-3.3.dll")]
     37    [TestCategory("Encodings.BinaryVector")]
     38    [TestProperty("Time", "short")]
    8839    public void SinglePointCrossoverCrossTest() {
    8940      UniformCrossover_Accessor target = new UniformCrossover_Accessor(new PrivateObject(typeof(UniformCrossover)));
    … …  
    9849        BinaryVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        BinaryVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12170    ///</summary>
    12271    [TestMethod]
     72    [TestCategory("Encodings.BinaryVector")]
     73    [TestProperty("Time", "short")]
    12374    public void SinglePointCrossoverApplyTest() {
    12475      TestRandom random = new TestRandom();
    … …  
    151102      try {
    152103        actual = UniformCrossover.Apply(random, parent1, parent2);
    153       }
    154       catch (System.ArgumentException) {
     104      } catch (System.ArgumentException) {
    155105        exceptionFired = true;
    156106      }
    157107      Assert.IsTrue(exceptionFired);
    158108    }
    159 
    160     /// <summary>
    161     ///A test for SinglePointCrossover Constructor
    162     ///</summary>
    163     [TestMethod]
    164     public void SinglePointCrossoverConstructorTest() {
    165       NPointCrossover target = new NPointCrossover();
    166     }
    167109  }
    168110}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/Auxiliary.cs

    r9764 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.IntegerVectorEncoding;
    23 
    2422namespace HeuristicLab.Encodings.IntegerVectorEncoding.Tests {
    2523  public static class Auxiliary {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r9766 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.IntegerVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.IntegerVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for DiscreteCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class DiscreteCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    8636    [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll")]
     37    [TestCategory("Encodings.IntegerVector")]
     38    [TestProperty("Time", "short")]
    8839    public void DiscreteCrossoverCrossTest() {
    8940      DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
    … …  
    9849        IntegerVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    10959    ///</summary>
    11060    [TestMethod]
     61    [TestCategory("Encodings.IntegerVector")]
     62    [TestProperty("Time", "short")]
    11163    public void DiscreteCrossoverApplyTest() {
    11264      TestRandom random = new TestRandom();
    … …  
    13082      try {
    13183        actual = DiscreteCrossover.Apply(random, new ItemArray<IntegerVector>(new IntegerVector[] { parent1, parent2 }));
    132       }
    133       catch (System.ArgumentException) {
     84      } catch (System.ArgumentException) {
    13485        exceptionFired = true;
    13586      }
    13687      Assert.IsTrue(exceptionFired);
    13788    }
    138 
    139     /// <summary>
    140     ///A test for DiscreteCrossover Constructor
    141     ///</summary>
    142     [TestMethod]
    143     public void DiscreteCrossoverConstructorTest() {
    144       DiscreteCrossover target = new DiscreteCrossover();
    145     }
    14689  }
    14790}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r9766 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.IntegerVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.IntegerVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for SinglePointCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class SinglePointCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    8636    [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll")]
     37    [TestCategory("Encodings.IntegerVector")]
     38    [TestProperty("Time", "short")]
    8839    public void SinglePointCrossoverCrossTest() {
    8940      SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
    … …  
    9849        IntegerVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        IntegerVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12170    ///</summary>
    12271    [TestMethod]
     72    [TestCategory("Encodings.IntegerVector")]
     73    [TestProperty("Time", "short")]
    12374    public void SinglePointCrossoverApplyTest() {
    12475      TestRandom random = new TestRandom();
    … …  
    14192      try {
    14293        actual = SinglePointCrossover.Apply(random, parent1, parent2);
    143       }
    144       catch (System.ArgumentException) {
     94      } catch (System.ArgumentException) {
    14595        exceptionFired = true;
    14696      }
    14797      Assert.IsTrue(exceptionFired);
    14898    }
    149 
    150     /// <summary>
    151     ///A test for SinglePointCrossover Constructor
    152     ///</summary>
    153     [TestMethod]
    154     public void SinglePointCrossoverConstructorTest() {
    155       SinglePointCrossover target = new SinglePointCrossover();
    156     }
    15799  }
    158100}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/UniformOnePositionManipulatorTest.cs

    r9766 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.IntegerVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class UniformOnePositionManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.IntegerVector")]
     38    [TestProperty("Time", "short")]
    8639    public void UniformOnePositionManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    9851      Assert.IsTrue(Auxiliary.IntegerVectorIsEqualByPosition(expected, parent));
    9952    }
    100 
    101     /// <summary>
    102     ///A test for UniformOnePositionManipulator Constructor
    103     ///</summary>
    104     [TestMethod]
    105     public void UniformOnePositionManipulatorConstructorTest() {
    106       UniformOnePositionManipulator target = new UniformOnePositionManipulator();
    107     }
    10853  }
    10954}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/Auxiliary.cs

    r9764 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    23 
    2422namespace HeuristicLab.Encodings.PermutationEncoding.Tests {
    2523  public static class Auxiliary {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class CosaCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void CosaCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void CosaCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    151104      try {
    152105        CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    153       }
    154       catch (System.ArgumentException) {
     106      } catch (System.ArgumentException) {
    155107        exceptionFired = true;
    156108      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class CyclicCrossover2Test {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void CyclicCrossover2CrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9446        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9547          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    96       }
    97       catch (System.InvalidOperationException) {
     48      } catch (System.InvalidOperationException) {
    9849        exceptionFired = true;
    9950      }
    … …  
    10556    ///</summary>
    10657    [TestMethod]
     58    [TestCategory("Encodings.Permutation")]
     59    [TestProperty("Time", "short")]
    10760    public void CyclicCrossover2ApplyTest() {
    10861      TestRandom random = new TestRandom();
    … …  
    12679      try {
    12780        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    128       }
    129       catch (System.ArgumentException) {
     81      } catch (System.ArgumentException) {
    13082        exceptionFired = true;
    13183      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class CyclicCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void CyclicCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void CyclicCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    12780      try {
    12881        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    129       }
    130       catch (System.ArgumentException) {
     82      } catch (System.ArgumentException) {
    13183        exceptionFired = true;
    13284      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class EdgeRecombinationCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void EdgeRecombinationCrossoverCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void EdgeRecombinationCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    12881      try {
    12982        EdgeRecombinationCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    130       }
    131       catch (System.ArgumentException) {
     83      } catch (System.ArgumentException) {
    13284        exceptionFired = true;
    13385      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/InsertionManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class InsertionManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void InsertionManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/InversionManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class InversionManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void InversionManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class MaximalPreservativeCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void MaximalPreservativeCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void MaximalPreservativeCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    12780      try {
    12881        MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    129       }
    130       catch (System.ArgumentException) {
     82      } catch (System.ArgumentException) {
    13183        exceptionFired = true;
    13284      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class OrderBasedCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void OrderBasedCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void OrderBasedCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    12578      try {
    12679        OrderBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    127       }
    128       catch (System.ArgumentException) {
     80      } catch (System.ArgumentException) {
    12981        exceptionFired = true;
    13082      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class OrderCrossover2Test {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void OrderCrossover2CrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9345        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9446          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    95       }
    96       catch (System.InvalidOperationException) {
     47      } catch (System.InvalidOperationException) {
    9748        exceptionFired = true;
    9849      }
    … …  
    10455    ///</summary>
    10556    [TestMethod]
     57    [TestCategory("Encodings.Permutation")]
     58    [TestProperty("Time", "short")]
    10659    public void OrderCrossover2ApplyTest() {
    10760      TestRandom random = new TestRandom();
    … …  
    12578      try {
    12679        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    127       }
    128       catch (System.ArgumentException) {
     80      } catch (System.ArgumentException) {
    12981        exceptionFired = true;
    13082      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class OrderCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void OrderCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void OrderCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    178131      try {
    179132        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    180       }
    181       catch (System.ArgumentException) {
     133      } catch (System.ArgumentException) {
    182134        exceptionFired = true;
    183135      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class PartiallyMatchedCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void PartiallyMatchedCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9547        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9648          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    97       }
    98       catch (System.InvalidOperationException) {
     49      } catch (System.InvalidOperationException) {
    9950        exceptionFired = true;
    10051      }
    … …  
    10657    ///</summary>
    10758    [TestMethod]
     59    [TestCategory("Encodings.Permutation")]
     60    [TestProperty("Time", "short")]
    10861    public void PartiallyMatchedCrossoverApplyTest() {
    10962      TestRandom random = new TestRandom();
    … …  
    13992      try {
    14093        PartiallyMatchedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    141       }
    142       catch (System.ArgumentException) {
     94      } catch (System.ArgumentException) {
    14395        exceptionFired = true;
    14496      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PermutationEqualityComparerTest.cs

    r9764 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using Microsoft.VisualStudio.TestTools.UnitTesting;
    2423
    … …  
    2726  public class PermutationEqualityComparerTest {
    2827    [TestMethod]
     28    [TestCategory("Encodings.Permutation")]
     29    [TestProperty("Time", "short")]
    2930    public void TestPermutationEqualityComparer() {
    3031      PermutationEqualityComparer comparer = new PermutationEqualityComparer();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class PositionBasedCrossoverTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Cross
    8435    ///</summary>
    8536    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8739    public void PositionBasedCrossoverCrossTest() {
    8840      TestRandom random = new TestRandom();
    … …  
    9648        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    9749          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
    98       }
    99       catch (System.InvalidOperationException) {
     50      } catch (System.InvalidOperationException) {
    10051        exceptionFired = true;
    10152      }
    … …  
    10758    ///</summary>
    10859    [TestMethod]
    109     [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
     60    [TestCategory("Encodings.Permutation")]
     61    [TestProperty("Time", "short")]
    11062    public void PositionBasedCrossoverApplyTest() {
    11163      TestRandom random = new TestRandom();
    … …  
    13183      try {
    13284        PositionBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    133       }
    134       catch (System.ArgumentException) {
     85      } catch (System.ArgumentException) {
    13586        exceptionFired = true;
    13687      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/ScrambleManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class ScrambleManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void ScrambleManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/Swap2ManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class Swap2ManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void Swap2ManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/Swap3ManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class Swap3ManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void Swap3ManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/TranslocationInversionManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class TranslocationInversionManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void TranslocationInversionManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/TranslocationManipulatorTest.cs

    r9767 r9777  
    2020#endregion
    2121
    22 using HeuristicLab.Encodings.PermutationEncoding;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3130  [TestClass()]
    3231  public class TranslocationManipulatorTest {
    33 
    34 
    35     private TestContext testContextInstance;
    36 
    37     /// <summary>
    38     ///Gets or sets the test context which provides
    39     ///information about and functionality for the current test run.
    40     ///</summary>
    41     public TestContext TestContext {
    42       get {
    43         return testContextInstance;
    44       }
    45       set {
    46         testContextInstance = value;
    47       }
    48     }
    49 
    50     #region Additional test attributes
    51     //
    52     //You can use the following additional attributes as you write your tests:
    53     //
    54     //Use ClassInitialize to run code before running the first test in the class
    55     //[ClassInitialize()]
    56     //public static void MyClassInitialize(TestContext testContext)
    57     //{
    58     //}
    59     //
    60     //Use ClassCleanup to run code after all tests in a class have run
    61     //[ClassCleanup()]
    62     //public static void MyClassCleanup()
    63     //{
    64     //}
    65     //
    66     //Use TestInitialize to run code before running each test
    67     //[TestInitialize()]
    68     //public void MyTestInitialize()
    69     //{
    70     //}
    71     //
    72     //Use TestCleanup to run code after each test has run
    73     //[TestCleanup()]
    74     //public void MyTestCleanup()
    75     //{
    76     //}
    77     //
    78     #endregion
    79 
    80 
    8132    /// <summary>
    8233    ///A test for Apply
    8334    ///</summary>
    8435    [TestMethod]
     36    [TestCategory("Encodings.Permutation")]
     37    [TestProperty("Time", "short")]
    8538    public void TranslocationManipulatorApplyTest() {
    8639      TestRandom random = new TestRandom();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs

    r9767 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.PermutationEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.PermutationEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for UniformLikeCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class UniformLikeCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    83 
    8433    /// <summary>
    8534    ///A test for Apply
    8635    ///</summary>
    8736    [TestMethod]
     37    [TestCategory("Encodings.Permutation")]
     38    [TestProperty("Time", "short")]
    8839    public void UniformLikeCrossoverApplyTest() {
    8940      // test from the paper
    … …  
    10859    ///</summary>
    10960    [TestMethod]
     61    [TestCategory("Encodings.Permutation")]
     62    [TestProperty("Time", "short")]
    11063    [DeploymentItem("HeuristicLab.Encodings.PermutationEncoding-3.3.dll")]
    11164    public void UniformLikeCrossoverCrossTest() {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/Auxiliary.cs

    r9764 r9777  
    2121
    2222using HeuristicLab.Common;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423
    2524namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs

    r9768 r9777  
    2626
    2727namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3028  /// <summary>
    3129  ///This is a test class for BlendAlphaBetaCrossoverTest and is intended
    … …  
    3432  [TestClass()]
    3533  public class BlendAlphaBetaCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8334    /// <summary>
    8435    ///A test for Cross
    8536    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     37    [TestMethod()]
     38    [TestCategory("Encodings.RealVector")]
     39    [TestProperty("Time", "short")]
    8840    public void BlendAlphaBetaCrossoverCrossTest() {
    8941      BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaBetaCrossover)));
    … …  
    11870    ///A test for Apply
    11971    ///</summary>
    120     [TestMethod]
     72    [TestMethod()]
     73    [TestCategory("Encodings.RealVector")]
     74    [TestProperty("Time", "short")]
    12175    public void BlendAlphaBetaCrossoverApplyTest() {
    12276      TestRandom random = new TestRandom();
    … …  
    162116      Assert.IsTrue(exceptionFired);
    163117    }
    164 
    165     /// <summary>
    166     ///A test for BlendAlphaBetaCrossover Constructor
    167     ///</summary>
    168     [TestMethod]
    169     public void BlendAlphaBetaCrossoverConstructorTest() {
    170       BlendAlphaBetaCrossover target = new BlendAlphaBetaCrossover();
    171     }
    172118  }
    173119}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs

    r9768 r9777  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.Data;
    24 using HeuristicLab.Encodings.RealVectorEncoding;
    2524using HeuristicLab.Tests;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
    2726
    2827namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    29 
    30 
    3128  /// <summary>
    3229  ///This is a test class for BlendAlphaCrossoverTest and is intended
    … …  
    3532  [TestClass()]
    3633  public class BlendAlphaCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    8434    /// <summary>
    8535    ///A test for Cross
    8636    ///</summary>
    87     [TestMethod]
    88     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     37    [TestMethod()]
     38    [TestCategory("Encodings.RealVector")]
     39    [TestProperty("Time", "short")]
    8940    public void BlendAlphaCrossoverCrossTest() {
    9041      BlendAlphaCrossover_Accessor target = new BlendAlphaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaCrossover)));
    … …  
    9950        RealVector actual;
    10051        actual = target.Cross(random, parents);
    101       }
    102       catch (System.ArgumentException) {
     52      } catch (System.ArgumentException) {
    10353        exceptionFired = true;
    10454      }
    … …  
    11161        RealVector actual;
    11262        actual = target.Cross(random, parents);
    113       }
    114       catch (System.ArgumentException) {
     63      } catch (System.ArgumentException) {
    11564        exceptionFired = true;
    11665      }
    … …  
    12170    ///A test for Apply
    12271    ///</summary>
    123     [TestMethod]
     72    [TestMethod()]
     73    [TestCategory("Encodings.RealVector")]
     74    [TestProperty("Time", "short")]
    12475    public void BlendAlphaCrossoverApplyTest() {
    12576      TestRandom random = new TestRandom();
    … …  
    155106      try {
    156107        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
    157       }
    158       catch (System.ArgumentException) {
     108      } catch (System.ArgumentException) {
    159109        exceptionFired = true;
    160110      }
    … …  
    170120      try {
    171121        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
    172       }
    173       catch (System.ArgumentException) {
     122      } catch (System.ArgumentException) {
    174123        exceptionFired = true;
    175124      }
    176125      Assert.IsTrue(exceptionFired);
    177126    }
    178 
    179     /// <summary>
    180     ///A test for BlendAlphaCrossover Constructor
    181     ///</summary>
    182     [TestMethod]
    183     public void BlendAlphaCrossoverConstructorTest() {
    184       BlendAlphaCrossover target = new BlendAlphaCrossover();
    185     }
    186127  }
    187128}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for DiscreteCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class DiscreteCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8839    public void DiscreteCrossoverCrossTest() {
    8940      DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
    … …  
    9849        RealVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    10858    ///A test for Apply
    10959    ///</summary>
    110     [TestMethod]
     60    [TestMethod()]
     61    [TestCategory("Encodings.RealVector")]
     62    [TestProperty("Time", "short")]
    11163    public void DiscreteCrossoverApplyTest() {
    11264      TestRandom random = new TestRandom();
    … …  
    13284      try {
    13385        actual = DiscreteCrossover.Apply(random, parents);
    134       }
    135       catch (System.ArgumentException) {
     86      } catch (System.ArgumentException) {
    13687        exceptionFired = true;
    13788      }
    13889      Assert.IsTrue(exceptionFired);
    13990    }
    140 
    141     /// <summary>
    142     ///A test for DiscreteCrossover Constructor
    143     ///</summary>
    144     [TestMethod]
    145     public void DiscreteCrossoverConstructorTest() {
    146       DiscreteCrossover target = new DiscreteCrossover();
    147     }
    14891  }
    14992}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for HeuristicCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class HeuristicCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8839    public void HeuristicCrossoverCrossTest() {
    8940      HeuristicCrossover_Accessor target = new HeuristicCrossover_Accessor(new PrivateObject(typeof(HeuristicCrossover)));
    … …  
    9849        RealVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        RealVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12069    ///A test for Apply
    12170    ///</summary>
    122     [TestMethod]
     71    [TestMethod()]
     72    [TestCategory("Encodings.RealVector")]
     73    [TestProperty("Time", "short")]
    12374    public void HeuristicCrossoverApplyTest() {
    12475      TestRandom random = new TestRandom();
    … …  
    14192      try {
    14293        actual = HeuristicCrossover.Apply(random, parent1, parent2);
    143       }
    144       catch (System.ArgumentException) {
     94      } catch (System.ArgumentException) {
    14595        exceptionFired = true;
    14696      }
    14797      Assert.IsTrue(exceptionFired);
    14898    }
    149 
    150     /// <summary>
    151     ///A test for HeuristicCrossover Constructor
    152     ///</summary>
    153     [TestMethod]
    154     public void HeuristicCrossoverConstructorTest() {
    155       HeuristicCrossover target = new HeuristicCrossover();
    156     }
    15799  }
    158100}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for LocalCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class LocalCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8839    public void LocalCrossoverCrossTest() {
    8940      LocalCrossover_Accessor target = new LocalCrossover_Accessor(new PrivateObject(typeof(LocalCrossover)));
    … …  
    9849        RealVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        RealVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12069    ///A test for Apply
    12170    ///</summary>
    122     [TestMethod]
     71    [TestMethod()]
     72    [TestCategory("Encodings.RealVector")]
     73    [TestProperty("Time", "short")]
    12374    public void LocalCrossoverApplyTest() {
    12475      TestRandom random = new TestRandom();
    … …  
    14192      try {
    14293        actual = LocalCrossover.Apply(random, parent1, parent2);
    143       }
    144       catch (System.ArgumentException) {
     94      } catch (System.ArgumentException) {
    14595        exceptionFired = true;
    14696      }
    14797      Assert.IsTrue(exceptionFired);
    14898    }
    149 
    150     /// <summary>
    151     ///A test for LocalCrossover Constructor
    152     ///</summary>
    153     [TestMethod]
    154     public void LocalCrossoverConstructorTest() {
    155       LocalCrossover target = new LocalCrossover();
    156     }
    15799  }
    158100}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/MichalewiczNonUniformAllPositionsManipulatorTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class MichalewiczNonUniformAllPositionsManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8639    public void MichalewiczNonUniformAllPositionsManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    11366      try {
    11467        MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, bounds, currentGeneration, maximumGenerations, generationsDependency);
    115       }
    116       catch (System.ArgumentException) {
     68      } catch (System.ArgumentException) {
    11769        exceptionFired = true;
    11870      }
    11971      Assert.IsTrue(exceptionFired);
    12072    }
    121 
    122     /// <summary>
    123     ///A test for MichalewiczNonUniformAllPositionsManipulator Constructor
    124     ///</summary>
    125     [TestMethod]
    126     public void MichalewiczNonUniformAllPositionsManipulatorConstructorTest() {
    127       MichalewiczNonUniformAllPositionsManipulator target = new MichalewiczNonUniformAllPositionsManipulator();
    128     }
    12973  }
    13074}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/MichalewiczNonUniformOnePositionManipulatorTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class MichalewiczNonUniformOnePositionManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8639    public void MichalewiczNonUniformOnePositionManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    11568      try {
    11669        MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, bounds, currentGeneration, maximumGenerations, generationsDependency);
    117       }
    118       catch (System.ArgumentException) {
     70      } catch (System.ArgumentException) {
    11971        exceptionFired = true;
    12072      }
    12173      Assert.IsTrue(exceptionFired);
    12274    }
    123 
    124     /// <summary>
    125     ///A test for MichalewiczNonUniformOnePositionManipulator Constructor
    126     ///</summary>
    127     [TestMethod]
    128     public void MichalewiczNonUniformOnePositionManipulatorConstructorTest() {
    129       MichalewiczNonUniformOnePositionManipulator target = new MichalewiczNonUniformOnePositionManipulator();
    130     }
    13175  }
    13276}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/PolynomialAllPositionManipulatorTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class PolynomialAllPositionManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8639    public void PolynomialAllPositionManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    11265      Assert.IsTrue(exceptionFired);
    11366    }
    114 
    115     /// <summary>
    116     ///A test for PolynomialAllPositionManipulator Constructor
    117     ///</summary>
    118     [TestMethod]
    119     public void PolynomialAllPositionManipulatorConstructorTest() {
    120       PolynomialAllPositionManipulator target = new PolynomialAllPositionManipulator();
    121     }
    12267  }
    12368}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/PolynomialOnePositionManipulatorTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class PolynomialOnePositionManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8639    public void PolynomialOnePositionManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    10962      try {
    11063        PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
    111       }
    112       catch (System.ArgumentException) {
     64      } catch (System.ArgumentException) {
    11365        exceptionFired = true;
    11466      }
    11567      Assert.IsTrue(exceptionFired);
    11668    }
    117 
    118     /// <summary>
    119     ///A test for PolynomialOnePositionManipulator Constructor
    120     ///</summary>
    121     [TestMethod]
    122     public void PolynomialOnePositionManipulatorConstructorTest() {
    123       PolynomialOnePositionManipulator target = new PolynomialOnePositionManipulator();
    124     }
    12569  }
    12670}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for RandomConvexCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class RandomConvexCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8839    public void RandomConvexCrossoverCrossTest() {
    8940      RandomConvexCrossover_Accessor target = new RandomConvexCrossover_Accessor(new PrivateObject(typeof(RandomConvexCrossover)));
    … …  
    9849        RealVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        RealVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12069    ///A test for Apply
    12170    ///</summary>
    122     [TestMethod]
     71    [TestMethod()]
     72    [TestCategory("Encodings.RealVector")]
     73    [TestProperty("Time", "short")]
    12374    public void RandomConvexCrossoverApplyTest() {
    12475      TestRandom random = new TestRandom();
    … …  
    14192      try {
    14293        actual = RandomConvexCrossover.Apply(random, parent1, parent2);
    143       }
    144       catch (System.ArgumentException) {
     94      } catch (System.ArgumentException) {
    14595        exceptionFired = true;
    14696      }
    14797      Assert.IsTrue(exceptionFired);
    14898    }
    149 
    150     /// <summary>
    151     ///A test for RandomConvexCrossover Constructor
    152     ///</summary>
    153     [TestMethod]
    154     public void RandomConvexCrossoverConstructorTest() {
    155       RandomConvexCrossover target = new RandomConvexCrossover();
    156     }
    15799  }
    158100}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs

    r9768 r9777  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.Data;
    24 using HeuristicLab.Encodings.RealVectorEncoding;
    2524using HeuristicLab.Tests;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
    2726
    2827namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    29 
    30 
    3128  /// <summary>
    3229  ///This is a test class for SimulatedBinaryCrossoverTest and is intended
    … …  
    3532  [TestClass()]
    3633  public class SimulatedBinaryCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    8434    /// <summary>
    8535    ///A test for Cross
    8636    ///</summary>
    87     [TestMethod]
    88     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     37    [TestMethod()]
     38    [TestCategory("Encodings.RealVector")]
     39    [TestProperty("Time", "short")]
    8940    public void SimulatedBinaryCrossoverCrossTest() {
    9041      SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(new PrivateObject(typeof(SimulatedBinaryCrossover)));
    … …  
    11970    ///A test for Apply
    12071    ///</summary>
    121     [TestMethod]
     72    [TestMethod()]
     73    [TestCategory("Encodings.RealVector")]
     74    [TestProperty("Time", "short")]
    12275    public void SimulatedBinaryCrossoverApplyTest() {
    12376      TestRandom random = new TestRandom();
    … …  
    161114      Assert.IsTrue(exceptionFired);
    162115    }
    163 
    164     /// <summary>
    165     ///A test for SimulatedBinaryCrossover Constructor
    166     ///</summary>
    167     [TestMethod]
    168     public void SimulatedBinaryCrossoverConstructorTest() {
    169       SimulatedBinaryCrossover target = new SimulatedBinaryCrossover();
    170     }
    171116  }
    172117}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    28 
    29 
    3027  /// <summary>
    3128  ///This is a test class for SinglePointCrossoverTest and is intended
    … …  
    3431  [TestClass()]
    3532  public class SinglePointCrossoverTest {
    36 
    37 
    38     private TestContext testContextInstance;
    39 
    40     /// <summary>
    41     ///Gets or sets the test context which provides
    42     ///information about and functionality for the current test run.
    43     ///</summary>
    44     public TestContext TestContext {
    45       get {
    46         return testContextInstance;
    47       }
    48       set {
    49         testContextInstance = value;
    50       }
    51     }
    52 
    53     #region Additional test attributes
    54     //
    55     //You can use the following additional attributes as you write your tests:
    56     //
    57     //Use ClassInitialize to run code before running the first test in the class
    58     //[ClassInitialize()]
    59     //public static void MyClassInitialize(TestContext testContext)
    60     //{
    61     //}
    62     //
    63     //Use ClassCleanup to run code after all tests in a class have run
    64     //[ClassCleanup()]
    65     //public static void MyClassCleanup()
    66     //{
    67     //}
    68     //
    69     //Use TestInitialize to run code before running each test
    70     //[TestInitialize()]
    71     //public void MyTestInitialize()
    72     //{
    73     //}
    74     //
    75     //Use TestCleanup to run code after each test has run
    76     //[TestCleanup()]
    77     //public void MyTestCleanup()
    78     //{
    79     //}
    80     //
    81     #endregion
    82 
    8333    /// <summary>
    8434    ///A test for Cross
    8535    ///</summary>
    86     [TestMethod]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8839    public void SinglePointCrossoverCrossTest() {
    8940      SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
    … …  
    9849        RealVector actual;
    9950        actual = target.Cross(random, parents);
    100       }
    101       catch (System.ArgumentException) {
     51      } catch (System.ArgumentException) {
    10252        exceptionFired = true;
    10353      }
    … …  
    11060        RealVector actual;
    11161        actual = target.Cross(random, parents);
    112       }
    113       catch (System.ArgumentException) {
     62      } catch (System.ArgumentException) {
    11463        exceptionFired = true;
    11564      }
    … …  
    12271        RealVector actual;
    12372        actual = target.Cross(random, parents);
    124       }
    125       catch (System.ArgumentException) {
     73      } catch (System.ArgumentException) {
    12674        exceptionFired = true;
    12775      }
    … …  
    13280    ///A test for Apply
    13381    ///</summary>
    134     [TestMethod]
     82    [TestMethod()]
     83    [TestCategory("Encodings.RealVector")]
     84    [TestProperty("Time", "short")]
    13585    public void SinglePointCrossoverApplyTest() {
    13686      TestRandom random = new TestRandom();
    … …  
    153103      try {
    154104        actual = SinglePointCrossover.Apply(random, parent1, parent2);
    155       }
    156       catch (System.ArgumentException) {
     105      } catch (System.ArgumentException) {
    157106        exceptionFired = true;
    158107      }
    … …  
    168117      // The following test is not based on published examples
    169118    }
    170 
    171     /// <summary>
    172     ///A test for SinglePointCrossover Constructor
    173     ///</summary>
    174     [TestMethod]
    175     public void SinglePointCrossoverConstructorTest() {
    176       SinglePointCrossover target = new SinglePointCrossover();
    177     }
    178119  }
    179120}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/UniformOnePositionManipulatorTest.cs

    r9768 r9777  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    3231  [TestClass()]
    3332  public class UniformOnePositionManipulatorTest {
    34 
    35 
    36     private TestContext testContextInstance;
    37 
    38     /// <summary>
    39     ///Gets or sets the test context which provides
    40     ///information about and functionality for the current test run.
    41     ///</summary>
    42     public TestContext TestContext {
    43       get {
    44         return testContextInstance;
    45       }
    46       set {
    47         testContextInstance = value;
    48       }
    49     }
    50 
    51     #region Additional test attributes
    52     //
    53     //You can use the following additional attributes as you write your tests:
    54     //
    55     //Use ClassInitialize to run code before running the first test in the class
    56     //[ClassInitialize()]
    57     //public static void MyClassInitialize(TestContext testContext)
    58     //{
    59     //}
    60     //
    61     //Use ClassCleanup to run code after all tests in a class have run
    62     //[ClassCleanup()]
    63     //public static void MyClassCleanup()
    64     //{
    65     //}
    66     //
    67     //Use TestInitialize to run code before running each test
    68     //[TestInitialize()]
    69     //public void MyTestInitialize()
    70     //{
    71     //}
    72     //
    73     //Use TestCleanup to run code after each test has run
    74     //[TestCleanup()]
    75     //public void MyTestCleanup()
    76     //{
    77     //}
    78     //
    79     #endregion
    80 
    81 
    8233    /// <summary>
    8334    ///A test for Apply
    8435    ///</summary>
    85     [TestMethod]
     36    [TestMethod()]
     37    [TestCategory("Encodings.RealVector")]
     38    [TestProperty("Time", "short")]
    8639    public void UniformOnePositionManipulatorApplyTest() {
    8740      TestRandom random = new TestRandom();
    … …  
    9851      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
    9952    }
    100 
    101     /// <summary>
    102     ///A test for UniformOnePositionManipulator Constructor
    103     ///</summary>
    104     [TestMethod]
    105     public void UniformOnePositionManipulatorConstructorTest() {
    106       UniformOnePositionManipulator target = new UniformOnePositionManipulator();
    107     }
    10853  }
    10954}

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/DirectScheduleGTCrossoverTest.cs

    r9769 r9777  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.ScheduleEncoding;
    2423using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
    2524using HeuristicLab.Encodings.ScheduleEncoding.ScheduleEncoding;
    … …  
    2827
    2928namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    30 
    31 
    3229  /// <summary>
    3330  ///This is a test class for DirectScheduleGTCrossoverTest and is intended
    … …  
    3633  [TestClass()]
    3734  public class DirectScheduleGTCrossoverTest {
    38 
    39 
    40     private TestContext testContextInstance;
    41 
    42     /// <summary>
    43     ///Gets or sets the test context which provides
    44     ///information about and functionality for the current test run.
    45     ///</summary>
    46     public TestContext TestContext {
    47       get {
    48         return testContextInstance;
    49       }
    50       set {
    51         testContextInstance = value;
    52       }
    53     }
    54 
    55     #region Additional test attributes
    56     //
    57     //You can use the following additional attributes as you write your tests:
    58     //
    59     //Use ClassInitialize to run code before running the first test in the class
    60     //[ClassInitialize()]
    61     //public static void MyClassInitialize(TestContext testContext)
    62     //{
    63     //}
    64     //
    65     //Use ClassCleanup to run code after all tests in a class have run
    66     //[ClassCleanup()]
    67     //public static void MyClassCleanup()
    68     //{
    69     //}
    70     //
    71     //Use TestInitialize to run code before running each test
    72     //[TestInitialize()]
    73     //public void MyTestInitialize()
    74     //{
    75     //}
    76     //
    77     //Use TestCleanup to run code after each test has run
    78     //[TestCleanup()]
    79     //public void MyTestCleanup()
    80     //{
    81     //}
    82     //
    83     #endregion
    84 
    85 
    8635    /// <summary>
    8736    ///A test for Apply
    8837    ///</summary>
    8938    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    9041    public void ApplyTest() {
    91       IRandom random = new TestRandom(new int[] {  1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1 }, new double[] { 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9 });
     42      IRandom random = new TestRandom(new int[] { 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1 }, new double[] { 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9 });
    9243      Schedule parent1 = TestUtils.CreateTestSchedule1();
    9344      Schedule parent2 = TestUtils.CreateTestSchedule2();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/JSMJOXCrossoverTest.cs

    r9769 r9777  
    2727
    2828namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    29 
    30 
    3129  /// <summary>
    3230  ///This is a test class for JSMJOXCrossoverTest and is intended
    … …  
    3533  [TestClass()]
    3634  public class JSMJOXCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    84 
    8535    /// <summary>
    8636    ///A test for Apply
    8737    ///</summary>
    8838    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    8941    public void ApplyTest() {
    9042      IRandom random = new TestRandom(new int[] { 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1 }, null);

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/JSMSXXCrossoverTest.cs

    r9769 r9777  
    2727
    2828namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    29 
    30 
    3129  /// <summary>
    3230  ///This is a test class for JSMSXXCrossoverTest and is intended
    … …  
    3533  [TestClass()]
    3634  public class JSMSXXCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    84 
    8535    /// <summary>
    8636    ///A test for Apply
    8737    ///</summary>
    8838    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    8941    public void ApplyTest() {
    9042      IRandom random = new TestRandom(new int[] { 3 }, null);

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/JSMShiftChangeManipulatorTest.cs

    r9769 r9777  
    2727
    2828namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    29 
    30 
    3129  /// <summary>
    3230  ///This is a test class for JSMShiftChangeManipulatorTest and is intended
    … …  
    3533  [TestClass()]
    3634  public class JSMShiftChangeManipulatorTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    84 
    8535    /// <summary>
    8636    ///A test for Apply
    8737    ///</summary>
    8838    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    8941    public void ApplyTest() {
    9042      IRandom random = new TestRandom(new int[] { 2, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 }, null);

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/PWRGOXCrossoverTest.cs

    r9769 r9777  
    2727
    2828namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    29 
    30 
    3129  /// <summary>
    3230  ///This is a test class for PWRGOXCrossoverTest and is intended
    … …  
    3533  [TestClass()]
    3634  public class PWRGOXCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    84 
    8535    /// <summary>
    8636    ///A test for Apply
    8737    ///</summary>
    8838    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    8941    public void ApplyTest() {
    9042      IRandom random = new TestRandom(new int[] { 3 }, null);

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/PWRPPXCrossoverTest.cs

    r9769 r9777  
    2727
    2828namespace HeuristicLab.Encodings.ScheduleEncoding.Tests {
    29 
    30 
    3129  /// <summary>
    3230  ///This is a test class for PWRPPXCrossoverTest and is intended
    … …  
    3533  [TestClass()]
    3634  public class PWRPPXCrossoverTest {
    37 
    38 
    39     private TestContext testContextInstance;
    40 
    41     /// <summary>
    42     ///Gets or sets the test context which provides
    43     ///information about and functionality for the current test run.
    44     ///</summary>
    45     public TestContext TestContext {
    46       get {
    47         return testContextInstance;
    48       }
    49       set {
    50         testContextInstance = value;
    51       }
    52     }
    53 
    54     #region Additional test attributes
    55     //
    56     //You can use the following additional attributes as you write your tests:
    57     //
    58     //Use ClassInitialize to run code before running the first test in the class
    59     //[ClassInitialize()]
    60     //public static void MyClassInitialize(TestContext testContext)
    61     //{
    62     //}
    63     //
    64     //Use ClassCleanup to run code after all tests in a class have run
    65     //[ClassCleanup()]
    66     //public static void MyClassCleanup()
    67     //{
    68     //}
    69     //
    70     //Use TestInitialize to run code before running each test
    71     //[TestInitialize()]
    72     //public void MyTestInitialize()
    73     //{
    74     //}
    75     //
    76     //Use TestCleanup to run code after each test has run
    77     //[TestCleanup()]
    78     //public void MyTestCleanup()
    79     //{
    80     //}
    81     //
    82     #endregion
    83 
    84 
    8535    /// <summary>
    8636    ///A test for Apply
    8737    ///</summary>
    8838    [TestMethod]
     39    [TestCategory("Encodings.Schedule")]
     40    [TestProperty("Time", "short")]
    8941    public void ApplyTest() {
    9042      IRandom random = new TestRandom(new int[] { 1, 1, 0, 0, 1, 1, 0, 0, 1 }, null);

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.ScheduleEncoding-3.3/TestUtils.cs

    r9764 r9777  
    2323using HeuristicLab.Encodings.IntegerVectorEncoding;
    2424using HeuristicLab.Encodings.PermutationEncoding;
    25 using HeuristicLab.Encodings.ScheduleEncoding;
    2625using HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix;
    2726using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
Note: See TracChangeset for help on using the changeset viewer.