public void StringToState()
{
Assert.True(StateTransformer.TransformStringToState("CHOOSE_LEVEL").
Equals(GameStateType.ChooseLevel));
Assert.True(StateTransformer.TransformStringToState("MAIN_MENU").
Equals(GameStateType.MainMenu));
Assert.True(StateTransformer.TransformStringToState("GAME_PAUSED").
Equals(GameStateType.GamePaused));
Assert.True(StateTransformer.TransformStringToState("GAME_RUNNING").
Equals(GameStateType.GameRunning));
}
public async Task ReadStateAsync(string grainType, GrainReference grainReference, IGrainState grainState)
{
if (!(grainState is IAggregateState))
{
throw new NotAggregateStateException(grainState.GetType());
}
var stream = this.GetStreamName(grainType, grainReference);
var sliceStart = 0;
StreamEventsSlice currentSlice;
do
{
var sliceCount = sliceStart + ReadPageSize;
currentSlice = await this.Connection.ReadStreamEventsForwardAsync(stream, sliceStart, sliceCount, true);
if (currentSlice.Status == SliceReadStatus.StreamNotFound)
{
return;
}
if (currentSlice.Status == SliceReadStatus.StreamDeleted)
{
throw new StreamDeletedException();
}
sliceStart = currentSlice.NextEventNumber;
foreach (var @event in currentSlice.Events)
{
dynamic deserialisedEvent = DeserializeEvent(@event.Event);
StateTransformer.ApplyEvent(deserialisedEvent, grainState as IAggregateState);
}
} while (!currentSlice.IsEndOfStream);
}
private void SetChild()
{
panelCenter.Controls.Clear();
UserControl uc = null;
AbstractDoubleTransformer tr = transformer.Transformer;
if (tr is StateTransformer)
{
StateTransformer str = tr as StateTransformer;
UserControlComponentCollectionVariablesStep ucs = new UserControlComponentCollectionVariablesStep();
uc = ucs;
ucs.Step = transformer.Step;
ucs.Collection = transformer;
ucs.SetStep += (double a) => { transformer.Step = a; };
}
else
{
UserControlComponentCollectionVariablesMeasure ucm = new UserControlComponentCollectionVariablesMeasure();
uc = ucm;
ucm.Transformer = transformer;
}
uc.Dock = DockStyle.Fill;
panelCenter.Controls.Add(uc);
}
public void TestStringToState(StateTransformer.GameStateType type, string input)
{
Assert.AreEqual(type, StateTransformer.TransformStringToState(input));
}
public void TestTransformStateToStringGAME_MAINMENU()
{
Assert.AreSame(StateTransformer.TransformStateToString(
StateTransformer.GameStateType.MainMenu), "GAME_MAINMENU");
}
public void TestTransformStringToStateGAME_RUNNING()
{
Assert.AreEqual(StateTransformer.TransformStringToState("GAME_RUNNING"),
StateTransformer.GameStateType.GameRunning);
}
public void TestTransformStringToStateGAME_PAUSED()
{
Assert.AreEqual(StateTransformer.TransformStringToState("GAME_PAUSED"),
StateTransformer.GameStateType.GamePaused);
}
public void TestTransformStringToStateGAME_MAINMENU()
{
Assert.AreEqual(StateTransformer.TransformStringToState("GAME_MAINMENU"),
StateTransformer.GameStateType.MainMenu);
}
public void TestStateTransformerCorrect(GameStateType x, string y)
{
Assert.AreEqual(x, StateTransformer.TransformStringToState(y));
Assert.AreEqual(StateTransformer.TransformStateToString(x), y);
}
public void Init()
{
testStateTransformer = new StateTransformer();
}
async static Task Main(string[] args)
{
var lines = File.ReadAllLinesAsync("input.txt");
var regex = new Regex("(?'mnemonic'[a-z]{3})\\s(?'operand'[+\\-][0-9]+)", RegexOptions.Compiled);
var program = (await lines)
.Select(l => regex.Match(l))
.Select(m =>
{
var mn = m.Groups["mnemonic"].Value switch
{
"nop" => InstructionCode.Nop,
"acc" => InstructionCode.Acc,
"jmp" => InstructionCode.Jmp,
_ => throw new Exception("Invalid opcode."),
};
var op = int.Parse(m.Groups["operand"].Value);
return(new Instruction(mn, op));
})
.ToList();
var runner = new StateTransformer
{
Program = program
};
var pcsVisited = new HashSet <int>();
var state = new State(0, 0);
while (!pcsVisited.Contains(state.ProgramCounter))
{
pcsVisited.Add(state.ProgramCounter);
Console.WriteLine($"PC={state.ProgramCounter} A={state.Accumulator}");
state = runner.Next(state);
}
foreach (var mutation in program
.Select((instr, idx) => (instr, idx))
.Where(p =>
p.instr.OpCode == InstructionCode.Jmp ||
p.instr.OpCode == InstructionCode.Nop)
)
{
var prog = program.ToList();
prog[mutation.idx] = prog[mutation.idx] with
{
OpCode = mutation.instr.OpCode switch
{
InstructionCode.Nop => InstructionCode.Jmp,
InstructionCode.Jmp => InstructionCode.Nop,
_ => throw new ArgumentOutOfRangeException()
}
};
var mutRunner = new StateTransformer
{
Program = prog
};
var mutPcVisited = new HashSet <int>();
var mutState = new State(0, 0);
while (mutState.ProgramCounter != prog.Count)
{
mutPcVisited.Add(mutState.ProgramCounter);
mutState = mutRunner.Next(mutState);
if (mutPcVisited.Contains(mutState.ProgramCounter))
{
break;
}
}
if (mutState.ProgramCounter == prog.Count)
{
Console.WriteLine("Excecuted Mutation.");
Console.WriteLine($"PC={mutState.ProgramCounter} A={mutState.Accumulator}");
}
}
}
public void StateToString2()
{
Assert.AreEqual(StateTransformer.TransformStateToString(GameStateType.GamePaused), "GAME_PAUSED");
}
public void StateToString3()
{
Assert.AreEqual(StateTransformer.TransformStateToString(GameStateType.MainMenu), "GAME_MAIN");
}
public void StateToString1()
{
Assert.AreEqual(StateTransformer.TransformStateToString(GameStateType.GameRunning), "GAME_RUNNING");
}
public void StringToState3()
{
Assert.AreEqual(StateTransformer.TransformStringToState("GAME_MAIN"), GameStateType.MainMenu);
}
public void TestStateTransformerThrows()
{
Assert.Throws <ArgumentException>(() => { StateTransformer.TransformStringToState("NOT_A_REAL_STATE"); });
// We cannot test if TransformStateToString throws, since there only are three possible cases for the enum,
// and they are all covered.
}
public void TestStateToString(string str, StateTransformer.GameStateType type)
{
Assert.AreEqual(str, StateTransformer.TransformStateToString(type));
}
public void TestStringToState2()
{
Assert.AreEqual(StateTransformer.TransformStringToState("MAIN_MENU"),
GameStateType.MainMenu);
}
public void TestNull()
{
Assert.Throws <ArgumentException>((() => StateTransformer.TransformStringToState("STOP")));
}
public void TestTransformStateToStringGAME_RUNNING()
{
Assert.AreSame(StateTransformer.TransformStateToString(
StateTransformer.GameStateType.GameRunning), "GAME_RUNNING");
}
public void TestTransformStateToStringGAME_PAUSED()
{
Assert.AreSame(StateTransformer.TransformStateToString(
StateTransformer.GameStateType.GamePaused), "GAME_PAUSED");
}
public void TestStateToString3()
{
Assert.AreEqual(StateTransformer.TransformStateToString(GameStateType.MainMenu),
"MAIN_MENU");
}
