Eclipse Yocto Test Cases: Difference between revisions

From Yocto Project
Jump to navigationJump to search
(Created page with "==Setuo Development Environment== : 1. Setup Docker, Crops/Poky and Crops/Toolchain image ::a) follow the setup instruction here : ::https://docs.docker.com/install/linux/do...")
 
 
(10 intermediate revisions by the same user not shown)
Line 1: Line 1:
==Setuo Development Environment==
== Eclipse-Yocto - Launch_Eclipse_Yocto_plugin ==
Install and launch Eclipse Yocto plugin on Eclipse
 
===prerequisites===
-
 
===execution===
 
: 1. Install "Eclipse IDE for C/C++ Developers" Photon release (4.8.0) 
:: a) Go to https://www.eclipse.org/downloads/packages/release click "Photon"  -> "R Packages"
:: b) Locate for "Eclipse IDE for C/C++ Developers"
:: c) Click on 32-bit or 64-bit to download the build for your OS 
:: d) Run "tar xf" to extract the downloaded archive
:: e) Run "eclipse/eclipse" to start Eclipse 
 
: 2. Optional steps for host machine behind proxy Network
:: a) In Eclipse workbench window, go to "Window "menu -> "Preferences...". 
:: b) In "Preferences" dialog, go to "General" -> "Network Connections", set "Active Provider" to "Manual". In "Proxy entries" table, select HTTP and click "Edit" -> enter host "your.proxy.com" and port port number, click OK. Repeat for HTTPS. Click "Apply and Close" to close Preferences dialog. 
:: c) Go to "File" menu -> "Restart" to restart Eclipse for proxy settings to take effect.
 
: 3. Install Eclipse Yocto plugins 
:: a) Download the eclipse yocto plugin archive file
:: b) In Eclipse workbench window, go to "Help" menu -> "Install New Software..." 
:: c) In "Install" dialog, click "Add..." button 
:: d) In "Add Repository" dialog, enter "Eclipse Yocto" for (repository) Name, click "Archive..."
:: e) In "Repository archive" browse dialog, select the downloaded Eclipse-Yocto repository archive 
:: f) Back in Add Repository dialog, click "Add" 
:: g) Back in "Install" dialog, make sure "Work with:" is set to "Eclipse Yocto" repository, check all available plugin, click "Next" > and verify plugins/features name/version, click "Next" > and accept license agreement, click "Finish" 
:: h) If "Security Warning" dialog appears, click "OK" to install unsigned content. 
:: i) In "Software Updates" dialog, click "Yes" to restart Eclipse to complete Eclipse Yocto plugins installation.
 
: 4.  In Eclipse workbench window, go to "Window" menu -> "Preferences". 
 
::: expected result:
 
<pre>Eclipse Yocto plugins installed and running successfully, observe that "Yocto Project (alpha)" appear in "Preferences" dialog. </pre>
 
== Eclipse-Yocto - Setup_Development_Environment ==
Setup Development environment required by upcoming test cases
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]
 
===execution===  
 
: 1. Setup Docker, Crops/Poky and Crops/Toolchain image
: 1. Setup Docker, Crops/Poky and Crops/Toolchain image
::a) follow the setup instruction here :
:: a) follow the setup instruction here :  
 
::https://docs.docker.com/install/linux/docker-ce/ubuntu/
::: https://docs.docker.com/install/linux/docker-ce/ubuntu/


::b) run below command to download Crops/Toolchain Images
:: b) run below command to download Crops/Toolchain Images
:: <pre>docker pull chinhuatang/toolchain
:: <pre>docker pull crops/poky


:[[File:Screen_Shot_2018-10-30_at_2.07.31_PM.png]]
<pre>docker pull crops/toolchain
docker pull crops/poky  </pre>


:
: 2. Setup build tree ( if you familiar with bitbake tools you can build any target machine image at your preferences)
: 2. Setup build tree ( if you familiar with bitbake tools you can build any target machine image at your preferences)
::a) clone poky and checkout to working branch
:: a) clone poky and checkout to working branch


        >git clone git://git.yoctoproject.org/poky
<pre>git clone git://git.yoctoproject.org/poky-contrib
        >git checkout tags/yocto-2.5 -b my-yocto-2.5
git checkout <commit tag for latest milestone> </pre>
   
   
    b) run crops/poky and initiate build environment  
:: b) run crops/poky and initiate build environment  
 
<pre>docker run -it --rm -v </path/to/poky>:/workdir crops/poky --worldir=/workdir
source oe-init-build-env</pre>
 
:: c) open another window/terminal to edit poky local.conf file. add below line to poky/build/conf/local.conf
 
<pre>EXTRA_IMAGE_FEATURES += "eclipse-debug"
EXTRA_IMAGE_FEATURES += "tools-sdk"
EXTRA_IMAGE_FEATURES += "ssh-server-openssh"</pre>
 
:: d) back to terminal in use in step 3.b, run below command.
 
<pre>bitbake core-image-sato-sdk
bitbake meta-ide-support</pre>
 
: 3. Setup YP SDK toolchain
:: a) Look for SDK toolchain script created in step 2 in path poky/build/tmp/deploy/sdk/
 
<pre>E.g:  /poky/build/tmp/deploy/sdk/poky-glibc-x86_64-meta-toolchain-core2-64-toolchain-2.5+snapshot.sh</pre>
 
:: b) execute the script in terminal
:: c) (optional) enter your preferred path to setup SDK
:: d) press "Enter" -> press "y" -> press "Enter"
 
: 4. Setup Eclipse to run Docker
:: a) In Eclipse workbench window, go to "Run" menu -> "Run configurations..." 
:: b) In "Configurations" window, go to "Run" menu -> right click "Run Docker Image"  -> new configuration
:: c) In "Configurations" window, select the new created configuration -> select "crops/poky:latest" for Image -> check "Keep STDIN open to console even if not attached (-i)"
:: d) In "Configurations" window, select "Volumes" tab, -> "Add..."
:: e) In "Data Volume" window, check "mount a host directory or host file" -> click "Directory" -> look for build tree path (path setup on step 2) -> copy build tree path and paste to Container path -> click "OK "
:: f) In "Configurations" window, click "Run"
 
::: expected result:
 
<pre>docker running in eclipse console and path mount correctly. </pre>
 
: 5. run QEMU in docker using eclipse console
:: a) In Eclipse Console window, switch to docker console (docker run on test case [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]] )
:: b) In Eclipse Console, cd to poky path 
:: c) In Eclipse Console, initiate build environment 
 
<pre>source oe-init-build-env </pre>
 
:: d) run QEMU 
 
<pre>runqemu <image> slirp nographic qemuparams="-redir tcp:2345::2345"
 
E.g :
runqemu qemux86 slirp nographic qemuparams="-redir tcp:2345::2345"</pre>
 
::: expected result:
 
<pre>Qemu running in eclipse console</pre>
 
 
 
 
 
 
== Eclipse-Yocto - Setup_Development_Profile ==
Setup Development Profile for different toolchain
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]
: 2. [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]
 
===execution===
 
: 1. In Eclipse workbench window, go to "Preferences" -> "Yocto Project (alpha)".
:: a) If you setup SDK toolchain (test case [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]] step 3) using default path, click on profile dropdown menu and select a profile.expected result:
 
<pre>Profile dropdown menu have default profile created and able to select it.</pre>
 
:: b) If you setup  SDK toolchain using custom path, expected result:
 
<pre>Profile dropdown menu disabled.</pre>
 
: 2. Create Yocto SDK toolchain Profile
:: a) In "Preferences" Window -> click "New". 
:: b) In "Create new profile" Window -> insert an identical profile name -> click "Ok". 
:: c) In "Preferences" Window -> Select "SDK installation" -> click "Edit" -> locate to SDK path setup on [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]  step 3 -> click "OK" -> click "Apply". 
 
: 3. Create Yocto build tree toolchain Profile
:: a) take similar action as steps 2.a and 2.b
:: b) In "Preferences" Window -> Select "Build directory" -> click "Edit" -> locate to poky/build/tmp (setup on [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]  step 1) -> click "OK" -> click "Apply". 
 
: 4. Create Yocto SDK toolchain Docker Profile
:: a) take similar action as steps 2.a and 2.b
:: b) In "Preferences" Window -> check "Build and launch using container" -> Select SDK installation -> click "Edit"
:: c) In prompt window, select Mount a host directory -> click "Browse..." -> locate to SDK path setup on [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]  step 3 ->  copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply". 
 
