Example #1
0
        public void ShouldParseNoParameters()
        {
            var parser = new ArgumentsParser();
            var paramDict = parser.ParseParameters(new string[0]);

            Assert.That(paramDict, Is.Empty);
        }
        public void ParaseArguments_Assigns_values()
        {
            var testAddress = "testAddress";
            var testUser = "******";
            var testPass = "******";
            var testDirectory = "C:\asdasd";
            var testToken = "asdagsdghADFSGesg";

            var args = new List<string>()
            {
                "-address", testAddress,
                "-user", testUser,
                "-password", testPass,
                "-directory", testDirectory,
                "-token", testToken
            };

            var argumentsParser = new ArgumentsParser(args);

            Assert.That(testAddress, Is.EqualTo(argumentsParser.Address));
            Assert.That(testUser, Is.EqualTo(argumentsParser.User));
            Assert.That(testPass, Is.EqualTo(argumentsParser.Password));
            Assert.That(testDirectory, Is.EqualTo(argumentsParser.Directory));
            Assert.That(testToken, Is.EqualTo(argumentsParser.ApiToken));
        }
Example #3
0
 public void Parsing_MailFrom_EmailOnly()
 {
     ArgumentsParser args = new ArgumentsParser("<*****@*****.**> ARG1 ARG2");
     Assert.Equal("<*****@*****.**>", args.Arguments[0]);
     Assert.Equal("ARG1", args.Arguments[1]);
     Assert.Equal("ARG2", args.Arguments[2]);
 }
Example #4
0
 public void Parsing_MailFrom_WithDisplayName()
 {
     ArgumentsParser args = new ArgumentsParser("<Robert Wood<*****@*****.**>> ARG1 ARG2");
     Assert.Equal("<Robert Wood<*****@*****.**>>", args.Arguments[0]);
     Assert.Equal("ARG1", args.Arguments[1]);
     Assert.Equal("ARG2", args.Arguments[2]);
 }
Example #5
0
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            var pargs = new ArgumentsParser(args);
            var runServer = pargs.GetValue<bool>("Server");
            var runClient = pargs.GetValue<bool>("Client");

            var serverService = new FlexibleProxyServerService();
            var clientService = new FlexibleProxyClientService();
            if (Environment.UserInteractive)
            {
                Console.WriteLine("Starting SERVER Service...");
                serverService.OnServiceStart(args);
                Console.WriteLine("SERVER is started in console.");

                Console.WriteLine("Starting CLIENT Service...");
                clientService.OnServiceStart(args);
                Console.WriteLine("CLIENT is started in console.");

                Console.WriteLine("Press ENTER to stop services and exit.");
                Console.ReadLine();

                serverService.OnServiceStop();
                clientService.OnServiceStop();
                Console.WriteLine("Both services are stopped.");
            }
            else
            {
                var servicesToRun = new List<ServiceBase>();
                if (runServer)
                    servicesToRun.Add(serverService);
                if (runClient)
                    servicesToRun.Add(clientService);
                ServiceBase.Run(servicesToRun.ToArray());
            }
        }
 public void ParseTest()
 {
     var parser = new ArgumentsParser(new[] { "-Arg1", "Value1", "-Arg2", "/Arg3", "Value2" });
     Assert.IsTrue(parser.GetValue<bool>("Arg2"));
     Assert.AreEqual(parser.GetValue<string>("Arg1"), "Value1");
     Assert.AreEqual(parser.GetValue<string>("Arg3"), "Value2");
 }
Example #7
0
        public void Test_ParseCompressMode_WrongValue()
        {
            var args = new[] { "decompress111", "input", "output" };

            var service = new ArgumentsParser(_fileService.Object);

            Assert.Throws <ArgumentException>(() => service.Parse(args));
        }
Example #8
0
        public void Test_ParseBlockSize_CannotParseValue()
        {
            var args = new[] { "compress", "input", "output", "--block-size", "qqq" };

            var service = new ArgumentsParser(_fileService.Object);

            Assert.Throws <ArgumentException>(() => service.Parse(args));
        }
Example #9
0
        public void Test_ArgsLengthLessThanThree()
        {
            var args = new[] { "compress", "input" };

            var service = new ArgumentsParser(_fileService.Object);

            Assert.Throws <ArgumentException>(() => service.Parse(args));
        }
Example #10
0
        public void Test_IgnoreUnknownArgs()
        {
            var args = new[] { "compress", "input", "output", "unknown" };

            var service = new ArgumentsParser(_fileService.Object);

            service.Parse(args);
        }
