Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/18/14 12:35:00 (10 years ago)
Author:
ascheibe
Message:

reverted last commit

Location:
branches/HiveStatistics/sources
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/HiveStatistics/sources

  • branches/HiveStatistics/sources/HeuristicLab.Tests

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

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2222using System;
    2323using System.Text;
     24using HeuristicLab.Problems.Instances.DataAnalysis;
    2425using Microsoft.VisualStudio.TestTools.UnitTesting;
    2526
    26 namespace HeuristicLab.Problems.Instances.DataAnalysis.Tests {
     27namespace HeuristicLab.Problems.Instances.DataAnalysis_34.Tests {
    2728  [TestClass()]
    2829  public class ClassificationInstanceProviderTest {
    2930
    30     [TestMethod]
    31     [TestCategory("Problems.Instances")]
    32     [TestProperty("Time", "short")]
     31    [TestMethod()]
    3332    public void UCIInstanceTest() {
    3433      var target = new UCIInstanceProvider();
    … …  
    3837        try {
    3938          target.LoadData(id);
    40         } catch (Exception ex) {
     39        }
     40        catch (Exception ex) {
    4141          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4242        }

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

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2222using System;
    2323using System.Text;
     24using HeuristicLab.Problems.Instances.DataAnalysis;
    2425using Microsoft.VisualStudio.TestTools.UnitTesting;
    2526
    26 namespace HeuristicLab.Problems.Instances.DataAnalysis.Tests {
     27namespace HeuristicLab.Problems.Instances.DataAnalysis_34.Tests {
    2728  [TestClass()]
    2829  public class RegressionInstanceProviderTest {
    2930
    30     [TestMethod]
    31     [TestCategory("Problems.Instances")]
    32     [TestProperty("Time", "medium")]
     31    [TestMethod()]
    3332    public void GetKeijzerInstanceTest() {
    3433      var target = new KeijzerInstanceProvider();
    … …  
    3837        try {
    3938          target.LoadData(id);
    40         } catch (Exception ex) {
     39        }
     40        catch (Exception ex) {
    4141          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    4242        }
    … …  
    4747    }
    4848
    49     [TestMethod]
    50     [TestCategory("Problems.Instances")]
    51     [TestProperty("Time", "short")]
     49    [TestMethod()]
    5250    public void GetKornInstanceTest() {
    5351      var target = new KornsInstanceProvider();
    … …  
    5755        try {
    5856          target.LoadData(id);
    59         } catch (Exception ex) {
     57        }
     58        catch (Exception ex) {
    6059          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    6160        }
    … …  
    6665    }
    6766
    68     [TestMethod]
    69     [TestCategory("Problems.Instances")]
    70     [TestProperty("Time", "short")]
     67    [TestMethod()]
    7168    public void GetNguyenInstanceTest() {
    7269      var target = new NguyenInstanceProvider();
    … …  
    7673        try {
    7774          target.LoadData(id);
    78         } catch (Exception ex) {
     75        }
     76        catch (Exception ex) {
    7977          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    8078        }
    … …  
    8583    }
    8684
    87     [TestMethod]
    88     [TestCategory("Problems.Instances")]
    89     [TestProperty("Time", "short")]
     85    [TestMethod()]
    9086    public void GetRealWorldInstanceTest() {
    9187      var target = new RegressionRealWorldInstanceProvider();
    … …  
    9591        try {
    9692          target.LoadData(id);
    97         } catch (Exception ex) {
     93        }
     94        catch (Exception ex) {
    9895          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    9996        }
    … …  
    104101    }
    105102
    106     [TestMethod]
    107     [TestCategory("Problems.Instances")]
    108     [TestProperty("Time", "short")]
     103    [TestMethod()]
    109104    public void GetVariousInstanceTest() {
    110105      var target = new VariousInstanceProvider();
    … …  
    114109        try {
    115110          target.LoadData(id);
    116         } catch (Exception ex) {
     111        }
     112        catch (Exception ex) {
    117113          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    118114        }
    … …  
    123119    }
    124120
    125     [TestMethod]
    126     [TestCategory("Problems.Instances")]
    127     [TestProperty("Time", "short")]
     121    [TestMethod()]
    128122    public void GetVladislavlevaInstanceTest() {
    129123      var target = new VladislavlevaInstanceProvider();
    … …  
    133127        try {
    134128          target.LoadData(id);
    135         } catch (Exception ex) {
     129        }
     130        catch (Exception ex) {
    136131          erroneousInstances.AppendLine(id.Name + ": " + ex.Message);
    137132        }

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

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2222using System;
    2323using System.IO;
     24using HeuristicLab.Problems.Instances.DataAnalysis;
    2425using Microsoft.VisualStudio.TestTools.UnitTesting;
    2526
    26 namespace HeuristicLab.Problems.Instances.DataAnalysis.Tests {
     27namespace HeuristicLab.Problems.Instances.DataAnalysis_34.Tests {
     28
    2729  [TestClass()]
    2830  public class TableFileParserTest {
    29     [TestMethod]
    30     [TestCategory("Problems.Instances")]
    31     [TestProperty("Time", "short")]
     31
     32    [TestMethod]
    3233    public void ParseCSV() {
    3334      string tempFileName = Path.GetTempFileName();
    … …  
    4142      TableFileParser parser = new TableFileParser();
    4243      try {
    43         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     44        parser.Parse(tempFileName);
    4445        Assert.AreEqual(6, parser.Rows);
    4546        Assert.AreEqual(4, parser.Columns);
    4647        Assert.AreEqual(parser.Values[3][0], 3.14);
    47       } finally {
    48         File.Delete(tempFileName);
    49       }
    50     }
    51 
    52     [TestMethod]
    53     [TestCategory("Problems.Instances")]
    54     [TestProperty("Time", "short")]
     48      }
     49      finally {
     50        File.Delete(tempFileName);
     51      }
     52    }
     53    [TestMethod]
    5554    public void ParseCSVWithNames() {
    5655      string tempFileName = Path.GetTempFileName();
    … …  
    6564      TableFileParser parser = new TableFileParser();
    6665      try {
    67         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     66        parser.Parse(tempFileName);
    6867        Assert.AreEqual(6, parser.Rows);
    6968        Assert.AreEqual(4, parser.Columns);
    7069        Assert.AreEqual(parser.Values[3][0], 3.14);
    71       } finally {
    72         File.Delete(tempFileName);
    73       }
    74     }
    75 
    76     [TestMethod]
    77     [TestCategory("Problems.Instances")]
    78     [TestProperty("Time", "short")]
     70      }
     71      finally {
     72        File.Delete(tempFileName);
     73      }
     74    }
     75
     76    [TestMethod]
    7977    public void ParseGermanCSV() {
    8078      string tempFileName = Path.GetTempFileName();
    … …  
    8886      TableFileParser parser = new TableFileParser();
    8987      try {
    90         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     88        parser.Parse(tempFileName);
    9189        Assert.AreEqual(6, parser.Rows);
    9290        Assert.AreEqual(4, parser.Columns);
    9391        Assert.AreEqual(parser.Values[3][0], 3.14);
    94       } finally {
    95         File.Delete(tempFileName);
    96       }
    97     }
    98 
    99     [TestMethod]
    100     [TestCategory("Problems.Instances")]
    101     [TestProperty("Time", "short")]
     92      }
     93      finally {
     94        File.Delete(tempFileName);
     95      }
     96    }
     97
     98    [TestMethod]
    10299    public void ParseGermanCSVWithNames() {
    103100      string tempFileName = Path.GetTempFileName();
    … …  
    112109      TableFileParser parser = new TableFileParser();
    113110      try {
    114         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     111        parser.Parse(tempFileName);
    115112        Assert.AreEqual(6, parser.Rows);
    116113        Assert.AreEqual(4, parser.Columns);
    117114        Assert.AreEqual(parser.Values[3][0], 3.14);
    118       } finally {
    119         File.Delete(tempFileName);
    120       }
    121     }
    122 
    123     [TestMethod]
    124     [TestCategory("Problems.Instances")]
    125     [TestProperty("Time", "short")]
     115      }
     116      finally {
     117        File.Delete(tempFileName);
     118      }
     119    }
     120
     121    [TestMethod]
    126122    public void ParseGermanCSVWithoutCommas() {
    127123      string tempFileName = Path.GetTempFileName();
    … …  
    135131      TableFileParser parser = new TableFileParser();
    136132      try {
    137         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    138         Assert.AreEqual(6, parser.Rows);
    139         Assert.AreEqual(4, parser.Columns);
    140         Assert.AreEqual((double)parser.Values[3][0], 3);
    141       } finally {
    142         File.Delete(tempFileName);
    143       }
    144     }
    145 
    146     [TestMethod]
    147     [TestCategory("Problems.Instances")]
    148     [TestProperty("Time", "short")]
     133        parser.Parse(tempFileName);
     134        Assert.AreEqual(6, parser.Rows);
     135        Assert.AreEqual(4, parser.Columns);
     136        Assert.AreEqual((double)parser.Values[3][0], 3);
     137      }
     138      finally {
     139        File.Delete(tempFileName);
     140      }
     141    }
     142    [TestMethod]
    149143    public void ParseGermanCSVWithoutCommasWithNames() {
    150144      string tempFileName = Path.GetTempFileName();
    … …  
    159153      TableFileParser parser = new TableFileParser();
    160154      try {
    161         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    162         Assert.AreEqual(6, parser.Rows);
    163         Assert.AreEqual(4, parser.Columns);
    164         Assert.AreEqual((double)parser.Values[3][0], 3);
    165       } finally {
    166         File.Delete(tempFileName);
    167       }
    168     }
    169 
    170     [TestMethod]
    171     [TestCategory("Problems.Instances")]
    172     [TestProperty("Time", "short")]
     155        parser.Parse(tempFileName);
     156        Assert.AreEqual(6, parser.Rows);
     157        Assert.AreEqual(4, parser.Columns);
     158        Assert.AreEqual((double)parser.Values[3][0], 3);
     159      }
     160      finally {
     161        File.Delete(tempFileName);
     162      }
     163    }
     164
     165    [TestMethod]
    173166    public void ParseEnglishCSVWithoutCommas() {
    174167      string tempFileName = Path.GetTempFileName();
    … …  
    182175      TableFileParser parser = new TableFileParser();
    183176      try {
    184         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    185         Assert.AreEqual(6, parser.Rows);
    186         Assert.AreEqual(4, parser.Columns);
    187         Assert.AreEqual((double)parser.Values[3][0], 3);
    188       } finally {
    189         File.Delete(tempFileName);
    190       }
    191     }
    192 
    193     [TestMethod]
    194     [TestCategory("Problems.Instances")]
    195     [TestProperty("Time", "short")]
     177        parser.Parse(tempFileName);
     178        Assert.AreEqual(6, parser.Rows);
     179        Assert.AreEqual(4, parser.Columns);
     180        Assert.AreEqual((double)parser.Values[3][0], 3);
     181      }
     182      finally {
     183        File.Delete(tempFileName);
     184      }
     185    }
     186
     187    [TestMethod]
    196188    public void ParseEnglishCSVWithoutCommasWithoutSpace() {
    197189      string tempFileName = Path.GetTempFileName();
    … …  
    205197      TableFileParser parser = new TableFileParser();
    206198      try {
    207         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    208         Assert.AreEqual(6, parser.Rows);
    209         Assert.AreEqual(4, parser.Columns);
    210         Assert.AreEqual((double)parser.Values[3][0], 3);
    211       } finally {
    212         File.Delete(tempFileName);
    213       }
    214     }
    215 
    216     [TestMethod]
    217     [TestCategory("Problems.Instances")]
    218     [TestProperty("Time", "short")]
     199        parser.Parse(tempFileName);
     200        Assert.AreEqual(6, parser.Rows);
     201        Assert.AreEqual(4, parser.Columns);
     202        Assert.AreEqual((double)parser.Values[3][0], 3);
     203      }
     204      finally {
     205        File.Delete(tempFileName);
     206      }
     207    }
     208
     209    [TestMethod]
    219210    public void ParseEnglishCSVWithoutCommasWithNames() {
    220211      string tempFileName = Path.GetTempFileName();
    … …  
    229220      TableFileParser parser = new TableFileParser();
    230221      try {
    231         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    232         Assert.AreEqual(6, parser.Rows);
    233         Assert.AreEqual(4, parser.Columns);
    234         Assert.AreEqual((double)parser.Values[3][0], 3);
    235       } finally {
    236         File.Delete(tempFileName);
    237       }
    238     }
    239 
    240     [TestMethod]
    241     [TestCategory("Problems.Instances")]
    242     [TestProperty("Time", "short")]
     222        parser.Parse(tempFileName);
     223        Assert.AreEqual(6, parser.Rows);
     224        Assert.AreEqual(4, parser.Columns);
     225        Assert.AreEqual((double)parser.Values[3][0], 3);
     226      }
     227      finally {
     228        File.Delete(tempFileName);
     229      }
     230    }
     231
     232    [TestMethod]
    243233    public void ParseEnglishCSVWithoutCommasWithoutSpacesWithNames() {
    244234      string tempFileName = Path.GetTempFileName();
    … …  
    253243      TableFileParser parser = new TableFileParser();
    254244      try {
    255         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    256         Assert.AreEqual(6, parser.Rows);
    257         Assert.AreEqual(4, parser.Columns);
    258         Assert.AreEqual((double)parser.Values[3][0], 3);
    259       } finally {
    260         File.Delete(tempFileName);
    261       }
    262     }
    263 
    264 
    265     [TestMethod]
    266     [TestCategory("Problems.Instances")]
    267     [TestProperty("Time", "short")]
     245        parser.Parse(tempFileName);
     246        Assert.AreEqual(6, parser.Rows);
     247        Assert.AreEqual(4, parser.Columns);
     248        Assert.AreEqual((double)parser.Values[3][0], 3);
     249      }
     250      finally {
     251        File.Delete(tempFileName);
     252      }
     253    }
     254
     255
     256    [TestMethod]
    268257    public void ParseGermanTabSeparated() {
    269258      string tempFileName = Path.GetTempFileName();
    … …  
    277266      TableFileParser parser = new TableFileParser();
    278267      try {
    279         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    280         Assert.AreEqual(6, parser.Rows);
    281         Assert.AreEqual(4, parser.Columns);
    282         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    283       } finally {
    284         File.Delete(tempFileName);
    285       }
    286     }
    287 
    288     [TestMethod]
    289     [TestCategory("Problems.Instances")]
    290     [TestProperty("Time", "short")]
     268        parser.Parse(tempFileName);
     269        Assert.AreEqual(6, parser.Rows);
     270        Assert.AreEqual(4, parser.Columns);
     271        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     272      }
     273      finally {
     274        File.Delete(tempFileName);
     275      }
     276    }
     277
     278    [TestMethod]
    291279    public void ParseGermanTabSeparatedWithNames() {
    292280      string tempFileName = Path.GetTempFileName();
    … …  
    301289      TableFileParser parser = new TableFileParser();
    302290      try {
    303         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    304         Assert.AreEqual(6, parser.Rows);
    305         Assert.AreEqual(4, parser.Columns);
    306         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    307       } finally {
    308         File.Delete(tempFileName);
    309       }
    310     }
    311 
    312     [TestMethod]
    313     [TestCategory("Problems.Instances")]
    314     [TestProperty("Time", "short")]
     291        parser.Parse(tempFileName);
     292        Assert.AreEqual(6, parser.Rows);
     293        Assert.AreEqual(4, parser.Columns);
     294        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     295      }
     296      finally {
     297        File.Delete(tempFileName);
     298      }
     299    }
     300
     301    [TestMethod]
    315302    public void ParseEnglishTabSeparated() {
    316303      string tempFileName = Path.GetTempFileName();
    … …  
    324311      TableFileParser parser = new TableFileParser();
    325312      try {
    326         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    327         Assert.AreEqual(6, parser.Rows);
    328         Assert.AreEqual(4, parser.Columns);
    329         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    330       } finally {
    331         File.Delete(tempFileName);
    332       }
    333     }
    334 
    335     [TestMethod]
    336     [TestCategory("Problems.Instances")]
    337     [TestProperty("Time", "short")]
     313        parser.Parse(tempFileName);
     314        Assert.AreEqual(6, parser.Rows);
     315        Assert.AreEqual(4, parser.Columns);
     316        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     317      }
     318      finally {
     319        File.Delete(tempFileName);
     320      }
     321    }
     322    [TestMethod]
    338323    public void ParseEnglishTabSeparatedWithNames() {
    339324      string tempFileName = Path.GetTempFileName();
    … …  
    348333      TableFileParser parser = new TableFileParser();
    349334      try {
    350         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    351         Assert.AreEqual(6, parser.Rows);
    352         Assert.AreEqual(4, parser.Columns);
    353         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    354       } finally {
    355         File.Delete(tempFileName);
    356       }
    357     }
    358 
    359     [TestMethod]
    360     [TestCategory("Problems.Instances")]
    361     [TestProperty("Time", "short")]
     335        parser.Parse(tempFileName);
     336        Assert.AreEqual(6, parser.Rows);
     337        Assert.AreEqual(4, parser.Columns);
     338        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     339      }
     340      finally {
     341        File.Delete(tempFileName);
     342      }
     343    }
     344
     345    [TestMethod]
    362346    public void ParseTabSeparatedWithoutCommas() {
    363347      string tempFileName = Path.GetTempFileName();
    … …  
    371355      TableFileParser parser = new TableFileParser();
    372356      try {
    373         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    374         Assert.AreEqual(6, parser.Rows);
    375         Assert.AreEqual(4, parser.Columns);
    376         Assert.AreEqual((double)parser.Values[3][0], 3);
    377       } finally {
    378         File.Delete(tempFileName);
    379       }
    380     }
    381 
    382     [TestMethod]
    383     [TestCategory("Problems.Instances")]
    384     [TestProperty("Time", "short")]
     357        parser.Parse(tempFileName);
     358        Assert.AreEqual(6, parser.Rows);
     359        Assert.AreEqual(4, parser.Columns);
     360        Assert.AreEqual((double)parser.Values[3][0], 3);
     361      }
     362      finally {
     363        File.Delete(tempFileName);
     364      }
     365    }
     366    [TestMethod]
    385367    public void ParseTabSeparatedWithoutCommasWithNames() {
    386368      string tempFileName = Path.GetTempFileName();
    … …  
    395377      TableFileParser parser = new TableFileParser();
    396378      try {
    397         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    398         Assert.AreEqual(6, parser.Rows);
    399         Assert.AreEqual(4, parser.Columns);
    400         Assert.AreEqual((double)parser.Values[3][0], 3);
    401       } finally {
    402         File.Delete(tempFileName);
    403       }
    404     }
    405 
    406     [TestMethod]
    407     [TestCategory("Problems.Instances")]
    408     [TestProperty("Time", "short")]
     379        parser.Parse(tempFileName);
     380        Assert.AreEqual(6, parser.Rows);
     381        Assert.AreEqual(4, parser.Columns);
     382        Assert.AreEqual((double)parser.Values[3][0], 3);
     383      }
     384      finally {
     385        File.Delete(tempFileName);
     386      }
     387    }
     388
     389    [TestMethod]
    409390    public void ParseWithEmtpyLines() {
    410391      string tempFileName = Path.GetTempFileName();
    … …  
    419400      TableFileParser parser = new TableFileParser();
    420401      try {
    421         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     402        parser.Parse(tempFileName);
    422403        Assert.AreEqual(4, parser.Rows);
    423404        Assert.AreEqual(4, parser.Columns);
    424       } finally {
    425         File.Delete(tempFileName);
    426       }
    427     }
    428 
    429     [TestMethod]
    430     [TestCategory("Problems.Instances")]
    431     [TestProperty("Time", "short")]
     405      }
     406      finally {
     407        File.Delete(tempFileName);
     408      }
     409    }
     410
     411    [TestMethod]
    432412    public void ParseGermanSpaceSeparated() {
    433413      string tempFileName = Path.GetTempFileName();
    … …  
    441421      TableFileParser parser = new TableFileParser();
    442422      try {
    443         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    444         Assert.AreEqual(6, parser.Rows);
    445         Assert.AreEqual(4, parser.Columns);
    446         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    447       } finally {
    448         File.Delete(tempFileName);
    449       }
    450     }
    451 
    452     [TestMethod]
    453     [TestCategory("Problems.Instances")]
    454     [TestProperty("Time", "short")]
     423        parser.Parse(tempFileName);
     424        Assert.AreEqual(6, parser.Rows);
     425        Assert.AreEqual(4, parser.Columns);
     426        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     427      }
     428      finally {
     429        File.Delete(tempFileName);
     430      }
     431    }
     432    [TestMethod]
    455433    public void ParseGermanSpaceSeparatedWithNames() {
    456434      string tempFileName = Path.GetTempFileName();
    … …  
    465443      TableFileParser parser = new TableFileParser();
    466444      try {
    467         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    468         Assert.AreEqual(6, parser.Rows);
    469         Assert.AreEqual(4, parser.Columns);
    470         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    471       } finally {
    472         File.Delete(tempFileName);
    473       }
    474     }
    475 
    476     [TestMethod]
    477     [TestCategory("Problems.Instances")]
    478     [TestProperty("Time", "short")]
     445        parser.Parse(tempFileName);
     446        Assert.AreEqual(6, parser.Rows);
     447        Assert.AreEqual(4, parser.Columns);
     448        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     449      }
     450      finally {
     451        File.Delete(tempFileName);
     452      }
     453    }
     454
     455    [TestMethod]
    479456    public void ParseEnglishSpaceSeparated() {
    480457      string tempFileName = Path.GetTempFileName();
    … …  
    488465      TableFileParser parser = new TableFileParser();
    489466      try {
    490         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    491         Assert.AreEqual(6, parser.Rows);
    492         Assert.AreEqual(4, parser.Columns);
    493         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    494       } finally {
    495         File.Delete(tempFileName);
    496       }
    497     }
    498 
    499     [TestMethod]
    500     [TestCategory("Problems.Instances")]
    501     [TestProperty("Time", "short")]
     467        parser.Parse(tempFileName);
     468        Assert.AreEqual(6, parser.Rows);
     469        Assert.AreEqual(4, parser.Columns);
     470        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     471      }
     472      finally {
     473        File.Delete(tempFileName);
     474      }
     475    }
     476    [TestMethod]
    502477    public void ParseEnglishSpaceSeparatedWithNames() {
    503478      string tempFileName = Path.GetTempFileName();
    … …  
    512487      TableFileParser parser = new TableFileParser();
    513488      try {
    514         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    515         Assert.AreEqual(6, parser.Rows);
    516         Assert.AreEqual(4, parser.Columns);
    517         Assert.AreEqual((double)parser.Values[3][0], 3.14);
    518       } finally {
    519         File.Delete(tempFileName);
    520       }
    521     }
    522 
    523     [TestMethod]
    524     [TestCategory("Problems.Instances")]
    525     [TestProperty("Time", "short")]
     489        parser.Parse(tempFileName);
     490        Assert.AreEqual(6, parser.Rows);
     491        Assert.AreEqual(4, parser.Columns);
     492        Assert.AreEqual((double)parser.Values[3][0], 3.14);
     493      }
     494      finally {
     495        File.Delete(tempFileName);
     496      }
     497    }
     498
     499    [TestMethod]
    526500    public void ParseEnglishSpaceSeparatedWithNamesManyColumns() {
    527501      string tempFileName = Path.GetTempFileName();
    … …  
    534508      TableFileParser parser = new TableFileParser();
    535509      try {
    536         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
     510        parser.Parse(tempFileName);
    537511        Assert.AreEqual(3, parser.Rows);
    538512        Assert.AreEqual(4507, parser.Columns);
    539       } finally {
    540         File.Delete(tempFileName);
    541       }
    542     }
    543 
    544     [TestMethod]
    545     [TestCategory("Problems.Instances")]
    546     [TestProperty("Time", "short")]
     513      }
     514      finally {
     515        File.Delete(tempFileName);
     516      }
     517    }
     518
     519    [TestMethod]
    547520    public void ParseSpaceSeparatedWithoutCommas() {
    548521      string tempFileName = Path.GetTempFileName();
    … …  
    556529      TableFileParser parser = new TableFileParser();
    557530      try {
    558         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    559         Assert.AreEqual(6, parser.Rows);
    560         Assert.AreEqual(4, parser.Columns);
    561         Assert.AreEqual((double)parser.Values[3][0], 3);
    562       } finally {
    563         File.Delete(tempFileName);
    564       }
    565     }
    566 
    567     [TestMethod]
    568     [TestCategory("Problems.Instances")]
    569     [TestProperty("Time", "short")]
     531        parser.Parse(tempFileName);
     532        Assert.AreEqual(6, parser.Rows);
     533        Assert.AreEqual(4, parser.Columns);
     534        Assert.AreEqual((double)parser.Values[3][0], 3);
     535      }
     536      finally {
     537        File.Delete(tempFileName);
     538      }
     539    }
     540    [TestMethod]
    570541    public void ParseSpaceSeparatedWithoutCommasWithNames() {
    571542      string tempFileName = Path.GetTempFileName();
    … …  
    580551      TableFileParser parser = new TableFileParser();
    581552      try {
    582         parser.Parse(tempFileName, parser.AreColumnNamesInFirstLine(tempFileName));
    583         Assert.AreEqual(6, parser.Rows);
    584         Assert.AreEqual(4, parser.Columns);
    585         Assert.AreEqual((double)parser.Values[3][0], 3);
    586       } finally {
     553        parser.Parse(tempFileName);
     554        Assert.AreEqual(6, parser.Rows);
     555        Assert.AreEqual(4, parser.Columns);
     556        Assert.AreEqual((double)parser.Values[3][0], 3);
     557      }
     558      finally {
    587559        File.Delete(tempFileName);
    588560      }
Note: See TracChangeset for help on using the changeset viewer.