public void Sync_Reports_Add()
{
var rand = new Bogus.Randomizer();
var fromPath = base.GetTempFilePath(".crz3", "Sync_Reports_Add_fromFile");
var toPath = base.GetTempFilePath(".crz3", "Sync_Reports_Add_toFile");
var syncOptions = new CruiseSyncOptions()
{
Processing = SyncFlags.Insert,
};
var cruiseID = Guid.NewGuid().ToString();
var saleID = Guid.NewGuid().ToString();
using var fromDb = CreateDatabaseFile(fromPath, cruiseID, saleID);
fromDb.CopyTo(toPath, true);
using var toDb = new CruiseDatastore_V3(toPath);
var reportID = Guid.NewGuid().ToString();
var report = new Reports
{
CruiseID = cruiseID,
ReportID = reportID,
Title = rand.String(),
};
fromDb.Insert(report);
var syncer = new CruiseSyncer();
syncer.Sync(cruiseID, fromDb, toDb, syncOptions);
toDb.GetRowCount("Reports", "WHERE ReportID = @p1", reportID).Should().Be(1);
}
public void Setup()
{
List <byte[]> bytesList = new List <byte[]>(Size);
List <byte[]> bytesList2 = new List <byte[]>(Size);
List <byte[]> bytesList3 = new List <byte[]>(Size);
List <MyTestClass> testClasses = new List <MyTestClass>(Size);
var bogus = new Bogus.Randomizer();
for (int i = 0; i < Size; i++)
{
MyTestClass myTestClass = new MyTestClass();
myTestClass.BoolProp = bogus.Bool();
myTestClass.IntList = new List <int>(100);
for (int j = 0; j < 100; j++)
{
myTestClass.IntList.Add(bogus.Int());
}
myTestClass.StringProp = bogus.String(10, 100);
myTestClass.StringProp2 = bogus.String(10, 100);
bytesList.Add(JsonSerializer.Serialize(myTestClass));
bytesList3.Add(System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(myTestClass));
bytesList2.Add(MessagePack.MessagePackSerializer.Typeless.Serialize(myTestClass, ContractlessStandardResolver.Options));
testClasses.Add(myTestClass);
}
_serializedObjectsUtf8Json = bytesList.ToArray();
_serializedObjectsMessagePack = bytesList2.ToArray();
_serializedObjectsTextJson = bytesList3.ToArray();
_testClasses = testClasses.ToArray();
}
public static int GoalsAssistsStatsRandomizer(this Bogus.Randomizer randomizer, Position playerPosition, int minValue, int maxValue)
{
return(playerPosition switch
{
Position.Goalkeeper => 0,
_ => randomizer.Int(minValue, maxValue)
});
public void SyncVolumeEquations_Add()
{
var rand = new Bogus.Randomizer();
var fromPath = base.GetTempFilePath(".crz3", "SyncVolumeEquations_Add_fromFile");
var toPath = base.GetTempFilePath(".crz3", "SyncVolumeEquations_Add_toFile");
var syncOptions = new CruiseSyncOptions()
{
Processing = SyncFlags.Insert,
};
var cruiseID = Guid.NewGuid().ToString();
var saleID = Guid.NewGuid().ToString();
using var fromDb = CreateDatabaseFile(fromPath, cruiseID, saleID);
fromDb.CopyTo(toPath, true);
using var toDb = new CruiseDatastore_V3(toPath);
var volEq = new VolumeEquation
{
CruiseID = cruiseID,
Species = "sp1",
PrimaryProduct = "01",
VolumeEquationNumber = "something"
};
fromDb.Insert(volEq);
var syncer = new CruiseSyncer();
syncer.Sync(cruiseID, fromDb, toDb, syncOptions);
toDb.GetRowCount("VolumeEquation", "WHERE VolumeEquationNumber = @p1", volEq.VolumeEquationNumber).Should().Be(1);
}
public void Setup()
{
var rand = new Bogus.Randomizer();
// generate input data, e.g.: [ t, f, f, t, t, t, f ]
bool[] data = Enumerable
.Range(0, Length)
.Select(_ => rand.Bool())
.ToArray();
// generate indexes to check, e.g.: [ 5, 2, 0, 6, 9, 1, 8, 3 ]
// (we don't really care whether bit is set or not; we need same indexes for all benchmarks)
_idx = Enumerable
.Range(0, Length)
.Select(_ => rand.Int(0, Length - 1))
.ToArray();
// only `true` values are stored, missing value means bit is not set
_bitArray = new System.Collections.BitArray(data);
_map = new Dictionary <int, bool>(
data.Select((v, i) => KeyValuePair.Create(i, v))
.Where(kv => kv.Value));
_set = new HashSet <int>(
data.Select((v, i) => (v, i))
.Where(t => t.v)
.Select(t => t.i));
}
public void InsertTest_MaxCount()
{
var bogus = new Bogus.Randomizer();
byte[] toInsert = TestHelper.GenerateByteArray(4, 0x0F);
ushort insertLength = (ushort)toInsert.Length;
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
DataPage dataPage = new DataPage(bufferSegment);
dataPage.IsFull.ShouldBeFalse();
byte index = 0;
for (int i = 0; i < 255; i++)
{
var ins = dataPage.Insert(insertLength, out index);
ins.WriteBytes(0, toInsert);
}
dataPage.IsInsertPossible(1).ShouldBe(false);
Should.Throw <Exception>(() =>
{
dataPage.Insert(insertLength, out var index);
});
dataPage.Delete(100);
dataPage.IsInsertPossible(1).ShouldBe(true);
dataPage.Insert(insertLength, out index);
index.ShouldBe((byte)100);
}
public void InsertTest_Continuous()
{
var bogus = new Bogus.Randomizer();
byte[] toInsert = Encoding.UTF8.GetBytes("Hello World!");
ushort insertLength = (ushort)toInsert.Length;
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
DataPage dataPage = new DataPage(bufferSegment);
dataPage.IsFull.ShouldBeFalse();
var ins = dataPage.Insert(insertLength, out var index);
index.ShouldBe((byte)1);
ins.Length.ShouldBe(insertLength);
ins.WriteBytes(0, toInsert);
dataPage.FreeContinuousBytes.ShouldBe((ushort)(Constants.MAX_USABLE_BYTES_IN_PAGE - insertLength));
bufferSegment.Span.Slice(Constants.PAGE_HEADER_SIZE, insertLength).ToArray().ShouldBe(toInsert);
ins = dataPage.Insert(insertLength, out index);
index.ShouldBe((byte)2);
ins.Length.ShouldBe(insertLength);
ins.WriteBytes(0, toInsert);
dataPage.FreeContinuousBytes.ShouldBe((ushort)(Constants.MAX_USABLE_BYTES_IN_PAGE - 4 - insertLength * 2));
bufferSegment.Span.Slice(Constants.PAGE_HEADER_SIZE + insertLength, insertLength).ToArray().ShouldBe(toInsert);
}
/// <summary>
/// Randomizes the letters and numbers in a string.
/// </summary>
/// <param name="s">The s.</param>
/// <returns></returns>
public static string RandomizeLettersAndNumbers(this string s)
{
var randomizer = new Bogus.Randomizer();
var chars = s.ToArray();
for (int i = 0; i < chars.Length; i++)
{
char c = chars[i];
if (char.IsLower(c))
{
chars[i] = randomizer.Char('a', 'z');
}
else if (char.IsUpper(c))
{
chars[i] = randomizer.Char('A', 'Z');
}
else if (char.IsNumber(c))
{
chars[i] = randomizer.Char('0', '9');
}
}
return(new string( chars ));
}
public async Task SimpleInsertAndGetWithCheckpointTest()
{
var bogus = new Bogus.Randomizer();
using BufferSegment headerBufferSegment = new BufferSegment(Constants.PAGE_SIZE);
var headerPage = HeaderPage.CreateHeaderPage(headerBufferSegment);
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
PageService pageService = new PageService(new InMemoryDiskService());
DataService dataService = new DataService(new NopCompressionService(), pageService);
TestObject testObject = new TestObject();
testObject.IntProp = bogus.Int();
testObject.StringProp = bogus.String2(1000);
var address = await dataService.Insert(testObject);
address.SlotId.ShouldBe((byte)1);
address.PageId.ShouldBe((ushort)1);
await pageService.CheckPoint();
var obj = await dataService.Get <TestObject>(address);
obj.ShouldNotBeNull();
obj.ShouldBe(testObject);
// there should be no second page
var secondPage = await pageService.GetPage <BasePage>(2);
secondPage.ShouldBeNull();
}
public async Task InsertMaxAmountOfEntriesPerPageTest()
{
var bogus = new Bogus.Randomizer();
using BufferSegment headerBufferSegment = new BufferSegment(Constants.PAGE_SIZE);
var headerPage = HeaderPage.CreateHeaderPage(headerBufferSegment);
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
PageService pageService = new PageService(new InMemoryDiskService());
DataService dataService = new DataService(new NopCompressionService(), pageService);
for (int i = 0; i < 300; i++)
{
var address = await dataService.Insert("ABC");
address.SlotId.ShouldBeGreaterThan((byte)0);
address.PageId.ShouldBeGreaterThan((byte)0);
if (i > 254)
{
address.PageId.ShouldBeGreaterThan((uint)1);
}
var resObject = await dataService.Get <string>(address);
resObject.ShouldBe("ABC");
}
}
public async Task LargeInsertTest()
{
var bogus = new Bogus.Randomizer();
using BufferSegment headerBufferSegment = new BufferSegment(Constants.PAGE_SIZE);
var headerPage = HeaderPage.CreateHeaderPage(headerBufferSegment);
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
PageService pageService = new PageService(new InMemoryDiskService());
DataService dataService = new DataService(new NopCompressionService(), pageService);
TestObject testObject = new TestObject();
testObject.IntProp = bogus.Int();
testObject.StringProp = bogus.String2(1000);
for (int i = 0; i < 10000; i++)
{
var address = await dataService.Insert(testObject);
address.SlotId.ShouldBeGreaterThan((byte)0);
address.PageId.ShouldBeGreaterThan((byte)0);
if (i > 254)
{
address.PageId.ShouldBeGreaterThan((uint)1);
}
var resObject = await dataService.Get <TestObject>(address);
resObject.ShouldBe(testObject);
}
}
public void Setup()
{
var bogus = new Bogus.Randomizer();
BufferSegment headerBufferSegment = new BufferSegment(Constants.PAGE_SIZE);
var headerPage = HeaderPage.CreateHeaderPage(headerBufferSegment);
BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
File.Delete(@"C:\Neuer Ordner\test.db");
PageService pageService = new PageService(FileDiskService.Create(new DatatentSettings()
{
InMemory = false, Path = @"C:\Neuer Ordner\test.db"
}));
_dataService = new DataService(new NopCompressionService(), pageService);
_objects = new List <TestObject>(50);
foreach (var i in Enumerable.Range(0, 50))
{
TestObject testObject = new TestObject();
testObject.IntProp = bogus.Int();
testObject.StringProp = bogus.String2(1000);
_objects.Add(testObject);
}
}
private POCOMultiTypeObject CreateRandomPoco(bool nullableSetNull = false)
{
var randomizer = new Bogus.Randomizer();
var poco = new POCOMultiTypeObject()
{
BoolField = randomizer.Bool(),
DateTimeField = DateTime.Now,
NDateTimeField = (nullableSetNull) ? (DateTime?)null : DateTime.Now,
StrDateTime = (nullableSetNull) ? (string)null : DateTime.Now.ToShortTimeString(),
DoubleField = randomizer.Double(),
FloatField = randomizer.Float(),
GuidField = randomizer.Guid(),
NGuidField = (nullableSetNull) ? (Guid?)null : randomizer.Guid(),
ID = randomizer.Int(),
IntField = randomizer.Int(),
LongField = randomizer.Long(),
NBoolField = (nullableSetNull) ? (bool?)null : randomizer.Bool(),
NDoubleField = (nullableSetNull) ? (double?)null : randomizer.Double(),
NFloatField = (nullableSetNull) ? (float?)null : randomizer.Float(),
NIntField = (nullableSetNull) ? (int?)null : randomizer.Int(),
NLongField = (nullableSetNull) ? (long?)null : randomizer.Long(),
//RowID = randomizer.Int(),
StringField = randomizer.String2(16),
};
return(poco);
}
public void Setup()
{
var rnd = new Bogus.Randomizer(1234);
_data = Enumerable
.Range(0, InputSize)
.Select(_ => rnd.Number(0, 100))
.ToArray();
}
public void Compression()
{
BrotliCompressionService brotliCompressionService = new BrotliCompressionService();
var bogus = new Bogus.Randomizer();
var bytesOrg = Encoding.UTF8.GetBytes(new Lorem().Sentence(500));
var span = new Span <byte>(new byte[bytesOrg.Length + 50]);
var result = brotliCompressionService.Compress(bytesOrg, span);
result.Length.ShouldBeLessThan(bytesOrg.Length);
}
public void GlobalSetup()
{
_brotliCompressionService = new BrotliCompressionService();
_lz4CompressionService = new Lz4CompressionService();
_nopCompressionService = new NopCompressionService();
var bogus = new Bogus.Randomizer();
_bytesOrg = Encoding.UTF8.GetBytes(new Lorem().Sentence(500));
var buffer = ArrayPool <byte> .Shared.Rent(Constants.MAX_USABLE_BYTES_IN_PAGE + 500);
ArrayPool <byte> .Shared.Return(buffer);
}
public void FactoryTest()
{
var random = new Bogus.Randomizer();
var person = new Bogus.Person(locale: "pt_BR");
var usuarioNovo = ObjectFactory.CriarUsuario(Guid.NewGuid(), person.FirstName, person.Email, 123456.ToString());
usuarioNovo.AdicionarTelefone("21", person.Phone);
Assert.AreEqual(person.FirstName, usuarioNovo.nome);
Assert.AreEqual(person.Email, usuarioNovo.email);
Assert.AreEqual(person.Phone, usuarioNovo.Telefones[0].numero);
Assert.AreEqual("21", usuarioNovo.Telefones[0].ddd);
}
public async Task ChangeAppPath()
{
// [Setup]
// setup webhost using appsettings with specific path
var random = new Bogus.Randomizer();
var randomPathChars = random.Chars('a', 'z', random.Int(1, 10));
var randomPath = new string(randomPathChars);
var randomSecret = random.Words(10);
var hostbuilder =
WebHost
.CreateDefaultBuilder()
.ConfigureServices(s =>
{
s
.AddOurOrders(appSettings =>
{
appSettings.Path = randomPath;
appSettings.JwtSecret = randomSecret;
})
.UseInMemoryDB();
})
.Configure(appbuilder =>
{
appbuilder
.UseOurOrders();
});
var server = new TestServer(hostbuilder);
var httpClient = server.CreateClient();
// [Exercise]
// send a request to the webhost on the specified path
var path = $"/{randomPath}/account/current";
var response = await httpClient.GetAsync(path);
// [Verify]
// check if request is successful
Assert.True(response.IsSuccessStatusCode);
// [Teardown]
// shut down the server that we setup
server.Dispose();
}
public byte[] GeneratePayload(bool generateJsonPayload, int payloadSize)
{
string payload = "";
if (generateJsonPayload)
{
string utcTimeStamp = ((long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalMilliseconds).ToString();
string randomString = new Bogus.Randomizer().ClampString("", payloadSize, payloadSize);
payload = $"{{'dt':{utcTimeStamp},'payload':'{randomString}'}}";
}
else
{
payload = new Bogus.Randomizer().ClampString("", payloadSize, payloadSize);
}
return(Encoding.UTF8.GetBytes(payload));
}
public static string BuildTestString(string pattern)
{
if (string.IsNullOrWhiteSpace(pattern))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(pattern));
}
var randomizer = new Bogus.Randomizer();
const int noMatchPercentage = 50;
if (WeightedMatch(noMatchPercentage))
{
return(randomizer.String());
}
const int charMatchPercentage = 95;
var strBuilder = new StringBuilder(pattern.Length * 2);
foreach (var patternCh in pattern)
{
if (patternCh == '?')
{
strBuilder.Append(randomizer.AlphaNumeric(1));
}
else if (patternCh == '*')
{
strBuilder.Append(randomizer.Words());
}
else
{
if (WeightedMatch(charMatchPercentage))
{
strBuilder.Append(patternCh);
}
}
}
var str = strBuilder.ToString();
return(str);
bool WeightedMatch(int percentage)
{
return(randomizer.Bool(percentage / 100f));
}
}
/// <summary>
/// Popula o DataBase com dados de Teste
/// </summary>
/// <param name="context"></param>
protected override void Seed(DesafioConcreteContext context)
{
var random = new Bogus.Randomizer();
var _context = DesafioConcreteContext.Context;
for (int i = 0; i < 9; i++)
{
var person = new Bogus.Person(locale: "pt_BR");
var usuarioNovo = ObjectFactory.CriarUsuario(Guid.NewGuid(), person.FirstName, person.Email, "123456");
usuarioNovo.AdicionarTelefone("21", person.Phone);
_context.Add(usuarioNovo);
}
//context.SaveChanges();
}
public void UpdatePlot()
{
var random = new Bogus.Randomizer();
var unitCode = "u1";
var stratumCode = "st1";
var plotNumber = 1;
var plotID = Guid.NewGuid().ToString();
var cruiseID = CruiseID;
using (var database = CreateDatabase())
{
var datastore = new CuttingUnitDatastore(database, cruiseID, TestDeviceInfoService.TEST_DEVICEID, new SamplerInfoDataservice(database, CruiseID, TestDeviceInfoService.TEST_DEVICEID));
var stratumPlot = new Plot_Stratum()
{
CuttingUnitCode = unitCode,
PlotNumber = plotNumber,
StratumCode = stratumCode,
IsEmpty = false,
};
database.Execute($"INSERT INTO Plot (CruiseID, PlotID, CuttingUnitCode, PlotNumber) VALUES " +
$"('{cruiseID}', '{plotID}', '{unitCode}', {plotNumber})");
var plot = datastore.GetPlot(unitCode, plotNumber);
var slope = random.Double();
plot.Slope = slope;
var aspect = random.Double();
plot.Aspect = aspect;
var remarks = random.String2(24);
plot.Remarks = remarks;
datastore.UpdatePlot(plot);
var plotAgain = datastore.GetPlot(unitCode, plotNumber);
plotAgain.Slope.Should().Be(slope);
plotAgain.Aspect.Should().Be(aspect);
plotAgain.Remarks.Should().Be(remarks);
}
}
public async Task SimpleInsertTest()
{
var bogus = new Bogus.Randomizer();
using BufferSegment headerBufferSegment = new BufferSegment(Constants.PAGE_SIZE);
var headerPage = HeaderPage.CreateHeaderPage(headerBufferSegment);
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
PageService pageService = new PageService(new InMemoryDiskService());
DataService dataService = new DataService(new NopCompressionService(), pageService);
TestObject testObject = new TestObject();
testObject.IntProp = bogus.Int();
testObject.StringProp = bogus.String2(1000);
var address = await dataService.Insert(testObject);
address.SlotId.ShouldBe((byte)1);
address.PageId.ShouldBe((ushort)1);
}
public void OnExecute()
{
Logger.LogSuccess("Press CTRL+C to stop");
Thread.Sleep(1000);
while (true)
{
var hacker = new Hacker();
var internet = new Internet();
var diceRoll = new Bogus.Randomizer().Number(0, 6);
Logger.Log($"Loading {hacker.Noun()} from {hacker.Noun()}");
Logger.Log($"{hacker.IngVerb()} data to {hacker.Noun()} at: {internet.IpAddress()} ");
if (diceRoll == 4)
{
Logger.LogError($"Failure to process. See error code: {internet.Ipv6EndPoint()}");
}
if (diceRoll % 3 == 0)
{
Logger.LogSuccess($"Processing succeeded for {internet.Mac()}");
}
Logger.Log($"");
Thread.Sleep(350);
}
}
public static string Identity(this Bogus.Randomizer randomizer)
{
return($"test|{randomizer.Hexadecimal(16, "")}");
}
private async Task GenerateLoad(CommandLineOptionsClass commandLineOptions)
{
string utcTimeStamp;
string randomPayload;
string payload;
DateTime start;
Int64 messageNumber = 0;
BrokeredMessage message;
List <BrokeredMessage> messageBatch = new List <BrokeredMessage>();
QueueClient sendClient = QueueClient.CreateFromConnectionString(commandLineOptions.ConnectionString, commandLineOptions.EHOrQueueOrTopicName);
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId}, started and connected");
try
{
start = DateTime.Now;
while (messageNumber < commandLineOptions.MessagesToSend || commandLineOptions.MessagesToSend <= 0)
{
utcTimeStamp = ((long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalMilliseconds).ToString();
randomPayload = new Bogus.Randomizer().ClampString("", commandLineOptions.MessageSize, commandLineOptions.MessageSize);
payload = String.Format("{{\"dt\":{0},\"payload\":\"{1}\"}}", utcTimeStamp, randomPayload);
message = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(payload)))
{
ContentType = "application/json",
Label = "MyPayload",
TimeToLive = TimeSpan.FromMinutes(100)
};
if (!commandLineOptions.BatchMode)
{
await sendClient.SendAsync(message);
if (messageNumber % commandLineOptions.Checkpoint == 0 && messageNumber > 0)
{
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId}, sent: {messageNumber} / {commandLineOptions.MessagesToSend} messages, message size: {message.Size} bytes, speed: {messageNumber / (DateTime.Now - start).TotalSeconds} msg/sec");
}
}
else
{
messageBatch.Add(message);
if ((messageNumber % commandLineOptions.BatchSize == 0 && messageNumber > 0) ||
(messageNumber == (commandLineOptions.MessagesToSend - 1)))
{
await sendClient.SendBatchAsync(messageBatch);
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId}, sent: {messageNumber} / {commandLineOptions.MessagesToSend} messages total, in batches of {commandLineOptions.BatchSize}, message size: {message.Size} bytes, speed: {messageNumber / (DateTime.Now - start).TotalSeconds} msg/sec");
messageBatch.Clear();
}
}
messageNumber++;
}
}
catch
{
//ignore, keep bombarding!
}
finally
{
await sendClient.CloseAsync();
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId}, finished");
}
}
public static decimal Money(this Bogus.Randomizer randomizer, decimal min = 0.0m, decimal max = 1.0m)
{
return(Math.Round(randomizer.Decimal(min, max), 9));
}
public void DeleteTest()
{
var bogus = new Bogus.Randomizer();
const int insertLength = 20;
using BufferSegment bufferSegment = new BufferSegment(Constants.PAGE_SIZE);
PageHeader header = new PageHeader(1, PageType.Data);
header.ToBuffer(bufferSegment.Span, 0);
byte[] toInsert = TestHelper.GenerateByteArray(insertLength, 0xFF);
DataPage dataPage = new DataPage(bufferSegment);
dataPage.IsFull.ShouldBeFalse();
byte index = 0;
for (int i = 0; i < 10; i++)
{
var ins = dataPage.Insert(insertLength, out index);
ins.WriteBytes(0, toInsert);
}
// Highest index should be 10
index.ShouldBe((byte)10);
dataPage.PageHeader.HighestSlotId.ShouldBe(index);
var before = dataPage.PageHeader.UsedBytes;
var unaligned = dataPage.PageHeader.UnalignedFreeBytes;
unaligned.ShouldBe((ushort)0);
// delete entry 3
var dirEntryPosition = SlotEntry.GetEntryPosition(3);
var dirEntry = SlotEntry.FromBuffer(bufferSegment.Span, dirEntryPosition);
dirEntry.DataLength.ShouldBe((ushort)insertLength);
dataPage.Delete(3);
// data should be gone
var data = bufferSegment.Span.Slice(dirEntry.DataOffset, dirEntry.DataLength);
data.ToArray().ShouldAllBe(b => b == 0x00);
dataPage.PageHeader.UsedBytes.ShouldBe((ushort)(before - insertLength));
// delete entry 7
dirEntryPosition = SlotEntry.GetEntryPosition(7);
dirEntry = SlotEntry.FromBuffer(bufferSegment.Span, dirEntryPosition);
dirEntry.DataLength.ShouldBe((ushort)insertLength);
dataPage.Delete(7);
// data should be gone
data = bufferSegment.Span.Slice(dirEntry.DataOffset, dirEntry.DataLength);
data.ToArray().ShouldAllBe(b => b == 0x00);
// delete entry 10
dirEntryPosition = SlotEntry.GetEntryPosition(10);
dirEntry = SlotEntry.FromBuffer(bufferSegment.Span, dirEntryPosition);
dirEntry.DataLength.ShouldBe((ushort)insertLength);
dataPage.Delete(10);
// data should be gone
data = bufferSegment.Span.Slice(dirEntry.DataOffset, dirEntry.DataLength);
data.ToArray().ShouldAllBe(b => b == 0x00);
dataPage.PageHeader.HighestSlotId.ShouldBe((byte)9);
dataPage.PageHeader.UnalignedFreeBytes.ShouldBe((ushort)40);
var s = dataPage.ToString();
}
private async Task <int> CreateUsers(int howMany, bool household, bool quiet)
{
int created = 0;
int[] familyOptions = { 1, 2, 3, 4, 5, FamilyRandomIndicator, GroupRandomIndicator };
float[] familyWeights = { 0.25F, 0.35F, 0.21F, 0.10F, 0.04F, 0.047F, 0.003F };
var issues = new List <string>();
// make the participants
var users = await _userDataGenerator.Generate(Site.Id, howMany);
var minDateTime = DateTime.MaxValue;
var maxDateTime = DateTime.MinValue;
if (!quiet)
{
Console.Write($"Inserting {howMany} users... ");
}
ProgressBar progress = quiet ? null : new ProgressBar();
try
{
var rand = new Bogus.Randomizer();
int familyMembers = 0;
Domain.Model.User parent = null;
// insert the participants
foreach (var user in users)
{
bool currentUserParent = false;
// set an appropriate random date and time for insertion
var setDateTime = _dateTimeDataGenerator.SetRandom(Site);
if (setDateTime < minDateTime)
{
minDateTime = setDateTime;
}
if (setDateTime > maxDateTime)
{
maxDateTime = setDateTime;
}
if (familyMembers > 0)
{
// we are processing family members
user.User.LastName = parent.LastName;
if (rand.Int(1, 100) > 5)
{
user.User.Username = null;
}
// insert the family member
try
{
await _facade
.UserService
.AddHouseholdMemberAsync(parent.Id, user.User);
created++;
}
catch (GraException gex)
{
issues.Add($"Household username: {user.User.Username} - {gex.Message}");
}
familyMembers--;
}
else
{
// not processing family members, should this person be a head of household?
if (household && rand.Int(1, 100) <= 31)
{
currentUserParent = true;
familyMembers = rand.WeightedRandom <int>(familyOptions, familyWeights);
if (familyMembers == FamilyRandomIndicator)
{
familyMembers = rand.Int(6, 10);
}
else if (familyMembers == GroupRandomIndicator)
{
familyMembers = rand.Int(11, 100);
}
}
// insert the created user
try
{
var inserted = await _facade
.UserService
.RegisterUserAsync(user.User, user.Password);
if (currentUserParent)
{
parent = inserted;
}
created++;
}
catch (Exception ex)
{
issues.Add($"Username: {user.User.Username} - {ex.Message}");
}
}
if (progress != null)
{
progress.Report((double)created / howMany);
}
}
}
finally
{
if (progress != null)
{
progress.Dispose();
}
}
Console.WriteLine($"Created {created} random users in {Site.Name}.");
Console.WriteLine($"Users registered between {minDateTime} and {maxDateTime}.");
if (issues.Count > 0)
{
Console.WriteLine("Some issues were encountered:");
foreach (string issue in issues)
{
Console.WriteLine($"- {issue}");
}
}
await DisplayUserCount();
return(howMany == created ? 0 : 1);
}
Generate(Site site, int count, int challengePercent, int codePercent, bool quiet)
{
int[] minuteCeilings = { 60, 120, 500 };
float[] minuteCeilingDistribution = { 0.85F, 0.1F, 0.05F };
var userList = await _userService.GetPaginatedUserListAsync(new UserFilter());
var codeList = await _triggerService.GetPaginatedListAsync(new TriggerFilter
{
SecretCodesOnly = true
});
var challengeList = await _challengeService
.GetPaginatedChallengeListAsync(new ChallengeFilter());
var activities = new List <GeneratedActivity>();
var rand = new Bogus.Randomizer();
if (!quiet)
{
Console.Write($"Generating {count} activity items... ");
}
ProgressBar progress = quiet ? null : new ProgressBar();
try
{
for (int i = 0; i < count; i++)
{
bool addActivity = false;
var randomUser = (await _userService.GetPaginatedUserListAsync(new UserFilter
{
SiteId = site.Id,
Skip = rand.Int(0, userList.Count - 1),
Take = 1
})).Data.First();
var act = new GeneratedActivity
{
User = randomUser,
};
if (challengePercent > 0 && rand.Int(1, 100) <= challengePercent)
{
bool isValid = false;
int challengeLookupCount = 0;
await _configureUserSite.Lookup(randomUser.Id);
_challengeService.ClearCachedUserContext();
DataWithCount <IEnumerable <Challenge> > randomChallenge = null;
while (!isValid)
{
challengeLookupCount++;
var filter = new ChallengeFilter()
{
Take = rand.Int(0, challengeList.Count - 1),
Skip = 1
};
randomChallenge = await _challengeService.GetPaginatedChallengeListAsync(filter);
if (randomChallenge.Data != null &&
randomChallenge.Data.FirstOrDefault() != null)
{
isValid = randomChallenge.Data.First().IsValid;
}
if (challengeLookupCount > 20)
{
_logger.LogError($"Unable to find an eligible challenge for user id {randomUser.Id} after 20 tries, giving up.");
randomChallenge = null;
addActivity = false;
break;
}
}
if (randomChallenge != null)
{
var randomTasks = await _challengeService
.GetChallengeTasksAsync(randomChallenge.Data.First().Id);
var randomTask = randomTasks
.Skip(rand.Int(0, randomTasks.Count() - 1)).First();
randomTask.IsCompleted = true;
act.ActivityType = ActivityType.ChallengeTasks;
act.ChallengeId = randomChallenge.Data.First().Id;
act.ChallengeTasks = new List <ChallengeTask> {
randomTask
};
addActivity = true;
}
}
else
{
if (codePercent > 0 && rand.Int(1, 100) <= codePercent)
{
var randomCode = (await _triggerService.GetPaginatedListAsync(new TriggerFilter
{
SiteId = site.Id,
Skip = rand.Int(0, codeList.Count - 1),
Take = 1,
SecretCodesOnly = true
})).Data.First();
act.ActivityType = ActivityType.SecretCode;
act.SecretCode = randomCode.SecretCode;
addActivity = true;
}
else
{
act.ActivityAmount = rand.Int(1, rand
.WeightedRandom <int>(minuteCeilings, minuteCeilingDistribution));
act.ActivityType = ActivityType.Default;
addActivity = true;
}
}
if (addActivity)
{
activities.Add(act);
}
if (progress != null)
{
progress.Report((double)i / count);
}
}
}
finally
{
if (progress != null)
{
progress.Dispose();
Console.WriteLine();
}
}
return(activities);
}