Example #11
0
        private PacketContent PaymentInstructionCashAction(SerializedInfo request, Token token)
        {
            var args = ArgumentsParser.Parse(request.Content);

            return(ClientService.PaymentInstructionCash(request.ClientInfo.Session, args[0], args[1], args[2],
                                                        args[3], args[4], args[5], args[6], args[7], args[8])
                   .ToPacketContent());
        }
Example #12
0
        private PacketContent FundTransferAction(SerializedInfo request, Token token)
        {
            var args = ArgumentsParser.Parse(request.Content);

            return(ClientService.FundTransfer(request.ClientInfo.Session, args[0], args[1],
                                              args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10])
                   .ToPacketContent());
        }
Example #13
0
        private PacketContent CallMarginExtensionAction(SerializedInfo request, Token token)
        {
            var args = ArgumentsParser.Parse(request.Content);

            return(ClientService.CallMarginExtension(request.ClientInfo.Session, args[0], args[1],
                                                     args[2], args[3], args[4], args[5], args[6], args[7], args[8])
                   .ToPacketContent());
        }
Example #14
0
        public void When_ArgumentIsPotentialJson_IsCorrectlyIdentified()
        {
            string[] args = new string[] { "TestOperation", "Arg1=123", "Arg2=aaaa", "Arg3={test:123}" };

            Operation[] operations = ArgumentsParser.Parse(args, ';');

            Assert.IsTrue(operations[0].Arguments[2].IsPotentialJson);
        }
Example #15
0
        private IISBindingOptions Options(string commandLine)
        {
            var x             = new IISBindingOptionsFactory(log, iis, helper);
            var optionsParser = new ArgumentsParser(log, plugins, commandLine.Split(' '));
            var arguments     = new ArgumentsService(log, optionsParser);

            return(x.Default(arguments));
        }
Example #16
0
        public void ShouldParseBooleanParameterInMiddle()
        {
            var parser    = new ArgumentsParser();
            var paramDict = parser.ParseParameters(Params("/fast /file:afile.txt"));

            Assert.That(paramDict["file"], Is.EqualTo("afile.txt"));
            Assert.That(paramDict["fast"], Is.EqualTo("true"));
        }
Example #17
0
        private PacketContent UpdateQuotePolicyDetailAction(SerializedInfo request, Token token)
        {
            var         args  = ArgumentsParser.Parse(request.Content);
            TraderState state = SessionManager.Default.GetTradingConsoleState(request.ClientInfo.Session);

            return(Application.Default.TradingConsoleServer.UpdateQuotePolicyDetail(args[0].ToGuid(), args[1].ToGuid(), state)
                   .ToPacketContent());
        }
Example #18
0
    // Token: 0x060155A1 RID: 87457 RVA: 0x0056AF14 File Offset: 0x00569114
    public void Execute(string strParams)
    {
        ArgumentsParser argumentsParser = new ArgumentsParser("i i", strParams);
        int             @int            = argumentsParser.GetInt32(0);
        int             int2            = argumentsParser.GetInt32(1);

        Debug.Log((@int + int2).ToString());
    }
Example #19
0
        public void Parsing_MailFrom_WithDisplayName()
        {
            ArgumentsParser args = new ArgumentsParser("<Robert Wood<*****@*****.**>> ARG1 ARG2");

            Assert.AreEqual("<Robert Wood<*****@*****.**>>", args.Arguments[0]);
            Assert.AreEqual("ARG1", args.Arguments[1]);
            Assert.AreEqual("ARG2", args.Arguments[2]);
        }
Example #20
0
        public void Parsing_MailFrom_EmailOnly()
        {
            ArgumentsParser args = new ArgumentsParser("<*****@*****.**> ARG1 ARG2");

            Assert.AreEqual("<*****@*****.**>", args.Arguments[0]);
            Assert.AreEqual("ARG1", args.Arguments[1]);
            Assert.AreEqual("ARG2", args.Arguments[2]);
        }
Example #21
0
        public void Should_be_able_to_Parse_multi_args_properly()
        {
            var arguments = ArgumentsParser.Parse <Arguments>(new[] { "-r", "localhost:8080", "-r", "localhost:8081", "-r", "localhost:8082" });

            Assert.That(arguments.Registries, Contains.Item("localhost:8080"));
            Assert.That(arguments.Registries, Contains.Item("localhost:8081"));
            Assert.That(arguments.Registries, Contains.Item("localhost:8082"));
        }
