private static void Main(string[] args)
{
IOperationParser operationParser = new OperationParser(OutputFile);
ICommandParser commandParser = new CommandParser(OutputFile);
var vmParser = new VmParserManager(operationParser, commandParser);
var fileReader = new VmFileReader(InputFile);
try
{
var vmOperations = fileReader.GetAll();
var vmInstructionInstances = VmInstructionFactory.CreateCollection(vmOperations);
var asmOperations = vmParser.ToHackAsm(vmInstructionInstances);
FileWriter.Write(asmOperations, OutputFilePath);
}
catch (Exception e)
{
if (e is DirectoryNotFoundException)
{
Console.WriteLine($"Directory error: {e.Message}\n" +
$"Make sure the path is correct and try again.");
}
else
{
Console.WriteLine(e);
}
}
Console.WriteLine("End");
}
public void Broadcast()
{
try
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
IPAddress broadcast = IPAddress.Parse("192.168.43.255");
IPEndPoint ep = new IPEndPoint(broadcast, 4210);
while (Running)
{
if (EnableBroadcasts)
{
Debug.Log("Broadcasting...");
s.SendTo(OperationParser.Broadcast(AcceptingPort), ep);
}
Thread.Sleep(BroadcastFrequency * 1000);
}
s.Close();
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
public void Run()
{
Listener = new UdpClient(Port);
try
{
while (Running)
{
byte[] bytes;
if (Listener.Available > 0)
{
bytes = Listener.Receive(ref EndPoint);
// Parse Bytes into event
Event e = OperationParser.Recieve(bytes, 0); // TODO multi controller player num
//Debug.Log(e.Action + " " + e.Value);
Events.Enqueue(e);
}
//else
// Thread.Sleep(10);
}
}
catch (Exception e)
{
Debug.LogError(e.ToString());
}
finally
{
Listener.Close();
Listener = null;
}
}
static void Main(string[] args)
{
// Usage/Example help blurb.
Console.WriteLine("Step 09 (Stretch 1)\n");
Console.WriteLine("=============================================");
Console.WriteLine("Usage: {operation} {n,n}");
Console.WriteLine("{operation:string = [add]} {n:integer(n > 0)}");
Console.WriteLine("Delimiters allowed: [',', '\\n']");
Console.WriteLine("Example: add 2,6\\n3\nResult: 11");
Console.WriteLine("=============================================\n");
try
{
// Create array of given arguments.
var arguments = Console.ReadLine().Split(' ');
// First position should be the `Operation` command.
var operationCmd = OperationParser.Parse(arguments[0]);
// Transform the `String` representation of all
// integers in the list to `Int` and also apply
// various cli rules during transformation.
var numbers = NumbersParser.Parse(arguments[1]);
Printer.PrintEquation(operationCmd, numbers);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void OperationParser_Test_RotateSteps_1()
{
var input = "rotate right 7 steps";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.RotateSteps, op.Op);
}
public void OperationParser_Test_RotateByLetter_1()
{
var input = "rotate based on position of letter c";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.RotateByLetter, op.Op);
}
public void OperationParser_Test_SwapLetter_3()
{
var input = "swap letter f with letter h";
var op = OperationParser.Parse(input);
Assert.AreEqual('h', op.Letter2);
}
public void OperationParser_Test_SwapLetter_1()
{
var input = "swap letter f with letter h";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.SwapLetters, op.Op);
}
public void OperationParser_Test_SwapPos_3()
{
var input = "swap position 5 with position 6";
var op = OperationParser.Parse(input);
Assert.AreEqual(6, op.Pos2);
}
public void OperationParser_Test_Move_3()
{
var input = "move position 1 to position 0";
var op = OperationParser.Parse(input);
Assert.AreEqual(0, op.Pos2);
}
public void OperationParser_Test_Move_1()
{
var input = "move position 1 to position 0";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.Move, op.Op);
}
public void OperationParser_Test_Reverse_3()
{
var input = "reverse positions 0 through 4";
var op = OperationParser.Parse(input);
Assert.AreEqual(4, op.Pos2);
}
public void OperationParser_Test_SwapPos_1()
{
var input = "swap position 5 with position 6";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.SwapPositions, op.Op);
}
public void OperationParser_Test_Reverse_1()
{
var input = "reverse positions 0 through 4";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Type.Reverse, op.Op);
}
public void OperationParser_Test_RotateSteps_3()
{
var input = "rotate right 7 steps";
var op = OperationParser.Parse(input);
Assert.AreEqual(7, op.Steps);
}
public void OperationParser_Test_RotateByLetter_2()
{
var input = "rotate based on position of letter c";
var op = OperationParser.Parse(input);
Assert.AreEqual('c', op.Letter1);
}
public void OperationParser_Test_RotateSteps_2()
{
var input = "rotate right 7 steps";
var op = OperationParser.Parse(input);
Assert.AreEqual(Operation.Direction.Right, op.Dir);
}
public string Solve(string[] input)
{
var parser = new OperationParser();
var steps = input.Select(line => parser.Parse(line));
var scrambler = new Scrambler();
return(scrambler.Scramble(Password, steps));
}
public void SetsDefaultOutputToJson()
{
const string functionName = "Users";
const string httpMethod = "post";
var parser = new OperationParser();
var operation = parser.Parse(httpMethod, functionName);
Assert.Single(operation.Produces, "application/json");
}
public void SetsOperationIdToConcatentationOfHttpVerbAndFunctionName()
{
const string functionName = "Users";
const string httpMethod = "post";
var parser = new OperationParser();
var operation = parser.Parse(httpMethod, functionName);
Assert.Equal("postUsers", operation.OperationId);
}
public void SetsHttpMethod()
{
const string functionName = "Users";
const string httpMethod = "get";
var parser = new OperationParser();
var operation = parser.Parse(httpMethod, functionName);
Assert.Equal(httpMethod, operation.HttpMethod);
}
public void Parser_Correctly_Parses_Row(string raw, double expected)
{
var parser = new OperationParser();
var operation = parser.Parse(raw);
var result = operation.Execute();
Assert.AreEqual(expected, result);
}
static void Main(string[] args)
{
System.IO.File.WriteAllText("output.txt", "");
string command = System.IO.File.ReadAllText("input.txt");
Operation operation = OperationParser.ParseCommand(command, Database.GetInstance());
operation.Execute();
operation.Revert();
}
public async Task HasExpectedType(string method, string url, OperationType?type)
{
var request = new StartRequest(method, url);
var sources = new List <string> {
NuGetSourceUrl
};
var context = await OperationParserContext.CreateAsync(sources);
var operationInfo = OperationParser.Parse(context, request);
Assert.Equal(type, operationInfo.Operation?.Type);
}
public void ExcludesGenerationFunctionPath(string generationFunctionName)
{
var operationParser = new OperationParser();
var responseParser = Substitute.For <IResponseParser>();
var parameterParser = Substitute.For <ParameterParser>();
var assembly = Assembly.GetAssembly(typeof(TestFunctions));
var pathFinder = new PathFinder(operationParser, responseParser, parameterParser, generationFunctionName);
var paths = pathFinder.FindPaths(assembly).ToList();
Assert.NotEmpty(paths);
Assert.DoesNotContain(paths, p => p.Route.Equals(pathFinder.GenerationFunctionName));
}
public void test_operation_parse()
{
var result = OperationParser.Parse("add");
Assert.AreEqual(result, OperationEnum.Add);
result = OperationParser.Parse("ADD");
Assert.AreEqual(result, OperationEnum.Add);
// Should throw exception b/c of invalid `Operation` rule.
Assert.Throws(Is.TypeOf <Exception>()
.And.Message.EqualTo("Operation command is invalid."),
delegate { OperationParser.Parse("dda"); });
}
static void Main(string[] args)
{
// Usage/Example help blurb.
Console.WriteLine("Step 03\n");
Console.WriteLine("=============================================");
Console.WriteLine("Usage: {operation} {n,n}");
Console.WriteLine("{operation:string = [add]} {n:integer}");
Console.WriteLine("Delimiters allowed: [',', '\\n']");
Console.WriteLine("Example: add 2,6\\n3\nResult: 11");
Console.WriteLine("=============================================\n");
try
{
// Create array of given arguments.
var arguments = Console.ReadLine().Split(' ');
// First position should be the `Operation` command.
var operationCmd = OperationParser.Parse(arguments[0]);
// Transform the `String` representation of all
// integers in the list to `Int` and also apply
// various cli rules during transformation.
var numbers = NumbersParser.Parse(arguments[1]);
// Find which `Operation` to run and get result.
var result = 0;
switch (operationCmd)
{
case OperationEnum.Add:
{
Console.WriteLine("Adding . . .");
result = Calculator.Add(numbers);
break;
}
default:
break;
}
Console.WriteLine("{0}", result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void Descramble_Scenario_Test_1()
{
var input = "decab";
input = OperationParser.Parse("rotate based on position of letter d", true).Execute(input);
input = OperationParser.Parse("rotate based on position of letter b", true).Execute(input);
input = OperationParser.Parse("move position 3 to position 0", true).Execute(input);
input = OperationParser.Parse("move position 1 to position 4", true).Execute(input);
input = OperationParser.Parse("rotate left 1 step", true).Execute(input);
input = OperationParser.Parse("reverse positions 0 through 4", true).Execute(input);
input = OperationParser.Parse("swap letter d with letter b", true).Execute(input);
input = OperationParser.Parse("swap position 4 with position 0", true).Execute(input);
Assert.AreEqual("abcde", input);
}
public void WithSpecifiedNamespace_IncludesOnlyFunctionsFromNamespace()
{
var operationParser = new OperationParser();
var responseParser = Substitute.For <IResponseParser>();
var parameterParser = Substitute.For <ParameterParser>();
var assembly = Assembly.GetAssembly(typeof(TestFunctions));
var pathFinder = new PathFinder(operationParser, responseParser, parameterParser);
var paths = pathFinder.FindPaths(assembly, typeof(IncNamespaceFuncs).Namespace).ToList();
Assert.NotEmpty(paths);
Assert.Contains(paths, p => p.Route.Equals("/included1"));
Assert.Contains(paths, p => p.Route.Equals("/included2"));
Assert.DoesNotContain(paths, p => !p.Route.StartsWith("/included"));
}
static void Main(string[] args)
{
#region - Usage/Example help blurb.
Console.WriteLine("Step 12 (Stretch 4)\n");
Console.WriteLine("========================================================");
Console.WriteLine("USAGE: {add} [//[DELIMITER][...]\\n]{n1[,...]} [OPTIONS]");
Console.WriteLine("OPTIONS:");
Console.WriteLine(" -delim:char – single char to override delimiter (defaults are `,`, `\\n`)");
Console.WriteLine(" -noneg – default is to allow negative integers");
Console.WriteLine(" -maxint:n – default is no upper bound");
Console.WriteLine("\nEXAMPLES:");
Console.WriteLine(" % add 2,6\\n3 –> 11");
Console.WriteLine(" % add 2^6^3 -delim:^ –> 11");
Console.WriteLine(" % add 2,-6,3 -noneg –> 'exception thrown'");
Console.WriteLine(" % add 2,11,3 -maxint:10 –> 5");
Console.WriteLine(" % add //[**]\\n2**6**3 –> 11");
Console.WriteLine(" % add //[**][!!]\\n2**6!!3 –> 11");
Console.WriteLine("========================================================\n");
//add //[@][!]\n55@33!22 -delim:% -maxint:50 -noneg
#endregion
var serviceProvider = new ServiceCollection()
.AddSingleton <ICalculator, Calculator>()
.BuildServiceProvider();
Console.CancelKeyPress += delegate { Console.WriteLine("Good bye!"); };
try
{
while (true)
{
var givenArgs = new Arguments(Console.ReadLine());
var operationCmd = OperationParser.Parse(givenArgs.GetOperationString());
var numbers = NumbersParser.Parse(givenArgs.GetNumbersString(), givenArgs.GetOptions());
serviceProvider.GetService <ICalculator>().CalcAndPrintEquation(operationCmd, numbers);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void LED() // TODO add to GameManager so we can change LEDs in game
{
//bytes[0] = (byte)OpCode.SetLEDPixel;
ByteColor color = new ByteColor();
color.red = 0;
color.blue = 0xFF;
color.green = 0;
byte[] colorChange = new byte[5];
colorChange[0] = (byte)OpCode.SetLEDPixel;
byte[] pixelColor = new byte[4];
pixelColor = OperationParser.SetLEDPixel(0, color);
Array.Copy(pixelColor, 0, colorChange, 1, pixelColor.Length);
Thread.Sleep(100);
Send(colorChange);
byte[] updateByte = new byte[1];
updateByte[0] = (byte)OpCode.UpdateLEDs;
Send(updateByte);
}
