{"id":2745,"date":"2024-03-28T15:53:38","date_gmt":"2024-03-28T15:53:38","guid":{"rendered":"https:\/\/www.emprog.com\/emprog\/product-devalert-copy\/"},"modified":"2024-05-01T15:37:38","modified_gmt":"2024-05-01T15:37:38","slug":"solidsands","status":"publish","type":"page","link":"https:\/\/www.emprog.com\/emprog\/solidsands\/","title":{"rendered":"Product Solid Sands"},"content":{"rendered":"
[vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text]\n

One-stop shop for any C and C++ compiler and library testing, validation and safety services. <\/span><\/p>\n[\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row][vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text]\n

SuperTest<\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

SuperTest Compiler Test and Validation Suite for C and C++<\/span><\/strong><\/span><\/p>\n

SuperTest is the test and validation suite for C and C++ compilers and libraries that has tracked the (ISO) language specifications for more than 30 years. It is a complete validation environment with:<\/span><\/p>\n

\u2022 A huge collection of hand-written test<\/span>
\n\u2022 A large body of generated tests<\/span>
\n\u2022 A configurable test driver to easily set up and run validations<\/span>
\n\u2022 A report generator that provides comprehensive overviews of validation results in multiple formats, including HTML and JUnit XML, and will immediately identify regressions of the latest compiler and library version compared to a designated reference<\/span>
\n\u2022 SuperTest comes with a bundle of ~24K hand-written files generating Millions lines of code to achieve all standard testing.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

SuperTest includes many more unique features that are not found in other test suites:<\/span><\/strong><\/span><\/p>\n

\u2022 Very easy and quick installation and configuration<\/span>
\n\u2022 Can be used to verify deeply embedded freestanding C implementations on memory constraint devices (down to 4K memory)<\/span>
\n\u2022 Clear and easy reporting in text, HTML, JUnit XML and CSV<\/span>
\n\u2022 The CGtrainer (Code Generator trainer), a suite of nearly one thousand tests aimed at bootstrapping new compiler development<\/span>
\n\u2022 Powerful testing of the code generator\/back-end<\/span>
\n\u2022 The Depth Suite is a collection of generated tests that exhaustively verifies arithmetic correctness relative to the target machine\u2019s data model. Depth Suites for many data models are included, but if your data model is not there, we will create one for you free of charge<\/span>
\n\u2022 Parallel testing automatically splits validation runs into a preconfigured numbers of threads to speed up the validation<\/span>
\n\u2022 Testing of libraries<\/span>
\n\u2022 A production rule driven test generator to create pseudo-random variations of a particular test<\/span>
\n\u2022 Easy addition of your own specific tests<\/span>
\n\u2022 Excellent professional support<\/span>
\n\u2022 Multi-processing to execute tests faster<\/span>
\n\u2022 Supports bare metal targets<\/span>
\n\u2022 Traceability to the sections of the ISO standards<\/span>
\n\u2022 Runs on Windows and Linux<\/span>
\n\u2022 Flexible test generators<\/span>
\n\u2022 Full control over the test sets<\/span>
\n\u2022 Python Configuration plugins<\/span>
\n\u2022 Reporting tools: SuperTest generates high quality reports that are easy to read and analyze<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

ISO Standard Conformance Testing<\/span><\/strong><\/span><\/p>\n

SuperTest can be used to qualify compilers and libraries for functional safety based on standards like ISO 26262, IEC 61508, EN 50128, IEC 62304. Even if you are a compiler end-user and can\u2019t fix the C\/C++ compiler, SuperTest will help you know what C\/C++ syntax to avoid so you don\u2019t have a runtime issue. <\/span><\/p>\n

The SuperTest suite covers the following ISO specifications:<\/span><\/p>\n

ISO\/IEC 9899:1990 C90 standard
\nISO\/IEC 9899:1999 C99 standard
\nISO\/IEC 9899:2011 C11 standard
\nISO\/IEC 9899:2018 C18 standard
\nISO\/IEC TR 18037:2008 Embedded C extension
\nISO\/IEC 14882:2003 C++03
\nISO\/IEC 14882:2011 C++11
\nISO\/IEC 14882:2014 C++14
\nISO\/IEC 14882:2017 C++17
\nISO\/IEC 14882:2020 C++20<\/span><\/p>\n

The test suite is systematically structured so that it is clear what section of which standard is tested by each test. Therefore, it is also easy to configure which language version should be tested when executing the test suite.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

Additional SuperTest Features<\/span><\/strong><\/span><\/p>\n

\u2022 Optimization correctness<\/span>
\n\u2022 C and C++ Standard Library Testing<\/span>
\n\u2022 Code Generator development<\/span>
\n\u2022 Data Model specific arithmetic<\/span>
\n\u2022 Calling convention testing<\/span>
\n\u2022 In-depth arithmetic testing<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text css=””]\n

SuperTest Can Qualify Any C or C++ Compiler<\/span><\/strong><\/span><\/p>\n

SuperTest can be configured to qualify any C or C++ compiler toolchain for any execution environment. We provide example configurations for many of the compiler toolchains and targets listed below. Using an example configuration, getting started with using SuperTest for the qualification of the compiler toolchain and target that you are using is easy. SuperTest targets open source based compilers such as GCC (all versions), LLVM (Clang, all versions), STM32CubeIDE, TI Code Composer, Renesas 22 Studio; and most popular proprietary C\/C++ compilers in the market. Email info@emprog.com<\/a> to check if you compiler has a ready-to-use SuperTest for it.<\/span> <\/span><\/p>\n

\"\"<\/p>\n

\"\"<\/p>\n[\/vc_column_text][vc_column_text]\n

SuperTest Testimonials<\/span><\/strong><\/span><\/p>\n

\u201cWith SuperTest, we can now reliably tell our customers that our compiler verification covers the entire C and C++ language standard. SuperTest includes tests for the optimizations that we often develop for our customers in order to meet their performance or code size requirements. As a result, we can run tests that target every part of the compiler,\u201d Customer\u2019s testimony after trying to develop their own test suit based on the LLVM and GCC Torture test suites.<\/em> <\/span><\/p>\n

\u201cBefore, when customers asked us how do we really know our compilers work, we didn\u2019t always have a very good answer. After using SuperTest, now we can say with a very high level of confidence that they do.\u201d Customer\u2019s testimony <\/em> <\/span><\/p>\n[\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row][vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text]\n

SuperGuard<\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

SuperGuard Library Safety Qualification Suite<\/span><\/strong><\/span><\/p>\n

The SuperGuard Library Safety Qualification Suite is a requirements-based test suite for the C and C++ standard libraries with full traceability between the requirements derived from the ISO C and C++ language definitions and the individual library tests. It is designed to support the qualification of implementations of the C and C++ standard libraries for safety-critical applications, both for third-party (COTS) and for self-developed or maintained library implementations. <\/span><\/p>\n

SuperGuard qualification suite focuses on ensuring the safety of standard libraries for C and C++ and ensures that the standard library meets its requirements.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

Requirements-Based Testing<\/span><\/strong><\/span><\/p>\n

SuperGuard provides a detailed breakdown of the ISO C and C++ library specifications into the requirements that must be met by an implementation of the library. These requirements are linked to test specifications that describe how a test verifies the requirements. In turn, the test specification is linked to tests in SuperGuard. In this way, a detailed path is created from the specification to the tests that is easy to comprehend and verify, so that it can be used to create confidence in the compliance of the C and C++ library implementations with their specifications.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

High Structural Code Coverage<\/span><\/strong><\/span><\/p>\n

SuperGuard is built to achieve high structural code coverage of the target library implementation. In addition to requirements traceability, this provides a second path to demonstrate the completeness of the test suite.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

Reporting Tool<\/span><\/strong><\/span><\/p>\n

The suite comes with a software tool that reports the requirements that are met, and which are not met, by C and C++ library implementations as verified by a run of the test suite for a specific use case or configuration.<\/span> <\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

SuperGuard includes many more unique features that are not found in other qualification suites:<\/span><\/strong><\/p>\n

\u2022 Compliance with the requirements of functional safety standards
\n\u2022 Very easy and quick installation and configuration
\n\u2022 Parallel testing automatically splits validation runs into a preconfigured number of threads to speed up the validation
\n\u2022 Full control over test sets
\n\u2022 Easy addition of your own specific tests
\n\u2022 Excellent professional support <\/span><\/p>\n[\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row][vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text]\n

SuperTest Code Generator Trainer (add-on)<\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

Developing a C\/C++ compiler for a new (or old) target processor is one of the greatest and most rewarding software engineering projects imaginable. It is also challenging and daunting. This is where the Code Generator Trainer comes in. <\/span><\/p>\n

The assumption is that this compiler is not written from scratch. It will be using an existing compiler development platform, either open source or proprietary, that already has a front-end, optimizations and a more or less retargetable code generator. What has to be done is writing a code generator for the new target processor. The Code Generator Trainer suite is going to make this project run smooth, efficiently and with a lot of fun on top of that. <\/span><\/p>\n

The Code Generator Trainer consists of nearly one thousand test files split over 25 carefully constructed levels aimed at boot-strapping new compiler development. Each level addresses a specific capability of the code generator. Level 0 is there to set up the minimal interface that is needed to run the tests. The next levels introduce simple integer arithmetic, conversions, pointers, addressing modes for structures, register allocation, control flow and calling conventions. Beyond that are levels dealing with characters and shorts, long long arithmetic and varargs.<\/span><\/p>\n

Each level is constructed to build upon the groundwork of the previous levels. This way, the code generator development progresses one logical step at a time. It gets you a better compiler, faster.<\/span><\/p>\n

By the time the compiler passes the final level, it is ready to take on SuperTest\u2019s big guns: the conformance suites that validate the front-end, optimization correctness and more nitty gritty details of code generation. There will be more work to do: add more features, improve efficiency, etc. You can be sure that this work builds on the solid foundations laid out by the Code Generator Trainer.<\/span><\/p>\n

Want to get your hands on the Code Generator Trainer and start developing your code generator now? Get the SuperTest demo by clicking the button below. You will find the first few levels included for free.<\/span> <\/span><\/p>\n[\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row][vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text]\n

Functional Safety Overview<\/span><\/p>\n[\/vc_column_text][vc_column_text]\n

Functional safety is one of the most important aspects of many embedded systems today, especially in sectors such as automotive, railway, industrial automation and medical. SuperTest and SuperGuard can be used to qualify compilers and libraries for functional safety. <\/span><\/p>\n

Compiler qualification is the process that can be used to develop the required confidence in the compiler. Compiler testing against the language specification is the proper method for this. SuperTest, with its traceability from the C and C++ language standards to the test, is the best test suite for compiler qualification. <\/span><\/p>\n

Library qualification is even more critical because the library contains code that is linked into the application and loaded onto the target device. If a library component is defective, the functional safety of the entire application is therefore jeopardized. SuperGuard can be used to support qualification of standard library implementations for safety critical applications.<\/span><\/p>\n

There are different functional safety standards for which you can use SuperTest and SuperGuard to qualify your compiler and library. <\/span><\/p>\n

ISO 26262<\/strong>
\nISO 26262 is the functional safety standard for electrical and electronic systems in series production passenger cars and other automotive categories. It requires qualification of all (electrical and electronic) components with respect to safety. The qualification process is described in the standard.<\/span><\/p>\n

IEC 61508<\/strong>
\nIEC 61508 is the international umbrella standard for functional safety. This standard and other standards derived from it are used in all kinds of industries with requirements on reliability and safety, for example process industries, nuclear power plants and railway control systems. <\/span><\/p>\n

EN 50128<\/strong>
\nEN 50128 is a European standard for safety related software in railway applications.<\/span><\/p>\n

IEC 62304<\/strong><\/span>
\nIEC 62304 is the international standard which specifies life cycle requirements for the development of medical software and medical devices.<\/span> <\/span><\/p>\n[\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row]\n<\/div>","protected":false},"excerpt":{"rendered":"

[vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text] One-stop shop for any C and C++ compiler and library testing, validation and safety services. [\/vc_column_text][\/vc_column][vc_column width=”1\/4″][\/vc_column][\/vc_row][vc_row][vc_column width=”1\/4″][\/vc_column][vc_column width=”1\/2″][vc_column_text] SuperTest [\/vc_column_text][vc_column_text] SuperTest Compiler Test and Validation Suite for C and C++ SuperTest is the test and validation …<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"template-full-width.php","meta":{"footnotes":""},"_links":{"self":[{"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/pages\/2745"}],"collection":[{"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/comments?post=2745"}],"version-history":[{"count":14,"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/pages\/2745\/revisions"}],"predecessor-version":[{"id":2782,"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/pages\/2745\/revisions\/2782"}],"wp:attachment":[{"href":"https:\/\/www.emprog.com\/emprog\/wp-json\/wp\/v2\/media?parent=2745"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}