Example #22
0
        public void Parsing_MailFrom_EmailOnly()
        {
            ArgumentsParser args = new ArgumentsParser("<*****@*****.**> ARG1 ARG2");

            Assert.Equal("<*****@*****.**>", args.Arguments.First());
            Assert.Equal("ARG1", args.Arguments.ElementAt(1));
            Assert.Equal("ARG2", args.Arguments.ElementAt(2));
        }
Example #23
0
        public void ShouldParseParametersWithSpaces()
        {
            var parser    = new ArgumentsParser();
            var paramDict = parser.ParseParameters(Params("/file afile.txt /name nobody"));

            Assert.That(paramDict["file"], Is.EqualTo("afile.txt"));
            Assert.That(paramDict["name"], Is.EqualTo("nobody"));
        }
Example #24
0
        private string?TestScript(string parameters)
        {
            var argParser = new ArgumentsParser(log, new MockPluginService(log),
                                                $"--scriptparameters {parameters} --verbose".Split(' '));
            var args = argParser.GetArguments <ScriptArguments>();

            return(args?.ScriptParameters);
        }
Example #25
0
        private IISOptions?Options(string commandLine)
        {
            var optionsParser = new ArgumentsParser(log, plugins, commandLine.Split(' '));
            var arguments     = new ArgumentsService(log, optionsParser);
            var x             = new IISOptionsFactory(log, helper, arguments, userRoleService);

            return(x.Default().Result);
        }
Example #26
0
        public void Parsing_MailFrom_WithDisplayName()
        {
            ArgumentsParser args = new ArgumentsParser("<Robert Wood<*****@*****.**>> ARG1 ARG2");

            Assert.Equal("<Robert Wood<*****@*****.**>>", args.Arguments.First());
            Assert.Equal("ARG1", args.Arguments.ElementAt(1));
            Assert.Equal("ARG2", args.Arguments.ElementAt(2));
        }
Example #27
0
        public void When_SingleOperationWithNoArguments_Returns_OperationWithNoArguments()
        {
            string[] args = new string[] { "TestOperation" };

            Operation[] operations = ArgumentsParser.Parse(args, ';');

            Assert.AreEqual(0, operations[0].Arguments.Length);
        }
        public void ParseTest()
        {
            var parser = new ArgumentsParser(new[] { "-Arg1", "Value1", "-Arg2", "/Arg3", "Value2" });

            Assert.IsTrue(parser.GetValue <bool>("Arg2"));
            Assert.AreEqual(parser.GetValue <string>("Arg1"), "Value1");
            Assert.AreEqual(parser.GetValue <string>("Arg3"), "Value2");
        }
Example #29
0
        private PacketContent UpdateAccountsSettingAction(SerializedInfo request, Token token)
        {
            List <string> argList = ArgumentsParser.Parse(request.Content);

            Guid[] accountIds = argList[0].ToGuidArray();
            return(AccountManager.Default.UpdateAccountSetting(request.ClientInfo.Session, accountIds)
                   .ToPacketContent());
        }
Example #30
0
        public void When_ArgumentIsNotPotentialJson_IsCorrectlyIdentified()
        {
            string[] args = new string[] { "TestOperation", "Arg1=123", "Arg2=aaaa", "Arg3=\"aaa bbbb\"" };

            Operation[] operations = ArgumentsParser.Parse(args, ';');

            Assert.IsFalse(operations[0].Arguments[1].IsPotentialJson);
        }
Example #31
0
        public void When_ArgumentIsString_IsCorrectlyIdentified()
        {
            string[] args = new string[] { "TestOperation", "Arg1=123", "Arg2=aaaa", "Arg3=\"aaa bbbb\"" };

            Operation[] operations = ArgumentsParser.Parse(args, ';');

            Assert.IsTrue(operations[0].Arguments[2].IsLiteralString);
        }
Example #32
0
        public void When_EmptyArgs_Returns_NoOperations()
        {
            string[] args = new string[0];

            Operation[] operations = ArgumentsParser.Parse(args, ';');

            Assert.AreEqual(0, operations.Length);
        }
Example #33
0
        private ManualOptions Options(string commandLine)
        {
            var x             = new ManualOptionsFactory(log);
            var optionsParser = new ArgumentsParser(log, plugins, commandLine.Split(' '));
            var arguments     = new ArgumentsService(log, optionsParser);

            return(x.Default(arguments));
        }
