Exemple #1
0
        static async Task Main(string[] args)
        {
            var configurationBuilder =
                new ConfigurationBuilder();

            configurationBuilder.AddUserSecrets<Program>();
            var config = configurationBuilder.Build();

            var settings = new Dictionary<string, string>
            {
                {"ashost", config["saprfc:ashost"]},
                {"sysnr", config["saprfc:sysnr"]},
                {"client", config["saprfc:client"]},
                {"user", config["saprfc:username"]},
                {"passwd", config["saprfc:password"]},
                {"lang", "EN"}

            };

            var runtime = new RfcRuntime(new SimpleConsoleLogger());

            Task<Either<RfcErrorInfo, IConnection>> ConnFunc() => Connection.Create(settings, runtime);

            using (var context = new RfcContext(ConnFunc))
            {
                await context.Ping();
                using (var memBuffer = new MemoryStream())
                {
                    var intBytes = BitConverter.GetBytes(1);
                    memBuffer.Write(intBytes, 0, intBytes.Length);

                    var setterCall = await context.CallFunctionAsUnit("Z_SET_COUNTER", Input:
                        func => func.BindAsync(f =>
                            f.SetFieldBytes("SET_VALUE", memBuffer.GetBuffer(), memBuffer.Length)));

                    setterCall.Match(r =>
                        {

                        },
                        l =>
                        {

                        });

                    var res = await context.CallFunction("Z_GET_COUNTER",
                        Output: func => func.GetField<int>("GET_VALUE"));
                    res.Match(r =>
                        {

                        },
                        l =>
                        {

                        });
                }

                var resStructure = await context.CallFunction("BAPI_DOCUMENT_GETDETAIL2",
                    Input: func => func
                        .SetField("DOCUMENTTYPE", "AW")
                        .SetField("DOCUMENTNUMBER", "AW001200")
                        .SetField("DOCUMENTVERSION", "01")
                        .SetField("DOCUMENTPART", "000"),
                    Output: func=> func.BindAsync(f => f.GetStructure("DOCUMENTDATA"))
                        .BindAsync(s =>s.GetField<string>("DOCUMENTVERSION")));

                resStructure.Match(r =>
                    {

                    },
                    l =>
                    {

                    });
            }
        }
Exemple #2
0
        static async Task Main(string[] args)
        {
            var configurationBuilder =
                new ConfigurationBuilder();

            configurationBuilder.AddInMemoryCollection(new[]
            {
                new KeyValuePair <string, string>("tests:repeats", "10"),
                new KeyValuePair <string, string>("tests:rows", "10")
            });
            configurationBuilder.AddEnvironmentVariables("saprfc");
            configurationBuilder.AddCommandLine(args);
            configurationBuilder.AddUserSecrets <Program>();

            var config = configurationBuilder.Build();

            var settings = new Dictionary <string, string>
            {
                { "ashost", config["saprfc:ashost"] },
                { "sysnr", config["saprfc:sysnr"] },
                { "client", config["saprfc:client"] },
                { "user", config["saprfc:username"] },
                { "passwd", config["saprfc:password"] },
                { "lang", "EN" }
            };

            var rows    = Convert.ToInt32(config["tests:rows"]);
            var repeats = Convert.ToInt32(config["tests:repeats"]);

            Console.WriteLine($"Test rows: {rows}");
            Console.WriteLine($"Test repeats: {repeats}");


            StartProgramDelegate callback = command =>
            {
                var programParts = command.Split(' ');
                var arguments    = command.Replace(programParts[0], "");
                var p            = Process.Start(AppDomain.CurrentDomain.BaseDirectory + @"\" + programParts[0] + ".exe",
                                                 arguments.TrimStart());

                return(RfcErrorInfo.Ok());
            };

            var connectionBuilder = new ConnectionBuilder(settings)
                                    .WithStartProgramCallback(callback)
                                    .ConfigureRuntime(c =>
                                                      c.WithLogger(new SimpleConsoleLogger()));

            using (var context = new RfcContext(connectionBuilder.Build()))
            {
                await context.PingAsync();

                await RunIntegrationTests(context);

                long totalTest1 = 0;
                long totalTest2 = 0;

                for (var run = 0; run < repeats; run++)
                {
                    Console.WriteLine($"starting Test Run {run + 1} of {repeats}\tTest 01");
                    totalTest1 += await RunPerformanceTest01(context, rows);

                    Console.WriteLine($"starting Test Run {run + 1} of {repeats}\tTest 02");
                    totalTest2 += await RunPerformanceTest02(context, rows);

                    GC.Collect();
                }

                Console.WriteLine("Total runtime Test 01: " + totalTest1);
                Console.WriteLine("Total runtime Test 02: " + totalTest2);
                Console.WriteLine("Average runtime Test 01: " + totalTest1 / repeats);
                Console.WriteLine("Average runtime Test 02: " + totalTest2 / repeats);
            }
        }