Eclipse Yocto Test Cases: Difference between revisions

From Yocto Project
Jump to navigationJump to search
No edit summary
 
(8 intermediate revisions by the same user not shown)
Line 1: Line 1:
== eclipse-yocto - Launch_Eclipse_with_Eclipse_Yocto_plugin ==
== Eclipse-Yocto - Launch_Eclipse_Yocto_plugin ==
Install and launch Eclipse Yocto plugin on Eclipse
Install and launch Eclipse Yocto plugin on Eclipse


Line 18: Line 18:
:: 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.   
:: 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.  
:: c) Go to "File" menu -> "Restart" to restart Eclipse for proxy settings to take effect.  


: 3. Install Eclipse Yocto plugins   
: 3. Install Eclipse Yocto plugins   
Line 27: Line 26:
:: e) In "Repository archive" browse dialog, select the downloaded Eclipse-Yocto repository archive   
:: e) In "Repository archive" browse dialog, select the downloaded Eclipse-Yocto repository archive   
:: f) Back in Add Repository dialog, click "Add"   
:: f) Back in Add Repository dialog, click "Add"   
:: g) Back in "Install" dialog, make sure "Work with:" is set to "Eclipse Yocto" repository, tick "Yocto Project Documentation Plug-in" and "Yocto Project SDK Plug-in", click "Next" > and verify plugins/features name/version, click "Next" > and accept license agreement, click "Finish"   
:: 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"   
 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>update plugin to select  >>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
:: h) If "Security Warning" dialog appears, click "OK" to install unsigned content.   
:: 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.
:: i) In "Software Updates" dialog, click "Yes" to restart Eclipse to complete Eclipse Yocto plugins installation.
Line 42: Line 36:
<pre>Eclipse Yocto plugins installed and running successfully, observe that "Yocto Project (alpha)" appear in "Preferences" dialog. </pre>
<pre>Eclipse Yocto plugins installed and running successfully, observe that "Yocto Project (alpha)" appear in "Preferences" dialog. </pre>


 
== Eclipse-Yocto - Setup_Development_Environment ==
 
== eclipse-yocto - Setup_Development_Environment ==
Setup Development environment required by upcoming test cases
Setup Development environment required by upcoming test cases


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]
: 1. [[#Eclipse-Yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]


===execution===  
===execution===  
Line 59: Line 51:
:: 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/toolchain  
docker pull crops/poky  </pre>
docker pull crops/poky  </pre>


Line 65: Line 57:
:: a) clone poky and checkout to working branch
:: a) clone poky and checkout to working branch


<pre>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 </pre>
git checkout <commit tag for latest milestone> </pre>
   
   
:: b) run crops/poky and initiate build environment  
:: b) run crops/poky and initiate build environment  
Line 81: Line 73:
:: d) back to terminal in use in step 3.b, run below command.  
:: d) back to terminal in use in step 3.b, run below command.  


<pre>bitbake core-image-sato
<pre>bitbake core-image-sato-sdk
bitbake meta-ide-support
bitbake meta-ide-support</pre>
bitbake meta-toolchain</pre>


: 3. Setup YP SDK toolchain
: 3. Setup YP SDK toolchain
:: a) Look for SDK toolchain script created in steps 2 in path poky/build/tmp/deploy/sdk/
:: 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>
<pre>E.g:  /poky/build/tmp/deploy/sdk/poky-glibc-x86_64-meta-toolchain-core2-64-toolchain-2.5+snapshot.sh</pre>
Line 106: Line 97:
<pre>docker running in eclipse console and path mount correctly. </pre>
<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"


== eclipse-yocto - Setup_Development_Profile ==
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
Setup Development Profile for different toolchain


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]  
: 1. [[#Eclipse-Yocto_-_Launch_Eclipse_with_Eclipse_Yocto_plugin|Launch_Eclipse_with_Eclipse_Yocto_plugin]]  
: 2. [[#eclipse-yocto_-_Setup_Development_Environment|Setup_Development_Environment]]
: 2. [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Environment]]


===execution===  
===execution===  


: 1. In Eclipse workbench window, go to "Preferences" -> "Yocto Project (alpha)".
: 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:  
:: 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>
<pre>Profile dropdown menu have default profile created and able to select it.</pre>
Line 129: Line 141:
:: a) In "Preferences" Window -> click "New".   
:: a) In "Preferences" Window -> click "New".   
:: b) In "Create new profile" Window -> insert an identical profile name -> click "Ok".   
:: 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 step 1 -> click "OK" -> click "Apply".   
:: 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 SDK toolchain Docker Profile  
: 3. Create Yocto build tree toolchain Profile  
:: a) take similar action as steps 2.a and 2.b
:: 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"
:: 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".   
:: c) In prompt window, select Mount a host directory -> click "Browse..." -> locate to SDK path setup on step 1 ->  copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply".   


