Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
08/20/13 17:03:31 (11 years ago)
Author:
mkommend
Message:

#2088: Merged all changesets regarding the unit test restructuring in the stable branch.

Location:
stable
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • stable

  • stable/HeuristicLab.Tests

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/Auxiliary.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Common;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423
    25 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     24namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2625  public static class Auxiliary {
    2726    public static bool RealVectorIsAlmostEqualByPosition(RealVector p1, RealVector p2) {

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs

    r9456 r9885  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.Data;
    24 using HeuristicLab.Encodings.RealVectorEncoding;
    2524using HeuristicLab.Tests;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
    2726
    28 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    29 
    30 
     27namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    3128  /// <summary>
    3229  ///This is a test class for BlendAlphaBetaCrossoverTest and is intended
    … …  
    3532  [TestClass()]
    3633  public class BlendAlphaBetaCrossoverTest {
    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>
    8737    [TestMethod()]
    88     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     38    [TestCategory("Encodings.RealVector")]
     39    [TestProperty("Time", "short")]
    8940    public void BlendAlphaBetaCrossoverCrossTest() {
    9041      BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaBetaCrossover)));
    … …  
    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      }
    … …  
    12271    ///</summary>
    12372    [TestMethod()]
     73    [TestCategory("Encodings.RealVector")]
     74    [TestProperty("Time", "short")]
    12475    public void BlendAlphaBetaCrossoverApplyTest() {
    12576      TestRandom random = new TestRandom();
    … …  
    14798      try {
    14899        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
    149       }
    150       catch (System.ArgumentException) {
     100      } catch (System.ArgumentException) {
    151101        exceptionFired = true;
    152102      }
    … …  
    161111      try {
    162112        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
    163       }
    164       catch (System.ArgumentException) {
     113      } catch (System.ArgumentException) {
    165114        exceptionFired = true;
    166115      }
    167116      Assert.IsTrue(exceptionFired);
    168117    }
    169 
    170     /// <summary>
    171     ///A test for BlendAlphaBetaCrossover Constructor
    172     ///</summary>
    173     [TestMethod()]
    174     public void BlendAlphaBetaCrossoverConstructorTest() {
    175       BlendAlphaBetaCrossover target = new BlendAlphaBetaCrossover();
    176     }
    177118  }
    178119}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs

    r9456 r9885  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.Data;
    24 using HeuristicLab.Encodings.RealVectorEncoding;
    2524using HeuristicLab.Tests;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
    2726
    28 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    29 
    30 
     27namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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>
    8737    [TestMethod()]
    88     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    12271    ///</summary>
    12372    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    28 
    29 
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    10959    ///</summary>
    11060    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    28 
    29 
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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>
    8636    [TestMethod()]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    12170    ///</summary>
    12271    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    28 
    29 
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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>
    8636    [TestMethod()]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    12170    ///</summary>
    12271    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/MichalewiczNonUniformAllPositionsManipulatorTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2827  /// <summary>
    2928  ///This is a test class for MichalewiczNonUniformAllPositionsManipulator and is intended
    … …  
    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>
    8536    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/MichalewiczNonUniformOnePositionManipulatorTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2827  /// <summary>
    2928  ///This is a test class for MichalewiczNonUniformOnePositionManipulator and is intended
    … …  
    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>
    8536    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/PolynomialAllPositionManipulatorTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2827  /// <summary>
    2928  ///This is a test class for PolynomialAllPositionManipulator and is intended
    … …  
    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>
    8536    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/PolynomialOnePositionManipulatorTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2827  /// <summary>
    2928  ///This is a test class for PolynomialOnePositionManipulator and is intended
    … …  
    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>
    8536    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    28 
    29 
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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>
    8636    [TestMethod()]
    87     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    12170    ///</summary>
    12271    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs

    r9456 r9885  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.Data;
    24 using HeuristicLab.Encodings.RealVectorEncoding;
    2524using HeuristicLab.Tests;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
    2726
    28 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    29 
    30 
     27namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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>
    8737    [TestMethod()]
    88     [DeploymentItem("HeuristicLab.Encodings.RealVectorEncoding-3.3.dll")]
     38    [TestCategory("Encodings.RealVector")]
     39    [TestProperty("Time", "short")]
    8940    public void SimulatedBinaryCrossoverCrossTest() {
    9041      SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(new PrivateObject(typeof(SimulatedBinaryCrossover)));
    … …  
    12071    ///</summary>
    12172    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Core;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
    28 
    29 
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    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.RealVectorEncoding-3.3.dll")]
     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      }
    … …  
    13381    ///</summary>
    13482    [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}

  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/UniformOnePositionManipulatorTest.cs

    r9456 r9885  
    2121
    2222using HeuristicLab.Data;
    23 using HeuristicLab.Encodings.RealVectorEncoding;
    2423using HeuristicLab.Tests;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    27 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
     26namespace HeuristicLab.Encodings.RealVectorEncoding.Tests {
    2827  /// <summary>
    2928  ///This is a test class for UniformOnePositionManipulator and is intended
    … …  
    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>
    8536    [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}
Note: See TracChangeset for help on using the changeset viewer.