Presented at Pycon italy 2010

1. Jython for Embedded Software Validation Raniero Virgilio IAG/ECG/PPD SW Pycon Quattro, 8/5/2010

2. Raniero Virgilio My Job Software Engineer in Intel Shannon, Ireland Responsible for Test Automation infrastructure My Team PPD (Performance Product Division) Embedded Software Complete SOCs for security, communications, storage and embedded designs http://www.intel.com/embedded/index.htm

3. Agenda Validation in embedded systems Runtime Plug-in model Runtime Plug-in model with Jython Jython and Eclipse Results

4. Validation in embedded systems A challenging environment Typical scenario Requirements and solutions

5. A challenging environment Multiple hw/sw deployments Configuration set up needs to be fast and reliable Support for different OS types and versions Consistent cooperation Several teams working on the same infrastructure Synchronization with overseas groups

6. Test Automation scenario Test Code XML-RPC session Server1 (Windows) Traffic Generator 1 XML-RPC session Traffic Generator 2 Server2 (Windows) Telnet session Test Driver DUT1 (Linux/Windows/FreeBSD) Test Execution Reports XML-RPC session Telnet session Test Suites DUT2 (Linux/Windows/FreeBSD) Telnet session DUT3 (Linux/Windows/FreeBSD)

7. Test Automation requirements Programming language Platform-independent Libraries for connectivity and string manipulation Test Framework design OOP to maximize reusability of test code Platform runtime extendibility Sustainable implementation An effective interface between test execution (local to DUT) and test reporting (distributed) Customizable open source solution

8. Proposed solution Programming language Python telnetlib, xmlrpclib, SimpleXMLRPCServer re,xml.dom.minidom Test Framework design Runtime plug-in model Sustainable implementation Jython embedded in Eclipse Jython is a Python interpreter written in 100% pure Java

9. Runtime plug-in model Definition Design Pattern

10. Runtime Plug-in Model The term plug-in refers to a type of program that contributes code to the system and adds a special capability to it. The plug-in is unknown at compile-time of the application for which the plug-in is designed. Plug-ins are dynamically plugged into the application they are designed for at runtime The key for this model is Dynamic Code Loading

12. Application capabilities are defined by the supported Plug-in

13. Plug-in can be loaded and unloaded at runtime

14. Plug-in development

15. Each Plug-in shall implement a specified interface

16. The plug-in delegates the Application for high-level services

17. Parallel life-cycle

20. StandardJavaFileManager handles the source code

21. JavaCompiler executes the compilation and creates a class file

22. DiagnosticCollector gathers compilation information

23. Class file deployment

24. A new Classloader has to be defined

25. It need to extend the previous one with the new class fileClient

27. The PluginHandler instantiates one PythonInterpreter

28. The Plug-in path is added in the PythonInterpretersys.path

29. The Plug-in is imported in the embedded Python environment

30. Lower complexity

31. Implementation is much easier

32. Code can be modified “on-the-fly” and reloaded

33. First time Plug-in loading is usually quicker on JythonClient

35. Independent Jython environments’ setups

37. When PluginHandler invokes a run() the execution is encapsulated in a Java Thread

38. Plug-ins expand the application concurrentlyClient

39. Jython and Eclipse XTP architecture The Execution Engines The JythonExchanger

40. The eXtendible Test Platform (XTP) Java Jython

42. provides high-level test services (logging, reporting, multithreading) and an interface with frontend

43. Execution Engine

45. The activation sequences contained in the EE Manifest are executed in the PythonInterpreter

47. Each EE uses it to access XTP high-level features

48. XTP infrastructure uses it to retrieve test results from EEs and show them in graphs and reports

51. Memory request increases without “exploding”

53. Common risks “Design your architecture” Test planning To make the most of the Plug-in design pattern, point out common test domains in advance Long-term investment Platform stability requires a significant effort Keep code under control Review carefully test code before integrating it Right-Size your hardware Concurrent executions may require performing machines

54. Q&A