: 4. Create Yocto build tree toolchain Profile  
: 4. Create Yocto SDK toolchain Docker Profile  
:: a) take similar action as steps 2.a and 2.b
:: 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 step 3) -> click "OK" -> click "Apply".   
:: 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  
: 5. Create Yocto build tree toolchain Docker Profile  
:: a) take similar action as steps 2.a and 2.b
:: 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"
:: 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 step 3 ->  copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply".   
:: 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:  
::: expected result:  
Line 149: Line 161:
<pre>4 new Profile created and available in cross development profile dropdown menu.</pre>
<pre>4 new Profile created and available in cross development profile dropdown menu.</pre>


 
== Eclipse-Yocto - Manage_Development_Profile ==
 
== eclipse-yocto - Manage_Development_Profile ==
switch between profile, rename and remove existing profile
switch between profile, rename and remove existing profile


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Environment|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Profile]]


===execution===  
===execution===  


: 1. take similar action as test case [[#eclipse-yocto_-_Setup_Development_Environment|Setup_Development_Profile]] step 1 and step 2
: 1. Follow test case [[#Eclipse-Yocto_-_Setup_Development_Environment|Setup_Development_Profile]] steps 1 and 2.


: 2. Rename Profile  
: 2. Rename Profile  
:: a) In "Preferences" Window(make sure the profile create in step 1 are selected in profile dropdown menu) ->click "Rename..."   
:: 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
:: b) In Rename Profile Window insert a new name -> OK


Line 170: Line 180:


: 3. Remove Profile  
: 3. Remove Profile  
:: a) In "Preferences" Window (make sure the profile used in step 2 are selected in profile dropdown menu) -> click "Remove..."   
:: a) In "Preferences" Window (make sure the profile used in step 2 selected in profile dropdown menu) -> click "Remove..."   


::: expected result:  
::: expected result:  
Line 181: Line 191:
::: expected result:  
::: expected result:  


<pre>Profile dropdown menu updated to select profile. Toolchain and QEMU section updated accordingly (match with the profile created in test case Setup_Development_Profile).</pre>
<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 ==
== eclipse-yocto - Configure_project_as_YP_Project ==
configure a project into yocto project's project
configure a project into yocto project's project


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  


===execution===  
===execution===  
Line 197: Line 205:
: 2. Select "C Managed Build" -> Next.   
: 2. Select "C Managed Build" -> Next.   


: 3. In Project type expand "GNU Autotools" -> select "Hello World ANSI C Autotools Project" -> in Toolchian select "GNU Autotools Toolchain" -> insert a project name -> Click "Finish".
: 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).
: 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 steps 2 -> click "Apply and Close".   
: 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:  
::: expected result:  
Line 210: Line 218:




== eclipse-yocto - Add_Yocto_Project_Nature ==
 
 
 
== Eclipse-Yocto - Add_Yocto_Project_Nature ==
create cmake project and add yocto project nature to project  
create cmake project and add yocto project nature to project  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  


===execution===  
===execution===  
Line 242: Line 253:




== eclipse-yocto - Cmake_build_with_Yocto_SDK_toolchain ==
 
 
 
== Eclipse-Yocto - Cmake_Yocto_SDK ==
build CMake project using Yocto SDK toolchain  
build CMake project using Yocto SDK toolchain  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]  
: 2. [[#eclipse-yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  


===execution===  
===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.
: 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]] steps 2 -> click "Apply and Close".  
: 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:  
::: expected result:  
Line 280: Line 294:
In Eclipse Console, look for cmake command.  
In Eclipse Console, look for cmake command.  
E.g:  
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>
/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_in_QEMU ==
execute and debug program build using cmake with Yocto SDK toolchain in QEMU


===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain|Cmake_build_with_Yocto_SDK_toolchain]]


===execution===
Setup_Development_Environment
: 1. run QEMU in docker in eclipse console
:: a) In Eclipse Console window, switch to running 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 


<pre>source oe-init-build-env </pre>
== Eclipse-Yocto - Debug_Cmake_Yocto_SDK_program ==
execute and debug CMake Yocto SDK toolchain project in QEMU


:: d) run QEMU 
===prerequisites===
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#Eclipse-Yocto_-_Cmake_Yocto_SDK|Cmake_Yocto_SDK]]


<pre>runqemu qemux86 slirp nographic qemuparams="-redir tcp:2345::2345" </pre>
===execution===


