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;
}
