public void AlterGenerateTest()
{
// Arrange
object parameter = "alter";
int seed = 1337;
int loopCount = 20;
BooleanGenerator bg = new BooleanGenerator();
List <bool> bools = new List <bool>();
List <bool> successList = new List <bool>();
// Act
var shouldBeValidResult = bg.Init(parameter, seed);
for (int i = 0; i < loopCount; i++)
{
var generateResult = bg.Generate(parameter: null, wantedOutput: null);
successList.Add(generateResult.success);
bools.Add((bool)generateResult.result);
bg.NextStep();
}
// Assert
Assert.IsTrue(shouldBeValidResult.success, "Init should have been successful");
CollectionAssert.DoesNotContain(successList, false, "All generates should have been successful");
Assert.AreEqual(loopCount / 2, bools.Where(item => item == true).Count(), "Half of the results should be true");
Assert.AreEqual(loopCount / 2, bools.Where(item => item == false).Count(), "Half of the results should be false");
}
public void BooleanGenerator()
{
IGenerator<bool> booleangenerator = new BooleanGenerator();
var boolvalue = (bool) booleangenerator.Generate();
Assert.IsNotNull(boolvalue);
Assert.IsInstanceOfType(typeof (bool), boolvalue);
}
public static void Main()
{
// Instantiate the Boolean generator.
BooleanGenerator boolGen = new BooleanGenerator();
int totalTrue = 0, totalFalse = 0;
// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++)
{
bool value = boolGen.NextBoolean();
if (value)
{
totalTrue++;
}
else
{
totalFalse++;
}
}
Console.WriteLine("Number of true values: {0,7:N0} ({1:P3})",
totalTrue,
((double)totalTrue) / (totalTrue + totalFalse));
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double)totalFalse) / (totalTrue + totalFalse));
}
public void InitTest()
{
// Arrange
object valid1 = null;
string valid2 = "alter";
string valid3 = "rng";
object invalid1 = new object();
int seed = 1337;
BooleanGenerator bg1 = new BooleanGenerator();
BooleanGenerator bg2 = new BooleanGenerator();
BooleanGenerator bg3 = new BooleanGenerator();
BooleanGenerator bg4 = new BooleanGenerator();
// Act
var shouldBeValidResult1 = bg1.Init(valid1, seed);
var shouldBeValidResult2 = bg2.Init(valid2, seed);
var shouldBeValidResult3 = bg3.Init(valid3, seed);
var shouldBeInvalidResult1 = bg4.Init(invalid1, seed);
// Assert
Assert.IsTrue(shouldBeValidResult1.success, "Init should have been successful");
Assert.IsTrue(shouldBeValidResult2.success, "Init should have been successful");
Assert.IsTrue(shouldBeValidResult3.success, "Init should have been successful");
Assert.IsFalse(shouldBeInvalidResult1.success, "Init should have failed");
}
public void BooleanGenerator()
{
IBooleanGenerator booleangeneerator = new BooleanGenerator();
bool booltest = booleangeneerator.Generate(random);
Assert.IsNotNull(booltest);
}
public void SeedTest()
{
// Arrange
int seed1 = 1337;
int seed2 = 13370;
int rounds = 100;
BooleanGenerator bg1 = new BooleanGenerator();
BooleanGenerator bg2 = new BooleanGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <object> gene2Objects = new List <object>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = bg1.Init(null, seed1);
var shouldBeValidInitResult2 = bg2.Init(null, seed2);
for (int i = 0; i < rounds; i++)
{
var genResult1 = bg1.Generate();
var genResult2 = bg2.Generate();
gene1Objects.Add(genResult1.result);
gene2Objects.Add(genResult2.result);
bg1.NextStep();
bg2.NextStep();
}
CollectionAssert.AreNotEqual(gene1Objects, gene2Objects);
}
public void BooleanGenerator()
{
IGenerator <bool> booleangenerator = new BooleanGenerator();
var boolvalue = (bool)booleangenerator.Generate();
Assert.IsNotNull(boolvalue);
Assert.IsInstanceOf <bool>(boolvalue);
}
public void BooleanGeneratorWithAttributeMap()
{
IBooleanGenerator booleangenerator = new BooleanGenerator();
AttributeMap attmap = new AttributeMap {
DefaultBoolValue = true
};
bool booltest = booleangenerator.Generate(random, attmap);
Assert.IsNotNull(booltest);
}
public GroveMessage GetSensorValue()
{
BooleanGenerator boolGen = new BooleanGenerator();
Random rnd = new Random();
GroveMessage message = new GroveMessage();
message.Temp = rnd.Next(10, 30);
message.Hum = rnd.Next(40, 100);
message.Sound = rnd.Next(100, 200);
message.Light = rnd.Next(100, 200);
message.GasSO = rnd.Next(10, 100);
message.PIR = boolGen.NextBoolean();
message.Timestamp = DateTime.Now.ToString();
return(message);
}
public void BooleanGenerator_GetRandomName()
{
var container = new List <bool>();
for (int i = 0; i < 100; i++)
{
container.Add(BooleanGenerator.GetRandom());
}
var countTrue = container.Where(v => v == true).Count();
Assert.True(countTrue > 0);
var countFalse = container.Where(v => v == false).Count();
Assert.True(countFalse > 0);
}
public void WantedOutputTypeTest()
{
// Arrange
object parameter = null;
int seed = 1337;
BooleanGenerator bg = new BooleanGenerator();
Type stringType = typeof(string);
Type boolType = typeof(bool);
Type doubleType = typeof(double);
// Act
var shouldBeValidInitResult = bg.Init(parameter, seed);
var shouldBeValidGenerateResult1 = bg.Generate(parameter: null, wantedOutput: null);
var shouldBeValidGenerateResult2 = bg.Generate(parameter: null, wantedOutput: stringType);
var shouldBeValidGenerateResult3 = bg.Generate(parameter: null, wantedOutput: boolType);
var shouldBeInvalidGenerateResult1 = bg.Generate(parameter: null, wantedOutput: doubleType);
// Assert
Assert.IsTrue(shouldBeValidGenerateResult1.success, "Generate should have succeeded");
Assert.IsTrue(shouldBeValidGenerateResult2.success, "Generate should have succeeded");
Assert.IsTrue(shouldBeValidGenerateResult3.success, "Generate should have succeeded");
Assert.AreEqual(stringType, shouldBeValidGenerateResult2.result.GetType(), "Output should be string");
Assert.AreEqual(true.ToString(), (string)shouldBeValidGenerateResult2.result, "Output should be 'True'");
Assert.AreEqual(boolType, shouldBeValidGenerateResult3.result.GetType(), "Output should be bool");
Assert.AreEqual(true, (bool)shouldBeValidGenerateResult3.result, "Output should be true");
Assert.IsFalse(shouldBeInvalidGenerateResult1.success, "Generate should have failed for double");
Assert.IsNull(shouldBeInvalidGenerateResult1.result, "Returned object should be null");
Assert.IsFalse(string.IsNullOrEmpty(shouldBeInvalidGenerateResult1.possibleError), "There should be an error");
}
public void RandomGenerateTest()
{
// Arrange
object parameter = null;
int seed = 1337;
int loopCount = 100;
BooleanGenerator bg = new BooleanGenerator();
List <bool> bools = new List <bool>();
List <bool> successList = new List <bool>();
// Act
var shouldBeValidResult = bg.Init(parameter, seed);
var generated1 = bg.Generate(parameter);
var generated2 = bg.Generate(parameter); // Same step should provide same result
for (int i = 0; i < loopCount; i++)
{
bg.NextStep();
var generateResult = bg.Generate(parameter: null, wantedOutput: null);
successList.Add(generateResult.success);
bools.Add((bool)generateResult.result);
}
// Assert
Assert.IsTrue(shouldBeValidResult.success, "Init should have been successful");
Assert.AreEqual(generated1.result, generated2.result, "Both generates should have same results since NextStep has not been called between them");
CollectionAssert.DoesNotContain(successList, false, "All generates should have been successful");
Assert.GreaterOrEqual(bools.Where(item => item == true).Count(), 25, "There should be at least some true values");
Assert.GreaterOrEqual(bools.Where(item => item == false).Count(), 25, "There should be at least some false values");
}
public void LoadTest()
{
// Arrange
int seed = 13237;
string loadString = $"~random~{seed}";
BooleanGenerator bg1 = new BooleanGenerator();
BooleanGenerator bg2 = new BooleanGenerator();
BooleanGenerator bg3 = new BooleanGenerator();
List <bool> results1 = new List <bool>();
List <bool> results2 = new List <bool>();
List <bool> results3 = new List <bool>();
// Act
var shouldBeValidInitResult1 = bg1.Init("random", seed);
var shouldBeValidInitResult2 = bg3.Init(null, 0);
var shouldBeValidLoadResult = bg2.Load(loadString);
for (int i = 0; i < 13; i++)
{
results1.Add((bool)bg1.Generate().result);
results2.Add((bool)bg2.Generate().result);
results3.Add((bool)bg3.Generate().result);
}
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success);
Assert.IsTrue(shouldBeValidInitResult2.success);
Assert.IsTrue(shouldBeValidLoadResult.success);
CollectionAssert.AreEqual(results1, results2);
CollectionAssert.AreNotEqual(results1, results3);
}
public void SaveTest()
{
// Arrange
int seed = 1337;
BooleanGenerator bg1 = new BooleanGenerator();
BooleanGenerator bg2 = new BooleanGenerator();
string initString = $"random";
// Act
var shouldBeValidInitResult1 = bg1.Init(null, 0);
string bg1String = bg1.Save();
var shouldBeValidInitResult2 = bg2.Init(initString, seed);
string bg2String = bg2.Save();
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success);
Assert.IsTrue(shouldBeValidInitResult2.success);
Assert.AreEqual("~random~0", bg1String, "Default Init should store random");
Assert.AreEqual($"~{initString}~{seed}", bg2String, "Init string should be saved");
}
private void ProcessE(object state)
{
Process _currentProcess = (Process)state;
ProgressBar _bar = m_ProcessBars[_currentProcess.Index];
TextBox _txt = m_ProcessTextBoxes[_currentProcess.Index];
BooleanGenerator boolGen = new BooleanGenerator();
_currentProcess.isStarted[4] = true;
while (_bar.Value < _bar.Maximum)
{
if (_currentProcess.CurrentDuration < _currentProcess.Duration)
{
_currentProcess.result[3] = _currentProcess.result[1];
_txt.Text = "E: F3 = F2 = " + _currentProcess.result[3].ToString();
}
_currentProcess.ChangeDurration();
int _newValue = _bar.Value + 100 / _currentProcess.Duration;
_bar.Invoke(new MethodInvoker(() =>
{
if (_newValue < _bar.Maximum)
{
_bar.Value = _newValue;
}
else
{
_bar.Value = _bar.Maximum;
}
}));
Thread.Sleep(1000);
}
_currentProcess.isCompleted[4] = true;
_currentProcess.isStarted[4] = false;
//Если завершен Е - старт F,G,H
if (_currentProcess.isCompleted[4] && _currentProcess.isCompleted[1] && _currentProcess.isCompleted[3])
{
for (int i = 5; i < 8; i++)
{
if (i == 5)
{
Thread _Thread5;
Process _currentProcess5 = new Process(i, 1, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread5 = new Thread(ProcessF);
_Thread5.IsBackground = true;
_Thread5.Start(_currentProcess5);
}
else if (i == 6)
{
Thread _Thread6;
Process _currentProcess6 = new Process(i, 1, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread6 = new Thread(ProcessG);
_Thread6.IsBackground = true;
_Thread6.Start(_currentProcess6);
}
else
{
Thread _Thread7;
Process _currentProcess7 = new Process(i, 1, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread7 = new Thread(ProcessH);
_Thread7.IsBackground = true;
_Thread7.Start(_currentProcess7);
}
}
}
}
//Потоки
//Process A
private void ProcessA(object state)
{
Process _currentProcess = (Process)state;
ProgressBar _bar = m_ProcessBars[_currentProcess.Index];
TextBox _txt = m_ProcessTextBoxes[_currentProcess.Index];
BooleanGenerator boolGen = new BooleanGenerator();
_currentProcess.isStarted[0] = true;
//Основной цикл
while (_bar.Value < _bar.Maximum)
{
if (_currentProcess.CurrentDuration < _currentProcess.Duration) //генерируются случайные R
{
_currentProcess.R[0] = boolGen.NextBoolean();
_currentProcess.R[1] = boolGen.NextBoolean();
_currentProcess.R[2] = boolGen.NextBoolean();
_txt.Text = "A: R1=" + _currentProcess.R[0].ToString()
+ " R2=" + _currentProcess.R[1].ToString() + " R3=" + _currentProcess.R[2].ToString(); //вывод
}
//отрисовка шкалы загрузки
int _newValue = _bar.Value + 100 / _currentProcess.Duration * 25;
_currentProcess.ChangeDurration();
_bar.Invoke(new MethodInvoker(() =>
{
if (_newValue < _bar.Maximum)
{
_bar.Value = _newValue;
}
else
{
_bar.Value = _bar.Maximum;
}
}));
Thread.Sleep(800); //приостановка процесса
}
_currentProcess.isCompleted[0] = true;
_currentProcess.isStarted[0] = false;
//Если А завершен - стартуют B, D, C
if (_currentProcess.isCompleted[0])
{
for (int i = 1; i < 4; i++)
{
if (i == 1) //B
{
Thread _Thread1;
Process _currentProcess1 = new Process(i, 2, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread1 = new Thread(MakeProcess);
_Thread1.IsBackground = true;
_Thread1.Start(_currentProcess1);
}
else if (i == 3) //D
{
Thread _Thread3;
Process _currentProcess3 = new Process(i, 2, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread3 = new Thread(MakeProcess);
_Thread3.IsBackground = true;
_Thread3.Start(_currentProcess3);
}
else //C
{
Thread _Thread2;
Process _currentProcess2 = new Process(i, 1, _currentProcess.R,
_currentProcess.result, _currentProcess.isCompleted, _currentProcess.isStarted);
_Thread2 = new Thread(MakeProcess);
_Thread2.IsBackground = true;
_Thread2.Start(_currentProcess2);
}
}
}
}
public void BooleanGenerator()
{
IBooleanGenerator booleangeneerator = new BooleanGenerator();
bool booltest = booleangeneerator.Generate(random);
Assert.IsNotNull(booltest);
}
public void BooleanGeneratorWithAttributeMap()
{
IBooleanGenerator booleangenerator = new BooleanGenerator();
AttributeMap attmap = new AttributeMap { DefaultBoolValue = true };
bool booltest = booleangenerator.Generate(random, attmap);
Assert.IsNotNull(booltest);
}
