public void TestDataFileNameMap(bool compressionEnabled) {
//I'm not exactly sure what this test is testing for, but the way files are named by the library
//is not playing well with this test. Seems like it wants a specific file extension. Some decision
//will have to be made about how to handle this problem. Does the library need to generate names differently?
//Or maybe this test should be different?
var generator = new DataGenerator();
var mapping = new DataFileNameMapping(TEST_DIRECTORY, compressionEnabled);
var sourcePath = @"..\..\TestInputs\function_def.cpp";
var srcmlPath = @"..\..\TestInputs\function_def.xml";
var mappedPath = mapping.GetTargetPath(sourcePath);
var actualExtension = Path.GetExtension(mappedPath);
var expectedExtension = (compressionEnabled ? XmlSerialization.DEFAULT_COMPRESSED_EXTENSION : XmlSerialization.DEFAULT_EXTENSION);
StringAssert.AreEqualIgnoringCase(expectedExtension, actualExtension);
//generator.Generate(srcmlPath, mappedPath);
LibSrcMLRunner runner = new LibSrcMLRunner();
runner.GenerateSrcMLFromFile(srcmlPath, mappedPath, Language.CPlusPlus, new Collection<uint> { LibSrcMLRunner.SrcMLOptions.SRCML_OPTION_POSITION }, new Dictionary<string, Language> { });
Assert.That(File.Exists(mappedPath), String.Format("Could not generate {0}", mappedPath));
var data = XmlSerialization.Load(mappedPath, compressionEnabled);
Assert.IsNotNull(data, String.Format("Could not load data from {0}. It should {1}be compressed", mappedPath, compressionEnabled ? String.Empty : "not "));
}
public void TestMissingSrcMLFile() {
var fileName = "missing.cpp";
var xmlFilePath = Path.Combine(OUTPUT_DIRECTORY, Path.ChangeExtension(fileName, "xml"));
var dataFilePath = Path.ChangeExtension(xmlFilePath, XmlSerialization.DEFAULT_EXTENSION);
var dataGenerator = new DataGenerator();
dataGenerator.Generate(xmlFilePath, dataFilePath);
}
public override int CompareTo(DataGenerator generator)
{
if (this.WellKnownDataType == WellKnownDataType.EndDate && (generator.WellKnownDataType == WellKnownDataType.StartDate || generator.WellKnownDataType == WellKnownDataType.Date))
{
return 1;
}
return base.CompareTo(generator);
}
public void ResetCharacterRequirements(bool includeUppercase, bool includeLowercase, bool includeNumbers, bool includeSpecials)
{
var dg = new DataGenerator(100, 200);
Assert.IsNotNull(dg);
dg.ResetCharacterRequirements(includeUppercase, includeLowercase, includeNumbers, includeSpecials);
}
public void Get_Rundom_Number()
{
DataGenerator dataGenerator = new DataGenerator();
_randomNumber =dataGenerator. GetRandomNumber(1,100);
Console.WriteLine("{0}", _randomNumber);
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
gRes.Visibility = Visibility.Visible;
gReq.Visibility = Visibility.Collapsed;
OKButton.IsEnabled = false;
OKButton.Visibility = Visibility.Collapsed;
CancelButton.IsEnabled = true;
CancelButton.Content = "Stop";
if (((App)Application.Current).Database == null)
{
((App)Application.Current).InitializePerstStorage();
}
else
{
_generator = new DataGenerator(((App)Application.Current).Database);
_generator.DropStorage();
((App)Application.Current).InitializePerstStorage();
}
_generator = new DataGenerator(((App)Application.Current).Database);
_generator.GeneratedContact +=
(sender1, e1) => Dispatcher.BeginInvoke(ReadLabels);
_generator.GenerationComplete +=
(sender1, e1) =>
{
_generator = null;
Dispatcher.BeginInvoke(() => DialogResult = true);
};
_generator.Committing +=
(sender1, e1) =>
Dispatcher.BeginInvoke(() =>
{
ReadLabels();
cStatus.Text = "Committing...";
CancelButton.IsEnabled = false;
});
var c = (int)sliderAllCount.Value;
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
var freespace = store.AvailableFreeSpace;
var needSpace = c * DataGenerator.OneObjectAvgSize;
if (freespace < needSpace)
{
if (!store.IncreaseQuotaTo(store.Quota + (needSpace - freespace)))
{
cStatus.Text = "Data generation aborted";
CancelButton.Content = "Ok";
_generator = null;
return;
}
}
}
ThreadPool.QueueUserWorkItem(state => _generator.Generate(c));
}
public override int CompareTo(DataGenerator generator)
{
if (generator.WellKnownDataType == WellKnownDataType.Gender)
{
return 1;
}
return base.CompareTo(generator);
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
OKButton.IsEnabled = false;
CancelButton.IsEnabled = false;
generator = new DataGenerator(((App)Application.Current).Database);
generator.ClearComplete += (sender1, e1) => Dispatcher.BeginInvoke(() => DialogResult = true);
ThreadPool.QueueUserWorkItem(state => generator.DropStorage());
}
public static void Main()
{
// Creating MongoDb database.
var dbMongoDb = new MediaDistributorsMongoData();
// Generating distributors.
var genedartor = new DataGenerator();
var generatedDistributors = genedartor.GenerateDistributors(3);
// Inserting to MongoDb.
dbMongoDb.InsertToMongo(generatedDistributors);
var distributorsToSql = dbMongoDb.GetFromMongo();
// Creating and insert to SQL Server database.
var dbSql = new MediaMonitoringSystemDbContext();
foreach (var distributor in distributorsToSql)
{
dbSql.MediaDistributors.Add(distributor);
}
dbSql.SaveChanges();
>>>>>>> e1c871f4a51ce55ee53ae24534264957938a56bb
var sqlite = new MediaMonitoringPricingData();
// Extracting zip file.
IArchiever zipArchiver = new ZipArchiever();
string zipPath = "../../MOCK_DATA.zip";
string extractedPath = "../../Export/";
zipArchiver.UnArchieve(zipPath, extractedPath);
IImporter excelImporter = new ExcelImporter(new MediaMonitoringSystemDbContext());
string[] paths = new string[]
{
"../../MOCK_DATA.zip",
"../../Export/",
"../../Export/MOCK_DATA/MOCK_DATA.xls"
};
// Importing data from excel.
IBulkImporter bulkImporter = new ExcelBulkImporter(zipArchiver, excelImporter, paths);
bulkImporter.ImportAll();
// Creating PDF file.
var pdfWriter = new PdfReportWriter();
pdfWriter.Generate();
// Generating JSONs files.
var jsonExporter = new JsonReportWriter();
jsonExporter.Generate();
//var xmlReporter = new XMLReportWriter();
//xmlReporter.Generate();
}
public override int CompareTo(DataGenerator generator)
{
if (generator.WellKnownDataType == WellKnownDataType.FirstName ||
generator.WellKnownDataType == WellKnownDataType.LastName ||
generator.WellKnownDataType == WellKnownDataType.UserName)
{
return 1;
}
return base.CompareTo(generator);
}
public void TestRoundTrip(string sourceFileName, bool compressOutput) {
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var srcMLGenerator = new SrcMLGenerator("SrcML");
var dataGenerator = new DataGenerator();
Assert.That(srcMLGenerator.Generate(sourceFilePath, DefaultInputName));
var fileUnit = SrcMLElement.Load(DefaultInputName);
var nsd = dataGenerator.Parse(fileUnit) as NamespaceDefinition;
XmlSerialization.WriteElement(nsd, DefaultOutputName, compressOutput);
var nsdFromFile = XmlSerialization.Load(DefaultOutputName, compressOutput) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
public static void Main()
{
Database.SetInitializer(
new MigrateDatabaseToLatestVersion<StudentsDbContext, Configuration>());
var db = new StudentsDbContext();
var generator = new DataGenerator();
generator.GenerateCourses(db, 20);
generator.GenerateStudents(db, 100);
db.SaveChanges();
generator.GenerateHomeworks(db, 250);
db.SaveChanges();
}
public object GetValue(DataGenerator dataGenerator)
{
if (dataGenerator == null) throw new ArgumentNullException("dataGenerator");
for (int i = 0; i < _dataGenerators.Count; i++)
{
if (dataGenerator == _dataGenerators[i])
{
return _values[i];
}
}
return null;
}
public void TestBadEncoding() {
string testCode = @"void Foo()";
var fileName = @"BadPath™.cpp";
var sourceFilePath = Path.Combine(SOURCE_DIRECTORY, fileName);
var xmlFilePath = Path.Combine(OUTPUT_DIRECTORY, Path.ChangeExtension(fileName, "xml"));
var dataFilePath = Path.ChangeExtension(xmlFilePath, XmlSerialization.DEFAULT_EXTENSION);
File.WriteAllText(sourceFilePath, testCode);
SrcMLGenerator generator = new SrcMLGenerator("SrcML");
generator.GenerateSrcMLFromFile(sourceFilePath, xmlFilePath, Language.C);
var dataGenerator = new DataGenerator();
dataGenerator.Generate(xmlFilePath, dataFilePath);
}
public void TestRoundTripWithDefaultExtension(string sourceFileName, bool useCompression) {
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var srcMLGenerator = new SrcMLGenerator("SrcML");
var dataGenerator = new DataGenerator();
Assert.That(srcMLGenerator.Generate(sourceFilePath, DefaultInputName));
var fileUnit = SrcMLElement.Load(DefaultInputName);
var nsd = dataGenerator.Parse(fileUnit) as NamespaceDefinition;
string outputFileName = Path.ChangeExtension(DefaultOutputName, useCompression ? XmlSerialization.DEFAULT_COMPRESSED_EXTENSION : XmlSerialization.DEFAULT_EXTENSION);
XmlSerialization.WriteElement(nsd, outputFileName);
var nsdFromFile = XmlSerialization.Load(outputFileName) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
public void TestRoundTrip(string sourceFileName, bool compressOutput) {
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var destFilePath = Path.Combine(TestInputPath, DefaultInputName);
LibSrcMLRunner runner = new LibSrcMLRunner();
runner.GenerateSrcMLFromFile(sourceFilePath, destFilePath + ".cpp", Language.CPlusPlus, new Collection<UInt32>() { LibSrcMLRunner.SrcMLOptions.SRCML_OPTION_POSITION }, new Dictionary<string, Language>() { });
Assert.That(File.Exists(destFilePath + ".cpp0.xml"));
var fileUnit = SrcMLElement.Load(destFilePath + ".cpp0.xml");
var dataGenerator = new DataGenerator();
var nsd = dataGenerator.Parse(fileUnit.Element(SRC.Unit)) as NamespaceDefinition;
XmlSerialization.WriteElement(nsd, DefaultOutputName, compressOutput);
var nsdFromFile = XmlSerialization.Load(DefaultOutputName, compressOutput) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
public void TestDataFileNameMap(bool compressionEnabled) {
var generator = new DataGenerator();
var mapping = new DataFileNameMapping(TEST_DIRECTORY, compressionEnabled);
var sourcePath = @"..\..\TestInputs\function_def.cpp";
var srcmlPath = @"..\..\TestInputs\function_def.xml";
var mappedPath = mapping.GetTargetPath(sourcePath);
var actualExtension = Path.GetExtension(mappedPath);
var expectedExtension = (compressionEnabled ? XmlSerialization.DEFAULT_COMPRESSED_EXTENSION : XmlSerialization.DEFAULT_EXTENSION);
StringAssert.AreEqualIgnoringCase(expectedExtension, actualExtension);
generator.Generate(srcmlPath, mappedPath);
Assert.That(File.Exists(mappedPath), String.Format("Could not generate {0}", mappedPath));
var data = XmlSerialization.Load(mappedPath, compressionEnabled);
Assert.IsNotNull(data, String.Format("Could not load data from {0}. It should {1}be compressed", mappedPath, compressionEnabled ? String.Empty : "not "));
}
public Hint(string tablePattern, string columnPattern, DataGenerator dataGenerator)
{
if (dataGenerator == null) throw new ArgumentNullException("dataGenerator");
_tablePattern = tablePattern;
_columnPattern = columnPattern;
_dataGenerator = dataGenerator;
if (_tablePattern != null)
{
_tableRegex = new Regex(tablePattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
if (_columnPattern != null)
{
_columnRegex = new Regex(columnPattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
}
public OctreeNode CreateSubdivisionsWithItem(int maxDepth, Vector3 pos)
{
OctreeNode nextChild = this;
for (int i = 0; i < maxDepth; i++)
{
if (nextChild.isLeaf())
{
Vector3[] positions = nextChild.childrenPositions(nextChild.pos);
nextChild.Subdivide(DataGenerator.GenerateChildData(this, positions), positions);
}
nextChild = ChildNodeWithItem(pos, nextChild);
if (nextChild == null)
{
return(null);
}
}
return(nextChild);
}
static void Main(string[] args)
{
DataGenerator generator = new DataGenerator();
FileWorker fileWorker = new FileWorker(generator);
DBWorker dbWorker = new DBWorker();
//Generating files
fileWorker.GenerateFiles("D:\\Files");
//Merging files into one
Console.WriteLine(fileWorker.MergeFiles("D:\\Files", null, "ПаШа") + " strings were deleted.");
fileWorker.ProcessInfo += FileWorker_ProcessInfo;
//Saving data to DB
fileWorker.SaveData("D:\\Files\\Result.txt", dbWorker);
Console.WriteLine("Sum is: " + dbWorker.GetSumFromIntColumn());
Console.WriteLine("Median is: " + dbWorker.GetMedian());
}
public static void Main(string[] args)
{
IWebHost webHost = CreateWebHostBuilder(args).Build();
using (IServiceScope scope = webHost.Services.CreateScope())
{
IServiceProvider serviceProvider = scope.ServiceProvider;
try
{
var dbContextOptions = serviceProvider.GetRequiredService <DbContextOptions <ManagementContext> >();
DataGenerator.Initialize(dbContextOptions);
}
catch (Exception e)
{
var logger = serviceProvider.GetRequiredService <ILogger <Program> >();
logger.LogCritical(e, "Could not initialize in memory database.");
}
}
webHost.Run();
}
public void CommodityCodeShouldBeUnique()
{
var productSpec1 = DataGenerator.NewProductSpec();
var productSpec2 = DataGenerator.NewProductSpec();
productSpec2.CommodityCode = productSpec1.CommodityCode;
using (var dbContext = fixture.NewDbContext())
{
dbContext.ProductSpecifications.Add(productSpec1);
dbContext.SaveChanges();
}
using (var dbContext = fixture.NewDbContext())
{
dbContext.ProductSpecifications.Add(productSpec2);
var exception = Assert.Throws <DbUpdateException>(() => dbContext.SaveChanges());
Assert.Contains("UNIQUE", exception.ToString());
}
}
unsafe public void QueueCommand(int time, DataGenerator generator)
{
var generateSchema = (commandSchema == null);
if (generateSchema)
{
commandSchema = new NetworkSchema(NetworkConfig.networkClientQueueCommandSchemaId);
}
var info = commandsOut.Acquire(++commandSequence);
info.time = time;
fixed(uint *buf = info.data)
{
var writer = new NetworkWriter(buf, info.data.Length, commandSchema, generateSchema);
generator(ref writer);
writer.Flush();
}
}
static void Main()
{
var ints = DataGenerator.GenerateRandomArray(30, 100);
var quizRunner = new QuizRunner(ints.ToList());
////////////////////////////////////////////////////////////////////////////////
//Quiz Registeration, later on bottom
////////////////////////////////////////////////////////////////////////////////
quizRunner.Register(new _130929MaxAndMinQuiz());
quizRunner.Register(new _131002_2To10());
quizRunner.Register(new _131003Sort());
////////////////////////////////////////////////////////////////////////////////
quizRunner.Run();
}
public static void Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <MovieDbContext>();
DataGenerator.Initialize(services);
}
var logger = NLog.LogManager.Setup()
.SetupExtensions(s => s.AutoLoadAssemblies(false).RegisterLayoutRenderer("default-template", typeof(DefaultLoggingTemplate)))
.RegisterNLogWeb()
.LoadConfigurationFromFile("nlog.config")
.GetCurrentClassLogger();
host.Run();
}
public static IWebHost BuildWebHost(string[] args)
{
var host = WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseUrls("http://*:8090")
.UseStartup <Startup>()
.UseIISIntegration()
.Build();
using (var scope = host.Services.CreateScope())
{
//3. Get the instance of BoardGamesDBContext in our services layer
var services = scope.ServiceProvider;
var context = services.GetRequiredService <POSStoreDbContext>();
//4. Call the DataGenerator to create sample data
DataGenerator.Initialize(services);
}
return(host);
}
public static void Main(string[] args)
{
///CreateHostBuilder(args).Build().Run();
//1. Get the IWebHost which will host this application.
var host = CreateHostBuilder(args).Build();
//2. Find the service layer within our scope.
using (var scope = host.Services.CreateScope())
{
//3. Get the instance of BoardGamesDBContext in our services layer
var services = scope.ServiceProvider;
var context = services.GetRequiredService <LavanderiaContext>();
//4. Call the DataGenerator to create sample data
DataGenerator.Initialize(services);
}
//Continue to run the application
host.Run();
}
private void SeedDb(BusTicketsContext context)
{
var generator = new DataGenerator();
var countries = GetCountries(generator, SeedCount);
var busCompanies = GetBusCompanies(generator, countries, SeedCount);
var towns = GetTowns(generator, countries, SeedCount);
var busStations = GetStations(generator, towns, SeedCount);
var customers = GetCustomers(generator, towns, SeedCount);
var bankAccounts = GetBankAccounts(generator, customers, SeedCount);
var trips = GetTrips(generator, busStations, busCompanies, SeedCount);
var tickets = GetTickets(generator, customers, trips, SeedCount);
var reviews = GetReviews(generator, busCompanies, customers, SeedCount / 2);
context.Trips.AddRange(trips);
context.Tickets.AddRange(tickets);
context.Reviews.AddRange(reviews);
context.BankAccounts.AddRange(bankAccounts);
context.SaveChanges();
}
public int GetNextID(string TableName)
{
var Tab = (from t in db.DataGenerator where t.TableName == TableName select t).FirstOrDefault();
if (Tab != null)
{
Tab.TableID += 1;
db.SaveChanges();
return(Tab.TableID);
}
else
{
DataGenerator datagen = new DataGenerator {
TableName = TableName, TableID = 1
};
db.DataGenerator.Add(datagen);
db.SaveChanges();
return(1);
}
}
public void Setup()
{
T value = DataGenerator.Generate <T>();
_serialized = JsonSerializer.Serialize(value);
JsonSerializerOptions options = new JsonSerializerOptions()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
_serializedCamelCased = JsonSerializer.Serialize(value, options);
_optionsBaseline = new JsonSerializerOptions();
_optionsCaseInsensitive = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
};
}
public int CreateTestData()
{
CUI.H1("Create Test Data");
if (!(String.IsNullOrEmpty(this.ConnectionString)))
{
DA.WWWingsContext.ConnectionString = this.ConnectionString;
}
CUI.PrintSuccess("Connection String=" + DA.WWWingsContext.ConnectionString);
try
{
DataGenerator.Run(true, this.FlightCount, this.PilotCount, this.PassengerCount);
CUI.PrintSuccess("CreateTestData done!");
return(0);
}
catch (Exception)
{
return(1);
}
}
private void SecureStorage()
{
var dataIndexes = GetUsingDataIndexes();
if (dataIndexes.Count == 0)
{
return;
}
List <DataModel> data = new List <DataModel>();
foreach (var index in dataIndexes)
{
data.Add(dataController.Get(SecureManager.GetIndexOf(index)));
}
Random rng = new Random();
DataGenerator generator = new DataGenerator();
int storageLength = dataController.Count();
foreach (var item in data)
{
for (int i = 0; i < storageLength / (50 * data.Count); i++)
{
int index;
do
{
index = rng.Next(storageLength);
} while (dataIndexes.Contains(index));
dataController.PasteAt(SecureManager.GetIndexOf(index),
new DataModel
{
Date = item.Date,
Description = item.Description,
Login = item.Login,
Password = generator.GenerateRandomPassword(item.Password.Length)
});
}
}
}
public static void DemoMemoization()
{
List <string> s = DataGenerator.GetRandomStringArray(10).ToList();
string result = string.Empty;
Dictionary <string, string> _upperCaseTempDictionary = new Dictionary <string, string>();
Benchmarker.Benchmark(() =>
{
foreach (var item in s)
{
result = item.ToUpper();
}
}, "ToUpper()", _count);
Benchmarker.Benchmark(() =>
{
foreach (var item in s)
{
if (_upperCaseTempDictionary.TryGetValue(item, out string lookupValue))
{
result = lookupValue;
continue;
}
lookupValue = item.ToUpper();
_upperCaseTempDictionary[item] = lookupValue;
}
}, "ToUpper() with lookup dictionary (memoization)", _count);
/*
* Memoization is a way of caching used to optimize a function.
* Known results are stored in memory, so the computation only runs once
*
* NOTE: the heavier a computation, the more useful this gets.
* Don't forget that Dictionaries will become slower as they increase in size!
* The following example would cause a performance hit when using a very big stringarray
*
* Alternative: inject IMemoryCache
*/
Console.WriteLine();
}
private void CreateInstanceWithConstructorParameters(Type type)
{
var values = new List <object>();
var constructor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)
.ToSafeList().First(c => !c.GetParameters().IsNullOrEmpty());
foreach (var parameter in constructor.GetParameters())
{
if (Mocks.HasValue(parameter.Name))
{
continue;
}
var parameterType = parameter.ParameterType;
object value = null;
if (parameter.ParameterType == typeof(string))
{
value = DataGenerator.GenerateString();
}
else
{
parameterType = typeof(Mock <>).MakeGenericType(parameter.ParameterType);
var mock = Convert.ChangeType(Activator.CreateInstance(parameterType,
null), parameterType);
var method = Mocks.GetType().GetMethod("Add");
var genericMethod = method.MakeGenericMethod(parameter.ParameterType);
genericMethod.Invoke(Mocks, new object[] { parameter.Name, mock });
value = GetObjectFromMock(mock, parameter.ParameterType);
}
values.Add(value);
}
SystemUnderTest = (TItemUnderTest)Activator.CreateInstance(typeof(TItemUnderTest), values.ToArray());
}
public override void Initialize()
{
var tasks = new Task[options.Threads];
for (var i = 0; i < options.Threads; i++)
{
var i1 = i;
tasks[i1] = Task.Run(() =>
{
var data = DataGenerator.GenerateString((int)(volume / options.Threads));
using Stream s = new MemoryStream();
using (var stream = new ZipOutputStream(s))
{
stream.SetLevel(9);
var entry = new ZipEntry("test.txt")
{
DateTime = DateTime.Now
};
stream.PutNextEntry(entry);
using var sw = new StreamWriter(stream);
sw.Write(data);
sw.Flush();
stream.CloseEntry();
stream.IsStreamOwner = false;
}
s.Seek(0, SeekOrigin.Begin);
using var sr = new StreamReader(s);
datas[i1] = sr.ReadToEnd();
});
}
Task.WaitAll(tasks);
}
public void TempGeneratorTester()
{
// Set the world size
DataGenerator generator = new DataGenerator(40, 60);
// Generate the tested world
float[][,] array = generator.CreateTemperatureLayers(4);
// Generate random coordinates
System.Random randy = new System.Random();
int i = randy.Next(0, generator.WORLDX);
int j = randy.Next(0, generator.WORLDZ);
string mapA = "";
string mapB = "";
for (int x = 0; x < generator.WORLDX; x++)
{
for (int z = 0; z < generator.WORLDZ; z++)
{
mapA += array[0][x, z] + ", ";
mapB += array[1][x, z] + ", ";
}
mapA += "\n";
mapB += "\n";
}
Debug.Log(mapA);
Debug.Log(mapB);
Assert.AreEqual(40, generator.WORLDX);
Assert.AreEqual(60, generator.WORLDZ);
Assert.GreaterOrEqual(array[0][0, 0], 30);
Assert.LessOrEqual(array[0][0, 0], 110);
Assert.GreaterOrEqual(array[0][i, j], 30);
Assert.LessOrEqual(array[0][i, j], 110);
Assert.GreaterOrEqual(array[1][0, 0], -20);
Assert.LessOrEqual(array[1][0, 0], array[0][0, 0] - 15);
Assert.GreaterOrEqual(array[1][i, j], -20);
Assert.LessOrEqual(array[1][i, j], array[0][i, j] - 15);
}
public static async Task Main(string[] args)
{
//Read Configuration from appSettings
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddJsonFile($"appsettings.{environment}.json", optional: true)
.Build();
//Initialize Logger
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(config)
.CreateLogger();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
//seed db with data
if (config.GetValue <bool>("UseInMemoryDatabase"))
{
// Call the DataGenerator to create sample data
await DataGenerator.InitializeInMemoryDb(services);
}
}
catch (Exception ex)
{
Log.Warning(ex, "An error occurred seeding the DB");
}
finally
{
Log.CloseAndFlush();
}
}
await host.RunAsync();
}
public void AccumulateCompoundInterest_IEnumerableToIEnumberable_DoubleProperty_SourceIsNotEmpty_CompoundInterestReturned()
{
IEnumerable <TimeSerie <double> > source = DataGenerator.CreateTimeSerieList <double>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.AccumulateCompoundInterest(
x => x.GrowthRate,
(x, cumProf) => new
{
Date = x.ReferenceDate,
CumulativePercentage = cumProf
})
.ToList();
resultList[0].CumulativePercentage.Should().Be(4.6532690000000043);
resultList[1].CumulativePercentage.Should().Be(6.3834690538636218);
resultList[2].CumulativePercentage.Should().Be(9.2061086593943742);
resultList[3].CumulativePercentage.Should().Be(16.340205199175784);
resultList[4].CumulativePercentage.Should().Be(22.53753158993068);
}
public void AccumulateCompoundInterest_IEnumerableToIEnumberable_DecimalProperty_SourceIsNotEmpty_CompoundInterestReturned()
{
IEnumerable <TimeSerie <decimal> > source = DataGenerator.CreateTimeSerieList <decimal>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.AccumulateCompoundInterest(
x => x.GrowthRate,
(x, cumProf) => new
{
Date = x.ReferenceDate,
CumulativePercentage = cumProf
})
.ToList();
resultList[0].CumulativePercentage.Should().Be(4.6532690000M);
resultList[1].CumulativePercentage.Should().Be(6.38346905386361M);
resultList[2].CumulativePercentage.Should().Be(9.2061086593943664664109M);
resultList[3].CumulativePercentage.Should().Be(16.34020519917575630512547822M);
resultList[4].CumulativePercentage.Should().Be(22.53753158993064966774320732M);
}
public void CalculateVariation_FloatProperty_SourceIsNotEmpty_ProperCumulativePercentageReturned()
{
IEnumerable <TimeSerie <float> > source = DataGenerator.CreateTimeSerieList <float>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.CalculateVariation(
x => x.Value,
(x, v) => new
{
Date = x.ReferenceDate,
Variation = v
})
.ToList();
resultList[0].Variation.Should().Be(0);
resultList[1].Variation.Should().Be(-26.6748428F);
resultList[2].Variation.Should().Be(-24.2525578F);
resultList[3].Variation.Should().Be(-48.0265F);
resultList[4].Variation.Should().Be(-24.0575676F);
}
public void CalculateVariation_DoubleProperty_SourceIsNotEmpty_ProperCumulativePercentageReturned()
{
IEnumerable <TimeSerie <double> > source = DataGenerator.CreateTimeSerieList <double>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.CalculateVariation(
x => x.Value,
(x, v) => new
{
Date = x.ReferenceDate,
Variation = v
})
.ToList();
resultList[0].Variation.Should().Be(0);
resultList[1].Variation.Should().Be(-26.674844581240954);
resultList[2].Variation.Should().Be(-24.252563283729156);
resultList[3].Variation.Should().Be(-48.026502945385388);
resultList[4].Variation.Should().Be(-24.057561393614336);
}
public void CalculateVariation_DecimalProperty_SourceIsNotEmpty_ProperCumulativePercentageReturned()
{
IEnumerable <TimeSerie <decimal> > source = DataGenerator.CreateTimeSerieList <decimal>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.CalculateVariation(
x => x.Value,
(x, v) => new
{
Date = x.ReferenceDate,
Variation = v
})
.ToList();
resultList[0].Variation.Should().Be(0M);
resultList[1].Variation.Should().Be(-26.674844581240951114701742780M);
resultList[2].Variation.Should().Be(-24.252563283729161439734017290M);
resultList[3].Variation.Should().Be(-48.026502945385381468909803190M);
resultList[4].Variation.Should().Be(-24.057561393614331023908141290M);
}
public void RedrawPlot(int variant)
{
var plotSeries = cPlot.Series[0];
plotSeries.Points.Clear();
var dayParams = typeof(DayInfo).GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var day in DataGenerator.Generate(variant))
{
Expression exp = new Expression(tFormula.Text, EvaluateOptions.IgnoreCase);
foreach (var property in dayParams)
{
exp.Parameters[property.Name] = property.GetValue(day);
}
double value = Convert.ToDouble(exp.Evaluate());
plotSeries.Points.AddXY(day.Date.Day, value);
}
}
public void InvertibleSimpleFold()
{
var addSize = 50;
var testData = DataGenerator.Generate().Take(addSize).ToArray();
var size = testData.Length;
var configuration = new DefaultBloomFilterConfiguration();
var bloomFilter = new InvertibleBloomFilter <TestEntity, long, sbyte>(configuration);
bloomFilter.Initialize(size, 1024, (uint)3);
foreach (var itm in testData)
{
bloomFilter.Add(itm);
}
var positiveCount = DataGenerator.Generate().Take(500).Count(itm => bloomFilter.Contains(itm));
var folded = bloomFilter.Fold(4);
var positiveCountAfterFold = DataGenerator.Generate().Take(500).Count(itm => bloomFilter.Contains(itm));
Assert.AreEqual(positiveCount, positiveCountAfterFold, "False positive count different after fold");
Assert.AreEqual(256, folded.Extract().BlockSize);
Assert.IsTrue(testData.All(item => bloomFilter.Contains(item)), "False negative found");
}
public void AccumulateCompoundInterest_IEnumerableToIEnumberable_FloatProperty_SourceIsNotEmpty_CompoundInterestReturned()
{
IEnumerable <TimeSerie <float> > source = DataGenerator.CreateTimeSerieList <float>();
var resultList = source
.OrderBy(x => x.ReferenceDate)
.AccumulateCompoundInterest(
x => x.GrowthRate,
(x, cumProf) => new
{
Date = x.ReferenceDate,
CumulativePercentage = cumProf
})
.ToList();
resultList[0].CumulativePercentage.Should().Be(4.653263F);
resultList[1].CumulativePercentage.Should().Be(6.383455F);
resultList[2].CumulativePercentage.Should().Be(9.206093F);
resultList[3].CumulativePercentage.Should().Be(16.3401966F);
resultList[4].CumulativePercentage.Should().Be(22.537529F);
}
public void LoadPortfolioTest()
{
File.Delete(PortfolioManager.PortfolioData);
PortfolioManager.Clear();
Assert.IsTrue(PortfolioManager.TryToCreate(DataGenerator.GetRandomString(5), DataGenerator.GetRandomString(6), out Portfolio portfolio1));
Assert.IsTrue(PortfolioManager.TryToCreate(DataGenerator.GetRandomString(5), DataGenerator.GetRandomString(6), out Portfolio portfolio2));
Assert.IsTrue(PortfolioManager.TryToCreate(DataGenerator.GetRandomString(5), DataGenerator.GetRandomString(6), out Portfolio portfolio3));
PortfolioManager.SavePortfolios();
PortfolioManager.LoadPortfolios();
Assert.IsTrue(PortfolioManager.TryToGet(portfolio1.PortfolioID, out Portfolio p1));
Assert.IsTrue(PortfolioManager.TryToGet(portfolio2.PortfolioID, out Portfolio p2));
Assert.IsTrue(PortfolioManager.TryToGet(portfolio3.PortfolioID, out Portfolio p3));
Assert.IsTrue(p1.Equals(portfolio1));
Assert.IsTrue(p2.Equals(portfolio2));
Assert.IsTrue(p3.Equals(portfolio3));
PortfolioManager.TryToRemove(portfolio1.PortfolioID);
PortfolioManager.TryToRemove(portfolio2.PortfolioID);
PortfolioManager.TryToRemove(portfolio3.PortfolioID);
}
public void Given_MbstWithNodes_Marshals(string delimiter, int numberOfNodes)
{
if (numberOfNodes < 0)
{
throw new ApplicationException("Number of nodes must be > 0");
}
// arrange
var tree = new MarshalledBinarySearchTree <int>(delimiter);
var input = DataGenerator.RandomTreeData(numberOfNodes);
tree.AddRange(input);
// act
var actual = tree.Marshall();
// assert
var expected = String.Join(delimiter, tree.TraversePreOrder());
Assert.Equal(expected, actual);
}
/// <summary>
/// Implement the member of IExternalCommand Execute.
/// </summary>
/// <param name="commandData">
/// The application object for the active instance of Autodesk Revit.
/// </param>
/// <param name="message">
/// A message that can be set by the external command and displayed in case of error.
/// </param>
/// <param name="elements">
/// A set of elements that can be displayed if an error occurs.
/// </param>
/// <returns>
/// A value that signifies if yout command was successful, failed or the user wishes to cancel.
/// </returns>
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
//for repeating click-events
m_Revit = commandData.Application;
BIM.OpenFOAMExport.Exporter.Instance.settings.setDocument(m_Revit);
string fileName = "wallSTL.stl";
// save Revit document's triangular data in a temporary file, generate openFOAM-casefolder and start simulation
Directory.CreateDirectory(BIM.OpenFOAMExport.Exporter.Instance.settings.localCaseFolder);
Directory.CreateDirectory(BIM.OpenFOAMExport.Exporter.Instance.settings.localCaseFolder + "\\constant");
Directory.CreateDirectory(BIM.OpenFOAMExport.Exporter.Instance.settings.localCaseFolder + "\\constant\\triSurface");
DataGenerator Generator = new DataGenerator(m_Revit.Application, m_Revit.ActiveUIDocument.Document);
DataGenerator.GeneratorStatus succeed = Generator.SaveSTLFile(fileName);
return(Result.Succeeded);
}
static void Main(string[] args)
{
DataGenerator dataGenerator = new DataGenerator();
DataObserver dataObserver1 = new DataObserver("O1");
dataGenerator.Subscribe(dataObserver1);
DataObserver dataObserver2 = new DataObserver("O2");
dataGenerator.Subscribe(dataObserver2);
DataObserver dataObserver3 = new DataObserver("O3");
dataGenerator.Subscribe(dataObserver3);
DataObserver dataObserver4 = new DataObserver("O4");
dataGenerator.Subscribe(dataObserver4);
DataObserver dataObserver5 = new DataObserver("O5");
dataGenerator.Subscribe(dataObserver5);
dataGenerator.Run();
Console.ReadLine();
}
public void SetDataGenerator(Column column, DataGenerator dataGenerator)
{
if (column == null) throw new ArgumentNullException("column");
_columns.Add(column);
var table = column.Parent;
IDictionary<Column, DataGenerator> dic;
if (!_dataGenerators.TryGetValue(table, out dic))
{
dic = new Dictionary<Column, DataGenerator>();
_dataGenerators.Add(table, dic);
}
if (dataGenerator == null)
{
dic.Remove(column);
}
else
{
dic[column] = dataGenerator;
Logger.Log(LogType.Information, indent: 1, value: string.Format("{0}: {1} ({2})", column.FullName, dataGenerator.GetType().Name, dataGenerator.Seed));
}
}
public void ResetLengths(int minimum, int maximum)
{
var dg = new DataGenerator(100, 200);
Assert.IsNotNull(dg);
dg.ResetLengths(minimum, maximum);
}
public void AddValue(DataGenerator dataGenerator, object value)
{
if (dataGenerator == null) throw new ArgumentNullException("dataGenerator");
for (int i = 0; i < _dataGenerators.Count; i++)
{
if (dataGenerator == _dataGenerators[i])
{
_values[i] = value;
}
}
}
public void Constructor6Params(int minimum, int maximum, bool includeUppercase, bool includeLowercase, bool includeNumbers, bool includeSpecials)
{
var dg = new DataGenerator(minimum, maximum, includeUppercase, includeLowercase, includeNumbers, includeSpecials);
Assert.IsNotNull(dg);
}
public void NextString(int min, int max, bool upper, bool lower, bool numbers, bool special)
{
var dataGenerator = new DataGenerator(min, max, upper, lower, numbers, special);
string value = dataGenerator.NextString();
Assert.Between(value.Length, min, max);
}
public void NextInteger(int min, int max)
{
var dataGenerator = new DataGenerator(min, max);
int value = dataGenerator.NextInteger();
Assert.Between(value, min, max);
}
public void NextDouble()
{
var dataGenerator = new DataGenerator(10, 100);
double value = dataGenerator.NextDouble();
Assert.Between(value, 0, 1);
}
public void Constructor2Params(int min, int max)
{
var dg = new DataGenerator(min, max);
Assert.IsNotNull(dg);
}
public void NextBytes(int? bufferLength)
{
byte[] original = null;
byte[] buffer = null;
if (bufferLength.HasValue)
{
original = new byte[bufferLength.Value];
buffer = new byte[bufferLength.Value];
}
var dataGenerator = new DataGenerator(10, 100);
dataGenerator.NextBytes(buffer);
if (original == null)
{
Assert.Fail("Original Is Null");
return;
}
int matches = 0;
for (int i = 0; i < original.Length; i++)
{
if (original[i] == buffer[i])
{
matches++;
}
}
Assert.AreNotEqual(matches, original.Length, "{0} - {1}", matches, original.Length);
}