: 5. Create Yocto build tree toolchain Docker Profile
:: a) take similar action as steps 2.a and 2.b
:: b) In "Preferences" Window -> check "Build and launch using container" -> Select "Build directory" -> click "Edit"
:: c) In prompt window, select Mount a host directory -> click "Browse..." -> locate to SDK path setup on [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]  step 1 ->  copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply". 
 
::: expected result:
 
<pre>4 new Profile created and available in cross development profile dropdown menu.</pre>
 
== Eclipse-Yocto - Manage_Development_Profile ==
switch between profile, rename and remove existing profile
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Profile]]
 
===execution===
 
: 1. Follow test case [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Profile]] steps 1 and 2.
 
: 2. Rename Profile
:: a) In "Preferences" Window(make sure the profile create in step 1 selected in profile dropdown menu) ->click "Rename..." 
:: b) In Rename Profile Window insert a new name -> OK
 
::: expected result:
 
<pre>Profile name updated. </pre>
 
: 3. Remove Profile
:: a) In "Preferences" Window (make sure the profile used in step 2 selected in profile dropdown menu) -> click "Remove..." 
 
::: expected result:
 
<pre>Profile removed from selection in profile dropdown menu. </pre>
 
: 4. Switch Profile
:: a) click on profile dropdown menu, select any profile name ( other than the showing profile)
 
::: expected result:
 
<pre>Profile dropdown menu updated to select profile. Toolchain section and QEMU section updated accordingly (match with the profile created in test case Setup_Development_Environment).</pre>
 
== Eclipse-Yocto - Configure_project_as_YP_Project ==
configure a project into yocto project's project
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
 
===execution===
 
: 1. In Eclipse workbench window, go to "New" -> "PreferencesC/C++ Project". 
 
: 2. Select "C Managed Build" -> Next. 
 
: 3. In Project type expand "GNU Autotools" -> select "Hello World ANSI C Autotools Project" -> in Toolchain, select "GNU Autotools Toolchain" -> insert a project name -> Click "Finish".
 
: 4. In project explorer, select the new created project -> right click -> Configure -> select Configure as Yocto Project Autotools project (alpha).
 
: 5. In "Properties" windows, in profile dropdown menu, select Yocto SDK toolchain Profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 2 -> click "Apply and Close". 
 
::: expected result:
 
<pre>Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "Autotools_Project [SDK_Profile]"</pre>
 
 
 
 
 


        >docker run -it --rm -v </path/to/poky>:/workdir crops/poky --worldir=/workdir
== Eclipse-Yocto - Add_Yocto_Project_Nature ==
        >source oe-init-build-env
create cmake project and add yocto project nature to project


    c) open another window/terminal to edit poky local.conf file. add below line to poky/build/conf/local.conf
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]


        >EXTRA_IMAGE_FEATURES += "eclipse-debug"
===execution===
        >EXTRA_IMAGE_FEATURES += "tools-sdk"
        >EXTRA_IMAGE_FEATURES += "ssh-server-openssh"


    d) back to terminal in use in step 3.b, run below command.  
: 1. In Eclipse workbench window, go to "New" -> "PreferencesC/C++ Project".


        >bitbake core-image-sato
: 2. Select "C Managed Build" -> Next. 
        >bitbake meta-ide-support
        >bitbake meta-toolchain


  3. Setup YP SDK toolchain
: 3. In Project type expand "CMake (alpha)" -> select Empty Project -> in Toolchian select "Yocto Project SDK CMake Toolchian (alpha)" -> insert a project name -> Click "Finish".
a) Look for SDK toolchain script created in steps 2 in path poky/build/tmp/deploy/sdk/
 
: 4. In project explorer, select the created new project -> right click -> Properties.
 
: 5. In "Properties" windows, select Project Natures -> "Add".
 
: 6. If eclipse prompt for "Confirm Project Nature update" click "Ok"
 
: 7. In "Select Nature" windows, select "Yocto Project Nature (alpha)" -> click "Ok"
 
: 8. In "Properties" windows, click "Apply and Close".
 
: 9. In project explorer, select the same project -> right click -> Properties.
    
    
        >E.g:  /poky/build/tmp/deploy/sdk/poky-glibc-x86_64-meta-toolchain-core2-64-toolchain-2.5+snapshot.sh
::: expected result:
 
<pre>"Yocto Project (alpha)" shows in Properties.</pre>
 
 
 
 
 
 
== Eclipse-Yocto - Cmake_Yocto_SDK ==
build CMake project using Yocto SDK toolchain
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]
 
===execution===
 
: 1. In project explorer, select the project created in test case [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]] -> right click -> Properties.
 
: 2. In "Properties" windows, select "Yocto Project (alpha)" -> in profile dropdown menu, select Yocto SDK toolchain Profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 2 -> click "Apply and Close".
 
::: expected result:
 
<pre>Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "CMake_Project [SDK_Profile]"</pre>
 
: 3. In project explorer, select the same project -> right click -> select "Clean Project".
 
: 4. if Eclipse prompt for "Regenerate CMake Build Files" windows, click "Yes"
 
: 5. In project explorer, select the same project -> right click -> select "Regenerate CMake build files". If prompt for "Regenerate CMake Build Files", click "Yes".
 
::: expected result:
 
<pre>Eclipse using Yocto SDK toolchain.
In Eclipse Console, the file path after line "Check for working C compiler:" should match with SDK installation path for selected profile.
E.g:
Check for working C compiler: /opt/poky/2.5+snapshot/sysroots/x86_64-pokysdk-linux/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works</pre>
 
: 6. In project explorer, select the same project -> right click -> select "Build Project"
 
::: expected result:
 
<pre>Eclipse using Yocto SDK toolchain.
In Eclipse Console, look for cmake command.
E.g:
/opt/poky/2.5+snapshot/sysroots/x86_64-pokysdk-linux/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0 </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Cmake_Yocto_SDK_program ==
execute and debug CMake Yocto SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Debug Configurations..."
 
: 2. In "Debug Configuration" window, select and right click on "C/C++ Remote Application" -> select "New Configuration"
 
: 3. In "Debug Configuration" window "Main" tab, insert a configuration name -> click "Browse..." select project created in test case [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]] -> "Ok"
 
: 4. In "Debug Configuration" window "Main" tab, insert path to .out file for project create in [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]] to "C/C++ Application:"
 
<pre>E.g:   
"src/a.out" </pre>
 
: 5. In "Debug Configuration" window "Main" tab, click "New..." for connection
 
: 6. In "Create a new connection" window, select "SSH" -> "OK"
 
: 7. In new window, insert a connection name -> insert "172.17.0.2" for Host -> insert "root" for User. Host might be differ depend on running docker on your machine.
 
: 8. In "Edit configuration" window, insert a connection name -> insert "172.17.0.2" for Host -> insert "root" for User. Host might be differ depend on running docker on your machine.
 
: 9. In "Edit configuration" window, expand "Advanced" insert "2222" for port -> click "Finish"
 
: 10. In "Debug Configuration" window, click "Debug". if prompt for "Confirm Perspective Switch" click "Switch"
 
::: expected result:
 
<pre>eclipse switch to debugging mode. </pre>
 
: 11. In Eclipse, click "F8" to execute the program.
 
::: expected result:
 
<pre>successful execute program.  </pre>
 
 
 
 
 
== Eclipse-Yocto - Run_Cmake_Yocto_SDK_program ==
run CMake Yocto SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Cmake_Yocto_SDK_program|Debug_Cmake_Yocto_SDK_program]]. if the configuration does not appear, follow steps 2 to 9 in test case [[#Eclipse-Yocto_-_Debug_Cmake_Yocto_SDK_program|Debug_Cmake_Yocto_SDK_program]] to create new configuration.
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful execute program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
== Eclipse-Yocto - CMake_Yocto_build_tree ==
build Cmake project using Yocto SDK toolchain
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]]. Repeat all the steps in test case [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]] with below settings and expected result.
:: a) In Step 2 select Yocto build tree toolchain Profile instead. (the profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 3)
:: b) expected result for step 5 :
 
<pre>Eclipse using Yocto build tree toolchain. 
In Eclipse Console, the file path after line "Check for working C compiler:" should match with  Build directory for selected profile.
E.g: 
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works </pre>
 
:: c) expected result for step 6 :
 