: 2. In Eclipse workbench window, click "Run" -> select "Debug Configurations..."
: 1. In Eclipse workbench window, click "Run" -> select "Debug Configurations..."


: 3. In "Debug Configuration" window, select and right click on "C/C++ Remote Application" -> select "New Configuration"
: 2. In "Debug Configuration" window, select and right click on "C/C++ Remote Application" -> select "New Configuration"


: 4. In "Debug Configuration" window "Main" tab, insert a configuration name -> click "Browse..." select project created in test case Cmake_build_with_Yocto_SDK_toolchain -> "Ok"  
: 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"  


: 5. In "Debug Configuration" window "Main" tab, insert path to .out file for project create in Cmake_build_with_Yocto_SDK_toolchain to "C/C++ Application:"
: 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:   
<pre>E.g:   
"src/a.out" </pre>
"src/a.out" </pre>


: 6. In "Debug Configuration" window "Main" tab, click "New..." for connection
: 5. In "Debug Configuration" window "Main" tab, click "New..." for connection


: 7. In "Create a new connection" window, select "SSH" -> "OK"
: 6. In "Create a new connection" window, select "SSH" -> "OK"


: 8. 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.
: 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.


: 9. 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.
: 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.


: 10. In "Edit configuration" window, expand "Advanced" insert "2222" for port -> click "Finish"
: 9. In "Edit configuration" window, expand "Advanced" insert "2222" for port -> click "Finish"


: 11. In "Debug Configuration" window, click "Debug". if prompt for "Confirm Perspective Switch" click "Switch"
: 10. In "Debug Configuration" window, click "Debug". if prompt for "Confirm Perspective Switch" click "Switch"


::: expected result:  
::: expected result:  
Line 331: Line 337:
<pre>eclipse switch to debugging mode. </pre>
<pre>eclipse switch to debugging mode. </pre>


: 12. In Eclipse, click "F8" to execute the program.
: 11. In Eclipse, click "F8" to execute the program.


::: expected result:  
::: expected result:  
Line 339: Line 345:




== eclipse-yocto - Cmake_build_with_Yocto_build_tree_toolchain ==
 
 
 
== 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  
build Cmake project using Yocto SDK toolchain  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  


===execution===
===execution===


: 1. Refer to test case [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain|Cmake_build_with_Yocto_SDK_toolchain]]. Repeat all the steps in test case [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain|Cmake_build_with_Yocto_SDK_toolchain]] with below settings and expected result.
: 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 Setup_Development_Profile steps 4)
:: 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 :
:: b) expected result for step 5 :


Line 362: Line 395:
In Eclipse Console, look for cmake command.  
In Eclipse Console, look for cmake command.  
E.g:  
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>
/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_in_QEMU ==
== Eclipse-Yocto - Debug_Cmake_Yocto_build_tree_program ==
execute and debug program build using cmake with Yocto build tree toolchain in QEMU
execute and debug CMake Yocto build tree toolchain project in QEMU


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Cmake_build_with_Yocto_build_tree_toolchain|Cmake_build_with_Yocto_build_tree_toolchain]]
: 1. [[#Eclipse-Yocto_-_CMake_Yocto_build_tree|CMake_Yocto_build_tree]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case [[#eclipse-yocto_-_Cmake_build_with_Yocto_build_tree_toolchain|Cmake_build_with_Yocto_build_tree_toolchain]].  
: 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 - Cmake_build_with_Yocto_SDK_toolchain_in_docker ==
 
== 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  
enable docker container setting and build Cmake project using Yocto SDK toolchain in docker  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  


===execution===  
===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.
: 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.
: 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 "chinhuatang/toolchain:latest".
: 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 steps 3 -> click "Apply and Close"
: 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:  
::: expected result:  
Line 410: Line 472:
<pre>Cmake command run in docker and using Yocto SDK toolchain.  
<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:".
In Eclipse Console look for running image and file path after line "Check for working C compiler:".
[Running in image <chinhuatang/toolchain:latest>]  
[Running in image <crops/toolchain:latest>]  
E.g:   
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>
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>
Line 420: Line 482:
<pre>Make command run in docker and using Yocto SDK toolchain.  
<pre>Make command run in docker and using Yocto SDK toolchain.  
E.g:  
E.g:  
[Running in image <chinhuatang/toolchain:latest>]  
[Running in image <crops/toolchain:latest>]  
make all  
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>
/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_Yocto_SDK_docker_build_program_in_QEMU ==
 
execute and debug program build using cmake with Yocto SDK toolchain build in docker  in QEMU
 
 
== 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===
===prerequisites===
: 1. [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain_in_docker|Cmake_build_with_Yocto_SDK_toolchain_in_docker]]
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_SDK|Cmake_CROPS_SDK]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain_in_docker|Cmake_build_with_Yocto_SDK_toolchain_in_docker]].  
: 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_build_with_Yocto_build_tree_toolchain_in_docker ==
 
 
 
 
 
