public void GenerateNewDataSet() { IDataGenerator dataGenerator = Bootstrapper.ServiceLocator.GetService <IDataGenerator>(viewModel.UseBinaryGenerator ? GeneratorType.Binary : GeneratorType.Numeric); // ProfileManager.Provider.GetPropertyValues if (ApplicationModel.System != null) { var sys = InformationSystem.CreateFromGenerator(dataGenerator, viewModel.NumberOfAttributes, viewModel.NumberOfObjects); ApplicationModel.System.Rows = sys.Rows; } else { ApplicationModel.System = InformationSystem.CreateFromGenerator(dataGenerator, viewModel.NumberOfAttributes, viewModel.NumberOfObjects); } IMainFormViewPresenter mainForm; #if WEB mainForm = HttpContext.Current.Session["presenter"] as IMainFormViewPresenter; #else mainForm = Bootstrapper.ServiceLocator.GetService <IMainFormViewPresenter>(); #endif mainForm.ViewModel.DataSetName = "zbiór wygenerowany"; mainForm.ViewModel.AttributesQuantity = ViewModel.NumberOfAttributes; mainForm.ViewModel.ObjectsQuantity = ViewModel.NumberOfObjects; }
public void Initialize() { context = new DataContext(); repository = new DataRepository(context); generator = new RandomValuesGenerator(); generator.GenarateData(context); }
private Action <StoredProcedureWorkload> BuildWorkloadAction(IDataGenerator generator) { Action <StoredProcedureWorkload> workloadReloadAction = null; object payload = new String('a', 100); if (config.Type.Equals("HYBRID")) { int queryCount = config.QueryCount; workloadReloadAction = workload => { HybridYCSBWorkload hybridWorkload = workload as HybridYCSBWorkload; for (int i = 0; i < queryCount; i++) { hybridWorkload.Keys[i] = generator.NextIntKey(); hybridWorkload.Values[i] = payload; hybridWorkload.Queries[i] = generator.NextOperation(); } }; } else { workloadReloadAction = workload => { YCSBWorkload ycsbWorkload = workload as YCSBWorkload; ycsbWorkload.Type = generator.NextOperation(); ycsbWorkload.Key = generator.NextIntKey(); ycsbWorkload.Value = payload; }; } return(workloadReloadAction); }
public TransactionsFeeDataGenerator(ITransactionData transactionData, IDataGenerator dataGenerator, IFeeCalculator feeCalculator, IOutputWritter outputWritter) { _transactionData = transactionData; _dataGenerator = dataGenerator; _feeCalculator = feeCalculator; _consoleWritter = outputWritter; }
private List <TransactionExecutor> fillYCSBWorkLoad() { List <TransactionExecutor> executorList = new List <TransactionExecutor>(); IDataGenerator generator = this.BuildDataGenerator(); var workloadAction = this.BuildWorkloadAction(generator); StoredProcedureWorkload.Reload = workloadAction; StoredProcedureType type = this.GetStoredProcedureType(config.Type); this.totalTasks = this.txCountPerExecutor * executorCount; for (int i = 0; i < executorCount; i++) { int partition_index = i % this.versionDb.PartitionCount; Queue <TransactionRequest> requestQueue = new Queue <TransactionRequest>(); for (int j = 0; j < this.txCountPerExecutor; j++) { StoredProcedureWorkload workload = GetStoredProcedureWorkload(config.Type, config.QueryCount); StoredProcedureWorkload.Reload(workload); string sessionId = (i * this.txCountPerExecutor + j + 1).ToString(); TransactionRequest request = new TransactionRequest(sessionId, workload, StoredProcedureType.YCSBStordProcedure); requestQueue.Enqueue(request); } executorList.Add(new TransactionExecutor(this.versionDb, null, requestQueue, partition_index, i, 0, null, tables, null, null, this.recordCount, this.txCountPerExecutor, null, null, type, config.PipelineSize)); } return(executorList); }
public void Initialize() { context = new DataContext(); service = new DataService(new DataRepository(context)); generator = new FixedValuesGenerator(); generator.GenarateData(context); }
private IDataGenerator ResolveUniqueDataGenerator(Type clrType, IDataGenerator dataGenerator, IEnumerable <DataGenerationHint> hints) { var genericMethod = this.GetType().GetMethods(false, false).Single(m => m.Name == "ResolveUniqueDataGenerator" && m.IsGenericMethodDefinition); genericMethod = genericMethod.MakeGenericMethod(clrType); return((IDataGenerator)genericMethod.Invoke(this, new object[] { dataGenerator, hints })); }
/// <summary> /// Generates data for members for which data generators are added. /// </summary> /// <returns>Key-value pairs where key is a member path and value is a member value.</returns> /// <remarks>If there is a loop in the data generators, it will randomly decide how deep to recurse.</remarks> public override IList <NamedValue> GenerateData() { ExceptionUtilities.CheckAllRequiredDependencies(this); if (this.currentRecursionDepth > this.recursionLimit) { // TODO: should this be null instead? return(new List <NamedValue>()); } if (this.currentRecursionDepth == 0) { this.recursionLimit = this.random.Next(MaxRecursionLimit); } try { this.currentRecursionDepth++; var result = new List <NamedValue>(); foreach (string currentMemberPath in this.membersDataGenerators.Keys) { IDataGenerator memberDataGenerator = this.GetMemberDataGenerator(currentMemberPath); var memberData = memberDataGenerator.GenerateData(); result.AddMemberData(currentMemberPath, memberData); } return(result); } finally { this.currentRecursionDepth--; } }
/// <summary> /// Adds the item. /// </summary> /// <param name="index"> /// The index. /// </param> /// <param name="item"> /// The item. /// </param> /// <param name="sourceToTarget"> /// if set to <c>true</c> from source to target. /// </param> private void AddItem(int index, object item, bool sourceToTarget = true) { ICollectionHandler handler = sourceToTarget ? this.TargetHandler : this.SourceHandler; BindContext bindContext = sourceToTarget ? this.BindTarget : this.BindSource; var list = bindContext.Value as IList; bool handled = false; if (handler != null) { handled = handler.AddItem(index, item, bindContext.Source, bindContext.Value); } if (!handled && list != null) { IDataGenerator dataGenerator = sourceToTarget ? this.TargetDataGenerator : this.SourceDataGenerator; object parameter = sourceToTarget ? this.TargetDataParameter : this.SourceDataParameter; Func <object, object, object> generator = sourceToTarget ? this.TargetGenerator : this.SourceGenerator; if (dataGenerator != null) { list.Insert(index, dataGenerator.Generate(item, parameter)); } else if (generator != null) { list.Insert(index, generator(item, parameter)); } else { list.Insert(index, item); } } }
public HomeController(ISharePointService sharePointService, IDataGenerator dataGenerator, IIndexVMFactory indexVMFactory) { this.sharePointService = sharePointService; this.dataGenerator = dataGenerator; this.indexVMFactory = indexVMFactory; }
public IDataGenerator Create(string type) { IDataGenerator generator = null; this.generators.TryGetValue(type, out generator); return(generator); }
public SubscriptionManager(ILogger <SubscriptionManager> logger, ILogger <RangeJoiner <RawDataRange> > rangeLogger, GeneratorConfiguration configuration, IDataGenerator generator) { _logger = logger; _rangeLogger = rangeLogger; _configuration = configuration; _generator = generator; }
/// <summary> /// Generates values for the properties with the specified paths. /// </summary> /// <param name="conceptualDataServices">Conceptual data services.</param> /// <param name="entitySetName">A name of the entity set for which data needs to be generated.</param> /// <param name="entityTypeFullName">An entity type full name.</param> /// <param name="propertyPaths">The property paths for which to generate values.</param> /// <param name="valuesToAvoid">The collection of named values where name is a property path and value is a property value which should be avoided when generating value for this property.</param> /// <returns>Generated properties' values.</returns> public static IEnumerable <NamedValue> GeneratePropertyValues(this IEntityModelConceptualDataServices conceptualDataServices, string entitySetName, string entityTypeFullName, IEnumerable <string> propertyPaths, IEnumerable <NamedValue> valuesToAvoid) { ExceptionUtilities.CheckArgumentNotNull(conceptualDataServices, "conceptualDataServices"); ExceptionUtilities.CheckArgumentNotNull(propertyPaths, "propertyPaths"); ExceptionUtilities.CheckArgumentNotNull(valuesToAvoid, "valuesToAvoid"); var memberDataGenerators = conceptualDataServices.GetStructuralGenerator(entityTypeFullName, entitySetName); const int MaxAttempts = 10; List <NamedValue> generatedValues = new List <NamedValue>(); foreach (string propertyPath in propertyPaths) { IDataGenerator propertyGenerator = memberDataGenerators.GetMemberDataGenerator(propertyPath); var valuesToAvoidForThisProperty = valuesToAvoid.Where(nv => nv.Name == propertyPath).Select(nv => nv.Value).ToList(); int attemptCount = 0; object value; do { value = propertyGenerator.GenerateData(); attemptCount++; }while (valuesToAvoidForThisProperty.Contains(value, ValueComparer.Instance) && attemptCount < MaxAttempts); generatedValues.AddMemberData(propertyPath, value); } return(generatedValues); }
private List <TransactionExecutor> MockFillYCSBWorkload(int offset = 0, int limit = -1) { int appendCount = limit == -1 ? this.executorCount : limit; List <TransactionExecutor> executors = new List <TransactionExecutor>(); IDataGenerator generator = this.BuildDataGenerator(); var workloadAction = this.BuildWorkloadAction(generator); StoredProcedureWorkload.Reload = workloadAction; StoredProcedureType spType = this.GetStoredProcedureType(config.Type); for (int i = offset; i < offset + appendCount; i++) { Queue <TransactionRequest> reqQueue = new Queue <TransactionRequest>(); StoredProcedureWorkload workload = GetStoredProcedureWorkload(config.Type, config.QueryCount); this.totalTasks += this.txCountPerExecutor; int partition_index = i % this.versionDb.PartitionCount; int txRangeStart = i; if (config.MultiProcessMode) { txRangeStart = i + config.ProcessOffset * RANGE_OFFSET_PER_PROCESS; } executors.Add(new TransactionExecutor(this.versionDb, null, reqQueue, partition_index, txRangeStart, 0, null, tables, null, null, this.recordCount, this.txCountPerExecutor, null, workload, spType, config.PipelineSize)); Console.WriteLine("Filled {0}-th executors", i + 1); } return(executors); }
private void addGenerator(string columnName, Type type) { DataColumn col = table.Columns.Add(columnName, type); IDataGenerator gen = DataGeneratorConverter.FromColumn(col); this.generators.Add(gen.GetType(), gen); }
public TrackingContext(IDataGenerator generator, ProgressTracker tracker) { this.generator = generator; this.tracker = tracker; generator.GenerationStart += OnGenerationStart; generator.GenerationComplete += OnGenerationComplete; generator.GenerationProgress += OnGenerationProgress; }
protected virtual void PopulateDataGenerators() { foreach (DataColumn column in this.Table.Columns) { IDataGenerator gen = DataGeneratorConverter.FromColumn(column); this.dataGenerators.Add(gen); } }
private IDataGenerator CreateObjectDataGenerator(Type clrType, IStructuralDataAdapter dataManager, INamedValuesGenerator memberValuesGenerator) { ConstructorInfo ci = typeof(StructuralDataGenerator <>).MakeGenericType(clrType).GetInstanceConstructor(true, new Type[] { typeof(IStructuralDataAdapter), typeof(INamedValuesGenerator) }); IDataGenerator objectDataGen = (IDataGenerator)ci.Invoke(new object[] { dataManager, memberValuesGenerator }); return(objectDataGen); }
public bool Contains(IDataGenerator dataGenerator) { if (dataGenerator == null) { throw new ArgumentNullException("dataGenerator"); } return(this.Contains(dataGenerator.Column)); }
public void Remove(IDataGenerator dataGenerator) { if (dataGenerator == null) { throw new ArgumentNullException("dataGenerator"); } this.Remove(dataGenerator.Column); }
private void Form1_Load(object sender, EventArgs e) { cB_Data.DataSource = data; cB_Factory.DataSource = factory; sData = data[0]; sFactory = factory[0]; }
public bool AllowDBNull(IDataGenerator dg) { if (dg == null) { throw new ArgumentNullException("dg"); } return(dg.Column.AllowDBNull); }
private void addGenerator(Type type, Type expectedGeneratorType) { DataColumn col = table.Columns.Add(type.Name, type); IDataGenerator gen = DataGeneratorConverter.FromColumn(col); Assert.AreEqual(expectedGeneratorType, gen.GetType()); Assert.AreEqual(type, gen.GeneratedType); }
public void Case1() { _dataGenerator = new AddressInfoCsvGenerator(); var data = _dataGenerator.Generate <API.Model.AddressInfo>(csvPath, query: x => x.Name == "Antalya"); _dataGenerator = new AddressInfoXmlGenerator(); Assert.IsNotNull(_dataGenerator.Save(data), "baþarýlý bir þekilde kaydedildi"); }
private IDataGenerator ResolveCollectionDataGenerator(CollectionDataType collectionType, IList <DataGenerationHint> dataGenHints) { IDataGenerator elementDataGenerator = this.ResolveNonCollectionDataGenerator(collectionType.ElementDataType, false, dataGenHints); int minCount = dataGenHints.Max <CollectionMinCountHint, int>(0); int maxCount = dataGenHints.Min <CollectionMaxCountHint, int>(Math.Max(minCount, 10)); return(new CollectionStructuralDataGenerator(elementDataGenerator, this.Random, minCount, maxCount)); }
public void Case2() { _dataGenerator = new AddressInfoCsvGenerator(); var data = _dataGenerator.Generate(csvPath); data.Cities = data.Cities.OrderBy(x => x.Name).ThenBy(x => x.Districts.OrderBy(c => c.Name)).ToList(); Assert.IsNotNull(_dataGenerator.Save(data), "baþarýlý"); }
public void Case3() { _dataGenerator = new AddressInfoXmlGenerator(); var data = _dataGenerator.Generate(xmlPath, x => x.Name == "Ankara", c => c.Districts.OrderBy(v => v.Zips.OrderByDescending(y => y.Code))); _dataGenerator = new AddressInfoCsvGenerator(); Assert.IsNotNull(_dataGenerator.Save(data), "baþarýlý bir þekilde kaydedildi"); }
public void Add(IDataGenerator dataGenerator) { if (dataGenerator == null) { throw new ArgumentNullException("dataGenerator"); } this.generators.Add(dataGenerator.Column.ColumnName, dataGenerator); }
/// <summary> /// Initializes instance of the FileWorker. /// </summary> /// <param name="generator">Data generator</param> /// <exception cref="ArgumentNullException">Throws when <paramref name="generator"/> is null.</exception> public FileWorker(IDataGenerator generator) { if (generator is null) { throw new ArgumentNullException(String.Format("{0} can't be null.", generator)); } Generator = generator; }
public object Clone() { IDataGenerator[] gen = new IDataGenerator[this.generators.Length]; for(int i=0; i<this.generators.Length; ++i) { gen[i] = (IDataGenerator)this.generators[i].Clone(); } return new MixedDataGenerator(gen); }
public object Clone() { IDataGenerator[] gen = new IDataGenerator[this.generators.Length]; for (int i = 0; i < this.generators.Length; ++i) { gen[i] = (IDataGenerator)this.generators[i].Clone(); } return(new MixedDataGenerator(gen)); }
public void GeneratesTheRightType(IDataGenerator dg) { dg.NullProbability=0; // generate row DataRow row = dg.Column.Table.NewRow(); dg.GenerateData(row); Assert.IsFalse(row.HasErrors); // check that value has the right type ReflectionAssert.IsAssignableFrom(dg.GeneratedType,row[dg.Column].GetType()); }
private static UnitCollectionsModel GenerateData(IRandomGenerator generator, IDataGenerator randomGenerator) { var generatedData = new UnitCollectionsModel() { Songs = randomGenerator.GenerateSongs(generator, 20), Albums = randomGenerator.GenerateAlbums(generator, 20), Artists = randomGenerator.GenerateArtists(generator, 20) }; return generatedData; }
public AppController(IUnitOfWork unitOfWork, IAppRepository appRepository, IDocRepository docRepository, IUserRepository userRepository, IClassificationRepository classificationRepository, INomRepository nomRepository, IDataGenerator dataGenerator) { this.unitOfWork = unitOfWork; this.appRepository = appRepository; this.docRepository = docRepository; this.userRepository = userRepository; this.classificationRepository = classificationRepository; this.nomRepository = nomRepository; this.dataGenerator = dataGenerator; }
public DataGeneratorExecutor(IDataGenerator dataGenerator, int entriesCount) { this.dataGenerator = dataGenerator; this.entriesCount = entriesCount; }
public void Remove(IDataGenerator dataGenerator) { if (dataGenerator==null) throw new ArgumentNullException("dataGenerator"); this.Remove(dataGenerator.Column); }
public CompressionRunner(IDataGenerator dataGenerator, IDataCompressor dataCompressor) { _dataGenerator = dataGenerator; _dataCompressor = dataCompressor; }
public bool AllowDBNull(IDataGenerator dg) { if (dg==null) throw new ArgumentNullException("dg"); return dg.Column.AllowDBNull; }
public void ColumnIsNotNull(IDataGenerator dg) { Assert.IsNotNull(dg.Column); }
public void GeneratedTypeIsNotNull(IDataGenerator dg) { Assert.IsNotNull(dg.GeneratedType); }
public void Add(IDataGenerator dataGenerator) { if (dataGenerator==null) throw new ArgumentNullException("dataGenerator"); this.generators.Add(dataGenerator.Column.ColumnName,dataGenerator); }
public MsTestBase(IDataGenerator dataGenerator, IObjectCreator objectCreator) : base(dataGenerator, objectCreator, new MsTestAssertAdapter()) { }
public bool Contains(IDataGenerator dataGenerator) { if (dataGenerator==null) throw new ArgumentNullException("dataGenerator"); return this.Contains(dataGenerator.Column); }
/// <summary> /// Constructor /// </summary> /// <param name="generator">The generator to use</param> /// <param name="token">A cancellation token</param> public GeneratorDataAdapter(IDataGenerator generator, CancellationToken token) { _generator = generator; _inputQueue = new LockedQueue<DataFrame>(-1, token); }
/// <summary> /// Constructor /// </summary> /// <param name="generator">The generator to use</param> public GeneratorDataAdapter(IDataGenerator generator) : this(generator, CancellationToken.None) { }
public object InitChanges(XmlElement fuzzLocationRoot) { _isPreCondition = fuzzLocationRoot.Name == "PreCondition"; if (SupportsStopCondition) ReadStopCondition (fuzzLocationRoot); else _stopCondition = null; if (SupportsDataGen) ReadDataGen (fuzzLocationRoot); else _dataGenerator = null; if (SupportsTrigger) ReadTriggers (fuzzLocationRoot, _connector); else _triggers = null; ChangeableComponents changeableComponent = new ChangeableComponents ( _stopCondition, _dataGenerator, _triggers, _isPreCondition); _changeableComponents.Add (changeableComponent); InternInitChanges (changeableComponent, fuzzLocationRoot); return changeableComponent; }
private void ReadDataGen(XmlElement root) { IDataGenerator dataGen = GenericClassIdentifierFactory.CreateFromClassIdentifierOrType<IDataGenerator> (XmlHelper.ReadString (root, "DataGenerator")); IDictionary<string, string> arguments = new Dictionary<string, string> (); foreach (XmlElement datagenArgNode in root.SelectNodes ("DataGenArg")) arguments.Add (datagenArgNode.GetAttribute ("name"), datagenArgNode.InnerText); dataGen.Setup (arguments); _dataGenerator = dataGen; }
public ChangeableComponents(IFuzzStopCondition stopCondition, IDataGenerator dataGenerator, ITrigger[] triggers, bool isPreCondition) { StopCondition = stopCondition; DataGenerator = dataGenerator; Triggers = triggers; IsPreCondition = isPreCondition; }
private static void InitializeGenerators(out IRandomGenerator randomGenerator, out IDataGenerator dataGenerator) { randomGenerator = RandomGenerator.GetInstance; dataGenerator = DataGenerator.GetInstance; }
/// <summary> /// IDataGenerator と音の長さを指定して初期化。 /// </summary> /// <param name="generator">データ生成クラス</param> /// <param name="length">音の長さ</param> public SoundFromData(IDataGenerator generator, int length) { this.generator = generator; this.length = length; }
/// <summary> /// Initializes a new instance of the DataGeneratorAnnotation class. /// </summary> /// <param name="dataGenerator">The data generator</param> internal DataGeneratorAnnotation(IDataGenerator dataGenerator) { ExceptionUtilities.CheckArgumentNotNull(dataGenerator, "dataGenerator"); this.DataGenerator = dataGenerator; }
public void NullProbabilityIsOneIfNonNull(IDataGenerator dg) { Assert.AreEqual(1,dg.NullProbability); }
public MsTestBase(IDataGenerator dataGenerator) : base(dataGenerator, new MsTestAssertAdapter()) { }
public void SetNullProbability(IDataGenerator dg) { dg.NullProbability=0; Assert.AreEqual(0,dg.NullProbability); }
public void ApplyChangeableId(object changeableId) { if (changeableId != null && changeableId is ChangeableComponents && _changeableComponents.Contains ((ChangeableComponents)changeableId)) { _stopCondition = ((ChangeableComponents)changeableId).StopCondition; _dataGenerator = ((ChangeableComponents)changeableId).DataGenerator; _triggers = ((ChangeableComponents)changeableId).Triggers; _isPreCondition = ((ChangeableComponents)changeableId).IsPreCondition; } else if (changeableId != null) throw new ArgumentException ("Unexpected changeable id"); }
public SmarterdamServer(IDataGenerator generator) { this.generator = generator; }