Free cookie consent management tool by TermsFeed Policy Generator

Changeset 9782


Ignore:
Timestamp:
07/26/13 13:57:00 (11 years ago)
Author:
abeham
Message:

#2088: Added test attributes to further tests

Location:
trunk/sources/HeuristicLab.Tests
Files:
24 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.PluginInfraStructure-3.3/InstallationManagerTest.cs

    r9771 r9782  
    2525
    2626namespace HeuristicLab.PluginInfrastructure.Tests {
    27 
    28 
    2927  /// <summary>
    3028  ///This is a test class for InstallationManagerTest and is intended
    … …  
    3331  [TestClass()]
    3432  public class InstallationManagerTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    82 
    8333    /// <summary>
    8434    ///A test for GetRemotePluginList
    8535    ///</summary>
    8636    [TestMethod]
     37    [TestCategory("General")]
     38    [TestProperty("Time", "long")]
    8739    public void GetRemotePluginListTest() {
    8840      string pluginDir = Environment.CurrentDirectory;
    … …  
    9143        var pluginList = target.GetRemotePluginList();
    9244        Assert.IsTrue(pluginList != null);
    93       }
    94       catch (Exception e) {
     45      } catch (Exception e) {
    9546        Assert.Fail("Connection to the update service failed. " + e.Message);
    9647      }
    … …  
    10152    ///</summary>
    10253    [TestMethod]
     54    [TestCategory("General")]
     55    [TestProperty("Time", "short")]
    10356    public void GetRemoteProductListTest() {
    10457      string pluginDir = Environment.CurrentDirectory;
    … …  
    10760        var productList = target.GetRemoteProductList();
    10861        Assert.IsTrue(productList != null);
    109       }
    110       catch (Exception e) {
     62      } catch (Exception e) {
    11163        Assert.Fail("Connection to the update service failed. " + e.Message);
    11264      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.PluginInfraStructure-3.3/TypeExtensionsTest.cs

    r9776 r9782  
    2222using System.Collections;
    2323using System.Collections.Generic;
    24 using System.Linq;
    2524using HeuristicLab.Core;
    2625using HeuristicLab.Data;
    2726using HeuristicLab.Parameters;
    2827using HeuristicLab.Problems.DataAnalysis;
    29 using HeuristicLab.Tests;
    3028using Microsoft.VisualStudio.TestTools.UnitTesting;
    3129
    … …  
    3533  /// </summary>
    3634  [TestClass]
    37   public class TypeDiscoveryTest {
    38     public TypeDiscoveryTest() { }
    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 { return testContextInstance; }
    48       set { testContextInstance = value; }
    49     }
    50 
    51     public static void MyClassInitialize(TestContext testContext) {
    52       PluginLoader.Assemblies.Any();
    53     }
    54 
     35  public class TypeExtensionsTest {
    5536    [TestMethod]
     37    [TestCategory("General")]
     38    [TestProperty("Time", "short")]
    5639    public void IsSubTypeOfTest() {
    5740      Assert.IsTrue(typeof(int).IsSubTypeOf(typeof(object)));
    … …  
    7962
    8063    [TestMethod]
     64    [TestCategory("General")]
     65    [TestProperty("Time", "short")]
    8166    public void BuildTypeTest() {
    8267      Assert.AreEqual(typeof(List<>).BuildType(typeof(List<>)), typeof(List<>));

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances-3.3/CordeauGQAPInstanceProviderTest.cs

    r9772 r9782  
    3030
    3131    [TestMethod]
     32    [TestCategory("Problems.Instances")]
     33    [TestProperty("Time", "short")]
    3234    public void GetCordeauGQAPInstanceTest() {
    3335      var target = new CordeauGQAPInstanceProvider();
    … …  
    3739        try {
    3840          target.LoadData(id);
    39         }
    40         catch (Exception ex) {
     41        } catch (Exception ex) {
    4142          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4243        }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances-3.3/ElloumiCTAPInstanceProviderTest.cs

    r9772 r9782  
    3030
    3131    [TestMethod]
     32    [TestCategory("Problems.Instances")]
     33    [TestProperty("Time", "short")]
    3234    public void GetElloumiCTAPInstanceTest() {
    3335      var target = new ElloumiCTAPInstanceProvider();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances-3.3/QAPLIBInstanceProviderTest.cs

    r9772 r9782  
    3030
    3131    [TestMethod]
     32    [TestCategory("Problems.Instances")]
     33    [TestProperty("Time", "medium")]
    3234    public void GetQAPLIBInstanceTest() {
    3335      var target = new QAPLIBInstanceProvider();
    … …  
    3739        try {
    3840          target.LoadData(id);
    39         }
    40         catch (Exception ex) {
     41        } catch (Exception ex) {
    4142          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4243        }
    … …  
    4849
    4950    [TestMethod]
     51    [TestCategory("Problems.Instances")]
     52    [TestProperty("Time", "short")]
    5053    public void GetMicroarrayQAPInstanceTest() {
    5154      var target = new MicroarrayQAPInstanceProvider();
    … …  
    6568
    6669    [TestMethod]
     70    [TestCategory("Problems.Instances")]
     71    [TestProperty("Time", "short")]
    6772    public void GetDreznerQAPInstanceTest() {
    6873      var target = new DreznerQAPInstanceProvider();
    … …  
    8287
    8388    [TestMethod]
     89    [TestCategory("Problems.Instances")]
     90    [TestProperty("Time", "long")]
    8491    public void GetTaillardQAPInstanceTest() {
    8592      var target = new TaillardQAPInstanceProvider();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances-3.3/TSPLIBInstanceProviderTest.cs

    r9772 r9782  
    2020#endregion
    2121
    22 
    2322using System;
    2423using System.Text;
    2524using HeuristicLab.Problems.Instances.TSPLIB;
    2625using Microsoft.VisualStudio.TestTools.UnitTesting;
     26
    2727namespace HeuristicLab.Problems.Instances.Tests {
    2828  [TestClass()]
    … …  
    3030
    3131    [TestMethod]
     32    [TestCategory("Problems.Instances")]
     33    [TestProperty("Time", "medium")]
    3234    public void GetTSPLIBTSPInstanceTest() {
    3335      var target = new TSPLIBTSPInstanceProvider();
    … …  
    3739        try {
    3840          target.LoadData(id);
    39         }
    40         catch (Exception ex) {
     41        } catch (Exception ex) {
    4142          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4243        }
    … …  
    4849
    4950    [TestMethod]
     51    [TestCategory("Problems.Instances")]
     52    [TestProperty("Time", "short")]
    5053    public void GetTSPLIBATSPInstanceTest() {
    5154      var target = new TSPLIBATSPInstanceProvider();
    … …  
    5558        try {
    5659          target.LoadData(id);
    57         }
    58         catch (Exception ex) {
     60        } catch (Exception ex) {
    5961          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    6062        }
    … …  
    6668
    6769    [TestMethod]
     70    [TestCategory("Problems.Instances")]
     71    [TestProperty("Time", "short")]
    6872    public void GetTSPLIBCVRPInstanceTest() {
    6973      var target = new TSPLIBCVRPInstanceProvider();
    … …  
    7377        try {
    7478          target.LoadData(id);
    75         }
    76         catch (Exception ex) {
     79        } catch (Exception ex) {
    7780          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    7881        }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances.DataAnalysis-3.3/ClassificationInstanceProviderTest.cs

    r9773 r9782  
    2222using System;
    2323using System.Text;
    24 using HeuristicLab.Problems.Instances.DataAnalysis;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    … …  
    3029
    3130    [TestMethod]
     31    [TestCategory("Problems.Instances")]
     32    [TestProperty("Time", "short")]
    3233    public void UCIInstanceTest() {
    3334      var target = new UCIInstanceProvider();
    … …  
    3738        try {
    3839          target.LoadData(id);
    39         }
    40         catch (Exception ex) {
     40        } catch (Exception ex) {
    4141          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4242        }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances.DataAnalysis-3.3/RegressionInstanceProviderTest.cs

    r9773 r9782  
    2222using System;
    2323using System.Text;
    24 using HeuristicLab.Problems.Instances.DataAnalysis;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    … …  
    3029
    3130    [TestMethod]
     31    [TestCategory("Problems.Instances")]
     32    [TestProperty("Time", "medium")]
    3233    public void GetKeijzerInstanceTest() {
    3334      var target = new KeijzerInstanceProvider();
    … …  
    3738        try {
    3839          target.LoadData(id);
    39         }
    40         catch (Exception ex) {
     40        } catch (Exception ex) {
    4141          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4242        }
    … …  
    4848
    4949    [TestMethod]
     50    [TestCategory("Problems.Instances")]
     51    [TestProperty("Time", "short")]
    5052    public void GetKornInstanceTest() {
    5153      var target = new KornsInstanceProvider();
    … …  
    5557        try {
    5658          target.LoadData(id);
    57         }
    58         catch (Exception ex) {
     59        } catch (Exception ex) {
    5960          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    6061        }
    … …  
    6667
    6768    [TestMethod]
     69    [TestCategory("Problems.Instances")]
     70    [TestProperty("Time", "short")]
    6871    public void GetNguyenInstanceTest() {
    6972      var target = new NguyenInstanceProvider();
    … …  
    7376        try {
    7477          target.LoadData(id);
    75         }
    76         catch (Exception ex) {
     78        } catch (Exception ex) {
    7779          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    7880        }
    … …  
    8486
    8587    [TestMethod]
     88    [TestCategory("Problems.Instances")]
     89    [TestProperty("Time", "short")]
    8690    public void GetRealWorldInstanceTest() {
    8791      var target = new RegressionRealWorldInstanceProvider();
    … …  
    9195        try {
    9296          target.LoadData(id);
    93         }
    94         catch (Exception ex) {
     97        } catch (Exception ex) {
    9598          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    9699        }
    … …  
    102105
    103106    [TestMethod]
     107    [TestCategory("Problems.Instances")]
     108    [TestProperty("Time", "short")]
    104109    public void GetVariousInstanceTest() {
    105110      var target = new VariousInstanceProvider();
    … …  
    109114        try {
    110115          target.LoadData(id);
    111         }
    112         catch (Exception ex) {
     116        } catch (Exception ex) {
    113117          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    114118        }
    … …  
    120124
    121125    [TestMethod]
     126    [TestCategory("Problems.Instances")]
     127    [TestProperty("Time", "short")]
    122128    public void GetVladislavlevaInstanceTest() {
    123129      var target = new VladislavlevaInstanceProvider();
    … …  
    127133        try {
    128134          target.LoadData(id);
    129         }
    130         catch (Exception ex) {
     135        } catch (Exception ex) {
    131136          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    132137        }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.Instances.DataAnalysis-3.3/TableFileParserTest.cs

    r9764 r9782  
    2222using System;
    2323using System.IO;
    24 using HeuristicLab.Problems.Instances.DataAnalysis;
    2524using Microsoft.VisualStudio.TestTools.UnitTesting;
    2625
    2726namespace HeuristicLab.Problems.Instances.DataAnalysis.Tests {
    28 
    2927  [TestClass()]
    3028  public class TableFileParserTest {
    31 
    32     [TestMethod]
     29    [TestMethod]
     30    [TestCategory("Problems.Instances")]
     31    [TestProperty("Time", "short")]
    3332    public void ParseCSV() {
    3433      string tempFileName = Path.GetTempFileName();
    … …  
    4645        Assert.AreEqual(4, parser.Columns);
    4746        Assert.AreEqual(parser.Values[3][0], 3.14);
    48       }
    49       finally {
    50         File.Delete(tempFileName);
    51       }
    52     }
    53     [TestMethod]
     47      } finally {
     48        File.Delete(tempFileName);
     49      }
     50    }
     51
     52    [TestMethod]
     53    [TestCategory("Problems.Instances")]
     54    [TestProperty("Time", "short")]
    5455    public void ParseCSVWithNames() {
    5556      string tempFileName = Path.GetTempFileName();
    … …  
    6869        Assert.AreEqual(4, parser.Columns);
    6970        Assert.AreEqual(parser.Values[3][0], 3.14);
    70       }
    71       finally {
    72         File.Delete(tempFileName);
    73       }
    74     }
    75 
    76     [TestMethod]
     71      } finally {
     72        File.Delete(tempFileName);
     73      }
     74    }
     75
     76    [TestMethod]
     77    [TestCategory("Problems.Instances")]
     78    [TestProperty("Time", "short")]
    7779    public void ParseGermanCSV() {
    7880      string tempFileName = Path.GetTempFileName();
    … …  
    9092        Assert.AreEqual(4, parser.Columns);
    9193        Assert.AreEqual(parser.Values[3][0], 3.14);
    92       }
    93       finally {
    94         File.Delete(tempFileName);
    95       }
    96     }
    97 
    98     [TestMethod]
     94      } finally {
     95        File.Delete(tempFileName);
     96      }
     97    }
     98
     99    [TestMethod]
     100    [TestCategory("Problems.Instances")]
     101    [TestProperty("Time", "short")]
    99102    public void ParseGermanCSVWithNames() {
    100103      string tempFileName = Path.GetTempFileName();
    … …  
    113116        Assert.AreEqual(4, parser.Columns);
    114117        Assert.AreEqual(parser.Values[3][0], 3.14);
    115       }
    116       finally {
    117         File.Delete(tempFileName);
    118       }
    119     }
    120 
    121     [TestMethod]
     118      } finally {
     119        File.Delete(tempFileName);
     120      }
     121    }
     122
     123    [TestMethod]
     124    [TestCategory("Problems.Instances")]
     125    [TestProperty("Time", "short")]
    122126    public void ParseGermanCSVWithoutCommas() {
    123127      string tempFileName = Path.GetTempFileName();
    … …  
    135139        Assert.AreEqual(4, parser.Columns);
    136140        Assert.AreEqual((double)parser.Values[3][0], 3);
    137       }
    138       finally {
    139         File.Delete(tempFileName);
    140       }
    141     }
    142     [TestMethod]
     141      } finally {
     142        File.Delete(tempFileName);
     143      }
     144    }
     145
     146    [TestMethod]
     147    [TestCategory("Problems.Instances")]
     148    [TestProperty("Time", "short")]
    143149    public void ParseGermanCSVWithoutCommasWithNames() {
    144150      string tempFileName = Path.GetTempFileName();
    … …  
    157163        Assert.AreEqual(4, parser.Columns);
    158164        Assert.AreEqual((double)parser.Values[3][0], 3);
    159       }
    160       finally {
    161         File.Delete(tempFileName);
    162       }
    163     }
    164 
    165     [TestMethod]
     165      } finally {
     166        File.Delete(tempFileName);
     167      }
     168    }
     169
     170    [TestMethod]
     171    [TestCategory("Problems.Instances")]
     172    [TestProperty("Time", "short")]
    166173    public void ParseEnglishCSVWithoutCommas() {
    167174      string tempFileName = Path.GetTempFileName();
    … …  
    179186        Assert.AreEqual(4, parser.Columns);
    180187        Assert.AreEqual((double)parser.Values[3][0], 3);
    181       }
    182       finally {
    183         File.Delete(tempFileName);
    184       }
    185     }
    186 
    187     [TestMethod]
     188      } finally {
     189        File.Delete(tempFileName);
     190      }
     191    }
     192
     193    [TestMethod]
     194    [TestCategory("Problems.Instances")]
     195    [TestProperty("Time", "short")]
    188196    public void ParseEnglishCSVWithoutCommasWithoutSpace() {
    189197      string tempFileName = Path.GetTempFileName();
    … …  
    201209        Assert.AreEqual(4, parser.Columns);
    202210        Assert.AreEqual((double)parser.Values[3][0], 3);
    203       }
    204       finally {
    205         File.Delete(tempFileName);
    206       }
    207     }
    208 
    209     [TestMethod]
     211      } finally {
     212        File.Delete(tempFileName);
     213      }
     214    }
     215
     216    [TestMethod]
     217    [TestCategory("Problems.Instances")]
     218    [TestProperty("Time", "short")]
    210219    public void ParseEnglishCSVWithoutCommasWithNames() {
    211220      string tempFileName = Path.GetTempFileName();
    … …  
    224233        Assert.AreEqual(4, parser.Columns);
    225234        Assert.AreEqual((double)parser.Values[3][0], 3);
    226       }
    227       finally {
    228         File.Delete(tempFileName);
    229       }
    230     }
    231 
    232     [TestMethod]
     235      } finally {
     236        File.Delete(tempFileName);
     237      }
     238    }
     239
     240    [TestMethod]
     241    [TestCategory("Problems.Instances")]
     242    [TestProperty("Time", "short")]
    233243    public void ParseEnglishCSVWithoutCommasWithoutSpacesWithNames() {
    234244      string tempFileName = Path.GetTempFileName();
    … …  
    247257        Assert.AreEqual(4, parser.Columns);
    248258        Assert.AreEqual((double)parser.Values[3][0], 3);
    249       }
    250       finally {
    251         File.Delete(tempFileName);
    252       }
    253     }
    254 
    255 
    256     [TestMethod]
     259      } finally {
     260        File.Delete(tempFileName);
     261      }
     262    }
     263
     264
     265    [TestMethod]
     266    [TestCategory("Problems.Instances")]
     267    [TestProperty("Time", "short")]
    257268    public void ParseGermanTabSeparated() {
    258269      string tempFileName = Path.GetTempFileName();
    … …  
    270281        Assert.AreEqual(4, parser.Columns);
    271282        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    272       }
    273       finally {
    274         File.Delete(tempFileName);
    275       }
    276     }
    277 
    278     [TestMethod]
     283      } finally {
     284        File.Delete(tempFileName);
     285      }
     286    }
     287
     288    [TestMethod]
     289    [TestCategory("Problems.Instances")]
     290    [TestProperty("Time", "short")]
    279291    public void ParseGermanTabSeparatedWithNames() {
    280292      string tempFileName = Path.GetTempFileName();
    … …  
    293305        Assert.AreEqual(4, parser.Columns);
    294306        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    295       }
    296       finally {
    297         File.Delete(tempFileName);
    298       }
    299     }
    300 
    301     [TestMethod]
     307      } finally {
     308        File.Delete(tempFileName);
     309      }
     310    }
     311
     312    [TestMethod]
     313    [TestCategory("Problems.Instances")]
     314    [TestProperty("Time", "short")]
    302315    public void ParseEnglishTabSeparated() {
    303316      string tempFileName = Path.GetTempFileName();
    … …  
    315328        Assert.AreEqual(4, parser.Columns);
    316329        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    317       }
    318       finally {
    319         File.Delete(tempFileName);
    320       }
    321     }
    322     [TestMethod]
     330      } finally {
     331        File.Delete(tempFileName);
     332      }
     333    }
     334
     335    [TestMethod]
     336    [TestCategory("Problems.Instances")]
     337    [TestProperty("Time", "short")]
    323338    public void ParseEnglishTabSeparatedWithNames() {
    324339      string tempFileName = Path.GetTempFileName();
    … …  
    337352        Assert.AreEqual(4, parser.Columns);
    338353        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    339       }
    340       finally {
    341         File.Delete(tempFileName);
    342       }
    343     }
    344 
    345     [TestMethod]
     354      } finally {
     355        File.Delete(tempFileName);
     356      }
     357    }
     358
     359    [TestMethod]
     360    [TestCategory("Problems.Instances")]
     361    [TestProperty("Time", "short")]
    346362    public void ParseTabSeparatedWithoutCommas() {
    347363      string tempFileName = Path.GetTempFileName();
    … …  
    359375        Assert.AreEqual(4, parser.Columns);
    360376        Assert.AreEqual((double)parser.Values[3][0], 3);
    361       }
    362       finally {
    363         File.Delete(tempFileName);
    364       }
    365     }
    366     [TestMethod]
     377      } finally {
     378        File.Delete(tempFileName);
     379      }
     380    }
     381
     382    [TestMethod]
     383    [TestCategory("Problems.Instances")]
     384    [TestProperty("Time", "short")]
    367385    public void ParseTabSeparatedWithoutCommasWithNames() {
    368386      string tempFileName = Path.GetTempFileName();
    … …  
    381399        Assert.AreEqual(4, parser.Columns);
    382400        Assert.AreEqual((double)parser.Values[3][0], 3);
    383       }
    384       finally {
    385         File.Delete(tempFileName);
    386       }
    387     }
    388 
    389     [TestMethod]
     401      } finally {
     402        File.Delete(tempFileName);
     403      }
     404    }
     405
     406    [TestMethod]
     407    [TestCategory("Problems.Instances")]
     408    [TestProperty("Time", "short")]
    390409    public void ParseWithEmtpyLines() {
    391410      string tempFileName = Path.GetTempFileName();
    … …  
    403422        Assert.AreEqual(4, parser.Rows);
    404423        Assert.AreEqual(4, parser.Columns);
    405       }
    406       finally {
    407         File.Delete(tempFileName);
    408       }
    409     }
    410 
    411     [TestMethod]
     424      } finally {
     425        File.Delete(tempFileName);
     426      }
     427    }
     428
     429    [TestMethod]
     430    [TestCategory("Problems.Instances")]
     431    [TestProperty("Time", "short")]
    412432    public void ParseGermanSpaceSeparated() {
    413433      string tempFileName = Path.GetTempFileName();
    … …  
    425445        Assert.AreEqual(4, parser.Columns);
    426446        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    427       }
    428       finally {
    429         File.Delete(tempFileName);
    430       }
    431     }
    432     [TestMethod]
     447      } finally {
     448        File.Delete(tempFileName);
     449      }
     450    }
     451
     452    [TestMethod]
     453    [TestCategory("Problems.Instances")]
     454    [TestProperty("Time", "short")]
    433455    public void ParseGermanSpaceSeparatedWithNames() {
    434456      string tempFileName = Path.GetTempFileName();
    … …  
    447469        Assert.AreEqual(4, parser.Columns);
    448470        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    449       }
    450       finally {
    451         File.Delete(tempFileName);
    452       }
    453     }
    454 
    455     [TestMethod]
     471      } finally {
     472        File.Delete(tempFileName);
     473      }
     474    }
     475
     476    [TestMethod]
     477    [TestCategory("Problems.Instances")]
     478    [TestProperty("Time", "short")]
    456479    public void ParseEnglishSpaceSeparated() {
    457480      string tempFileName = Path.GetTempFileName();
    … …  
    469492        Assert.AreEqual(4, parser.Columns);
    470493        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    471       }
    472       finally {
    473         File.Delete(tempFileName);
    474       }
    475     }
    476     [TestMethod]
     494      } finally {
     495        File.Delete(tempFileName);
     496      }
     497    }
     498
     499    [TestMethod]
     500    [TestCategory("Problems.Instances")]
     501    [TestProperty("Time", "short")]
    477502    public void ParseEnglishSpaceSeparatedWithNames() {
    478503      string tempFileName = Path.GetTempFileName();
    … …  
    491516        Assert.AreEqual(4, parser.Columns);
    492517        Assert.AreEqual((double)parser.Values[3][0], 3.14);
    493       }
    494       finally {
    495         File.Delete(tempFileName);
    496       }
    497     }
    498 
    499     [TestMethod]
     518      } finally {
     519        File.Delete(tempFileName);
     520      }
     521    }
     522
     523    [TestMethod]
     524    [TestCategory("Problems.Instances")]
     525    [TestProperty("Time", "short")]
    500526    public void ParseEnglishSpaceSeparatedWithNamesManyColumns() {
    501527      string tempFileName = Path.GetTempFileName();
    … …  
    511537        Assert.AreEqual(3, parser.Rows);
    512538        Assert.AreEqual(4507, parser.Columns);
    513       }
    514       finally {
    515         File.Delete(tempFileName);
    516       }
    517     }
    518 
    519     [TestMethod]
     539      } finally {
     540        File.Delete(tempFileName);
     541      }
     542    }
     543
     544    [TestMethod]
     545    [TestCategory("Problems.Instances")]
     546    [TestProperty("Time", "short")]
    520547    public void ParseSpaceSeparatedWithoutCommas() {
    521548      string tempFileName = Path.GetTempFileName();
    … …  
    533560        Assert.AreEqual(4, parser.Columns);
    534561        Assert.AreEqual((double)parser.Values[3][0], 3);
    535       }
    536       finally {
    537         File.Delete(tempFileName);
    538       }
    539     }
    540     [TestMethod]
     562      } finally {
     563        File.Delete(tempFileName);
     564      }
     565    }
     566
     567    [TestMethod]
     568    [TestCategory("Problems.Instances")]
     569    [TestProperty("Time", "short")]
    541570    public void ParseSpaceSeparatedWithoutCommasWithNames() {
    542571      string tempFileName = Path.GetTempFileName();
    … …  
    555584        Assert.AreEqual(4, parser.Columns);
    556585        Assert.AreEqual((double)parser.Values[3][0], 3);
    557       }
    558       finally {
     586      } finally {
    559587        File.Delete(tempFileName);
    560588      }

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.LinearAssignment-3.3/LinearAssignmentProblemSolverTest.cs

    r9774 r9782  
    2424using Microsoft.VisualStudio.TestTools.UnitTesting;
    2525
    26 namespace HeuristicLab.Problems.LinearAssignment.Tests_33 {
     26namespace HeuristicLab.Problems.LinearAssignment.Tests {
    2727  /// <summary>
    2828  ///This is a test class for LinearAssignmentProblemSolverTest and is intended
    … …  
    3131  [TestClass()]
    3232  public class LinearAssignmentProblemSolverTest {
    33 
    34     private TestContext testContextInstance;
    35 
    36     /// <summary>
    37     ///Gets or sets the test context which provides
    38     ///information about and functionality for the current test run.
    39     ///</summary>
    40     public TestContext TestContext {
    41       get { return testContextInstance; }
    42       set { testContextInstance = value; }
    43     }
    44 
    45 
    4633    /// <summary>
    4734    ///A test for Solve
    4835    ///</summary>
    4936    [TestMethod]
     37    [TestCategory("Problems.Assignment")]
     38    [TestProperty("Time", "short")]
    5039    public void SolveTest() {
    5140      double[,] costs = new double[,] {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.QuadraticAssignment-3.3/QAPLIBInstancesTest.cs

    r9456 r9782  
    2727using Microsoft.VisualStudio.TestTools.UnitTesting;
    2828
    29 namespace HeuristicLab.Problems.QuadraticAssignment.Tests_33 {
     29namespace HeuristicLab.Problems.QuadraticAssignment.Tests {
    3030  [TestClass]
    3131  public class QAPLIBInstancesTest {
    … …  
    189189
    190190    [TestMethod]
     191    [TestCategory("Problems.Assignment")]
     192    [TestProperty("Time", "long")]
    191193    public void TestQAPLIBInstances() {
    192194      var provider = new QAPLIBInstanceProvider();
    … …  
    208210
    209211    [TestMethod]
     212    [TestCategory("Problems.Assignment")]
     213    [TestProperty("Time", "long")]
    210214    public void TestQAPLIBSolutions() {
    211215      var provider = new QAPLIBInstanceProvider();
    … …  
    226230
    227231    [TestMethod]
     232    [TestCategory("Problems.Assignment")]
     233    [TestProperty("Time", "short")]
    228234    public void TestQAPLIBLowerBounds() {
    229235      var provider = new QAPLIBInstanceProvider();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.QuadraticAssignment-3.3/QAPMoveEvaluatorTest.cs

    r9456 r9782  
    2727using Microsoft.VisualStudio.TestTools.UnitTesting;
    2828
    29 namespace HeuristicLab.Problems.QuadraticAssignment.Tests_33 {
    30 
     29namespace HeuristicLab.Problems.QuadraticAssignment.Tests {
    3130  /// <summary>
    3231  ///This is a test class for the QAP move evaluators
    … …  
    8685
    8786    [TestMethod]
     87    [TestCategory("Problems.Assignment")]
     88    [TestProperty("Time", "short")]
    8889    public void Swap2MoveEvaluatorFastEvaluationTest() {
    8990
    … …  
    126127
    127128    [TestMethod]
     129    [TestCategory("Problems.Assignment")]
     130    [TestProperty("Time", "short")]
    128131    public void Swap2MoveEvaluatorTest() {
    129132      for (int i = 0; i < 500; i++) {
    … …  
    157160
    158161    [TestMethod]
     162    [TestCategory("Problems.Assignment")]
     163    [TestProperty("Time", "short")]
    159164    public void InversionMoveEvaluatorTest() {
    160165      for (int i = 0; i < 500; i++) {
    … …  
    189194
    190195    [TestMethod]
     196    [TestCategory("Problems.Assignment")]
     197    [TestProperty("Time", "short")]
    191198    public void TranslocationMoveEvaluatorTest() {
    192199      for (int i = 0; i < 500; i++) {
    … …  
    227234
    228235    [TestMethod]
     236    [TestCategory("Problems.Assignment")]
     237    [TestProperty("Time", "short")]
    229238    public void ScrambleMoveEvaluatorTest() {
    230239      for (int i = 0; i < 500; i++) {

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for AckleyEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class AckleyEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void AckleyEvaluateFunctionTest() {
    8839      AckleyEvaluator_Accessor target = new AckleyEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for BealeEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class BealeEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void BealeEvaluateFunctionTest() {
    8839      BealeEvaluator_Accessor target = new BealeEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for BoothEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class BoothEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void BoothEvaluateFunctionTest() {
    8839      BoothEvaluator_Accessor target = new BoothEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for GriewankEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class GriewankEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void GriewankEvaluateFunctionTest() {
    8839      GriewankEvaluator_Accessor target = new GriewankEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for LevyEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class LevyEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void LevyEvaluateFunctionTest() {
    8839      LevyEvaluator_Accessor target = new LevyEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for MatyasEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class MatyasEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void MatyasEvaluateFunctionTest() {
    8839      MatyasEvaluator_Accessor target = new MatyasEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for RastriginEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class RastriginEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void RastriginEvaluateFunctionTest() {
    8839      RastriginEvaluator_Accessor target = new RastriginEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for RosenbrockEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class RosenbrockEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void RosenbrockEvaluateFunctionTest() {
    8839      RosenbrockEvaluator_Accessor target = new RosenbrockEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for SphereEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class SphereEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void SphereEvaluateFunctionTest() {
    8839      SphereEvaluator_Accessor target = new SphereEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for SumSquaresEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class SumSquaresEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void SumSquaresEvaluateFunctionTest() {
    8839      SumSquaresEvaluator_Accessor target = new SumSquaresEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs

    r9775 r9782  
    2121
    2222using HeuristicLab.Encodings.RealVectorEncoding;
    23 using HeuristicLab.Problems.TestFunctions;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
    2524
    2625namespace HeuristicLab.Problems.TestFunctions.Tests {
    27 
    28 
    2926  /// <summary>
    3027  ///This is a test class for ZakharovEvaluatorTest and is intended
    … …  
    3330  [TestClass()]
    3431  public class ZakharovEvaluatorTest {
    35 
    36 
    37     private TestContext testContextInstance;
    38 
    39     /// <summary>
    40     ///Gets or sets the test context which provides
    41     ///information about and functionality for the current test run.
    42     ///</summary>
    43     public TestContext TestContext {
    44       get {
    45         return testContextInstance;
    46       }
    47       set {
    48         testContextInstance = value;
    49       }
    50     }
    51 
    52     #region Additional test attributes
    53     //
    54     //You can use the following additional attributes as you write your tests:
    55     //
    56     //Use ClassInitialize to run code before running the first test in the class
    57     //[ClassInitialize()]
    58     //public static void MyClassInitialize(TestContext testContext)
    59     //{
    60     //}
    61     //
    62     //Use ClassCleanup to run code after all tests in a class have run
    63     //[ClassCleanup()]
    64     //public static void MyClassCleanup()
    65     //{
    66     //}
    67     //
    68     //Use TestInitialize to run code before running each test
    69     //[TestInitialize()]
    70     //public void MyTestInitialize()
    71     //{
    72     //}
    73     //
    74     //Use TestCleanup to run code after each test has run
    75     //[TestCleanup()]
    76     //public void MyTestCleanup()
    77     //{
    78     //}
    79     //
    80     #endregion
    81 
    8232    /// <summary>
    8333    ///A test for EvaluateFunction
    8434    ///</summary>
    8535    [TestMethod]
    86     [DeploymentItem("HeuristicLab.Problems.TestFunctions-3.3.dll")]
     36    [TestCategory("Problems.TestFunctions")]
     37    [TestProperty("Time", "short")]
    8738    public void ZakharovEvaluateFunctionTest() {
    8839      ZakharovEvaluator_Accessor target = new ZakharovEvaluator_Accessor();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TravelingSalesman-3.3/TSPMoveEvaluatorTest.cs

    r9764 r9782  
    2424using HeuristicLab.Data;
    2525using HeuristicLab.Encodings.PermutationEncoding;
    26 using HeuristicLab.Problems.TravelingSalesman;
    2726using HeuristicLab.Random;
    2827using Microsoft.VisualStudio.TestTools.UnitTesting;
    2928
    3029namespace HeuristicLab.Problems.TravelingSalesman.Tests {
    31 
    3230  /// <summary>
    3331  ///This is a test class for TSP move evaluators
    … …  
    4038    private static Permutation tour;
    4139    private static MersenneTwister random;
    42 
    43     private TestContext testContextInstance;
    44     /// <summary>
    45     ///Gets or sets the test context which provides
    46     ///information about and functionality for the current test run.
    47     ///</summary>
    48     public TestContext TestContext {
    49       get { return testContextInstance; }
    50       set { testContextInstance = value; }
    51     }
    5240
    5341    [ClassInitialize]
    … …  
    7058
    7159    [TestMethod]
     60    [TestCategory("Problems.TravelingSalesman")]
     61    [TestProperty("Time", "short")]
    7262    public void InversionMoveEvaluatorTest() {
    7363      var evaluator = new TSPRoundedEuclideanPathEvaluator();
    … …  
    10191
    10292    [TestMethod]
     93    [TestCategory("Problems.TravelingSalesman")]
     94    [TestProperty("Time", "short")]
    10395    public void TranslocationMoveEvaluatorTest() {
    10496      var evaluator = new TSPRoundedEuclideanPathEvaluator();

  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj

    r9718 r9782  
    393393    <Compile Include="HeuristicLab.Persistence-3.3\UseCases.cs" />
    394394    <Compile Include="HeuristicLab.PluginInfraStructure-3.3\InstallationManagerTest.cs" />
    395     <Compile Include="HeuristicLab.PluginInfraStructure-3.3\TypeDiscoveryTest.cs" />
     395    <Compile Include="HeuristicLab.PluginInfraStructure-3.3\TypeExtensionsTest.cs" />
    396396    <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\ThresholdCalculatorsTest.cs" />
    397397    <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\OnlineCalculatorPerformanceTest.cs" />
Note: See TracChangeset for help on using the changeset viewer.