<pre>Eclipse using Yocto build tree toolchain.
In Eclipse Console, look for cmake command.
E.g:
/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0 </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Cmake_Yocto_build_tree_program ==
execute and debug CMake Yocto build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_CMake_Yocto_build_tree|CMake_Yocto_build_tree]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_CMake_Yocto_build_tree|CMake_Yocto_build_tree]].
 
 
 
 
 
 
== Eclipse-Yocto - Run_Cmake_Yocto_build_tree_program ==
run CMake Yocto build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_CMake_Yocto_build_tree|CMake_Yocto_build_tree]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Cmake_Yocto_build_tree_program|Debug_Cmake_Yocto_build_tree_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_CMake_Yocto_build_tree|CMake_Yocto_build_tree]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Cmake_CROPS_SDK ==
enable docker container setting and build Cmake project using Yocto SDK toolchain in docker
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]
 
===execution===
 
: 1. In project explorer, select the project created in test case [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]] -> right click -> Properties.
 
: 2. In "Properties" windows, expand "C/C++ Build" -> select "Settings" -> select "Container Settings" tab.
 
: 3. In "Container Settings" tab, check "Build inside Docker Image", select a connection for docker. In Images field, select "crops/toolchain:latest".
 
: 4.  In "Properties" windows, select "Yocto Project (alpha)" ->  in profile dropdown menu, select Yocto SDK toolchain Docker Profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 4 -> click "Apply and Close"
 
::: expected result:
 
<pre>Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "CMake_Project [SDK_Docker_Profile]" </pre>
 
: 5.  In project explorer, select the same project -> right click -> select "Clean Project"
 
: 6. if Eclipse prompt for "Regenerate CMake Build Files" windows, click "Yes"
 
: 7. In project explorer, select the same project -> right click -> select "Regenerate CMake build files". If prompt for "Regenerate CMake Build Files", click "Yes".
 
::: expected result:
 
<pre>Cmake command run in docker and using Yocto SDK toolchain.
In Eclipse Console look for running image and file path after line "Check for working C compiler:".
[Running in image <crops/toolchain:latest>]
E.g: 
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works </pre>
 
: 8. In project explorer, select the same project -> right click -> select "Build Project"
 
::: expected result:
 
<pre>Make command run in docker and using Yocto SDK toolchain.
E.g:
[Running in image <crops/toolchain:latest>]
make all
/Data/opt/poky/2.5.1__andromeda_qemux86_64_sato_meta_toolchain/sysroots/x86_64-pokysdk-linux/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0 </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Cmake_CROPS_SDK_program ==
execute and debug CMake CROPS SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]].
 
 
 
 
 
 
== Eclipse-Yocto - Run_Cmake_CROPS_SDK_program ==
run CMake CROPS SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Cmake_CROPS_SDK_program|Debug_Cmake_CROPS_SDK_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Cmake_CROPS_build_tree ==
Cmake project using Yocto build tree toolchain in docker
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]]. Repeat all the steps in test case [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]] with below settings and expected result.
:: a) In Step 4 select Yocto build tree toolchain Docker Profile instead. (the profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 5)
:: b) expected result for step 5 :
 
<pre>Cmake command run in docker and using Yocto build tree toolchain.
In Eclipse Console, look for running image and the file path after line "Check for working C compiler:" should match with Build directory for selected profile.
E.g: 
[Running in image <crops/toolchain:latest>]
......
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works </pre>
 
:: c) expected result for step 6 :
 
<pre>Make run in docker and using Yocto build tree toolchain. 
In Eclipse Console, look for running image and path for cmake command.
E.g: 
[Running in image <crops/toolchain:latest>]
make all
......
/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0 </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Cmake_CROPS_build_tree_program ==
execute and debug CMake CROPS build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_build_tree|Cmake_CROPS_build_tree]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case  [[#Eclipse-Yocto_-_Cmake_CROPS_build_tree|Cmake_CROPS_build_tree]].
 
 
 
 
 
 
== Eclipse-Yocto - Run_Cmake_CROPS_build_tree_program ==
run CMake CROPS build tree toolchain project in QEMU
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_build_tree|Cmake_CROPS_build_tree]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Cmake_CROPS_build_tree_program|Debug_Cmake_CROPS_build_tree_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Cmake_CROPS_build_tree|Cmake_CROPS_build_tree]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
 
== Eclipse-Yocto - Autotools_Yocto_SDK ==
build autotools project using Yocto SDK toolchain
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
 
===execution===
 
: 1. In project explorer, select the project created in test case [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]] -> right click -> Properties.
 
: 2. In "Properties" windows, in profile dropdown menu, select Yocto SDK toolchain Profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 2 -> click "Apply and Close". 
 
: 3. In project explorer, select the project created in test case [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]] -> right click -> select "Clean Project".
 
: 4. In project explorer, select the same project -> right click -> select "Reconfigure Project"
 
::: expected result:
 
<pre>Eclipse configure project using Yocto SDK toolchain. 
In Eclipse Console, the file path after line "configure: loading site script" should match with  Build directory for selected profile. 
E.g: 
configure: loading site script /opt/poky/2.5+snapshot/site-config-core2-64-poky-linux </pre>
 
: 5. In project explorer, select the same project -> right click -> select "Build Project"
 
::: expected result:
 
<pre>Eclipse make using Yocto SDK toolchain.
E.g:
make all
Making all in src
make[1]: Entering directory '/Data/runtime-Eclipse-Yocto/autotools-hw/src'
x86_64-poky-linux-gcc  -m64 -march=core2 -mtune=core2 -msse3 -mfpmath=sse --sysroot=/opt/poky/2.5+snapshot/sysroots/core2-64-poky-linux -DPACKAGE_NAME=\"autotools-hw\" -DPACKAGE_TARNAME=\"autotools-hw\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"autotools-hw\ 1.0\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"autotools-hw\" -DVERSION=\"1.0\" -I. -O2 -pipe -g -feliminate-unused-debug-types  -MT autotools-hw.o -MD -MP -MF .deps/autotools-hw.Tpo -c -o autotools-hw.o autotools-hw.c </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Autotools_Yocto_SDK_program ==
execute and debug Autotools Yocto SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case  [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]].
 
 
 
 
 
 
== Eclipse-Yocto - Run_Autotools_Yocto_SDK_program ==
run Autotools Yocto SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Autotools_Yocto_SDK_program|Debug_Autotools_Yocto_SDK_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Autotools_Yocto_build_tree ==
build autotools project using Yocto build tree toolchain
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]]. Repeat all the steps in test case [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]] with below settings and expected result.
:: a) In Step 2 select Yocto build tree toolchain Profile instead. (the profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 3)
:: b) expected result for step 4 :
 
<pre>Eclipse configure project using Yocto build tree toolchain.
In Eclipse Console, look for configure command, all the parameter should match with Build directory for selected profile.
E.g: 
sh -c "/Data/runtime-Eclipse-Yocto/autotools-hw/configure --target=x86_64-poky-linux --host=x86_64-poky-linux --build=x86_64-linux --with-libtool-sysroot=/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot" </pre>
 
:: c) expected result for step 5 :
 
<pre>Eclipse make using Yocto SDK toolchain. 
E.g:
make all
Making all in src
make[1]: Entering directory '/Data/runtime-Eclipse-Yocto/autotools-hw/src'
x86_64-poky-linux-gcc  -m64 -march=core2 -mtune=core2 -msse3 -mfpmath=sse -fstack-protector-strong  -D_FORTIFY_SOURCE=2 -Wformat -Wformat-security -Werror=format-security --sysroot=/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot -DPACKAGE_NAME=\"autotools-hw\" -DPACKAGE_TARNAME=\"autotools-hw\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"autotools-hw\ 1.0\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"autotools-hw\" -DVERSION=\"1.0\" -I. -O2 -pipe -g -feliminate-unused-debug-types  -MT autotools-hw.o -MD -MP -MF .deps/autotools-hw.Tpo -c -o autotools-hw.o autotools-hw.c </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Autotools_Yocto_build_tree_program ==
execute and debug Autotools Yocto build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_build_tree|Autotools_Yocto_build_tree]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case  [[#Eclipse-Yocto_-_Autotools_Yocto_build_tree|Autotools_Yocto_build_tree]].
 
 
 
 
 
 
== Eclipse-Yocto - Run_Autotools_Yocto_build_tree_program ==
run Autotools Yocto build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_build_tree|Autotools_Yocto_build_tree]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Autotools_Yocto_build_tree_program|Debug_Autotools_Yocto_build_tree_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Autotools_Yocto_build_tree|Autotools_Yocto_build_tree]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Autotools_CROPS_SDK ==
build Autotools project using Crops SDK toolchain in docker
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
 
