private void Memory_Clicked(object sender, EventArgs e)
{
Button memory = (Button)sender;
switch (memory.Text)
{
case ("M+"):
try
{
MemoryValue = int.Parse(currentExpression.Text);
break;
}
catch (Exception exception)
{
DisplayAlert("Memory Error", "You can only add single numbers into memory", "OK");
break;
}
case ("M"):
currentExpression.Text = MemoryValue.ToString();
answerString.Append(MemoryValue.ToString());
break;
case ("M-"):
MemoryValue = 0;
break;
}
}
public void Be_represented_on_36bits(
long value,
string expectedRepresentation)
{
// Given
// When
var memValue = new MemoryValue(value);
// Then
Assert.Equal(expectedRepresentation, $"{memValue}");
}
public void Be_construct_through_representation(
string memoryValueRepresentation,
long expectedValue)
{
// Given
var expectedMemoryValue = new MemoryValue(expectedValue);
// When
var actualMemoryValue = new MemoryValue(memoryValueRepresentation);
// Then
Assert.Equal(expectedMemoryValue, actualMemoryValue);
}
public void Read_set_memory_instruction(string programInstruction, uint memoryPosition, long value)
{
// Given
var expectedMemoryValue = new MemoryValue(value);
// When
var actualMemory = InitializationProgramInterpreter.ExecuteInstruction(
new Memory(new Memory.OverwriteStrategy()),
programInstruction);
var actualMemoryValue = actualMemory.ValueAt(memoryPosition);
// Then
Assert.Equal(expectedMemoryValue, actualMemoryValue);
}
public void Get_value()
{
// Given
var memory = new Memory(new Memory.OverwriteStrategy());
var expectedMemoryValue = new MemoryValue(11);
var memoryAddress = new MemoryAddress(8);
memory.WriteAt(memoryAddress, new MemoryValue(11));
// When
var actualMemoryValue = memory.ValueAt(8);
// Then
Assert.Equal(expectedMemoryValue, actualMemoryValue);
}
public void Overwrite_memory_value(
long value,
string maskDescription,
string expectedRepresentation)
{
// Given
var expectedMemoryValue = new MemoryValue(expectedRepresentation);
var memoryValue = new MemoryValue(value);
var mask = new BitMask(maskDescription);
// When
var overwrittenMemoryValue = mask.Overwrite(memoryValue);
// Then
Assert.Equal(expectedMemoryValue, overwrittenMemoryValue);
}
public void Be_add_up(
long firstValue,
long secondValue,
long totalValue)
{
// Given
var firstMemoryValue = new MemoryValue(firstValue);
var secondMemoryValue = new MemoryValue(secondValue);
var expectedTotalMemoryValue = new MemoryValue(totalValue);
// When
var actualTotalMemoryValue = firstMemoryValue + secondMemoryValue;
// Then
Assert.Equal(expectedTotalMemoryValue, actualTotalMemoryValue);
}
public MemoryValueEditor(AutoSplitEnv env, MemoryValue source = null) : base(env, source)
{
InitializeComponent();
_env = env;
cbAddresses.DataSource = _env.Addresses.Where(w => IsSupportedMemoryWatcher(w)).OrderBy(w => w.Name).ToList();
cbAddresses.SelectionChangeCommitted += (s, e) => ChangeAddress((MemoryWatcher)cbAddresses.SelectedItem);
if (source != null)
{
var addr = _env.Addresses.FirstOrDefault(m => m.Name == source.MemoryWatcherName);
if (addr != null)
{
cbAddresses.SelectedItem = addr;
}
else
{
MessageBox.Show($"The address \"{source.MemoryWatcherName}\" does not exist.\nPlease choose another one.",
"Address not found", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
ChangeAddress((MemoryWatcher)cbAddresses.SelectedItem);
if (source != null)
{
if (cbValue.DropDownStyle == ComboBoxStyle.DropDownList)
{
cbValue.SelectedItem = source.Value;
}
else
{
var value = source.Value as IFormattable;
cbValue.Text = value.ToString(null, CultureInfo.InvariantCulture);
}
cbComparison.SelectedItem = source.Comparison;
chkOnChange.Checked = source.OnValueChanged;
if (source is StringValue)
{
var stringValue = (StringValue)source;
chkIgnoreCase.Checked = stringValue.IgnoreCase;
chkContains.Checked = stringValue.IsContained;
}
}
}
public void Write_value_with_bitmask_overwrite_value(
long value,
string maskDescription,
string expectedRepresentation)
{
// Given
var memory = new Memory(new Memory.OverwriteStrategy());
memory.UpdateBitMask(new BitMask(maskDescription));
var expectedMemoryValue = new MemoryValue(expectedRepresentation);
// When
memory.WriteAt(new MemoryAddress(1), new MemoryValue(value));
// Then
Assert.Equal(expectedMemoryValue, memory.ValueAt(1));
}
public MemoryValue Apply(MemoryValue value)
{
var result = new bool[Memory.REGISTER_SIZE];
for (int n = 0; n < Memory.REGISTER_SIZE; n++)
{
if (bitMask[n].HasValue)
{
result[n] = bitMask[n].Value;
}
else
{
result[n] = value.Value[n];
}
}
return(new MemoryValue(result));
}
public void Determine_the_sum_of_all_values_left_in_memory_after_read_and_decode(
string initializationProgramDescription,
long expectedSum)
{
// Given
var programInstructions = initializationProgramDescription.Split("\n");
var memory = new Memory(new Memory.DecodeStrategy());
var expectedSumMemoryValue = new MemoryValue(expectedSum);
// When
memory = programInstructions.Aggregate(
memory,
InitializationProgramInterpreter.ExecuteInstruction);
var actualSumMemoryValue = memory.Sum;
// Then
Assert.Equal(expectedSumMemoryValue, actualSumMemoryValue);
}
public void Sum_all_values()
{
// Given
var memory = new Memory(new Memory.OverwriteStrategy());
var eightMemoryAddress = new MemoryAddress(8);
var seventhMemoryAddress = new MemoryAddress(7);
var mask = new BitMask("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X");
memory.UpdateBitMask(mask);
memory.WriteAt(eightMemoryAddress, new MemoryValue(11));
memory.WriteAt(seventhMemoryAddress, new MemoryValue(101));
memory.WriteAt(eightMemoryAddress, new MemoryValue(0));
var expectedSumMemoryValue = new MemoryValue(165);
// When
var actualSumMemoryValue = memory.Sum;
// Then
Assert.Equal(expectedSumMemoryValue, actualSumMemoryValue);
}
private void ProcessOperation(string s)
{
try
{
float f = 0.0F;
switch (s)
{
case "Divide":
if (ClearDisplay)
{
_prevOp = MathOperations.Divide;
break;
}
CalculateResult();
_prevOp = MathOperations.Divide;
PrevValue = Display;
ClearDisplay = true;
break;
case "Multiply":
if (ClearDisplay)
{
_prevOp = MathOperations.Multiply;
break;
}
CalculateResult();
_prevOp = MathOperations.Multiply;
PrevValue = Display;
ClearDisplay = true;
break;
case "Subtract":
if (ClearDisplay)
{
_prevOp = MathOperations.Subtract;
break;
}
CalculateResult();
_prevOp = MathOperations.Subtract;
PrevValue = Display;
ClearDisplay = true;
break;
case "Add":
if (ClearDisplay)
{
_prevOp = MathOperations.Add;
break;
}
CalculateResult();
_prevOp = MathOperations.Add;
PrevValue = Display;
ClearDisplay = true;
break;
case "Equals":
if (ClearDisplay)
{
break;
}
CalculateResult();
ClearDisplay = true;
_prevOp = MathOperations.None;
PrevValue = Display;
break;
case "SquareRoot":
_prevOp = MathOperations.SquareRoot;
PrevValue = Display;
CalculateResult();
PrevValue = Display;
ClearDisplay = true;
_prevOp = MathOperations.None;
break;
case "Percent":
if (ClearDisplay)
{
_prevOp = MathOperations.Percent;
break;
}
CalculateResult();
_prevOp = MathOperations.Percent;
PrevValue = Display;
ClearDisplay = true;
break;
case "PlusMinus":
_prevOp = MathOperations.PlusMinus;
PrevValue = Display;
CalculateResult();
PrevValue = Display;
ClearDisplay = true;
_prevOp = MathOperations.None;
break;
case "ClearAll":
_prevOp = MathOperations.None;
Display = PrevValue = string.Empty;
Equation.Clear();
UpdateDisplay();
break;
case "ClearEntry":
_prevOp = MathOperations.None;
Display = PrevValue;
UpdateDisplay();
break;
case "MemoryClear":
MemoryValue = 0.0F;
DisplayMemory();
break;
case "MemorySave":
MemoryValue = float.Parse(Display, CultureInfo.InvariantCulture.NumberFormat);
DisplayMemory();
ClearDisplay = true;
break;
case "MemoryRecall":
Display = MemoryValue.ToString();
UpdateDisplay();
ClearDisplay = false;
break;
case "MemoryAdd":
f = MemoryValue + float.Parse(Display, CultureInfo.InvariantCulture.NumberFormat);
MemoryValue = f;
DisplayMemory();
ClearDisplay = true;
break;
}
}
catch (Exception exception)
{
Equation.AddResult("Error");
}
}
protected internal override void WriteAt(Memory memory, MemoryAddress address, MemoryValue value)
{
foreach (var decodedMemoryAddress in MemoryAddressDecoder.Decode(memory.BitMask, address))
{
memory.values[decodedMemoryAddress.Position] = value;
}
}
protected internal abstract void WriteAt(Memory memory, MemoryAddress address, MemoryValue value);
private static bool CanSkip(
MemoryAddressSpace currentAddressSpace,
MemoryValue toSkip) =>
toSkip switch
{
public SetValue(long memPosition, long value)
{
this.memPosition = MemoryPosition.FromLong(memPosition);
this.value = MemoryValue.FromLong(value);
}
protected internal override void WriteAt(Memory memory, MemoryAddress address, MemoryValue value) => memory.values[address.Position] = memory.BitMask.Overwrite(value);
