Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/14/11 05:34:43 (14 years ago)
Author:
swagner
Message:

Worked on OKB (#1174)

Location:
branches/OKB
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/OKB

    • Property svn:ignore

      •  

        old new  
        11*.suo
         2TestResults

  • branches/OKB/HeuristicLab.Services.OKB.DataAccess/3.3/Tests/UnitTest.cs

    r4558 r5295  
    2020#endregion
    2121
     22using System;
     23using System.Data.Linq;
     24using System.Linq;
    2225using HeuristicLab.Services.OKB.DataAccess;
    2326using Microsoft.VisualStudio.TestTools.UnitTesting;
    … …  
    2932  [TestClass]
    3033  public class UnitTest {
     34    private const int PLATFORMS = 1;
     35    private const int DATATYPES_PER_PLATFORM = 500;
     36    private const int ALGORITHMCLASSES_PER_PLATFORM = 10;
     37    private const int ALGORITHMS_PER_CLASS = 10;
     38    private const int PROBLEMCLASSES_PER_PLATFORM = 10;
     39    private const int PROBLEMS_PER_CLASS = 10;
     40    private const int PARAMETERS_PER_ALGORITHM = 10;
     41    private const int RESULTS_PER_ALGORITHM = 10;
     42    private const int PARAMETERS_PER_PROBLEM = 10;
     43    private const int EXPERIMENTS_PER_PLATFORM = 1000;
     44    private const int RUNS_PER_EXPERIMENT = 10;
     45    private const int ALGORITHMDATA_SIZE = 1024 * 1024;
     46    private const int PROBLEMDATA_SIZE = 1024 * 1024;
     47    private const int BLOBVALUE_SIZE = 1024;
     48
     49    private string[] sqlNames = new string[] { "varbinary", "nvarchar", "float", "bit", "bigint" };
     50    private Random random = new Random();
     51    private DataType[] varbinaryTypes;
     52    private DataType[] nvarcharTypes;
     53    private DataType[] floatTypes;
     54    private DataType[] bitTypes;
     55    private DataType[] bigintTypes;
     56
    3157    public UnitTest() {
    3258      //
    … …  
    7399
    74100    [TestMethod]
    75     public void TestMethod1() {
     101    public void ClearDB() {
    76102      using (OKBDataContext okb = new OKBDataContext()) {
    77         okb.AlgorithmParameterIntValues.DeleteAllOnSubmit(okb.AlgorithmParameterIntValues);
    78         okb.AlgorithmParameters.DeleteAllOnSubmit(okb.AlgorithmParameters);
    79         okb.Experiments.DeleteAllOnSubmit(okb.Experiments);
    80         okb.Algorithms.DeleteAllOnSubmit(okb.Algorithms);
    81         okb.Problems.DeleteAllOnSubmit(okb.Problems);
    82         okb.ProblemClasses.DeleteAllOnSubmit(okb.ProblemClasses);
    83         okb.AlgorithmClasses.DeleteAllOnSubmit(okb.AlgorithmClasses);
     103        okb.ExecuteCommand("DELETE FROM dbo.ResultBlobValue");
     104        okb.ExecuteCommand("DELETE FROM dbo.ResultBoolValue");
     105        okb.ExecuteCommand("DELETE FROM dbo.ResultFloatValue");
     106        okb.ExecuteCommand("DELETE FROM dbo.ResultIntValue");
     107        okb.ExecuteCommand("DELETE FROM dbo.ResultStringValue");
     108
     109        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameterBlobValue");
     110        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameterBoolValue");
     111        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameterFloatValue");
     112        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameterIntValue");
     113        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameterStringValue");
     114
     115        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameterBlobValue");
     116        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameterBoolValue");
     117        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameterFloatValue");
     118        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameterIntValue");
     119        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameterStringValue");
     120
     121        okb.ExecuteCommand("DELETE FROM dbo.Run");
     122        okb.ExecuteCommand("DELETE FROM dbo.Experiment");
     123        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmData");
     124        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmUser");
     125        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmParameter");
     126        okb.ExecuteCommand("DELETE FROM dbo.Result");
     127        okb.ExecuteCommand("DELETE FROM dbo.Algorithm");
     128        okb.ExecuteCommand("DELETE FROM dbo.AlgorithmClass");
     129        okb.ExecuteCommand("DELETE FROM dbo.ProblemData");
     130        okb.ExecuteCommand("DELETE FROM dbo.ProblemUser");
     131        okb.ExecuteCommand("DELETE FROM dbo.ProblemParameter");
     132        okb.ExecuteCommand("DELETE FROM dbo.Problem");
     133        okb.ExecuteCommand("DELETE FROM dbo.ProblemClass");
     134        okb.ExecuteCommand("DELETE FROM dbo.DataType");
     135        okb.ExecuteCommand("DELETE FROM dbo.Platform");
     136      }
     137    }
     138
     139    [TestMethod]
     140    public void InitDummyDB() {
     141      using (OKBDataContext okb = new OKBDataContext()) {
     142        for (int i = 0; i < PLATFORMS; i++) {
     143          CreatePlatform(okb);
     144        }
    84145        okb.SubmitChanges();
    85         AlgorithmClass ac = new AlgorithmClass() { Name = "AlgorithmClass" };
    86         ProblemClass pc = new ProblemClass() { Name = "ProblemClass" };
    87         Algorithm a = new Algorithm() { Name = "Alg", AlgorithmClass = ac, PlatformId = 1 };
    88         Problem p = new Problem() { Name = "Prb", ProblemClass = pc, PlatformId = 1 };
    89         Experiment e = new Experiment() { Algorithm = a, Problem = p };
    90         AlgorithmParameter ap = new AlgorithmParameter() { Name = "Param", Algorithm = a, DataTypeId = 1 };
    91         ap.AlgorithmParameterIntValues.Add(new AlgorithmParameterIntValue() { AlgorithmParameterId = 0, Experiment = e, Value = 23 });
    92         okb.AlgorithmClasses.InsertOnSubmit(ac);
    93         okb.SubmitChanges();
     146      }
     147    }
     148
     149    [TestMethod]
     150    public void CreateDummyExperiments() {
     151      using (OKBDataContext okb = new OKBDataContext()) {
     152        foreach (Platform platform in okb.Platforms) {
     153          for (int i = 0; i < EXPERIMENTS_PER_PLATFORM; i++) {
     154            Algorithm[] algorithms = okb.Algorithms.Where(x => x.PlatformId == platform.Id).ToArray();
     155            Problem[] problems = okb.Problems.Where(x => x.PlatformId == platform.Id).ToArray();
     156            varbinaryTypes = null;
     157            nvarcharTypes = null;
     158            floatTypes = null;
     159            bitTypes = null;
     160            bigintTypes = null;
     161
     162            CreateExperiment(okb, algorithms[random.Next(algorithms.Length)], problems[random.Next(problems.Length)], platform);
     163          }
     164          okb.SubmitChanges();
     165        }
     166      }
     167    }
     168
     169    private void CreatePlatform(OKBDataContext okb) {
     170      Platform entity = new Platform();
     171      entity.Name = Guid.NewGuid().ToString();
     172      entity.Description = Guid.NewGuid().ToString();
     173      okb.Platforms.InsertOnSubmit(entity);
     174
     175      for (int i = 0; i < DATATYPES_PER_PLATFORM; i++) {
     176        CreateDataType(okb, entity);
     177      }
     178      okb.SubmitChanges();
     179
     180      varbinaryTypes = null;
     181      nvarcharTypes = null;
     182      floatTypes = null;
     183      bitTypes = null;
     184      bigintTypes = null;
     185
     186      for (int i = 0; i < ALGORITHMCLASSES_PER_PLATFORM; i++) {
     187        CreateAlgorithmClass(okb, entity);
     188      }
     189      for (int i = 0; i < PROBLEMCLASSES_PER_PLATFORM; i++) {
     190        CreateProblemClass(okb, entity);
     191      }
     192    }
     193    private void CreateDataType(OKBDataContext okb, Platform platform) {
     194      DataType entity = new DataType();
     195      entity.Name = Guid.NewGuid().ToString();
     196      entity.TypeName = Guid.NewGuid().ToString();
     197      entity.SqlName = sqlNames[random.Next(sqlNames.Length)];
     198      entity.Platform = platform;
     199      okb.DataTypes.InsertOnSubmit(entity);
     200    }
     201    private DataType GetDataType(OKBDataContext okb, Platform platform, string sqlName) {
     202      if (varbinaryTypes == null) varbinaryTypes = okb.DataTypes.Where(x => (x.PlatformId == platform.Id) && (x.SqlName == "varbinary")).ToArray();
     203      if (nvarcharTypes == null) nvarcharTypes = okb.DataTypes.Where(x => (x.PlatformId == platform.Id) && (x.SqlName == "nvarchar")).ToArray();
     204      if (floatTypes == null) floatTypes = okb.DataTypes.Where(x => (x.PlatformId == platform.Id) && (x.SqlName == "float")).ToArray();
     205      if (bitTypes == null) bitTypes = okb.DataTypes.Where(x => (x.PlatformId == platform.Id) && (x.SqlName == "bit")).ToArray();
     206      if (bigintTypes == null) bigintTypes = okb.DataTypes.Where(x => (x.PlatformId == platform.Id) && (x.SqlName == "bigint")).ToArray();
     207
     208      switch (sqlName) {
     209        case "varbinary": return varbinaryTypes[random.Next(varbinaryTypes.Length)];
     210        case "nvarchar": return nvarcharTypes[random.Next(nvarcharTypes.Length)];
     211        case "float": return floatTypes[random.Next(floatTypes.Length)];
     212        case "bit": return bitTypes[random.Next(bitTypes.Length)];
     213        case "bigint": return bigintTypes[random.Next(bigintTypes.Length)];
     214        default: return null;
     215      }
     216    }
     217    private void CreateAlgorithmClass(OKBDataContext okb, Platform platform) {
     218      AlgorithmClass entity = new AlgorithmClass();
     219      entity.Name = Guid.NewGuid().ToString();
     220      entity.Description = Guid.NewGuid().ToString();
     221      for (int i = 0; i < ALGORITHMS_PER_CLASS; i++) {
     222        CreateAlgorithm(okb, entity, platform);
     223      }
     224      okb.AlgorithmClasses.InsertOnSubmit(entity);
     225    }
     226    private void CreateProblemClass(OKBDataContext okb, Platform platform) {
     227      ProblemClass entity = new ProblemClass();
     228      entity.Name = Guid.NewGuid().ToString();
     229      entity.Description = Guid.NewGuid().ToString();
     230      for (int i = 0; i < PROBLEMS_PER_CLASS; i++) {
     231        CreateProblem(okb, entity, platform);
     232      }
     233      okb.ProblemClasses.InsertOnSubmit(entity);
     234    }
     235    private void CreateAlgorithm(OKBDataContext okb, AlgorithmClass algorithmClass, Platform platform) {
     236      Algorithm entity = new Algorithm();
     237      entity.Name = Guid.NewGuid().ToString();
     238      entity.Description = Guid.NewGuid().ToString();
     239      entity.AlgorithmClass = algorithmClass;
     240      entity.Platform = platform;
     241      CreateAlgorithmData(okb, entity, platform);
     242      for (int i = 0; i < PARAMETERS_PER_ALGORITHM; i++) {
     243        CreateAlgorithmParameter(okb, entity, platform);
     244      }
     245      for (int i = 0; i < RESULTS_PER_ALGORITHM; i++) {
     246        CreateResult(okb, entity, platform);
     247      }
     248      okb.Algorithms.InsertOnSubmit(entity);
     249    }
     250    private void CreateAlgorithmData(OKBDataContext okb, Algorithm algorithm, Platform platform) {
     251      AlgorithmData entity = new AlgorithmData();
     252      entity.Algorithm = algorithm;
     253      entity.Data = new System.Data.Linq.Binary(new byte[ALGORITHMDATA_SIZE]);
     254      entity.DataType = GetDataType(okb, platform, "varbinary");
     255      okb.AlgorithmDatas.InsertOnSubmit(entity);
     256    }
     257    private void CreateAlgorithmParameter(OKBDataContext okb, Algorithm algorithm, Platform platform) {
     258      AlgorithmParameter entity = new AlgorithmParameter();
     259      entity.Name = Guid.NewGuid().ToString();
     260      entity.Alias = Guid.NewGuid().ToString();
     261      entity.Description = Guid.NewGuid().ToString();
     262      entity.Algorithm = algorithm;
     263      entity.DataType = GetDataType(okb, platform, sqlNames[random.Next(sqlNames.Length)]);
     264      okb.AlgorithmParameters.InsertOnSubmit(entity);
     265    }
     266    private void CreateResult(OKBDataContext okb, Algorithm algorithm, Platform platform) {
     267      Result entity = new Result();
     268      entity.Name = Guid.NewGuid().ToString();
     269      entity.Alias = Guid.NewGuid().ToString();
     270      entity.Description = Guid.NewGuid().ToString();
     271      entity.Algorithm = algorithm;
     272      entity.DataType = GetDataType(okb, platform, sqlNames[random.Next(sqlNames.Length)]);
     273      okb.Results.InsertOnSubmit(entity);
     274    }
     275    private void CreateProblem(OKBDataContext okb, ProblemClass problemClass, Platform platform) {
     276      Problem entity = new Problem();
     277      entity.Name = Guid.NewGuid().ToString();
     278      entity.Description = Guid.NewGuid().ToString();
     279      entity.ProblemClass = problemClass;
     280      entity.Platform = platform;
     281      CreateProblemData(okb, entity, platform);
     282      for (int i = 0; i < PARAMETERS_PER_PROBLEM; i++) {
     283        CreateProblemParameter(okb, entity, platform);
     284      }
     285      okb.Problems.InsertOnSubmit(entity);
     286    }
     287    private void CreateProblemData(OKBDataContext okb, Problem problem, Platform platform) {
     288      ProblemData entity = new ProblemData();
     289      entity.Problem = problem;
     290      entity.Data = new System.Data.Linq.Binary(new byte[PROBLEMDATA_SIZE]);
     291      entity.DataType = GetDataType(okb, platform, "varbinary");
     292      okb.ProblemDatas.InsertOnSubmit(entity);
     293    }
     294    private void CreateProblemParameter(OKBDataContext okb, Problem problem, Platform platform) {
     295      ProblemParameter entity = new ProblemParameter();
     296      entity.Name = Guid.NewGuid().ToString();
     297      entity.Alias = Guid.NewGuid().ToString();
     298      entity.Description = Guid.NewGuid().ToString();
     299      entity.Problem = problem;
     300      entity.DataType = GetDataType(okb, platform, sqlNames[random.Next(sqlNames.Length)]);
     301      okb.ProblemParameters.InsertOnSubmit(entity);
     302    }
     303    private void CreateExperiment(OKBDataContext okb, Algorithm algorithm, Problem problem, Platform platform) {
     304      Experiment entity = new Experiment();
     305      entity.Algorithm = algorithm;
     306      entity.Problem = problem;
     307
     308      foreach (AlgorithmParameter algorithmParameter in okb.AlgorithmParameters.Where(x => x.AlgorithmId == algorithm.Id)) {
     309        CreateAlgorithmParameterValue(okb, algorithmParameter, entity, platform);
     310      }
     311      foreach (ProblemParameter problemParameter in okb.ProblemParameters.Where(x => x.ProblemId == problem.Id)) {
     312        CreateProblemParameterValue(okb, problemParameter, entity, platform);
     313      }
     314
     315      for (int i = 0; i < RUNS_PER_EXPERIMENT; i++) {
     316        CreateRun(okb, entity, platform);
     317      }
     318      okb.Experiments.InsertOnSubmit(entity);
     319    }
     320    private void CreateAlgorithmParameterValue(OKBDataContext okb, AlgorithmParameter algorithmParameter, Experiment experiment, Platform platform) {
     321      switch (algorithmParameter.DataType.SqlName) {
     322        case "varbinary":
     323          AlgorithmParameterBlobValue v1 = new AlgorithmParameterBlobValue();
     324          v1.AlgorithmParameter = algorithmParameter;
     325          v1.Experiment = experiment;
     326          v1.Value = new Binary(new byte[BLOBVALUE_SIZE]);
     327          v1.DataType = GetDataType(okb, platform, "varbinary");
     328          okb.AlgorithmParameterBlobValues.InsertOnSubmit(v1);
     329          return;
     330        case "bit":
     331          AlgorithmParameterBoolValue v2 = new AlgorithmParameterBoolValue();
     332          v2.AlgorithmParameter = algorithmParameter;
     333          v2.Experiment = experiment;
     334          v2.Value = random.Next(2) == 0;
     335          v2.DataType = GetDataType(okb, platform, "bit");
     336          okb.AlgorithmParameterBoolValues.InsertOnSubmit(v2);
     337          return;
     338        case "float":
     339          AlgorithmParameterFloatValue v3 = new AlgorithmParameterFloatValue();
     340          v3.AlgorithmParameter = algorithmParameter;
     341          v3.Experiment = experiment;
     342          v3.Value = random.NextDouble();
     343          v3.DataType = GetDataType(okb, platform, "float");
     344          okb.AlgorithmParameterFloatValues.InsertOnSubmit(v3);
     345          return;
     346        case "bigint":
     347          AlgorithmParameterIntValue v4 = new AlgorithmParameterIntValue();
     348          v4.AlgorithmParameter = algorithmParameter;
     349          v4.Experiment = experiment;
     350          v4.Value = random.Next();
     351          v4.DataType = GetDataType(okb, platform, "bigint");
     352          okb.AlgorithmParameterIntValues.InsertOnSubmit(v4);
     353          return;
     354        case "nvarchar":
     355          AlgorithmParameterStringValue v5 = new AlgorithmParameterStringValue();
     356          v5.AlgorithmParameter = algorithmParameter;
     357          v5.Experiment = experiment;
     358          v5.Value = Guid.NewGuid().ToString();
     359          v5.DataType = GetDataType(okb, platform, "nvarchar");
     360          okb.AlgorithmParameterStringValues.InsertOnSubmit(v5);
     361          return;
     362      }
     363    }
     364    private void CreateProblemParameterValue(OKBDataContext okb, ProblemParameter problemParameter, Experiment experiment, Platform platform) {
     365      switch (problemParameter.DataType.SqlName) {
     366        case "varbinary":
     367          ProblemParameterBlobValue v1 = new ProblemParameterBlobValue();
     368          v1.ProblemParameter = problemParameter;
     369          v1.Experiment = experiment;
     370          v1.Value = new Binary(new byte[BLOBVALUE_SIZE]);
     371          v1.DataType = GetDataType(okb, platform, "varbinary");
     372          okb.ProblemParameterBlobValues.InsertOnSubmit(v1);
     373          return;
     374        case "bit":
     375          ProblemParameterBoolValue v2 = new ProblemParameterBoolValue();
     376          v2.ProblemParameter = problemParameter;
     377          v2.Experiment = experiment;
     378          v2.Value = random.Next(2) == 0;
     379          v2.DataType = GetDataType(okb, platform, "bit");
     380          okb.ProblemParameterBoolValues.InsertOnSubmit(v2);
     381          return;
     382        case "float":
     383          ProblemParameterFloatValue v3 = new ProblemParameterFloatValue();
     384          v3.ProblemParameter = problemParameter;
     385          v3.Experiment = experiment;
     386          v3.Value = random.NextDouble();
     387          v3.DataType = GetDataType(okb, platform, "float");
     388          okb.ProblemParameterFloatValues.InsertOnSubmit(v3);
     389          return;
     390        case "bigint":
     391          ProblemParameterIntValue v4 = new ProblemParameterIntValue();
     392          v4.ProblemParameter = problemParameter;
     393          v4.Experiment = experiment;
     394          v4.Value = random.Next();
     395          v4.DataType = GetDataType(okb, platform, "bigint");
     396          okb.ProblemParameterIntValues.InsertOnSubmit(v4);
     397          return;
     398        case "nvarchar":
     399          ProblemParameterStringValue v5 = new ProblemParameterStringValue();
     400          v5.ProblemParameter = problemParameter;
     401          v5.Experiment = experiment;
     402          v5.Value = Guid.NewGuid().ToString();
     403          v5.DataType = GetDataType(okb, platform, "nvarchar");
     404          okb.ProblemParameterStringValues.InsertOnSubmit(v5);
     405          return;
     406      }
     407    }
     408    private void CreateRun(OKBDataContext okb, Experiment experiment, Platform platform) {
     409      Run entity = new Run();
     410      entity.RandomSeed = random.Next();
     411      entity.CreatedDate = DateTime.Now;
     412      entity.UserId = Guid.NewGuid();
     413      entity.ClientId = Guid.NewGuid();
     414      entity.Experiment = experiment;
     415
     416      foreach (Result result in okb.Results.Where(x => x.AlgorithmId == experiment.AlgorithmId)) {
     417        CreateResultValue(okb, result, entity, platform);
     418      }
     419      okb.Runs.InsertOnSubmit(entity);
     420    }
     421    private void CreateResultValue(OKBDataContext okb, Result result, Run run, Platform platform) {
     422      switch (result.DataType.SqlName) {
     423        case "varbinary":
     424          ResultBlobValue v1 = new ResultBlobValue();
     425          v1.Result = result;
     426          v1.Run = run;
     427          v1.Value = new Binary(new byte[BLOBVALUE_SIZE]);
     428          v1.DataType = GetDataType(okb, platform, "varbinary");
     429          okb.ResultBlobValues.InsertOnSubmit(v1);
     430          return;
     431        case "bit":
     432          ResultBoolValue v2 = new ResultBoolValue();
     433          v2.Result = result;
     434          v2.Run = run;
     435          v2.Value = random.Next(2) == 0;
     436          v2.DataType = GetDataType(okb, platform, "bit");
     437          okb.ResultBoolValues.InsertOnSubmit(v2);
     438          return;
     439        case "float":
     440          ResultFloatValue v3 = new ResultFloatValue();
     441          v3.Result = result;
     442          v3.Run = run;
     443          v3.Value = random.NextDouble();
     444          v3.DataType = GetDataType(okb, platform, "float");
     445          okb.ResultFloatValues.InsertOnSubmit(v3);
     446          return;
     447        case "bigint":
     448          ResultIntValue v4 = new ResultIntValue();
     449          v4.Result = result;
     450          v4.Run = run;
     451          v4.Value = random.Next();
     452          v4.DataType = GetDataType(okb, platform, "bigint");
     453          okb.ResultIntValues.InsertOnSubmit(v4);
     454          return;
     455        case "nvarchar":
     456          ResultStringValue v5 = new ResultStringValue();
     457          v5.Result = result;
     458          v5.Run = run;
     459          v5.Value = Guid.NewGuid().ToString();
     460          v5.DataType = GetDataType(okb, platform, "nvarchar");
     461          okb.ResultStringValues.InsertOnSubmit(v5);
     462          return;
    94463      }
    95464    }
Note: See TracChangeset for help on using the changeset viewer.