===execution===
 
: 1. In project explorer, select the project use in test case [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]] -> right click -> Properties.
 
: 2. In "Properties" windows, expand "C/C++ Build" -> select "Settings" -> select "Container Settings" tab.
 
: 3. In "Container Settings" tab, check "Build inside Docker Image", select a connection for docker. In Images field, select "crops/toolchain:latest".
 
: 4.  In "Properties" windows, select "Yocto Project (alpha)" ->  in profile dropdown menu, select Yocto SDK toolchain Docker Profile created in test case [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]] steps 4 -> click "Apply and Close"
 
::: expected result:
 
<pre>Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "Autotools_Project [SDK_Docker_Profile]" </pre>
 
: 5.  In project explorer, select the same project -> right click -> select "Clean Project"
 
: 6. In project explorer, select the same project -> right click -> select "Reconfigure Project"
 
::: expected result:
 
<pre>Eclipse run configure command in docker using Yocto SDK toolchain.
In Eclipse Console, check for running image and the file path after line "configure: loading site script" should match with SDK installation path for selected profile.
<pre>E.g: 
[Running in image <crops/toolchain:latest>]
......
configure: loading site script /Data/opt/poky/2.5.1__andromeda_qemux86_64_sato_meta_toolchain/site-config-core2-64-poky-linux </pre>
 
: 7. In project explorer, select the same project -> right click -> select "Build Project"
 
::: expected result:
 
<pre>Make command run in docker using Yocto SDK toolchain.
In Eclipse Console, check for running image
 
[Running in image <crops/toolchain:latest>] </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Autotools_CROPS_SDK_program ==
execute and debug Autotools CROPS SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]].
 
 
 
 
 
 
 
== Eclipse-Yocto - Run_Autotools_CROPS_SDK_program ==
run Autotools CROPS SDK toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]]
 
===execution===
 
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
 
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Autotools_CROPS_SDK_program|Debug_Autotools_CROPS_SDK_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </pre>
 
 
 
 
 
 
 
== Eclipse-Yocto - Autotools_CROPS_build_tree ==
build Autotools project using Yocto build tree toolchain in docker
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
 
===execution===
 
 
: 1. Refer to test case [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]]. Repeat all the steps in test case [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]] with below settings and expected result.
:: a) In Step 4 select Yocto build tree toolchain Docker Profile instead. (the profile created in test case [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]] step 5)
:: b) expected result for step 6 :
 
<pre>Eclipse using Yocto build tree toolchain in docker .
In Eclipse Console, check for running image and the file path after line "configure: loading site script" should match with SDK installation path for selected profile.
E.g:
[Running in image <crops/toolchain:latest>] </pre>
 
 
:: c) expected result for step 7 :
 
<pre>Eclipse using Yocto build tree toolchain.
In Eclipse Console, look for cmake command. 
E.g:
[Running in image <crops/toolchain:latest>] </pre>
 
 
 
 
 
 
== Eclipse-Yocto - Debug_Autotools_CROPS_build_tree_program ==
execute and debug Autotools CROPS build tree toolchain project in QEMU
 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_build_tree|Autotools_CROPS_build_tree]]
 
===execution===
 
: 1. Refer to test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]]. Repeat all steps in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] with similar expected results but changes to target project for steps 3 and 4 to project create in test case  [[#Eclipse-Yocto_-_Autotools_CROPS_build_tree|Autotools_CROPS_build_tree]].
 
 
 


    b) execute the script in terminal
    c) (optional) enter your preferred path to setup SDK
    d) press "Enter" -> press "y" -> press "Enter"


  4. Setup Eclipse to run Docker
a) In Eclipse workbench window, go to "Run" menu -> "Run configurations..." 
b) In "Configurations" window, go to "Run" menu -> right click "Run Docker Image"  -> new configuration
c) In "Configurations" window, select the new created configuration -> select "crops/poky:latest" for Image -> check "Keep STDIN open to console even if not attached (-i)"
d) In "Configurations" window, select "Volumes" tab, -> "Add..."
e) In "Data Volume" window, check "mount a host directory or host file" -> click "Directory" -> look for build tree path (path setup on step 2) -> copy build tree path and paste to Container path -> click "OK "
f) In "Configurations" window, click "Run"


    expected result:


        docker running in eclipse console and path mount correctly.
== Eclipse-Yocto - Run_Autotools_CROPS_build_tree_program ==
run Autotools CROPS build tree toolchain project in QEMU


[[File:example.jpg|frameless|caption]]
===prerequisites===
===Common Prerequisites===
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_build_tree|Autotools_CROPS_build_tree]]
: 1. Have a clone of poky:
:: <pre>$ git clone git://git.yoctoproject.org/poky</pre>
: 2. Check out the required commit using git:
:: <pre>$ git checkout [COMMIT_HASH]</pre>
: 3. Source the build environment to create the configuration files:
:: <pre>$ cd [POKY_PATH]</pre>
:: <pre>$ . oe-init-build-env</pre>
: 4. Open the conf/local.conf file:
:: <pre>$ vi conf/local.conf</pre>
:: Establish the machine to qemux86-64 by setting the line:
:: <pre>MACHINE = "qemux86-64"</pre>
: 5. Compile a minimal image:
:: <pre>$ bitbake core-image-minimal</pre>
: 6. Get and take note of the linux-yocto kernel version (only the first two numbers, for example: 4.10):
:: <pre>$ bitbake virtual/kernel -e | grep LINUX_VERSION</pre>
: 7. Create a layer to store kernel test metadata. For this task, you could use the bitbake-layers and its default recipe values:
:: <pre>$ cd [POKY_PATH]</pre>
:: <pre>$ bitbake-layers create-layer [LAYER-NAME]</pre>
:: Note: In the rest of this document "meta-kerneltest" is used as the [LAYER-NAME].
: 8. Create the recipe directory structure inside the created layer:
:: <pre>$ mkdir -p meta-kerneltest/recipes-kernel/linux/</pre>
: 9. Create a recipe append file inside the directory:
:: <pre>$ touch meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend</pre>
: 10. Copy the recipe file corresponding to the linux-yocto version inside the directory:
:: <pre>$ cp meta/recipes-kernel/linux/linux-yocto_[VERSION].bb meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb</pre>
: 11. Edit the linux-yocto-custom recipe:
:: <pre>$  vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb</pre>
:: Set the PV variable with the LINUX_VERSION variable value:
:: <pre>PV = "${LINUX_VERSION}"</pre>
: 12. Create directory "linux-yocto":
:: <pre>$ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto/</pre>
: 13. Create directory "linux-yocto-custom":
:: <pre>$ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto-custom/</pre>
: 14. Add the created layer to bblayers.conf. For this task, you could use the bitbake-layers script from inside the build directory:
:: <pre>$ cd build</pre>
:: <pre>$ bitbake-layers add-layer ../meta-kerneltest</pre>
===General Remarks===
: 1. As a suggestion, open another terminal in order to perform git commands.
: 2. Remember to source the environment and ensure your current work directory is [POKY_PATH]/build before using bitbake scripts and tools.
: 3. You can edit any required file with vim, emacs, or your preferred text editor.
: 4. If there is not a proper response after building an image, be sure to clean the shared state, and try again. To clean it, you can use:
:: <pre>$ bitbake virtual/kernel -c cleansstate</pre>
: 5. Be careful with the information added to recipe and recipe append files, using the same values -- including spaces-- to set a recipe variable value.
: 6. To ensure all the sources are correctly downloaded and the required taks are executed, ensure no shared states proxies are set on conf/local.conf.
: 7. Make sure to point to the correct linux-yocto version.


<br />
===execution===


