Kernel Development Test Cases

==Document Conventions==
:1. In command and configuration snippets that exist on the rest of the document, words or short phrases that appear in uppercase letters and enclosed on square brackets (for example, [VERSION]) are placeholders that need to be manually replaced by their correct value, depending on the context.
: 2. In command snippets, the dollar symbol and subsequent space at the beginning of the line indicates the command line prompt. This two characters should not be used when entering the command.
: 3. Other characters should be left as they appear on command or configuration sentences.
==Setup==
===Common Prerequisites===
: 1. Have a clone of poky:
:: $ git clone git://git.yoctoproject.org/poky
: 2. Check out the required commit using git:
:: $ git checkout [COMMIT_HASH]
: 3. Source the build environment to create the configuration files:
:: $ cd [POKY_PATH]
:: $ . oe-init-build-env
: 4. Open the conf/local.conf file:
:: $ vi conf/local.conf
:: Establish the machine to qemux86-64 by setting the line:
:: MACHINE = "qemux86-64"
: 5. Compile a minimal image:
:: $ bitbake core-image-minimal
: 6. Get and take note of the linux-yocto kernel version (only the first two numbers, for example: 4.10):
:: $ bitbake virtual/kernel -e | grep LINUX_VERSION
: 7. Create a layer to store kernel test metadata. For this task, you could use the bitbake-layers and its default recipe values:
:: $ cd [POKY_PATH]
:: $ bitbake-layers create-layer [LAYER-NAME]
:: Note: In the rest of this document "meta-kerneltest" is used as the [LAYER-NAME].
: 8. Create the recipe directory structure inside the created layer:
:: $ mkdir -p meta-kerneltest/recipes-kernel/linux/
: 9. Create a recipe append file inside the directory:
:: $ touch meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
: 10. Copy the recipe file corresponding to the linux-yocto version inside the directory:
:: $ cp meta/recipes-kernel/linux/linux-yocto_[VERSION].bb meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
: 11. Edit the linux-yocto-custom recipe:
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the PV variable with the LINUX_VERSION variable value:
:: PV = "${LINUX_VERSION}"
: 12. Create directory "linux-yocto":
:: $ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto/
: 13. Create directory "linux-yocto-custom":
:: $ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto-custom/
: 14. Add the created layer to bblayers.conf. For this task, you could use the bitbake-layers script from inside the build directory:
:: $ cd build
:: $ bitbake-layers add-layer ../meta-kerneltest
===General Remarks===
: 1. As a suggestion, open another terminal in order to perform git commands.
: 2. Remember to source the environment and ensure your current work directory is [POKY_PATH]/build before using bitbake scripts and tools.
: 3. You can edit any required file with vim, emacs, or your preferred text editor.
: 4. If there is not a proper response after building an image, be sure to clean the shared state, and try again. To clean it, you can use:
:: $ bitbake virtual/kernel -c cleansstate
: 5. Be careful with the information added to recipe and recipe append files, using the same values -- including spaces-- to set a recipe variable value.
: 6. To ensure all the sources are correctly downloaded and the required taks are executed, ensure no shared states proxies are set on conf/local.conf.
: 7. Make sure to point to the correct linux-yocto version.
==TC_KD_01 – Applying Patches==
===Use Case===
As a developer, I want to be able to apply a single patch to the Linux kernel source.
===Prerequisites===
: 1. Generate the patch:
:: 1.1. Go to kernel source directory:
::: $ cd [POKY_PATH]/build/tmp/work-shared/qemux86-64/kernel-source
:: 1.2. Add some information at the end of the README file:
::: $ echo This is a test to apply a patch to the kernel. >> README
:: 1.3. Add the modified file to the patch:
::: $ git add README
:: 1.4. Commit the change:
::: $ git commit -s -m "KERNEL DEV TEST CASE"
:: 1.5. Format the patch:
::: $ git format-patch -1
===Steps===
: 1. Move the generated patch to the "linux-yocto" directory :
:: $ mv 0001-KERNEL-DEV-TEST-CASE.patch [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto/
: 2. Add the SRC_URI var with the patch to the linux-yocto_4%.bbappend file:
:: $ cd [POKY_PATH]
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Add the following lines and save and close the file:
:: SRC_URI += "file://0001-KERNEL-DEV-TEST-CASE.patch"
:: FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"
: 3. Delete the README file:
:: $ rm build/tmp/work-shared/qemux86-64/kernel-source/README
: 4. Clean the shared state:
:: $ cd build
:: $ bitbake virtual/kernel -c cleansstate
: 5. Build the patch:
:: $ bitbake virtual/kernel -c patch
: 6. Verify the patch is applied properly:
:: $ tail tmp/work-shared/qemux86-64/kernel-source/README
===Expected Results===
: 1. Bitbake should complete the build without errors.
: 2. The README file should exist.
: 3. The patch changes should be displayed at the end of the file.
==TC_KD_02 – linux-yocto Local Source==
===Use Case===
As a developer, I want to to be able to work with my own Linux kernel sources.
===Prerequisites===
: 1. Have a recipe append file for linux-yocto (created previously).
: 2. Clone in a specific directory (different of poky):
:: $ cd [KERNEL_REPOS_PATH]
:: $ git clone git://git.yoctoproject.org/yocto-kernel-cache
:: $ git clone git://git.yoctoproject.org/linux-yocto-[VERSION]
:: $ For Linux version 4.14 and onwards, use following command
:: $ git clone git://git.yoctoproject.org/linux-yocto 
: 3. Go to the cloned yocto-kernel-cache directory:
:: $ cd [KERNEL_REPOS_PATH]/yocto-kernel-cache
:: Checkout the required yocto-version branch:
:: $ git checkout yocto-[VERSION] # For example: $ git checkout yocto-4.8
: 4. Go to the linux-yocto-[VERSION] directory:
:: $ cd [KERNEL_REPOS_PATH]/linux-yocto-[VERSION]
:: Checkout the standard/base branch:
:: $ git checkout standard/base
:: $ For Linux version 4.14 and onwards, use following command
:: $ git checkout v[VERSION]/standard/base
: 5. Edit the conf/local.conf file in the repository where you are working for execution:
:: $ cd [POKY_PATH]
:: $ vi build/conf/local.conf
:: Set the following line:
:: PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"
===Steps===
: 1. Edit the linux-yocto recipe append file previously created at your "meta-kerneltest" directory:
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
: 2. Clean the shared state:
:: $ cd build
:: $ bitbake virtual/kernel -c cleansstate
: 3. Build the kernel:
:: $ bitbake virtual/kernel
: 4. Verify the changes by executing:
:: $ bitbake virtual/kernel -e | grep "name=machine;branch"
===Expected Results===
: 1. The changes should be performed successfully.
: 2. The build should be completed successfully.
: 3. The bitbake variables output should display that the SRC_URI variable is now:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
==TC_KD_03 – linux-yocto Custom Local Source==
===Use Case===
As a developer, I want to be able to work with my own local sources for a customized linux-yocto kernel.
===Prerequisites===
: 1. Make sure you have the custom recipe file corresponding to the latest linux-yocto version:
:: [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: This file should originate from [POKY_PATH]/meta/recipes-kernel/linux/linux-yocto_[VERSION].bb
: 2. Edit the linux-yocto-custom recipe file:
:: $ cd [POKY_PATH]
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
===Steps===
: 1. Go to the poky build directory:
:: $ cd [POKY_PATH]/build
: 2. At conf/local.conf add the following variable:
:: PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
: 3. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 4. Compile the kernel:
:: $ bitbake virtual/kernel
: 5. Verify the changes by executing:
:: $ bitbake virtual/kernel -e | grep -E "PREFERRED_PROVIDER_virtual/kernel|SRC_URI"
===Expected Results===
: 1. The variables "PREFERRED_PROVIDER_virtual/kernel" and "SRC_URI" should be set successfully.
: 2. Compilation process should be performed successfully.
==TC_KD_04 – Local Parallel Meta==
===Use Case===
As a developer, I want to be able to work with local source with parallel meta.
===Prerequisites===
: 1. Edit the linux-yocto-custom recipe file:
:: $ cd [POKY_PATH]
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
: 2. Go to the poky build directory:
:: $ cd [POKY_PATH]/build
: 3. At conf/local.conf add the following variable:
:: PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
: 4. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 5. Execute the kernel configuration task:
:: $ bitbake virtual/kernel -c kernel_configme
: 6. Verify that CONFIG_WIMAX option is not set at:
:: tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
: 7. Set parallel-meta for linux-yocto-custom, adding a specific fragment:
:: 7.1. Create four directories --"files", "parallel-kmeta","features" and "wimax"-- to work with parallel meta:
::: $ cd [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/
::: $ mkdir -p files/parallel-kmeta/features/wimax
:: 7.2. Inside "wimax" directory create two files: wimax.cfg and wimax.scc:
::: $ cd files/parallel-kmeta/features/wimax
::: $ touch wimax.cfg wimax.scc
:: 7.3. Inside wimax.cfg add the following configuration:
::: CONFIG_WIMAX=y
:: 7.4. Inside wimax.scc add the following lines:
::: define KFEATURE_DESCRIPTION "WiMAX Wireless Broadband support"
::: define KFEATURE_COMPATIBILITY board
::: 
::: kconf hardware wimax.cfg
===Steps===
: 1. Edit the linux-yocto-custom recipe file:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
:: Add the fragment by setting the next line:
:: KERNEL_FEATURES_append = " features/wimax/wimax.scc"
: 2. Edit conf/local.conf
:: $ cd [POKY_PATH]/build/
:: $ vi conf/local.conf
:: Set the following variable:
:: PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
: 3. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 4. Execute the kernel configuration task:
:: $ bitbake virtual/kernel -c kernel_configme
:: Note: The build should fail at this step with an error indicating the "wimax.scc" fragment is not found.
: 4. Edit the linux-yocto-custom recipe file:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}; \
:: file://parallel-kmeta;protocol=file;type=kmeta;name=p-kmeta;destsuffix=parallel-kmeta"
: 4. Execute the kernel configuration task:
:: $ bitbake virtual/kernel -c kernel_configme
: 6. Verify that CONFIG_WIMAX=y option was set properly at:
:: tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
: 7. Verify the variables were set succesfully using:
:: $ bitbake virtual/kernel -e | grep -E "PREFERRED_PROVIDER_virtual/kernel|SRC_URI"
===Expected Results===
: 1. The variables should be set successfully. 
: 2. Compilation process should be performed successfully.
: 3. CONFIG_WIMAX=y option should be set properly in the .config file after executing the kernel configuration task.
===Remarks===
: 1. If the WIMAX feature is included on a build by default, verify on the following link a feature that is not included, and use it instead, updating the test case for future reference:
:: http://git.yoctoproject.org/cgit/cgit.cgi/yocto-kernel-cache/tree/features
==TC_KD_05 – Recipe-space Meta==
===Use Case===
As a developer, I want to be able to work with recipe-space meta.
===Prerequisites===
: 1. Edit the linux-yocto-custom recipe file:
:: $ cd [POKY_PATH]
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \
:: git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
:: Ensure the following value is not set:
:: SRC_URI_append = " file://pwm-test.scc"
: 2. At build/conf/local.conf add the following variable:
:: PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
: 3. Clean the shared state:
:: $ cd [POKY_PATH]/build
:: $ bitbake virtual/kernel -c cleansstate
: 4. Compile the kernel:
:: $ bitbake virtual/kernel
: 5. Verify that CONFIG_PWM option is not set at:
:: tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
: 6. Create the files pwm-test.cfg and pwm-test.scc on meta-kerneltest in the linux-yocto-custom directory:
:: $ cd [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom
:: $ touch pwm-test.cfg pwm-test.scc
:: 6.1. Inside pwm-test.cfg include the line:
::: CONFIG_PWM=y
:: 6.2. Inside pwm-test.scc include the following information:
::: define KFEATURE_DESCRIPTION "Enable core options for PWM support - TC_KD_recipe-space_meta"
::: define KFEATURE_COMPATIBILITY board
::: 
::: kconf hardware pwm-test.cfg
===Steps===
: 1. Edit the linux-yocto-custom recipe:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb
:: Add the following lines:
:: FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"
:: SRC_URI += " file://pwm-test.scc"
: 2. Edit local.conf:
:: $ cd [POKY_PATH]/build
:: $ vi conf/local.conf
:: Set the following variables:
:: PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"
:: PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
: 3. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 4. Compile the kernel:
:: $ bitbake virtual/kernel
: 5. Verify that CONFIG_PWM=y option was set properly at:
:: tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
===Expected Results===
: 1. The variables should be set successfully. 
: 2. Compilation process should be performed successfully.
: 3. CONFIG_PWM=y option should be set properly in the .config file.
===Remarks===
: 1. If the PWM feature is included on a build by default, verify on the following link a feature that is not included, and use it instead, updating the test case for future reference:
:: http://git.yoctoproject.org/cgit/cgit.cgi/yocto-kernel-cache/tree/features
==TC_KD_06 – External Source==
===Use Case===
As a developer, I want to be able to work with external sources.
===Prerequisites===
: 1. Open a new terminal, different than the one being used for executing the testing steps.
: 2. Create git bare repositories of Linux sources and cache:
:: 2.1. Create and go to an empty directory (outside the poky repository) to set is at the root to publish git repositories:
::: $ mkdir -p [GIT_REPOS_PATH]
::: $ cd [GIT_REPOS_PATH]
:: 2.2. Inside the directory, type the following commands to clone the bare repositories:
::: $ git clone --bare git://git.yoctoproject.org/linux-yocto-[VERSION]
::: $ git clone --bare git://git.yoctoproject.org/yocto-kernel-cache
:: 2.3. Obtain the local git server IP and take note of it:
::: $ sudo /sbin/ifconfig
:: 2.4. Execute the following command to launch the git daemon and leave it running:
::: $ git daemon --reuseaddr --base-path=. --export-all --verbose
: 3. Return to the terminal being used for executing the testing steps.
: 4. Disable any proxy being used by git. For example, if the git proxy environment variable is set, you can unset it with:
:: $ unset GIT_PROXY_COMMAND
:: Verify the variable was unset with:
:: $ echo $GIT_PROXY_COMMAND
: 5. Ensure the git daemon is working:
:: 5.1. Go to any directory were you can test cloning from your local git repository.
:: 5.2. Verify that the git daemon responds and allows cloning the repo using the following command:
::: git clone git://[IP_OF_YOUR_LOCAL_REPO]/linux-yocto-[VERSION].git
:: 5.3. After confirming the daemon is working, delete the cloned repository:
::: $ rm linux-yocto-[VERSION] -rf
: 6. Go to the test poky build repository:
:: $ cd [POKY_PATH]/build
: 7. Make sure to comment or remove the following line on conf/local.conf:
:: # PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
:: Also, ensure the following line is set on the same file:
:: PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"
===Steps===
: 1. Edit the linux-yocto recipe append file previously created at your "meta-kerneltest" directory:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Set the SRC_URI variable with the following information:
:: SRC_URI = "git://[IP_OF_YOUR_LOCAL_REPO]/linux-yocto-[VERSION].git;name=machine;branch=${KBRANCH}; \
:: git://[IP_OF_YOUR_LOCAL_REPO]/yocto-kernel-cache;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"
: 2. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 3. Execute the fetch task for the kernel:
:: $ bitbake virtual/kernel -c fetch
: 4. Re-enable any previous git proxy settings. If using the git proxy environment variable, return it to its previous value, or close and reopen the terminal.
===Expected Results===
: 1. The configuration should be successfully added.
: 2. Compilation should be performed successfully
: 3. The terminal where the daemon was launched should display some information like:
:: [9243] Connection from IP_LOCAL:PORT
:: [9243] Extended attributes (20 bytes) exist <host=IP_LOCAL>
:: [9243] Request upload-pack for '/linux-yocto-4.9.git'
==TC_KD_07 – defconfig==
===Use Case===
As a developer, I want to be able to generate and change configuration files (defconfig).
===Prerequisites===
: 1. Have a clone of poky.
: 2. Have availability to another machine/server in the same network to use it as reference.
: 3. Make sure to have the same architecture in the reference machine than the Yocto machine to build.
: 4. Edit the local.conf file on the poky repository in the testing machine:
:: $ cd [POKY_PATH]/build
:: $ vi conf/local.conf
:: Make sure to comment or remove the following line:
:: # PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
:: Ensure the following line is set:
:: PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"
:: Set the same architecture than the one of the reference machine. For example, if you have an ubuntu_x86_64 as reference, in local.conf set:
:: MACHINE = "qemux86-64"
: 5. Clean the shared state:
:: $ bitbake virtual/kernel -c cleansstate
: 6. Execute the kernel_configme task:
:: $ bitbake virtual/kernel -c kernel_configme
: 7. After the image compilation is completed, in order to have a copy of the original configuration, copy the .config file from:
:: [POKY_PATH]/build/tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
:: to:
:: /home/[USER]/poky-defconfig
: 8. Create a meta layer for test purpose using "bitbake-layers" command.
:: $ cd [POKY_PATH]
:: $ bitbake-layers create-layer meta-kerneltest
: 9. Remove the redundant recipes-example in meta-kerneltest
:: $ cd meta-kerneltest
:: $ rm -r recipes-example
: 10. Edit layer.conf for meta-kerneltest (Known issue in bitbake-layers in 2.4; Fixed in 2.5)
:: $ vi conf/layer.conf
:: Remove the additional "\" at the end of line 4:
:: BBFILES += "${LAYERDIR}/recipes-*/*/*.bb \\ <-- Additional \ will cause bitbake parse warning and unable to look for *.bbappend
:: Correct code:
:: BBFILES += "${LAYERDIR}/recipes-*/*/*.bb \
: 11. Add the meta layer into build/conf/bblayers.conf
:: $ cd [POKY_PATH]/build
:: $ bitbake-layers add-layer ../meta-kerneltest
===Steps===
: 1. Set defconfig:
:: 1.1. Open a terminal on your reference machine and copy the config file located at: /boot/config-[VERSION-GENERIC] to the machine where the test poky repository is located. Select a name to identify the reference defconfig:
::: $ scp /boot/config[VERSION-GENERIC] [USER]@[TEST_MACHINE_IP]:reference-defconfig
:: 1.2. Return to the terminal on the test machine and copy the reference file to the linux-yocto path in meta-kerneltest with the name defconfig:
::: $ cp ~/reference-defconfig [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto/defconfig
: 2. Edit the recipe append file:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Remove or comment any existing customization, add the following lines and save and close the file:
:: FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"
:: SRC_URI += "file://defconfig"
: 3. Clean the shared state:
:: $ cd [POKY_PATH]/build
:: $ bitbake virtual/kernel -c cleansstate
: 4. Execute the kernel_configme task:.
:: $ bitbake virtual/kernel -c kernel_configme
: 5. Verify that the output defconfig file is equal to the [DISTRO]-defconfig file saved on step 1.1:
:: $ vimdiff tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/defconfig ~/reference-defconfig
: 6. Verify the output config file is based on the reference defconfig, by comparing both to identify similarities between them:
:: $ vimdiff tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config ~/reference-defconfig
: 7. Verify the output config file has many more differences with the original defconfig file saved as part of the prerequisites:
:: $ vimdiff tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config ~/poky-defconfig
: 8. Clean the build environment:
:: $ bitbake virtual/kernel -c cleanall
===Expected Results===
: 1. The variable should be set.
: 2. The execution of kernel_configme task should be successful.
: 3. The reference defconfig and output defconfig should be the same.
: 4. The .config and the reference-defconfig files should be similar.
: 5. The .config and the original poky-defconfig files should have several more differences than when compared with the reference-defconfig file.
==TC_KD_08 – defconfig Fragments==
===Use Case===
As a developer, I want to be able to generate and change configuration files (defconfig + fragments).
===Prerequisites===
: 1. Same prerequisites than TC_KD_07.
===Steps===
: 1. Apply steps 1 to 4 from the TC_KD_07 test case.
: 2. Verify that CONFIG_EXT2_FS option is not set at:
:: tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config
: 3. Edit the recipe append file:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Add the following line and save and close the file:
:: SRC_URI += "file://fragment.cfg"
: 4. Create fragment.cfg file under the linux-yocto directory:
:: $ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto/fragment.cfg
:: Add the following line inside and save and close the file:
:: CONFIG_EXT2_FS=y
: 5. Clean the shared state:
:: $ cd [POKY_PATH]/build
:: $ bitbake virtual/kernel -c cleansstate
: 6. Execute the kernel_configme task:.
:: $ bitbake virtual/kernel -c kernel_configme
: 7. Verify that the output defconfig file is equal to the [DISTRO]-defconfig file saved on step 1.1:
:: $ vimdiff tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/defconfig ~/reference-defconfig
: 8. Verify the output config file is based on the reference defconfig, and confirm the configuration fragment has been applied correctly:
:: $ vimdiff tmp/work/qemux86_64-poky-linux/linux-yocto/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config ~/reference-defconfig
: 9. Clean the build environment:
:: $ bitbake virtual/kernel -c cleanall
===Expected Results===
: 1. The fragment file should be appended to the SRC_URI variable.
: 2. The execution of kernel_configme task should be successful.
: 3. The reference defconfig and output defconfig should be the same.
: 4. The .config and the reference-defconfig files should be similar, and .config should contain the configuration option from the fragment (CONFIG_EXT2_FS=y).
===Remarks===
: 1. If the EXT2_FS feature is included on a build by default, verify on the following link a feature that is not included, and use it instead, updating the test case for future reference:
:: http://git.yoctoproject.org/cgit/cgit.cgi/yocto-kernel-cache/tree/features
==TC_KD_09 – linux-yocto Meta Data and Local Fragments==
===Use Case===
As a developer, I want to be able to configure linux-yocto meta data + local fragments.
===Prerequisites===
: TBD, MUST HAVE REPOSITORY OF YOCTO KERNEL CACHE.
===Steps===
: TBD.
===Expected Results===
: TBD.
==TC_KD_10 – Building hello-mod==
===Use Case===
As a developer, I want to be able to build external modules (hello-mod).
===Prerequisites===
: 1. Copy the hello-mod directory from meta-skeleton to meta-kerneltest:
:: $ cp -r [POKY_PATH]/meta-skeleton/recipes-kernel/hello-mod [POKY_PATH]/meta-kerneltest/recipes-kernel/
: 2. Make sure to comment or remove the following line on conf/local.conf:
:: # PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"
:: Also, ensure the following line is set on the same file:
:: PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"
===Steps===
: 1. Set the hello module variable information on conf/local.conf (in your testing build environment), with the following line:
:: MACHINE_ESSENTIAL_EXTRA_RDEPENDS += "kernel-module-hello"
: 2. Edit the linux-yocto recipe append file:
:: $ cd [POKY_PATH]
:: $ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend
:: Make sure you have only the following line, and save and close the file:
:: FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"
: 3. Clean the shared state:
:: $ cd [POKY_PATH]/build
:: $ bitbake virtual/kernel -c cleansstate
: 4. Compile the hello module:
:: $ bitbake hello-mod
: 5. Create a minimal image:
:: $ bitbake core-image-minimal
: 6. Boot the image using QEMU:
:: $ runqemu nographic core-image-minimal
:: 6.1. Once the qemu terminal is ready, verify on it that the hello module was successfully added:
::: $ modprobe hello 
:: 6.2. Remove the hello module: 
::: $ rmmod hello
:: 6.3. Power off and exit the qemu terminal:
::: $ poweroff
===Expected Results===
: 1. The variables should be set successfully.
: 2. Compilation process should be performed successfully.
: 3. Image should be compiled without errors.
: 4. Verify the message "Hello World!"is displayed after executing modprobe on the QEMU terminal.
: 5. Verify the message "Goodbye Cruel world!" is displayed after removing the module on the QEMU terminal.
==References==
* http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html
* http://www.yoctoproject.org/docs/latest/kernel-dev/kernel-dev.html
Compendium of Yocto Project manuals, including the two above:
* https://www.yoctoproject.org/docs/latest/mega-manual/mega-manual.html