== Eclipse-Yocto - Cmake_CROPS_build_tree ==
Cmake project using Yocto build tree toolchain in docker  
Cmake project using Yocto build tree toolchain in docker  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  
: 2. [[#Eclipse-Yocto_-_Add_Yocto_Project_Nature|Add_Yocto_Project_Nature]]  


===execution===  
===execution===  


: 1. Refer to test case Cmake_build_with_Yocto_SDK_toolchain_in_docker. Repeat all the steps in test case [[#eclipse-yocto_-_Cmake_build_with_Yocto_SDK_toolchain|Cmake_build_with_Yocto_SDK_toolchain]] with below settings and expected result.
: 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 Setup_Development_Profile steps 5)
:: 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 :
:: b) expected result for step 5 :


Line 454: Line 545:
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.  
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:   
E.g:   
[Running in image <chinhuatang/toolchain:latest>]  
[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>
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>
Line 463: Line 554:
In Eclipse Console, look for running image and path for cmake command.  
In Eclipse Console, look for running image and path for cmake command.  
E.g:   
E.g:   
[Running in image <chinhuatang/toolchain:latest>]
[Running in image <crops/toolchain:latest>]
make all  
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>
/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_docker_build_program_in_QEMU ==
 
execute and debug program build using cmake with Yocto build tree toolchain in docker in QEMU
== Eclipse-Yocto - Debug_Cmake_CROPS_build_tree_program ==
execute and debug CMake CROPS build tree toolchain project in QEMU


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Cmake_build_with_Yocto_build_tree_toolchain_in_docker|Cmake_build_with_Yocto_build_tree_toolchain_in_docker]]
: 1. [[#Eclipse-Yocto_-_Cmake_CROPS_build_tree|Cmake_CROPS_build_tree]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case  [[#eclipse-yocto_-_Cmake_build_with_Yocto_build_tree_toolchain_in_docker|Cmake_build_with_Yocto_build_tree_toolchain_in_docker]].  
: 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 - Autotools_build_with_Yocto_SDK_toolchain ==
 
 
 
== 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  
build autotools project using Yocto SDK toolchain  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]


===execution===  
===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.
: 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]] steps 2 -> click "Apply and Close".   
: 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".  
: 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"
: 4. In project explorer, select the same project -> right click -> select "Reconfigure Project"
Line 514: Line 634:
make all  
make all  
Making all in src  
Making all in src  
make[1]: Entering directory '/Data/runtime-eclipse-yocto/autotools-hw/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>
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_in_QEMU ==
 
execute and debug program build using cmake with Yocto SDK toolchain in QEMU
 
 
== Eclipse-Yocto - Debug_Autotools_Yocto_SDK_program ==
execute and debug Autotools Yocto SDK toolchain project in QEMU


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain|Autotools_build_with_Yocto_SDK_toolchain]]
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_SDK|Autotools_Yocto_SDK]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case  [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain|Autotools_build_with_Yocto_SDK_toolchain]].  
: 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 - Autotools_build_with_Yocto_build_tree_toolchain ==
 
 
 
== 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  
build autotools project using Yocto build tree toolchain  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain|Autotools_build_with_Yocto_SDK_toolchain]]. Repeat all the steps in test case [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain|Autotools_build_with_Yocto_SDK_toolchain]] with below settings and expected result.
: 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 Setup_Development_Profile steps 4)
:: 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 :
:: b) expected result for step 4 :


Line 547: Line 696:
In Eclipse Console, look for configure command, all the parameter should match with Build directory for selected profile.  
In Eclipse Console, look for configure command, all the parameter should match with Build directory for selected profile.  
E.g:   
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>
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 :
:: c) expected result for step 5 :
Line 555: Line 704:
make all  
make all  
Making all in src
Making all in src
make[1]: Entering directory '/Data/runtime-eclipse-yocto/autotools-hw/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>
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_in_QEMU ==
 