==TC_KD_01 – Applying Patches==
: 1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
===Use Case===
As a developer, I want to be able to apply a single patch to the Linux kernel source.
===Prerequisites===
: 1. Generate the patch:
:: 1.1. Go to kernel source directory:
::: <pre>$ cd [POKY_PATH]/build/tmp/work-shared/qemux86-64/kernel-source</pre>
:: 1.2. Add some information at the end of the README file:
::: <pre>$ echo This is a test to apply a patch to the kernel. >> README</pre>
:: 1.3. Add the modified file to the patch:
::: <pre>$ git add README</pre>
:: 1.4. Commit the change:
::: <pre>$ git commit -s -m "KERNEL DEV TEST CASE"</pre>
:: 1.5. Format the patch:
::: <pre>$ git format-patch -1</pre>
===Steps===
: 1. Move the generated patch to the "linux-yocto" directory :
:: <pre>$ mv 0001-KERNEL-DEV-TEST-CASE.patch [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto/</pre>
: 2. Add the SRC_URI var with the patch to the linux-yocto_4%.bbappend file:
:: <pre>$ cd [POKY_PATH]</pre>
:: <pre>$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend</pre>
:: Add the following lines and save and close the file:
:: <pre>SRC_URI += "file://0001-KERNEL-DEV-TEST-CASE.patch"</pre>
:: <pre>FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"</pre>
: 3. Delete the README file:
:: <pre>$ rm build/tmp/work-shared/qemux86-64/kernel-source/README</pre>
: 4. Clean the shared state:
:: <pre>$ cd build</pre>
:: <pre>$ bitbake virtual/kernel -c cleansstate</pre>
: 5. Build the patch:
:: <pre>$ bitbake virtual/kernel -c patch</pre>
: 6. Verify the patch is applied properly:
:: <pre>$ tail tmp/work-shared/qemux86-64/kernel-source/README</pre>
===Expected Results===
: 1. Bitbake should complete the build without errors.
: 2. The README file should exist.
: 3. The patch changes should be displayed at the end of the file.


<br />
: 2. Expand "C/C++ Remote Application" -> select configuration create in test case [[#Eclipse-Yocto_-_Debug_Autotools_CROPS_build_tree_program|Debug_Autotools_CROPS_build_tree_program]]. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case [[#Eclipse-Yocto_-_debug_Cmake_Yocto_SDK_program|debug_Cmake_Yocto_SDK_program]] but changes to target project for steps 3 and 4 to project create in test case [[#Eclipse-Yocto_-_Autotools_CROPS_build_tree|Autotools_CROPS_build_tree]].


==TC_KD_02 – linux-yocto Local Source==
: 3. In "Run configurations" window, click "Run"
===Use Case===
As a developer, I want to to be able to work with my own Linux kernel sources.
===Prerequisites===
: 1. Have a recipe append file for linux-yocto (created previously).
: 2. Clone in a specific directory (different of poky):
:: <pre>$ cd [KERNEL_REPOS_PATH]</pre>
:: <pre>$ git clone git://git.yoctoproject.org/yocto-kernel-cache</pre>
:: <pre>$ git clone git://git.yoctoproject.org/linux-yocto-[VERSION]</pre>
:: <pre>$ For Linux version 4.14 and onwards, use following command</pre>
:: <pre>$ git clone git://git.yoctoproject.org/linux-yocto </pre> 
: 3. Go to the cloned yocto-kernel-cache directory:
:: <pre>$ cd [KERNEL_REPOS_PATH]/yocto-kernel-cache</pre>
:: Checkout the required yocto-version branch:
:: <pre>$ git checkout yocto-[VERSION]  # For example: $ git checkout yocto-4.8</pre>
: 4. Go to the linux-yocto-[VERSION] directory:
:: <pre>$ cd [KERNEL_REPOS_PATH]/linux-yocto-[VERSION]</pre>
:: Checkout the standard/base branch:
:: <pre>$ git checkout standard/base</pre>
:: <pre>$ For Linux version 4.14 and onwards, use following command</pre>
:: <pre>$ git checkout v[VERSION]/standard/base</pre>
: 5. Edit the conf/local.conf file in the repository where you are working for execution:
:: <pre>$ cd [POKY_PATH]</pre>
:: <pre>$ vi build/conf/local.conf</pre>
:: Set the following line:
:: <pre>PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"</pre>


===Steps===
::: expected result:  
: 1. Edit the linux-yocto recipe append file previously created at your "meta-kerneltest" directory:
:: <pre>$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend</pre>
:: Set the SRC_URI variable with the following information:
:: <pre>SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \</pre>
:: <pre>          git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"</pre>
: 2. Clean the shared state:
:: <pre>$ cd build</pre>
:: <pre>$ bitbake virtual/kernel -c cleansstate</pre>
: 3. Build the kernel:
:: <pre>$ bitbake virtual/kernel</pre>
: 4. Verify the changes by executing:
:: <pre>$ bitbake virtual/kernel -e | grep "name=machine;branch"</pre>
===Expected Results===
: 1. The changes should be performed successfully.
: 2. The build should be completed successfully.
: 3. The bitbake variables output should display that the SRC_URI variable is now:
:: <pre>SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \</pre>
:: <pre>          git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"</pre>


<br />
<pre>successful run the program. Results shows in eclipse console. </pre>
==TC_KD_03 – linux-yocto Custom Local Source==
===Use Case===
As a developer, I want to be able to work with my own local sources for a customized linux-yocto kernel.
===Prerequisites===
: 1. Make sure you have the custom recipe file corresponding to the latest linux-yocto version:
:: <pre>[POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb</pre>
:: This file should originate from [POKY_PATH]/meta/recipes-kernel/linux/linux-yocto_[VERSION].bb
: 2. Edit the linux-yocto-custom recipe file:
:: <pre>$ cd [POKY_PATH]</pre>
:: <pre>$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb</pre>
:: Set the SRC_URI variable with the following information:
:: <pre>SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \</pre>
:: <pre>          git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"</pre>
===Steps===
: 1. Go to the poky build directory:
:: <pre>$ cd [POKY_PATH]/build</pre>
: 2. At conf/local.conf add the following variable:
:: <pre>PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"</pre>
: 3. Clean the shared state:
:: <pre>$ bitbake virtual/kernel -c cleansstate</pre>
: 4. Compile the kernel:
:: <pre>$ bitbake virtual/kernel</pre>
: 5. Verify the changes by executing:
:: <pre>$ bitbake virtual/kernel -e | grep -E "PREFERRED_PROVIDER_virtual/kernel|SRC_URI"</pre>

Latest revision as of 07:29, 10 December 2018

Eclipse-Yocto - Launch_Eclipse_Yocto_plugin

Install and launch Eclipse Yocto plugin on Eclipse

prerequisites

-

execution

1. Install "Eclipse IDE for C/C++ Developers" Photon release (4.8.0)
a) Go to https://www.eclipse.org/downloads/packages/release click "Photon" -> "R Packages"
b) Locate for "Eclipse IDE for C/C++ Developers"
c) Click on 32-bit or 64-bit to download the build for your OS
d) Run "tar xf" to extract the downloaded archive
e) Run "eclipse/eclipse" to start Eclipse
2. Optional steps for host machine behind proxy Network
a) In Eclipse workbench window, go to "Window "menu -> "Preferences...".
b) In "Preferences" dialog, go to "General" -> "Network Connections", set "Active Provider" to "Manual". In "Proxy entries" table, select HTTP and click "Edit" -> enter host "your.proxy.com" and port port number, click OK. Repeat for HTTPS. Click "Apply and Close" to close Preferences dialog.
c) Go to "File" menu -> "Restart" to restart Eclipse for proxy settings to take effect.
3. Install Eclipse Yocto plugins
a) Download the eclipse yocto plugin archive file
b) In Eclipse workbench window, go to "Help" menu -> "Install New Software..."
c) In "Install" dialog, click "Add..." button
d) In "Add Repository" dialog, enter "Eclipse Yocto" for (repository) Name, click "Archive..."
e) In "Repository archive" browse dialog, select the downloaded Eclipse-Yocto repository archive
f) Back in Add Repository dialog, click "Add"
g) Back in "Install" dialog, make sure "Work with:" is set to "Eclipse Yocto" repository, check all available plugin, click "Next" > and verify plugins/features name/version, click "Next" > and accept license agreement, click "Finish"
h) If "Security Warning" dialog appears, click "OK" to install unsigned content.
i) In "Software Updates" dialog, click "Yes" to restart Eclipse to complete Eclipse Yocto plugins installation.
4. In Eclipse workbench window, go to "Window" menu -> "Preferences".
expected result:
Eclipse Yocto plugins installed and running successfully, observe that "Yocto Project (alpha)" appear in "Preferences" dialog.

Eclipse-Yocto - Setup_Development_Environment

Setup Development environment required by upcoming test cases

prerequisites

1. Launch_Eclipse_with_Eclipse_Yocto_plugin

execution

