OTX-Runtime Converter  
Sample Program

The console application demonstrates the main functionality of the OTX-Runtime Converter API. It can be used as a reference and the source code below is like a reference guide about the proper programming of the API.

When the OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication is started without arguments, the usage of API will be exposed.

Important: the target framework of OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication is Net6.0 so that it can work on both Windows and Linux.

Sample Commands

Suppose the current directory is installation location of OTX-Runtime Converter API.

OS Command
Window OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication "D:\RoutineControl_TestFunctions.ptx" -out:"D:\out\RoutineControl_TestFunctions.ptx" -validate -diagPort:8888 -importDVGs:"D:\DiagValidationGroups1.xml" -dbPort:1984
Linux ./OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication.exe "/home/emotive/RoutineControl_TestFunctions.ptx" -out:"/home/emotive/out/RoutineControl_TestFunctions.ptx" -validate -diagPort:8888 -importDVGs:"D:\DiagValidationGroups1.xml" -dbPort:1984

Code Example

Code snippet of the OTX-Runtime Converter API Sample Program.

1 using OpenTestSystem.Otx.RuntimeConverter.Api.License;
2 using OpenTestSystem.Otx.RuntimeConverter.Api.Settings;
3 using OpenTestSystem.Otx.RuntimeConverter.Api.Validator;
4 using System;
5 using System.Diagnostics;
6 using System.IO;
7 using System.Linq;
8 using System.Text;
9 using System.Threading;
10 using System.Threading.Tasks;
11 
12 namespace OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication
13 {
14  class Program
15  {
16  static void Main(string[] args)
17  {
18  LicenseManager.SetLicenseKey(Constants.LICENSE);
19  IRuntimeConverter runtimeConverter = null;
20  Arguments arguments;
21  string message;
22  if (!Arguments.ReadArguments(args, out arguments, out message))
23  {
24  System.Console.WriteLine(message);
25  return;
26  }
27 
28  Config.TraceLevel = arguments.TraceLevel;
29  if (!string.IsNullOrEmpty(arguments.OutputFolder))
30  {
31  Config.OutputFolder = arguments.OutputFolder;
32  }
33 
34  if (Config.TraceLevel != TraceLevels.OFF)
35  {
36  Console.WriteLine("*** Tracer was setup");
37  Console.WriteLine("- Output folder".PadRight(20) + Config.OutputFolder);
38  Console.WriteLine("- Trace folder".PadRight(20) + Config.TraceFolder);
39  Console.WriteLine("- Trace level".PadRight(20) + Config.TraceLevel);
40  }
41 
42  if (arguments.DiagPort != 0)
43  {
44  runtimeConverter = RuntimeConverterFactory.CreateSocketRuntimeConverter(arguments.DiagPort);
45  Console.WriteLine("Diag port is " + arguments.DiagPort);
46  }
47  else if (!string.IsNullOrEmpty(arguments.DiagPipe))
48  {
49  runtimeConverter = RuntimeConverterFactory.CreatePipeRuntimeConverter(arguments.DiagPipe);
50  Console.WriteLine("Diag pipe is " + arguments.DiagPipe);
51  }
52  else
53  {
54  runtimeConverter = RuntimeConverterFactory.CreateSocketRuntimeConverter(8888);
55  Console.WriteLine("Diag port is 8888");
56  }
57 
58  runtimeConverter.XmlDbPort = arguments.XmlDbPort;
59  Console.WriteLine("XmlDb port is " + runtimeConverter.XmlDbPort);
60 
61  if (!string.IsNullOrEmpty(arguments.ImportDVGs))
62  {
63  Console.WriteLine();
64  Console.WriteLine("Importing DiagValidationGroups from {0}", GetAbsolutePath(arguments.ImportDVGs));
65  runtimeConverter.DiagValidationGroups = new DiagValidationGroups();
66  runtimeConverter.DiagValidationGroups.Import(GetAbsolutePath(arguments.ImportDVGs));
67  Console.WriteLine("All DiagValidationGroups are imported");
68  }
69 
70  Console.WriteLine();
71  if (arguments.Type == Arguments.Types.ptx)
72  {
73  Console.WriteLine("Loading ptx {0}", GetAbsolutePath(arguments.InputPath));
74  runtimeConverter.LoadPtx(GetAbsolutePath(arguments.InputPath), arguments.Password);
75  }
76  else if (arguments.Type == Arguments.Types.ppx)
77  {
78  Console.WriteLine("Loading ppx {0}", GetAbsolutePath(arguments.InputPath));
79  runtimeConverter.LoadPpx(GetAbsolutePath(arguments.InputPath), arguments.Password);
80  }
81  else
82  {
83  Console.WriteLine("Loading project {0}", GetAbsolutePath(arguments.InputPath));
84  runtimeConverter.LoadProject(GetAbsolutePath(arguments.InputPath));
85  }
86 
87  if (arguments.Validate)
88  {
89  Console.WriteLine();
90  StartClock("Validating...");
91  IError[] errors = runtimeConverter.Validate();
92  StopClock();
93  Console.WriteLine();
94  Console.WriteLine("Validation is completed.");
95  if (errors.Length > 0)
96  {
97  Console.WriteLine();
98  Console.WriteLine("*** {0} Error(s):", errors.Count(err => err.SeverityType == SeverityTypes.Critical));
99  foreach (IError error in errors.Where(err => err.SeverityType == SeverityTypes.Critical))
100  {
101  WriteError(error);
102  }
103 
104  Console.WriteLine();
105  Console.WriteLine("*** {0} Warning(s):", errors.Count(err => err.SeverityType == SeverityTypes.Warning));
106  foreach (IError error in errors.Where(err => err.SeverityType == SeverityTypes.Warning))
107  {
108  WriteError(error);
109  }
110 
111  Console.WriteLine();
112  Console.WriteLine("*** {0} Deprecation(s):", errors.Count(err => err.SeverityType == SeverityTypes.Deprecation));
113  foreach (IError error in errors.Where(err => err.SeverityType == SeverityTypes.Deprecation))
114  {
115  WriteError(error);
116  }
117 
118  Console.WriteLine();
119  Console.WriteLine("*** {0} Specification(s):", errors.Count(err => err.SeverityType == SeverityTypes.Specification));
120  foreach (IError error in errors.Where(err => err.SeverityType == SeverityTypes.Specification))
121  {
122  WriteError(error);
123  }
124 
125  if (errors.FirstOrDefault(err => err.SeverityType == SeverityTypes.Critical) != null)
126  {
127  Console.WriteLine();
128  Console.WriteLine("*** The {0} cannot be compiled because it has {1} error(s) and {2} warning(s).", arguments.Type, errors.Count(err => err.SeverityType == SeverityTypes.Critical), errors.Count(err => err.SeverityType == SeverityTypes.Warning));
129  return;
130  }
131  }
132  }
133 
134  if (File.Exists(arguments.OutputFile))
135  {
136  string selection = string.Empty;
137  while (selection.Trim() != "y" && selection.Trim() != "n")
138  {
139  Console.WriteLine();
140  Console.Write("Override existing file {0}? y(yes)/n(no): ", arguments.OutputFile);
141  selection = Console.ReadLine();
142  }
143 
144  if (selection == "n")
145  {
146  return;
147  }
148  }
149 
150  Console.WriteLine();
151  Console.WriteLine("Compiling ...");
152  runtimeConverter.Compile(arguments.OutputFile);
153  if (File.Exists(arguments.OutputFile))
154  {
155  Console.WriteLine("{0} is written successfully.", arguments.OutputFile);
156  }
157  }
158 
159  private static string GetAbsolutePath(string path)
160  {
161  return Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), path);
162  }
163 
164  private static void WriteError(IError error)
165  {
166  Console.Write("<SeverityType>");
167  Console.Write(error.SeverityType);
168  Console.Write("</SeverityType>");
169  Console.Write("<Description>");
170  Console.Write(error.Description);
171  Console.Write("</Description>");
172  Console.Write("<ScopeId>");
173  Console.Write(error.ScopeId);
174  Console.Write("</ScopeId>");
175  Console.Write("<ScopeName>");
176  Console.Write(error.ScopeName);
177  Console.Write("</ScopeName>");
178  Console.Write("<ElementType>");
179  Console.Write(error.ElementType);
180  Console.Write("</ElementType>");
181  Console.Write("<ErrorCode>");
182  Console.Write(error.ErrorCode);
183  Console.Write("</ErrorCode>");
184  Console.Write("<Procedure>");
185  Console.Write(error.Procedure);
186  Console.Write("</Procedure>");
187  Console.Write("<Document>");
188  Console.Write(error.Document);
189  Console.Write("</Document>");
190  Console.Write("<Package>");
191  Console.Write(error.Package);
192  Console.Write("</Package>");
193  Console.Write("<Project>");
194  Console.Write(error.Project);
195  Console.Write("</Project>");
196  Console.WriteLine();
197  }
198 
199  private static CancellationTokenSource cts;
200 
201  private static void StartClock(string text)
202  {
203  cts = new CancellationTokenSource();
204 
205  Stopwatch sw = Stopwatch.StartNew();
206 
207  Task.Run(() =>
208  {
209  while (!cts.Token.IsCancellationRequested)
210  {
211  Console.Write($"\r{text} {sw.Elapsed:mm\\:ss}");
212 
213  Thread.Sleep(100);
214  }
215 
216  }, cts.Token);
217  }
218 
219  private static void StopClock()
220  {
221  cts?.Cancel();
222  }
223  }
224 }
1 //-----------------------------------------------------------------------
2 // <copyright file="Arguments.cs">
3 // Copyright (c). All rights reserved.
4 // </copyright>
5 //-----------------------------------------------------------------------
6 
7 namespace OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication
8 {
9  using OpenTestSystem.Otx.RuntimeConverter.Api.Settings;
10  using System;
11  using System.Collections.Generic;
12  using System.Linq;
13  using System.Text;
14 
18  public class Arguments
19  {
20  public enum Types
21  {
22  ptx,
23  ppx,
24  project
25  }
26 
27  private const string UnrecognizeOption = "Unrecognized option: ";
28  private const string optionType = "-type";
29  private const string optionPassword = "-password";
30  private const string optionValidate = "-validate";
31  private const string optionOut = "-out";
32  private const string optionImportDVGs = "-importDVGs";
33  private const string optionDiagPort = "-diagPort";
34  private const string optionDiagPipe = "-diagPipe";
35  private const string optionTraceLevel = "-traceLevel";
36  private const string optionOutputFolder = "-outputFolder";
37  private const string optionDbPort = "-dbPort";
38 
39  #region Fields
40 
41  #endregion
42 
43  #region ctors
44  public Arguments()
45  {
46  this.TraceLevel = TraceLevels.ERROR;
47  }
48 
49  #endregion
50 
51  #region Properties
52  public string InputPath { get; set; }
53  public Types Type { get; private set; }
54  public string Password { get; private set; }
55  public bool Validate { get; private set; }
56  public string OutputFile { get; set; }
57  public string ImportDVGs { get; private set; }
58  public ushort DiagPort { get; private set; }
59  public string DiagPipe { get; private set; }
60  public TraceLevels TraceLevel { get; private set; }
61  public string OutputFolder { get; private set; }
62  public ushort XmlDbPort { get; private set; }
63  #endregion
64 
65  #region Methods
66  public static bool ReadArguments(string[] args, out Arguments arguments, out string message)
67  {
68  message = "";
69  arguments = new Arguments();
70  arguments.Type = Types.ptx;
71  arguments.DiagPort = 8888;
72  arguments.XmlDbPort = 1984;
73  if (args.Length == 0)
74  {
75  message = PrintUsage();
76  return false;
77  }
78 
79  foreach (string arg in args)
80  {
81  if (arg.StartsWith("-"))//option
82  {
83  if (!ProcessOption(arg, arguments, out message))
84  {
85  return false;
86  }
87  }
88  else
89  {
90  if (string.IsNullOrEmpty(arguments.InputPath))
91  {
92  arguments.InputPath = arg;
93  }
94  else
95  {
96  message = string.Format("More than 1 input path: {0}, {1}.", arguments.InputPath, arg);
97  return false;
98  }
99  }
100  }
101 
102  if (string.IsNullOrEmpty(arguments.InputPath))
103  {
104  message = PrintUsage();
105  return false;
106  }
107 
108  if (string.IsNullOrEmpty(arguments.OutputFile))
109  {
110  if ((arguments.Type == Types.ptx || arguments.Type == Types.ppx))
111  {
112  arguments.OutputFile = arguments.InputPath;
113  }
114  else
115  {
116  message = "The -out:<file> is mandatory if -type:project is set.";
117  return false;
118  }
119  }
120 
121  return true;
122  }
123 
124  private static bool ProcessOption(string value, Arguments arguments, out string error)
125  {
126  error = "";
127  if (!value.StartsWith("-"))
128  {
129  throw new ArgumentException(value + " is not an option.");
130  }
131 
132  List<string> arr = value.Split(':').ToList();
133  string optionName = arr[0];
134  arr.RemoveAt(0);
135  string optionValue = string.Join(":", arr);
136  switch (optionName)
137  {
138  case optionType:
139  if (optionValue == "ptx")
140  {
141  arguments.Type = Types.ptx;
142  }
143  else if (optionValue == "ppx")
144  {
145  arguments.Type = Types.ppx;
146  }
147  else if (optionValue == "project")
148  {
149  arguments.Type = Types.project;
150  }
151  else
152  {
153  error = UnrecognizeOption + value + ".";
154  return false;
155  }
156 
157  break;
158  case optionPassword:
159  arguments.Password = optionValue;
160  break;
161  case optionValidate:
162  if (!string.IsNullOrEmpty(optionValue))
163  {
164  error = UnrecognizeOption + value + ".";
165  return false;
166  }
167 
168  arguments.Validate = true;
169  break;
170  case optionOut:
171  arguments.OutputFile = optionValue;
172  break;
173  case optionImportDVGs:
174  arguments.ImportDVGs = optionValue;
175  break;
176  case optionDiagPort:
177  ushort diagPort = 0;
178  if (ushort.TryParse(optionValue, out diagPort))
179  {
180  arguments.DiagPort = diagPort;
181  }
182  else
183  {
184  error = UnrecognizeOption + value + ".";
185  return false;
186  }
187 
188  break;
189  case optionDiagPipe:
190  arguments.DiagPipe = optionValue;
191  arguments.DiagPort = 0;
192  break;
193  case optionTraceLevel:
194  TraceLevels traceLevel;
195  if (Enum.TryParse(optionValue.ToUpper(), out traceLevel))
196  {
197  arguments.TraceLevel = traceLevel;
198  }
199  else
200  {
201  error = UnrecognizeOption + value + ".";
202  return false;
203  }
204  break;
205  case optionOutputFolder:
206  arguments.OutputFolder = optionValue;
207  break;
208  case optionDbPort:
209  ushort dbPort = 0;
210  if (ushort.TryParse(optionValue, out dbPort))
211  {
212  arguments.XmlDbPort = dbPort;
213  }
214  else
215  {
216  error = UnrecognizeOption + value + ".";
217  return false;
218  }
219  break;
220  default:
221  error = UnrecognizeOption + value + ".";
222  return false;
223  }
224 
225  return true;
226  }
227 
228  private static bool ParseDictionary(string str, out Dictionary<string, string> dictionary)
229  {
230  dictionary = new Dictionary<string, string>();
231  str = str.Trim();
232  if (str.StartsWith("{") && str.EndsWith("}"))
233  {
234  str = str.Substring(1, str.Length - 2);
235  string[] arr = str.Split(',');
236  foreach (string pair in arr)
237  {
238  string[] nameAndValue = pair.Split('=');
239  if (nameAndValue.Length != 2)
240  {
241  return false;
242  }
243 
244  string name = nameAndValue[0];
245  string value = nameAndValue[1];
246  if (dictionary.ContainsKey(arr[0]))
247  {
248  return false;
249  }
250 
251  dictionary.Add(name, value);
252  }
253 
254  return true;
255  }
256 
257  return false;
258  }
259 
260  private static string PrintUsage()
261  {
262  StringBuilder builder = new StringBuilder();
263  int count = 35;
264  builder.AppendLine(string.Format("RuntimeConverter version {0}", Config.Version));
265  builder.AppendLine("Usage: OpenTestSystem.Otx.RuntimeConverter.Api.ReferenceApplication [options] <path>");
266  builder.AppendLine();
267  builder.AppendLine("<path>".PadRight(count) + "ptx file, ppx file or project directory");
268  builder.AppendLine();
269  builder.AppendLine("options".PadLeft(count));
270  builder.AppendLine(string.Format("{0}:ptx", optionType).PadRight(count) + "Load a ptx file (default)");
271  builder.AppendLine(string.Format("{0}:ppx", optionType).PadRight(count) + "Load a ppx file");
272  builder.AppendLine(string.Format("{0}:project", optionType).PadRight(count) + "Load a project directory containing project file (*.otfPrj)");
273  builder.AppendLine(string.Format("{0}:<password>", optionPassword).PadRight(count) + "Specify password to decrypt the input ptx or ppx");
274  builder.AppendLine(string.Format("{0}", optionValidate).PadRight(count) + "Validate before compiling. If an error occurs, compiling will be canceled");
275  builder.AppendLine(string.Format("{0}:<file>", optionOut).PadRight(count) + "Specify output file");
276  builder.AppendLine(new string(' ', count) + string.Format("If {0}:ptx or {0}:ppx is set and this option is ommitted, output file will be the same as input file", optionType));
277  builder.AppendLine(new string(' ', count) + string.Format("If {0}:project is set, this option is mandatory", optionType));
278  builder.AppendLine(string.Format("{0}:<file>", optionImportDVGs).PadRight(count) + "Import a DiagValidationGroups file (xml)");
279  builder.AppendLine(string.Format("{0}:<port>", optionDiagPort).PadRight(count) + "Specify diag port. Default is 8888");
280  builder.AppendLine(string.Format("{0}:<pipe name>", optionDiagPipe).PadRight(count) + "Specify diag pipe name");
281  builder.AppendLine(string.Format("{0}:<db port>", optionDbPort).PadRight(count) + "Specify XmlDb port. Default is 1984");
282  builder.AppendLine(string.Format("{0}:<trace level>", optionTraceLevel).PadRight(count) + "Specify trace level: ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL or OFF (default)");
283  builder.AppendLine(string.Format("{0}:<folder>", optionOutputFolder).PadRight(count) + "Specify a folder where BaseX databases, extracted files, trace files are put in");
284  return builder.ToString();
285  }
286  #endregion
287  }
288 }
Generic
OpenTestSystem.Otx.RuntimeConverter.Api.Validator
Namespace containing all objects for validation.
Definition: IError.cs:11
OpenTestSystem.Otx.RuntimeConverter.Api
Namespace containing the programming interface for for validation and compilation of PTX,...
Definition: Config.cs:8
OpenTestSystem.Otx.RuntimeConverter.Api.TraceLevels
TraceLevels
Enumeration of TraceLevels
Definition: TraceLevels.cs:13
OpenTestSystem.Otx.RuntimeConverter.Api.License
Namespace containing all objects related to licensing
Definition: LicenseManager.cs:16
OpenTestSystem.Otx
Namespace containing all objects which are standardized according to ISO 13209 (OTX)
OpenTestSystem.Otx.RuntimeConverter
Namespace containing all objects for validation and compilation of PTX, PPX, PROJECT
Definition: Config.cs:8
OpenTestSystem.Otx::Extensions::Job::DataTypes::SeverityTypes
SeverityTypes
OpenTestSystem
Namespace containing all objects related to testing inside automotive industry
OpenTestSystem.Otx.RuntimeConverter.Api.Settings
Namespace containing all objects related to DiagValidationGroups.
Definition: Api2ModelConverter.cs:6