execute and debug program build using cmake with Yocto build tree toolchain in QEMU
 
 
== 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===
===prerequisites===
: 1. [[#eclipse-yocto_-_Autotools_build_with_Yocto_build_tree_toolchain|Autotools_build_with_Yocto_build_tree_toolchain]]
: 1. [[#Eclipse-Yocto_-_Autotools_Yocto_build_tree|Autotools_Yocto_build_tree]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case   [[#eclipse-yocto_-_Autotools_build_with_Yocto_build_tree_toolchain|Autotools_build_with_Yocto_build_tree_toolchain]].  
: 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_build_with_Yocto_SDK_toolchain_in_docker ==
== Eclipse-Yocto - Autotools_CROPS_SDK ==
build Autotools project using Yocto SDK toolchain in docker  
build Autotools project using Crops SDK toolchain in docker  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]


===execution===  
===execution===  


: 1. In project explorer, select the project use in test case Autotools_build_with_Yocto_SDK_toolchain -> right click -> Properties.
: 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.
: 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 "chinhuatang/toolchain:latest".
: 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_build_with_Yocto_SDK_toolchain steps 3 -> click "Apply and Close"
: 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:  
::: expected result:  
Line 603: Line 781:
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.  
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:   
<pre>E.g:   
[Running in image <chinhuatang/toolchain:latest>]
[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>
configure: loading site script /Data/opt/poky/2.5.1__andromeda_qemux86_64_sato_meta_toolchain/site-config-core2-64-poky-linux </pre>
Line 614: Line 792:
In Eclipse Console, check for running image  
In Eclipse Console, check for running image  


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






== eclipse-yocto - Debug_Autotools_Yocto_SDK_docker_build_program_in_QEMU ==
 
execute and debug program build using cmake with Yocto SDK toolchainin docker in QEMU
 
== Eclipse-Yocto - Debug_Autotools_CROPS_SDK_program ==
execute and debug Autotools CROPS SDK toolchain project in QEMU


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain_in_docker|Autotools_build_with_Yocto_SDK_toolchain_in_docker]]
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_SDK|Autotools_CROPS_SDK]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain_in_docker|Autotools_build_with_Yocto_SDK_toolchain_in_docker]].  
: 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 - Autotools_build_with_Yocto_build_tree_toolchain_in_docker ==
 
 
 
 
== 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  
build Autotools project using Yocto build tree toolchain in docker  


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 1. [[#Eclipse-Yocto_-_Setup_Development_Profile|Setup_Development_Profile]]
: 2. [[#eclipse-yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]
: 2. [[#Eclipse-Yocto_-_Configure_project_as_YP_Project|Configure_project_as_YP_Project]]


===execution===  
===execution===  




: 1. Refer to test case Autotools_build_with_Yocto_SDK_toolchain_in_docker. Repeat all the steps in test case [[#eclipse-yocto_-_Autotools_build_with_Yocto_SDK_toolchain_in_docker|Autotools_build_with_Yocto_SDK_toolchain_in_docker]] with below settings and expected result.
: 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 Setup_Development_Profile steps 5)
:: 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 :
:: b) expected result for step 6 :


Line 647: Line 856:
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.
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:
E.g:
[Running in image <chinhuatang/toolchain:latest>] </pre>
[Running in image <crops/toolchain:latest>] </pre>




Line 655: Line 864:
In Eclipse Console, look for cmake command.   
In Eclipse Console, look for cmake command.   
E.g:  
E.g:  
[Running in image <chinhuatang/toolchain:latest>] </pre>
[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]].




== eclipse-yocto - Debug_Autotools_Yocto_build_tree_docker_build_program_in_QEMU ==
 
execute and debug program build using cmake with Yocto SDK toolchainin docker in QEMU
 
 
 
 
== Eclipse-Yocto - Run_Autotools_CROPS_build_tree_program ==
run Autotools CROPS build tree toolchain project in QEMU


===prerequisites===
===prerequisites===
: 1. [[#eclipse-yocto_-_Autotools_build_with_Yocto_build_tree_toolchain_in_docker|Autotools_build_with_Yocto_build_tree_toolchain_in_docker]]
: 1. [[#Eclipse-Yocto_-_Autotools_CROPS_build_tree|Autotools_CROPS_build_tree]]


===execution===  
===execution===  


: 1. Refer to test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]]. Repeat steps 2 to 12 in test case [[#eclipse-yocto_-_debug_Cmake_Yocto_SDK_program_in_QEMU|debug_Cmake_Yocto_SDK_program_in_QEMU]] with similar expected results but changes to target project for steps 4 and 5 to project create in test case [[#eclipse-yocto_-_Autotools_build_with_Yocto_build_tree_toolchain_in_docker|Autotools_build_with_Yocto_build_tree_toolchain_in_docker]].
: 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_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]].
 
: 3. In "Run configurations" window, click "Run"
 
::: expected result:
 
<pre>successful run the program. Results shows in eclipse console. </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.