Example #34
0
        private ScriptOptions Options(string commandLine)
        {
            var optionsParser = new ArgumentsParser(log, plugins, commandLine.Split(' '));
            var arguments     = new ArgumentsService(log, optionsParser);
            var x             = new ScriptOptionsFactory(log, arguments);
            var target        = new Target();

            return(x.Default(target).Result);
        }
        public void When_SingleOperationWithSingleArgument_Returns_ArgumentWithCorrectValue()
        {
            string[] args = new string[] { "TestOperation", "Arg1=123" };

            Operation[] Operations = ArgumentsParser.Parse(args);

            Assert.AreEqual(1, Operations[0].Arguments.Length);
            Assert.AreEqual("123", Operations[0].Arguments[0].Value);
        }
Example #36
0
        /// <summary>
        /// Implements strlen().
        /// </summary>
        /// <param name="functionArgs">Arguments to the function.</param>
        /// <returns>Tuple - length of the string (str) and the data type (Numeric).</returns>
        public static Tuple <object, TokenType> StringLength(List <Tuple <object, TokenType> > functionArgs)
        {
            var argParser = new ArgumentsParser("strlen", 1, functionArgs);

            argParser.Validate(new[] { StringLiteral });

            var(arg, _) = functionArgs[0];
            return(new Tuple <object, TokenType>((double)((string)arg).Length, Numeric));
        }
 public void ParseDataArgumentsWordsOnly()
 {
     string testWords = "Greece, default, default, greece";
     ArgumentsParser argParser = new ArgumentsParser();
     argParser.Parse(new string[] { "http://www.cnn.com", testWords, "-w", });
     Assert.False(argParser.CharsNumberNeeded);
     Assert.False(argParser.SentencesNeeded);
     Assert.False(argParser.Verbose);
     Assert.True(argParser.WordsNumberNeeded);
 }
Example #38
0
        public void ShouldParseBooleanParameterInMiddle()
        {
            var parser = new ArgumentsParser();
            var paramDict = parser.ParseParameters(Params("/fast /file:afile.txt"));

            Assert.That(paramDict["file"], Is.EqualTo("afile.txt"));
            Assert.That(paramDict["fast"], Is.EqualTo("true"));

            Assert.That(Props.Get("file"), Is.EqualTo("afile.txt"));
            Assert.That(Props.Get("fast"), Is.EqualTo("true"));
        }
Example #39
0
        public void ShouldParseParametersWithSpaces()
        {
            var parser = new ArgumentsParser();
            var paramDict = parser.ParseParameters(Params("/file afile.txt /name nobody"));

            Assert.That(paramDict["file"], Is.EqualTo("afile.txt"));
            Assert.That(paramDict["name"], Is.EqualTo("nobody"));

            Assert.That(Props.Get("file"), Is.EqualTo("afile.txt"));
            Assert.That(Props.Get("name"), Is.EqualTo("nobody"));
        }
Example #40
0
        public void GivenZeroArguments_ThenParseFails()
        {
            // Arrange
            var parser = new ArgumentsParser(new string[0]);

            // Act
            parser.Parse();

            // Assert
            Assert.IsFalse(parser.Success);
            Assert.IsFalse(string.IsNullOrWhiteSpace(parser.ErrorMessage), "Error message must be populated");
        }
Example #41
0
        public void GivenOneValidArgument_ThenParseSucceeds()
        {
            // Arrange
            var parser = new ArgumentsParser(new string[] { "one" });

            // Act
            parser.Parse();

            // Assert
            Assert.IsTrue(parser.Success);
            Assert.AreEqual("one", parser.Filename);
        }
Example #42
0
        public void ShouldParseParametersWithColons()
        {
            var args = Params("/file:afile.txt /name:nobody").ToList();
            var parser = new ArgumentsParser();
            var paramDict = parser.ParseParameters(args);

            Assert.That(paramDict["file"], Is.EqualTo("afile.txt"));
            Assert.That(paramDict["name"], Is.EqualTo("nobody"));

            Assert.That(Props.Get("file"), Is.EqualTo("afile.txt"));
            Assert.That(Props.Get("name"), Is.EqualTo("nobody"));
        }
 public void ParseListOfUrlsTest()
 {
     string urlListPath = @"D:\github\web-scraper\Scraper\Scraper.Tests\TestData\UrlList.txt";
     string[] expectedData = new string[]
     {
         "http://www.cnn.com",
         "http://www.cnn2.com",
         "http://www.cnn3.com"
     };
     ArgumentsParser argParser = new ArgumentsParser();
     argParser.Parse(new string[] { urlListPath });
     Assert.AreEqual(3, argParser.Urls.Length);
     Assert.AreEqual(expectedData, argParser.Urls);
 }