1. Setup Docker, Crops/Poky and Crops/Toolchain image
a) follow the setup instruction here :
https://docs.docker.com/install/linux/docker-ce/ubuntu/
b) run below command to download Crops/Toolchain Images
docker pull crops/toolchain 
docker pull crops/poky
2. Setup build tree ( if you familiar with bitbake tools you can build any target machine image at your preferences)
a) clone poky and checkout to working branch
git clone git://git.yoctoproject.org/poky-contrib
git checkout <commit tag for latest milestone>
b) run crops/poky and initiate build environment
docker run -it --rm -v </path/to/poky>:/workdir crops/poky --worldir=/workdir
source oe-init-build-env
c) open another window/terminal to edit poky local.conf file. add below line to poky/build/conf/local.conf
EXTRA_IMAGE_FEATURES += "eclipse-debug"
EXTRA_IMAGE_FEATURES += "tools-sdk"
EXTRA_IMAGE_FEATURES += "ssh-server-openssh"
d) back to terminal in use in step 3.b, run below command.
bitbake core-image-sato-sdk
bitbake meta-ide-support
3. Setup YP SDK toolchain
a) Look for SDK toolchain script created in step 2 in path poky/build/tmp/deploy/sdk/
E.g:  /poky/build/tmp/deploy/sdk/poky-glibc-x86_64-meta-toolchain-core2-64-toolchain-2.5+snapshot.sh
b) execute the script in terminal
c) (optional) enter your preferred path to setup SDK
d) press "Enter" -> press "y" -> press "Enter"
4. Setup Eclipse to run Docker
a) In Eclipse workbench window, go to "Run" menu -> "Run configurations..."
b) In "Configurations" window, go to "Run" menu -> right click "Run Docker Image" -> new configuration
c) In "Configurations" window, select the new created configuration -> select "crops/poky:latest" for Image -> check "Keep STDIN open to console even if not attached (-i)"
d) In "Configurations" window, select "Volumes" tab, -> "Add..."
e) In "Data Volume" window, check "mount a host directory or host file" -> click "Directory" -> look for build tree path (path setup on step 2) -> copy build tree path and paste to Container path -> click "OK "
f) In "Configurations" window, click "Run"
expected result:
docker running in eclipse console and path mount correctly.
5. run QEMU in docker using eclipse console
a) In Eclipse Console window, switch to docker console (docker run on test case Setup_Development_Environment )
b) In Eclipse Console, cd to poky path
c) In Eclipse Console, initiate build environment
source oe-init-build-env
d) run QEMU
runqemu <image> slirp nographic qemuparams="-redir tcp:2345::2345" 

E.g :
runqemu qemux86 slirp nographic qemuparams="-redir tcp:2345::2345"
expected result:
Qemu running in eclipse console




Eclipse-Yocto - Setup_Development_Profile

Setup Development Profile for different toolchain

prerequisites

1. Launch_Eclipse_with_Eclipse_Yocto_plugin
2. Setup_Development_Environment

execution

1. In Eclipse workbench window, go to "Preferences" -> "Yocto Project (alpha)".
a) If you setup SDK toolchain (test case Setup_Development_Environment step 3) using default path, click on profile dropdown menu and select a profile.expected result:
Profile dropdown menu have default profile created and able to select it.
b) If you setup SDK toolchain using custom path, expected result:
Profile dropdown menu disabled.
2. Create Yocto SDK toolchain Profile
a) In "Preferences" Window -> click "New".
b) In "Create new profile" Window -> insert an identical profile name -> click "Ok".
c) In "Preferences" Window -> Select "SDK installation" -> click "Edit" -> locate to SDK path setup on Setup_Development_Environment step 3 -> click "OK" -> click "Apply".
3. Create Yocto build tree toolchain Profile
a) take similar action as steps 2.a and 2.b
b) In "Preferences" Window -> Select "Build directory" -> click "Edit" -> locate to poky/build/tmp (setup on Setup_Development_Environment step 1) -> click "OK" -> click "Apply".
4. Create Yocto SDK toolchain Docker Profile
a) take similar action as steps 2.a and 2.b
b) In "Preferences" Window -> check "Build and launch using container" -> Select SDK installation -> click "Edit"
c) In prompt window, select Mount a host directory -> click "Browse..." -> locate to SDK path setup on Setup_Development_Environment step 3 -> copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply".
5. Create Yocto build tree toolchain Docker Profile
a) take similar action as steps 2.a and 2.b
b) In "Preferences" Window -> check "Build and launch using container" -> Select "Build directory" -> click "Edit"
c) In prompt window, select Mount a host directory -> click "Browse..." -> locate to SDK path setup on Setup_Development_Environment step 1 -> copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply".
expected result:
4 new Profile created and available in cross development profile dropdown menu.

Eclipse-Yocto - Manage_Development_Profile

switch between profile, rename and remove existing profile

prerequisites

1. Setup_Development_Profile

execution

1. Follow test case Setup_Development_Profile steps 1 and 2.
2. Rename Profile
a) In "Preferences" Window(make sure the profile create in step 1 selected in profile dropdown menu) ->click "Rename..."
b) In Rename Profile Window insert a new name -> OK
expected result:
Profile name updated.
3. Remove Profile
a) In "Preferences" Window (make sure the profile used in step 2 selected in profile dropdown menu) -> click "Remove..."
expected result:
Profile removed from selection in profile dropdown menu.
4. Switch Profile
a) click on profile dropdown menu, select any profile name ( other than the showing profile)
expected result:
Profile dropdown menu updated to select profile. Toolchain section and QEMU section updated accordingly (match with the profile created in test case Setup_Development_Environment).

Eclipse-Yocto - Configure_project_as_YP_Project

configure a project into yocto project's project

prerequisites

1. Setup_Development_Profile

execution

1. In Eclipse workbench window, go to "New" -> "PreferencesC/C++ Project".
2. Select "C Managed Build" -> Next.
3. In Project type expand "GNU Autotools" -> select "Hello World ANSI C Autotools Project" -> in Toolchain, select "GNU Autotools Toolchain" -> insert a project name -> Click "Finish".
4. In project explorer, select the new created project -> right click -> Configure -> select Configure as Yocto Project Autotools project (alpha).
5. In "Properties" windows, in profile dropdown menu, select Yocto SDK toolchain Profile created in test case Setup_Development_Profile step 2 -> click "Apply and Close".
expected result:
Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "Autotools_Project [SDK_Profile]"




Eclipse-Yocto - Add_Yocto_Project_Nature

create cmake project and add yocto project nature to project

prerequisites

1. Setup_Development_Profile

execution

1. In Eclipse workbench window, go to "New" -> "PreferencesC/C++ Project".
2. Select "C Managed Build" -> Next.
3. In Project type expand "CMake (alpha)" -> select Empty Project -> in Toolchian select "Yocto Project SDK CMake Toolchian (alpha)" -> insert a project name -> Click "Finish".
4. In project explorer, select the created new project -> right click -> Properties.
5. In "Properties" windows, select Project Natures -> "Add".
6. If eclipse prompt for "Confirm Project Nature update" click "Ok"
7. In "Select Nature" windows, select "Yocto Project Nature (alpha)" -> click "Ok"
8. In "Properties" windows, click "Apply and Close".
9. In project explorer, select the same project -> right click -> Properties.
expected result:
"Yocto Project (alpha)" shows in Properties.




Eclipse-Yocto - Cmake_Yocto_SDK

build CMake project using Yocto SDK toolchain

prerequisites

1. Setup_Development_Profile
2. Add_Yocto_Project_Nature

execution

1. In project explorer, select the project created in test case Add_Yocto_Project_Nature -> right click -> Properties.
2. In "Properties" windows, select "Yocto Project (alpha)" -> in profile dropdown menu, select Yocto SDK toolchain Profile created in test case Setup_Development_Profile step 2 -> click "Apply and Close".
expected result:
Profile name shows in bracket at the end of the project name In Project Explorer.
E.g: "CMake_Project [SDK_Profile]"
3. In project explorer, select the same project -> right click -> select "Clean Project".
4. if Eclipse prompt for "Regenerate CMake Build Files" windows, click "Yes"
5. In project explorer, select the same project -> right click -> select "Regenerate CMake build files". If prompt for "Regenerate CMake Build Files", click "Yes".
expected result:
Eclipse using Yocto SDK toolchain. 
In Eclipse Console, the file path after line "Check for working C compiler:" should match with SDK installation path for selected profile. 
E.g: 
Check for working C compiler: /opt/poky/2.5+snapshot/sysroots/x86_64-pokysdk-linux/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works
6. In project explorer, select the same project -> right click -> select "Build Project"
expected result:
Eclipse using Yocto SDK toolchain.
In Eclipse Console, look for cmake command. 
E.g: 
/opt/poky/2.5+snapshot/sysroots/x86_64-pokysdk-linux/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0




