Eclipse Yocto Test Cases

eclipse-yocto - Launch_Eclipse_with_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, 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"

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>update plugin to select >>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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 chinhuatang/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 
git checkout tags/yocto-2.5 -b my-yocto-2.5 

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
bitbake meta-ide-support
bitbake meta-toolchain

3. Setup YP SDK toolchain

a) Look for SDK toolchain script created in steps 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. 

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 step 1 -> click "OK" -> click "Apply".

3. 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 step 1 -> copy the Directory -> paste to "Container path" -> click "Ok" -> click "Apply".

4. 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 step 3) -> 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 step 3 -> 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. take similar action as test case Setup_Development_Profile step 1 and step 2

2. Rename Profile

a) In "Preferences" Window(make sure the profile create in step 1 are 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 are 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 and QEMU section updated accordingly (match with the profile created in test case Setup_Development_Profile).

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 Toolchian 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 steps 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_build_with_Yocto_SDK_toolchain

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 steps 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_in_QEMU

execute and debug program build using cmake with Yocto SDK toolchain in QEMU

prerequisites

1. Setup_Development_Profile

2. 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

source oe-init-build-env 

d) run QEMU

runqemu qemux86 slirp nographic qemuparams="-redir tcp:2345::2345" 

2. 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"

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"

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:"

E.g:  
"src/a.out" 

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

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

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.

10. 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"

expected result:

eclipse switch to debugging mode. 

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

expected result:

successful execute program.  

eclipse-yocto - Cmake_build_with_Yocto_build_tree_toolchain

build Cmake project using Yocto SDK toolchain

prerequisites

1. Setup_Development_Profile

2. Add_Yocto_Project_Nature

execution

1. Refer to test case Cmake_build_with_Yocto_SDK_toolchain. Repeat all the steps in test case Cmake_build_with_Yocto_SDK_toolchain 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)

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_in_QEMU

execute and debug program build using cmake with Yocto build tree toolchain in QEMU

prerequisites

1. Cmake_build_with_Yocto_build_tree_toolchain

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Cmake_build_with_Yocto_build_tree_toolchain.

eclipse-yocto - Cmake_build_with_Yocto_SDK_toolchain_in_docker

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 "chinhuatang/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"

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 <chinhuatang/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 <chinhuatang/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_Yocto_SDK_docker_build_program_in_QEMU

execute and debug program build using cmake with Yocto SDK toolchain build in docker in QEMU

prerequisites

1. Cmake_build_with_Yocto_SDK_toolchain_in_docker

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Cmake_build_with_Yocto_SDK_toolchain_in_docker.

eclipse-yocto - Cmake_build_with_Yocto_build_tree_toolchain_in_docker

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_build_with_Yocto_SDK_toolchain_in_docker. Repeat all the steps in test case Cmake_build_with_Yocto_SDK_toolchain 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)

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 <chinhuatang/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 <chinhuatang/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_Yocto_build_tree_docker_build_program_in_QEMU

execute and debug program build using cmake with Yocto build tree toolchain in docker in QEMU

prerequisites

1. Cmake_build_with_Yocto_build_tree_toolchain_in_docker

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Cmake_build_with_Yocto_build_tree_toolchain_in_docker.

eclipse-yocto - Autotools_build_with_Yocto_SDK_toolchain

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 steps 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_in_QEMU

execute and debug program build using cmake with Yocto SDK toolchain in QEMU

prerequisites

1. Autotools_build_with_Yocto_SDK_toolchain

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Autotools_build_with_Yocto_SDK_toolchain.

eclipse-yocto - Autotools_build_with_Yocto_build_tree_toolchain

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_build_with_Yocto_SDK_toolchain. Repeat all the steps in test case Autotools_build_with_Yocto_SDK_toolchain 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)

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_in_QEMU

execute and debug program build using cmake with Yocto build tree toolchain in QEMU

prerequisites

1. Autotools_build_with_Yocto_build_tree_toolchain

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Autotools_build_with_Yocto_build_tree_toolchain.

eclipse-yocto - Autotools_build_with_Yocto_SDK_toolchain_in_docker

build Autotools project using Yocto 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_build_with_Yocto_SDK_toolchain -> 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 "chinhuatang/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"

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 <chinhuatang/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 <chinhuatang/toolchain:latest>] 

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

prerequisites

1. Autotools_build_with_Yocto_SDK_toolchain_in_docker

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Autotools_build_with_Yocto_SDK_toolchain_in_docker.

eclipse-yocto - Autotools_build_with_Yocto_build_tree_toolchain_in_docker

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_build_with_Yocto_SDK_toolchain_in_docker. Repeat all the steps in test case Autotools_build_with_Yocto_SDK_toolchain_in_docker 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)

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 <chinhuatang/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 <chinhuatang/toolchain:latest>] 

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

prerequisites

1. Autotools_build_with_Yocto_build_tree_toolchain_in_docker

execution

1. Refer to test case debug_Cmake_Yocto_SDK_program_in_QEMU. Repeat steps 2 to 12 in test case 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 Autotools_build_with_Yocto_build_tree_toolchain_in_docker.