Example #44
0
 public void ThrowsIfNonNamedArgumentFound()
 {
     var parser = new ArgumentsParser();
     Assert.That(() => parser.ParseParameters(Params("afile.txt")), Throws.InstanceOf<NonNamedArgumentException>());
 }
Example #45
0
 public void Parsing_FirstArgumentAferVerbWithColon_Split()
 {
     ArgumentsParser args = new ArgumentsParser("ARG1=VALUE:BLAH");
     Assert.Equal(1, args.Arguments.Length);
     Assert.Equal("ARG1=VALUE:BLAH", args.Arguments[0]);
 }
Example #46
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            ArgumentsParser argumentsParser = new ArgumentsParser(command.ArgumentsText);

            if (argumentsParser.Arguments.Length > 0)
            {
                if (connection.Session.Authenticated)
                {
                    throw new SmtpServerException(new SmtpResponse(StandardSmtpResponseCode.BadSequenceOfCommands,
                                                                   "Already authenticated"));
                }

                string mechanismId = argumentsParser.Arguments[0];
                IAuthMechanism mechanism = AuthExtensionProcessor.MechanismMap.Get(mechanismId);

                if (mechanism == null)
                {
                    throw new SmtpServerException(
                        new SmtpResponse(StandardSmtpResponseCode.CommandParameterNotImplemented,
                                         "Specified AUTH mechanism not supported"));
                }

                if (!AuthExtensionProcessor.IsMechanismEnabled(mechanism))
                {
                    throw new SmtpServerException(
                        new SmtpResponse(StandardSmtpResponseCode.AuthenticationFailure,
                                         "Specified AUTH mechanism not allowed right now (might require secure connection etc)"));
                }

                IAuthMechanismProcessor authMechanismProcessor =
                    mechanism.CreateAuthMechanismProcessor(connection);

                string initialData = null;
                if (argumentsParser.Arguments.Length > 1)
                {
                    initialData = string.Join(" ", argumentsParser.Arguments.Skip(1).ToArray());
                }

                AuthMechanismProcessorStatus status =
                    await authMechanismProcessor.ProcessResponseAsync(initialData);
                while (status == AuthMechanismProcessorStatus.Continue)
                {
                    string response = await connection.ReadLineAsync();

                    if (response == "*")
                    {
                        await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments, "Authentication aborted"));
                        return;
                    }

                    status = await authMechanismProcessor.ProcessResponseAsync(response);
                }

                if (status == AuthMechanismProcessorStatus.Success)
                {
                    await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.AuthenticationOK,
                                                              "Authenticated OK"));
                    connection.Session.Authenticated = true;
                    connection.Session.AuthenticationCredentials = authMechanismProcessor.Credentials;
                }
                else
                {
                    await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.AuthenticationFailure,
                                                              "Authentication failure"));
                }
            }
            else
            {
                throw new SmtpServerException(new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments,
                                                               "Must specify AUTH mechanism as a parameter"));
            }
        }
 public void ParseWordsList()
 {
     string testWords = "Greece, default, default, greece";
     ArgumentsParser argParser = new ArgumentsParser();
     argParser.Parse(new string[] { "http://www.cnn.com", testWords });
     Assert.AreEqual(2, argParser.Words.Length);
     Assert.AreEqual(new string[] { "Greece", "default" }, argParser.Words);
 }
 public void ParseWord()
 {
     string testWords = "Greece";
     ArgumentsParser argParser = new ArgumentsParser();
     argParser.Parse(new string[] { "http://www.cnn.com", testWords });
     Assert.AreEqual(1, argParser.Words.Length);
     Assert.AreEqual(new string[] { testWords }, argParser.Words);
 }
 public void ParseUrlTest()
 {
     string testUrl = "http://www.cnn.com";
     ArgumentsParser argParser = new ArgumentsParser();
     argParser.Parse(new string[] { testUrl });
     Assert.AreEqual(1, argParser.Urls.Length);
     Assert.AreEqual(testUrl, argParser.Urls[0]);
 }