Eclipse-Yocto - Debug_Cmake_Yocto_SDK_program

execute and debug CMake Yocto SDK toolchain project in QEMU

prerequisites

1. Setup_Development_Profile
2. Cmake_Yocto_SDK

execution

1. In Eclipse workbench window, click "Run" -> select "Debug Configurations..."
2. In "Debug Configuration" window, select and right click on "C/C++ Remote Application" -> select "New Configuration"
3. In "Debug Configuration" window "Main" tab, insert a configuration name -> click "Browse..." select project created in test case Cmake_Yocto_SDK -> "Ok"
4. In "Debug Configuration" window "Main" tab, insert path to .out file for project create in Cmake_Yocto_SDK to "C/C++ Application:"
E.g:  
"src/a.out"
5. In "Debug Configuration" window "Main" tab, click "New..." for connection
6. In "Create a new connection" window, select "SSH" -> "OK"
7. In new window, insert a connection name -> insert "172.17.0.2" for Host -> insert "root" for User. Host might be differ depend on running docker on your machine.
8. In "Edit configuration" window, insert a connection name -> insert "172.17.0.2" for Host -> insert "root" for User. Host might be differ depend on running docker on your machine.
9. In "Edit configuration" window, expand "Advanced" insert "2222" for port -> click "Finish"
10. In "Debug Configuration" window, click "Debug". if prompt for "Confirm Perspective Switch" click "Switch"
expected result:
eclipse switch to debugging mode.
11. In Eclipse, click "F8" to execute the program.
expected result:
successful execute program.




Eclipse-Yocto - Run_Cmake_Yocto_SDK_program

run CMake Yocto SDK toolchain project in QEMU

prerequisites

1. Setup_Development_Profile
2. Cmake_Yocto_SDK

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Cmake_Yocto_SDK_program. if the configuration does not appear, follow steps 2 to 9 in test case Debug_Cmake_Yocto_SDK_program to create new configuration.
3. In "Run configurations" window, click "Run"
expected result:
successful execute program. Results shows in eclipse console.




Eclipse-Yocto - CMake_Yocto_build_tree

build Cmake project using Yocto SDK toolchain

prerequisites

1. Setup_Development_Profile
2. Add_Yocto_Project_Nature

execution

1. Refer to test case Cmake_Yocto_SDK. Repeat all the steps in test case Cmake_Yocto_SDK with below settings and expected result.
a) In Step 2 select Yocto build tree toolchain Profile instead. (the profile created in test case Setup_Development_Profile step 3)
b) expected result for step 5 :
Eclipse using Yocto build tree toolchain.  
In Eclipse Console, the file path after line "Check for working C compiler:" should match with  Build directory for selected profile. 
E.g:  
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works
c) expected result for step 6 :
Eclipse using Yocto build tree toolchain. 
In Eclipse Console, look for cmake command. 
E.g: 
/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0




Eclipse-Yocto - Debug_Cmake_Yocto_build_tree_program

execute and debug CMake Yocto build tree toolchain project in QEMU

prerequisites

1. CMake_Yocto_build_tree

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case CMake_Yocto_build_tree.




Eclipse-Yocto - Run_Cmake_Yocto_build_tree_program

run CMake Yocto build tree toolchain project in QEMU

prerequisites

1. CMake_Yocto_build_tree

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Cmake_Yocto_build_tree_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case CMake_Yocto_build_tree.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Cmake_CROPS_SDK

enable docker container setting and build Cmake project using Yocto SDK toolchain in docker

prerequisites

1. Setup_Development_Profile
2. Add_Yocto_Project_Nature

execution

1. In project explorer, select the project created in test case Add_Yocto_Project_Nature -> right click -> Properties.
2. In "Properties" windows, expand "C/C++ Build" -> select "Settings" -> select "Container Settings" tab.
3. In "Container Settings" tab, check "Build inside Docker Image", select a connection for docker. In Images field, select "crops/toolchain:latest".
4. In "Properties" windows, select "Yocto Project (alpha)" -> in profile dropdown menu, select Yocto SDK toolchain Docker Profile created in test case Setup_Development_Profile step 4 -> click "Apply and Close"
expected result:
Profile name shows in bracket at the end of the project name In Project Explorer. 
E.g: "CMake_Project [SDK_Docker_Profile]"
5. In project explorer, select the same project -> right click -> select "Clean Project"
6. if Eclipse prompt for "Regenerate CMake Build Files" windows, click "Yes"
7. In project explorer, select the same project -> right click -> select "Regenerate CMake build files". If prompt for "Regenerate CMake Build Files", click "Yes".
expected result:
Cmake command run in docker and using Yocto SDK toolchain. 
In Eclipse Console look for running image and file path after line "Check for working C compiler:".
[Running in image <crops/toolchain:latest>] 
E.g:  
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works
8. In project explorer, select the same project -> right click -> select "Build Project"
expected result:
Make command run in docker and using Yocto SDK toolchain. 
E.g: 
[Running in image <crops/toolchain:latest>] 
make all 
/Data/opt/poky/2.5.1__andromeda_qemux86_64_sato_meta_toolchain/sysroots/x86_64-pokysdk-linux/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0




Eclipse-Yocto - Debug_Cmake_CROPS_SDK_program

execute and debug CMake CROPS SDK toolchain project in QEMU

prerequisites

1. Cmake_CROPS_SDK

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Cmake_CROPS_SDK.




Eclipse-Yocto - Run_Cmake_CROPS_SDK_program

run CMake CROPS SDK toolchain project in QEMU

prerequisites

1. Cmake_CROPS_SDK

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Cmake_CROPS_SDK_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Cmake_CROPS_SDK.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Cmake_CROPS_build_tree

Cmake project using Yocto build tree toolchain in docker

prerequisites

1. Setup_Development_Profile
2. Add_Yocto_Project_Nature

execution

1. Refer to test case Cmake_CROPS_SDK. Repeat all the steps in test case Cmake_Yocto_SDK with below settings and expected result.
a) In Step 4 select Yocto build tree toolchain Docker Profile instead. (the profile created in test case Setup_Development_Profile step 5)
b) expected result for step 5 :
Cmake command run in docker and using Yocto build tree toolchain. 
In Eclipse Console, look for running image and the file path after line "Check for working C compiler:" should match with Build directory for selected profile. 
E.g:  
[Running in image <crops/toolchain:latest>] 
...... 
Check for working C compiler: /Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/x86_64-poky-linux/x86_64-poky-linux-gcc -- works
c) expected result for step 6 :
Make run in docker and using Yocto build tree toolchain.  
In Eclipse Console, look for running image and path for cmake command. 
E.g:  
[Running in image <crops/toolchain:latest>]
make all 
...... 
/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot-native/usr/bin/cmake -H/Data/runtime-Eclipse-Yocto/cmake -B/Data/runtime-Eclipse-Yocto/cmake/Debug --check-build-system CMakeFiles/Makefile.cmake 0




Eclipse-Yocto - Debug_Cmake_CROPS_build_tree_program

execute and debug CMake CROPS build tree toolchain project in QEMU

prerequisites

1. Cmake_CROPS_build_tree

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Cmake_CROPS_build_tree.




Eclipse-Yocto - Run_Cmake_CROPS_build_tree_program

run CMake CROPS build tree toolchain project in QEMU

prerequisites

1. Cmake_CROPS_build_tree

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Cmake_CROPS_build_tree_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Cmake_CROPS_build_tree.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Autotools_Yocto_SDK

build autotools project using Yocto SDK toolchain

prerequisites

1. Setup_Development_Profile
2. Configure_project_as_YP_Project

execution

