 Welcome to the CTS Learning Series, Chapter 6, Testing an OSS UOC Example. Video 3, Construction of an OSS Toolchain. In this video, we will demonstrate the complete construction of an OSS Toolchain, and validate the constructed OSS Toolchain. In Chapter 3, Video 2, we introduced the overall CTS testing workflow, which began with the construction and validation of the Toolchain configuration file. In Chapter 5, Video 2, we demonstrated the construction of a non-OSS Toolchain. What we will be demonstrating here is similar to constructing a non-OSS Toolchain with a few notable differences, as introduced in Chapter 6, Video 2. Let's accomplish this first step by opening the Toolchain files list and clicking on New to create a new Toolchain configuration file. Let's save the Toolchain immediately, so we don't lose progress as we're configuring the Toolchain. Let's name it CTS Learning Series OSS Toolchain Demonstration. We'll save it in the CTS's default directory, which is your installation of the CTS slash Toolchain slash configuration underscore files. If you recall, this is the Toolchain files directory that was defined in the Toolchain files list. Click on Save to save the Toolchain. Then, we can select the language our USE is to target. Since we will be testing the C++ standard library, let's select C++. We are testing an OSS USE that doesn't implement the configuration interface in this chapter. So let's select the OSS nonconvig option. The OSS profile will determine the minimum set of functions that the C++ standard library must provide. Let's pick General. We'll need the slash user slash bin directory as a path addition to make sure that our compiler can be recognized by the CTS. We don't need to add any environment variables to the Toolchain, however. Let's click on the File Extensions tab. Just like non OSS C++ USEs, we'll need to provide the C++ file extensions. For header files, it's HPP. For source files, it's CPP. For libraries, it's A. For objects, it's O. For the executables, it's X. If we were working on Windows, the executable would be EXE. Let's now click on the Tools tab. In the Compilers section, the compiler executable is G++ as we installed G++ in Chapter 2. For the compiler's flags, we need to provide what's shown on screen. Our output flag will be dash O. In the Linker section, our executable will also be G++ and our output flag will be dash O. In the Archiver section, our executable will be AR and our flags will be CR. Finally, the Toolchain template can be found at your installation of the CTS slash data files slash string template slash default C++ C toolchain templates dot stg. Let's click on the Compiler Specific tab. As we mentioned before, compiler-specific options, the null definition, allowed definitions, and openGL definitions don't contribute to the overall testing of the C++ runtime, so we can leave those blank. However, the exact types definitions is still required to be defined. The exact types definitions section allows us to define compiler-specific interpretations of fixed-width integer types. It is important to note that we are using G++ version 4.8 for our demonstration. In G++, we know that an int8 underscore t is 8 bits, and the minimum size of a char is 8 bits, or 1 byte. The face technical standard uses type-defs to define special types of the same size as existing primitive types. The face int8t is type-deft to an int8t, which we know is a char. For that reason, we can enter char in the field corresponding to face int8t. This process is repeated for 16 bits, or 2 bytes, and 32 bits, which are 4 bytes. Filling in short int and int in the face int16t and the face int32t fields, respectively. Similarly, unsigned integers must be defined as well. Luckily, we just need to add unsigned in front of char, short int, and int, since we just did the signed versions of those types. Size t is an unsigned value of size 4 bytes on a 32-bit architecture and 8 bytes on a 64-bit architecture. This demonstration's version of CentOS 7 is 64-bit, so size t is 8 bytes, which means an unsigned long int type, which is 8 bytes, should be used for face size t. Our operating system does support 64-bit architecture, so we must enable the support 64-bit checkbox and supply the face int64t and the face int64t as well. Just like size t, which was 64-bit, we know that the signed int64 should be long int, which is 64-bit, or 8 bytes, and the unsigned int64 should be unsigned long int, which is 64-bit, or 8 bytes. Finally, the notes tab does not contribute to the overall configuration of the toolchain configuration file, so we'll leave that blank. We are ready to check the toolchain's configuration. Click on the Check Configuration button at the top left of the interface to see if we have configured our toolchain correctly. Our configuration is now valid. With this message, we know that we have correctly configured the toolchain configuration file, and we're ready to use it in a project configuration. Thank you for watching. In the next video, entitled Demonstration of an OSS Conformance Test, we will demonstrate building a configuration file that tests the C++ standard libraries from GNU.