1. In project explorer, select the project created in test case Configure_project_as_YP_Project -> right click -> Properties.
2. In "Properties" windows, in profile dropdown menu, select Yocto SDK toolchain Profile created in test case Setup_Development_Profile step 2 -> click "Apply and Close".
3. In project explorer, select the project created in test case Configure_project_as_YP_Project -> right click -> select "Clean Project".
4. In project explorer, select the same project -> right click -> select "Reconfigure Project"
expected result:
Eclipse configure project using Yocto SDK toolchain.  
In Eclipse Console, the file path after line "configure: loading site script" should match with  Build directory for selected profile.  
E.g:  
configure: loading site script /opt/poky/2.5+snapshot/site-config-core2-64-poky-linux
5. In project explorer, select the same project -> right click -> select "Build Project"
expected result:
Eclipse make using Yocto SDK toolchain. 
E.g: 
make all 
Making all in src 
make[1]: Entering directory '/Data/runtime-Eclipse-Yocto/autotools-hw/src' 
x86_64-poky-linux-gcc  -m64 -march=core2 -mtune=core2 -msse3 -mfpmath=sse --sysroot=/opt/poky/2.5+snapshot/sysroots/core2-64-poky-linux -DPACKAGE_NAME=\"autotools-hw\" -DPACKAGE_TARNAME=\"autotools-hw\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"autotools-hw\ 1.0\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"autotools-hw\" -DVERSION=\"1.0\" -I. -O2 -pipe -g -feliminate-unused-debug-types  -MT autotools-hw.o -MD -MP -MF .deps/autotools-hw.Tpo -c -o autotools-hw.o autotools-hw.c




Eclipse-Yocto - Debug_Autotools_Yocto_SDK_program

execute and debug Autotools Yocto SDK toolchain project in QEMU

prerequisites

1. Autotools_Yocto_SDK

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Autotools_Yocto_SDK.




Eclipse-Yocto - Run_Autotools_Yocto_SDK_program

run Autotools Yocto SDK toolchain project in QEMU

prerequisites

1. Autotools_Yocto_SDK

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Autotools_Yocto_SDK_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Autotools_Yocto_SDK.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Autotools_Yocto_build_tree

build autotools project using Yocto build tree toolchain

prerequisites

1. Setup_Development_Profile
2. Configure_project_as_YP_Project

execution

1. Refer to test case Autotools_Yocto_SDK. Repeat all the steps in test case Autotools_Yocto_SDK with below settings and expected result.
a) In Step 2 select Yocto build tree toolchain Profile instead. (the profile created in test case Setup_Development_Profile step 3)
b) expected result for step 4 :
Eclipse configure project using Yocto build tree toolchain. 
In Eclipse Console, look for configure command, all the parameter should match with Build directory for selected profile. 
E.g:  
sh -c "/Data/runtime-Eclipse-Yocto/autotools-hw/configure --target=x86_64-poky-linux --host=x86_64-poky-linux --build=x86_64-linux --with-libtool-sysroot=/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot"
c) expected result for step 5 :
Eclipse make using Yocto SDK toolchain.  
E.g: 
make all 
Making all in src
make[1]: Entering directory '/Data/runtime-Eclipse-Yocto/autotools-hw/src'
x86_64-poky-linux-gcc  -m64 -march=core2 -mtune=core2 -msse3 -mfpmath=sse -fstack-protector-strong  -D_FORTIFY_SOURCE=2 -Wformat -Wformat-security -Werror=format-security --sysroot=/Data/poky/build/tmp/work/core2-64-poky-linux/meta-ide-support/1.0-r3/recipe-sysroot -DPACKAGE_NAME=\"autotools-hw\" -DPACKAGE_TARNAME=\"autotools-hw\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"autotools-hw\ 1.0\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"autotools-hw\" -DVERSION=\"1.0\" -I. -O2 -pipe -g -feliminate-unused-debug-types  -MT autotools-hw.o -MD -MP -MF .deps/autotools-hw.Tpo -c -o autotools-hw.o autotools-hw.c




Eclipse-Yocto - Debug_Autotools_Yocto_build_tree_program

execute and debug Autotools Yocto build tree toolchain project in QEMU

prerequisites

1. Autotools_Yocto_build_tree

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Autotools_Yocto_build_tree.




Eclipse-Yocto - Run_Autotools_Yocto_build_tree_program

run Autotools Yocto build tree toolchain project in QEMU

prerequisites

1. Autotools_Yocto_build_tree

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Autotools_Yocto_build_tree_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Autotools_Yocto_build_tree.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Autotools_CROPS_SDK

build Autotools project using Crops SDK toolchain in docker

prerequisites

1. Setup_Development_Profile
2. Configure_project_as_YP_Project

execution

1. In project explorer, select the project use in test case Autotools_Yocto_SDK -> right click -> Properties.
2. In "Properties" windows, expand "C/C++ Build" -> select "Settings" -> select "Container Settings" tab.
3. In "Container Settings" tab, check "Build inside Docker Image", select a connection for docker. In Images field, select "crops/toolchain:latest".
4. In "Properties" windows, select "Yocto Project (alpha)" -> in profile dropdown menu, select Yocto SDK toolchain Docker Profile created in test case Autotools_Yocto_SDK steps 4 -> click "Apply and Close"
expected result:
Profile name shows in bracket at the end of the project name In Project Explorer. 
E.g: "Autotools_Project [SDK_Docker_Profile]"
5. In project explorer, select the same project -> right click -> select "Clean Project"
6. In project explorer, select the same project -> right click -> select "Reconfigure Project"
expected result:
Eclipse run configure command in docker using Yocto SDK toolchain. 
In Eclipse Console, check for running image and the file path after line "configure: loading site script" should match with SDK installation path for selected profile. 
<pre>E.g:  
[Running in image <crops/toolchain:latest>]
...... 
configure: loading site script /Data/opt/poky/2.5.1__andromeda_qemux86_64_sato_meta_toolchain/site-config-core2-64-poky-linux
7. In project explorer, select the same project -> right click -> select "Build Project"
expected result:
Make command run in docker using Yocto SDK toolchain.
In Eclipse Console, check for running image 

[Running in image <crops/toolchain:latest>]




Eclipse-Yocto - Debug_Autotools_CROPS_SDK_program

execute and debug Autotools CROPS SDK toolchain project in QEMU

prerequisites

1. Autotools_CROPS_SDK

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Autotools_CROPS_SDK.




Eclipse-Yocto - Run_Autotools_CROPS_SDK_program

run Autotools CROPS SDK toolchain project in QEMU

prerequisites

1. Autotools_CROPS_SDK

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Autotools_CROPS_SDK_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Autotools_CROPS_SDK.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.




Eclipse-Yocto - Autotools_CROPS_build_tree

build Autotools project using Yocto build tree toolchain in docker

prerequisites

1. Setup_Development_Profile
2. Configure_project_as_YP_Project

execution

1. Refer to test case Autotools_CROPS_SDK. Repeat all the steps in test case Autotools_CROPS_SDK with below settings and expected result.
a) In Step 4 select Yocto build tree toolchain Docker Profile instead. (the profile created in test case Setup_Development_Profile step 5)
b) expected result for step 6 :
Eclipse using Yocto build tree toolchain in docker . 
In Eclipse Console, check for running image and the file path after line "configure: loading site script" should match with SDK installation path for selected profile.
E.g:
[Running in image <crops/toolchain:latest>]


c) expected result for step 7 :
Eclipse using Yocto build tree toolchain. 
In Eclipse Console, look for cmake command.   
E.g: 
[Running in image <crops/toolchain:latest>]




Eclipse-Yocto - Debug_Autotools_CROPS_build_tree_program

execute and debug Autotools CROPS build tree toolchain project in QEMU

prerequisites

1. Autotools_CROPS_build_tree

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program. Repeat all steps in test case debug_Cmake_Yocto_SDK_program with similar expected results but changes to target project for steps 3 and 4 to project create in test case Autotools_CROPS_build_tree.




Eclipse-Yocto - Run_Autotools_CROPS_build_tree_program

run Autotools CROPS build tree toolchain project in QEMU

prerequisites

1. Autotools_CROPS_build_tree

execution

1. In Eclipse workbench window, click "Run" -> select "Run Configurations..."
2. Expand "C/C++ Remote Application" -> select configuration create in test case Debug_Autotools_CROPS_build_tree_program. If the configuration does not appear, create new configuration by following steps 2 to 9 in test case debug_Cmake_Yocto_SDK_program but changes to target project for steps 3 and 4 to project create in test case Autotools_CROPS_build_tree.
3. In "Run configurations" window, click "Run"
expected result:
successful run the program. Results shows in eclipse console.
Retrieved from "https://wiki.yoctoproject.org/wiki/index.php?title=Eclipse_Yocto_Test_Cases&oldid=45195"