QAM Buzwords

Quality Assurance Manager  buzword  – state of the art

test management, desktop & mobile applications, QA processes, QA-strategies, resource planning,  testlink, regression tests,requirements, specification,test documentation, test status, test report, sprint plan, Regression Testing: Selenium watir, Cucumber, Tracker Tools: z.B. JIRA and Greenhopper, Best Practices
Testmanagement and Projektmanagement, Scrum,  agile test methods, Web 2.0, social networks, communities, Mobile Plattforms, such as  J2ME, Android, iPhone, automatic testing, testlink tool. Win, Mac, Linux, Certified Tester Foundation Level, ISTQB Zertifizierung

UID, EUID, SUID, FSUID

I just discovered this page of Elizabeth Stinson
explaining the the differences between UID, EUID, SUId and FSUID and how they take effect for Linux, BSD, Solaris, and other Unices. Great document!

As backup her page is cited here:

SETUID syscall: modifies userIDs

Access control in Unix systems: based on a process's userIDs

Each process has a set of userIDs and groupIDs
 -- these userIDs and groupIDs determine which resources [files, network
    ports, ...] that process can access

 -- the privileged userIDs and groupIDs allow a process to access
    restricted system resources

userID == 0 --> ROOT; process can access all system resources

In some apps, a user process needs extra privileges; e.g. permission to
read or change the password file

"principle of least privilege" == process should DROP those extra privs, ASAP

UID-setting syscalls: offered by UNIX systems; used by a process to raise
& drop its privilege level; poorly designed, not well documented

USER ID MODEL:
 - each user has a unique UID
 - UID determines which resources a user can access

Each process has 3 UIDs:
(1) real UID: identifies process OWNER
(2) effective UID: used in access control decisions
(3) saved user ID: stores a previous UID so that it can be restored later

Each process has 3 groupIDs:
(1) real GID
(2) effective GID
(3) saved GID

In Linux, each process *also* has:
(1) FSUID
(2) FSGID
--used for access control to the file system
--FSUID usually follows effective UID unless it's explicitly set by the
setfsuid syscall
--FSGID usually follows effective GID unless explicitly set by setfsgid()

When a process is created by FORK, the created process inherits its
parent's UIDs

When a process executes a NEW FILE via EXEC, that executing process keeps
ITS OWN UIDs unless the SETUID in the new file is set.
 -- if the SETUID bit is set in the file we're EXECing, then
    --> process's EUID == file owner's UID
    --> process's SUID == file owner's UID

To drop privilege temporarily, a process will remove the privileged UID
from its EUID but keep it saved as its saved UID (SUID); later the process
can restore the privileges by setting its EUID to its SUID. To drop
privileges permanently a process removes the privileged UID from all three
of its UIDs; thereafter the process cannot restore that privileged access

Bell Labs patented Dennis Ritchie's idea to have a bit to indicate whether
when a file is executed that file should be executed with the privileges
of its owner (normal) or THE INVOKER (setuid bit == 1 for latter case).

Early UNIX: a process had 2 UIDs, RUID & EUID
--Only one syscall, SETUID:

       if (EUID == 0)
	  RUID = ;
          EUID = ;

       else
          EUID = ;

Problem: no way to temporarily drop root privileges only to restore them later

         UNIX
         /  \
        /    \
    Sys V    BSD

System V: added SUID and SETUEID syscall

SETEUID:
           if (EUID == 0)
	      EUID can be set to any value;
           else
              EUID can be set to RUID or SUID ONLY

SETUID was modified:

           if (EUID != 0)
	      EUID can be set;
           else
	      EUID = ;
              RUID = ;
              SUID = ;

Sys V: so if you're not root, you can use SETUID to set EUID and you can
use SETEUID to set EUID = RUID or EUID = SUID; if you ARE root, you can
use SETUID to set EUID, SUID, RUID and you can use SETEUID to set EUID to
anything; 

BSD: dropped SETUID, created SETREUID

SETREUID:   if (EUID == 0)
	       RUID = anyUID;
	       EUID = anyUID;
            else
               RUID = EUID; OR
	       EUID = RUID;

POSIX: SETUID can set all three UIDs whether you're root or not

SETRESUID(newRUID,newEUID,newSUID)
 -- to call this function, the EUID of the calling process must be ROOT OR
 -- each of the 3 params must equal one of the process's 3 UIDs
 -- all or nothing effect;
 -- FreeBSD & Linux offer SETRESUID; Solaris does not;

SOLARIS:  through /proc FS any process can examine its 3 UIDs and a
superuser process can set any of those UIDs;

SETEUID(newEUID):
--sets EUID; doesn't touch RUID or SUID
--Among UNIX systems, if the current EUID != ROOT
  (a) Solaris, Linux
      newEUID can equal EUID, RUID, or SUID
  (b) FreeBSD
      newEUID can equal RUID or SUID

SETREUID(newRUID,newEUID)
--modifies RUID and EUID and in some cases SUID
(a) Solaris & Linux: a process can swap RUID & EUID
(b) FreeBSD: a process can't switch RUID & EUID

SETUID(newUID): POSIX
(a) Linux & Solaris: newUID must equal RUID or SUID (if EUID != 0)
(b) FreeBSD: newUID may equal EUID, too

The action of SETUID depends on whether th process is privileged or not
(a) Linux & Solaris:

    if (EUID == 0)
       setuid(newID) sets RUID = newUID;
			  EUID = newUID;
			  SUID = newUID;

    else
       setuid(newUID) sets EUID = newUID;

(b) FreeBSD:

    setuid(newID) sets RUID = EUID = SUID = newID regardless of whether
    current EUID is 0 or not

SETFSUID(newFSUID)
--FSUID used for access control to the FS
--FSUID == EUID unless FSUID explicitly set
--tries to maintian invariant: FSUID = 0 only if RUID, SUID, OR EUID == 0
--if change EUID, that changed val will be propagated to FSUID

Buggy tho; while every setuid & setreuid sets FSUID to EUID, if call
setresuid and *don't change* EUID, then setresuid will NOT set FSUID = EUID

E.g. RUID = EUID = SUID = 0; FSUID = 0;

setresuid(x,x,-1)	RUID = EUID = FSUID = x; SUID = 0;
setfsuid(0)             RUID = EUID = x; SUID = FSUID = 0;
setresuid(-1,-1,x)	RUID = EUID = SUID = x; FSUID = 0;

 --> INVARIANT violated

(passing -1 as value means don't change this UID)

SETGID & relatives: 

 permissions check for setregid != permissions check for setreuid

 (in Solaris)

Privileges carried by EUID... so having EGID == 0 doesn't buy you anything

Upstart & STAF

New Linux distributions are using upstart framework to manage start and stop of services. Upstart does not rely on init.d-scripts anymore, but introduced a new declaration syntax to describe dependencies and requirements. Per service a single file is placed in directory /etc/init/, containing the service declaration.

STAF is the Software Testing Automation Framework, an open source, multi-platform, multi-language framework for distributed testing. Each host integrating into the test framework must execute the staf-service as background service receiving and executing commands on that host.

For Ubuntu 10.4 (Upstart based), STAF can be added to the list of system services being started during boot the following way.

We assume that STAF has been installed under directory /usr/local/staf. STAF is shipped with a startup script startSTAFProc.sh. The problem with that script is, that it starts the STAF process as detached subprocess, and terminates when done so. For upstart the script must be modified, so that upstart can keep a handle on the running service process, here STAF.

I prepared the following script /usr/local/staf/serviceSTAFProc.sh, which is sourcing the environment variables and finally replacing the shell context by the new STAF service context. The difference is subtle, but the effect is significant.

#!/bin/sh
#
# Sets up the STAF environment variables and
# replaces shell process by STAFProc process
# File: $STAF_HOME/serviceSTAFProc.sh
STAF_HOME=/usr/local/staf
. $STAF_HOME/STAFEnv.sh
exec $STAF_HOME/bin/STAFProc

This script will block until the process STRAFProc terminated. You may invoke the script on console and terminate by Ctrl-C.

An upstart configuration file (/etc/init/staf.conf) will tell upstart in which situation that STAF service is to be started.

# staf - software testing automation framework
#
# The Software Testing Automation Framework (STAF is
# an open source, multi language framework designed
# around the idea of reusable components
#
# File: /etc/init/staf.conf
#
description "software testing automation framework daemon"
start on runlevel [2345]
exec /usr/local/staf/serviceSTAFProc.sh


Now you should be able to start/stop the STAF service and query its state:

user@vmub1004c:~$ sudo initctl start staf
staf start/running, process 3173
user@vmub1004c:~$ sudo initctl status staf
staf start/running, process 3173
user@vmub1004c:~$ sudo initctl stop staf
staf stop/waiting


If you get an error message unknown job above, validate the executable-path or check for typos in the file staf.conf.

Qdroid 2.0 on SmartQ7

If you are one of the owners of the SmartQ7 (not the SmartQ V7 having improved hardware) you might be reading this document with interest. This document explains how to install Qdroid 2.0 Alpha – an Android port – onto the SmartQ7 device.

I bought my SmartQ7 from http://www.allpmp.com end of 2009, being shipped directly from China. In the meanwhile allpmp also ships from UK for European customers.

When I switched on my SmartQ7 the first time I wasn’t really satisfiedwith the Linux system running it. The hardware is nice, but the GUI did not go well with the touch screen the SmartQ7 provides. For example typing text into an text field, the onscreen keyboard popping up did hide the text field underneath, causing blind typing.

So I was keen on testing Android OS on my nice hardware. Whereas Android is focusing the smartphones, its port Qdroid is focusing the SmartQ product family. A google code page is hosting the project, providing a short description how to install the Qdroid-2.0-Alpha version on the SmartQ7.

http://code.google.com/p/qdroid/wiki/QdroidTwoAlphaOneEn

Once installed, it turned out to be best OS I ever run on that device. Although Alpha state, all applications run smooth and I did not have any problems installing other Android applications.

The installation process of Android applications is really simple, either downloading directly via apps-store or just copying the specific APK-file onto the SD card and selecting the file from within Qdroid’s file manager.

Installing Qdroid

As the installation of Qdroid itself is a bit tricky, I poured the given description into a script installing Qdroid 2.0 from firmware package onto SD card step by step.  In addition the script is activating English as the default language on first boot, instead of Chinese.

Before invoking the script one has got to download the desired firmware of the Qdroid system. The latest firmware can be downloaded from http://code.google.com/p/qdroid/downloads/list. The time writing this is the package Qdroid_2.0_Alpha2_2010.01.09.tar.bz2.

The package contains the firmware supporting SmartQ5 and Q7. With Android-2.0 the firmware has grown and does fit anymore into the internal flash of the SmartQ7 device. Now the firmware can only boot from SD Card.

Once you have got the firmware the script is performing the following magic steps to install the Qdroid system on the SD card.

First the SD card must is partitioned into two partitions, first partition is FAT32 format, which will hold the media files later, so the size should be enough to hold movies or MP3 files later, the second partition is EXT3 format (the recommended size should be larger than 150MB), then the following steps are performed:

1. Extract the files from firmeware package into temporary directory.
2. Copy “boot” directory to the FAT32 partition.
3. Copy the “files and folders” under the Qdroid_rootfs directory to the EXT3 partition.
4. Copy the kernel kernel/Q7/qdroid_kernel into the boot directory on the FAT32 partition.
5. Configure properties country=US, and language=en, so you dont have to bother the Chinese symbols on first boot.
6. Finally the script ensures  make sure that all files on EXT3 partition are executable and readable

To create the boot disk you require admin/root privileges, being able to invoke sudo command. The script is invoked with the device id as second argument.  The command dmesg will tell you the device id associated with the SD cards.

The following command line demonstrates the invocation, whereas /dev/sdb must be replaced by the device id your SD card is associated with on your system, it might be /dev/sdb or /dev/sbc, or other.

sudo ./qdroid-inst.sh Qdroid_2.0_Alpha2_2010.01.09.tar.bz2 /dev/sdb

The  script is hosted at https://sourceforge.net/projects/qdroid-inst/

#!/bin/sh -e
## File: qdroid-inst.sh
## Installing the Qdroid 2.0 firmware for SmartQ7 and SmartQ5 on SD card
##
## Author: Frank Rehberger
## Copyright: 2010 Sked.net
## License: GPLv3
## Version: 1.0
## Last Edited: 2010-04-09echo “args $#”
if [ "$#" != "2" ]; then
echo “Error, usage: $0 <firmeware-package> <device>”
exit 1
fi

## read arguments from command line
PKG=$1
DEV=$2

## may be one of Q7 or Q5
SMARTQ_DEV=Q7

## Size of Ext partition in percentage of total capacity. Size must be
## 150MB at least, arround 200MB is a good value. Choose the right
## value depending on capacity:
##
## 1GB choose PERCENTAGE=25
## 4GB choose PERCENTAGE=5
PERCENTAGE=5

## unmount the devices if mounted
mount | grep “$DEV” &&  umount “${DEV}1″ “${DEV}2″

## read size of device and calculate the number of cyls for the FAT32 partition
NOF_CYLINDERS=`sfdisk -g ${DEV} | (read t0 cyl t1; echo $cyl)`
EXT_CYLINDERS=`expr \( “$NOF_CYLINDERS” \* “$PERCENTAGE” \) / 100`
FAT_CYLINDERS=`expr “$NOF_CYLINDERS” – “$EXT_CYLINDERS”`

## partition the SD card, first is FAT32 partition using most of the
## space, second one is Linux partition using the remaining space on
## that device
echo “Creating two partitions on device”
sfdisk “$DEV” <<EOF
,${FAT_CYLINDERS},c
,,L
EOF

## format the newly created partitions, label them MEDIA and SYS
mkfs.vfat  “${DEV}1″
mkfs.ext3  -j “${DEV}2″
## disable periodic partition checks
#tune2fs -c 0 “${DEV}2″

## mount the partitions beneath the /tmp directory
echo “Mounting partitions”
mkdir -p /tmp/MEDIA; mount “${DEV}1″ /tmp/MEDIA
mkdir -p /tmp/SYS;   mount “${DEV}2″ /tmp/SYS

## creating a tmp-subdir makes the following commands independed of
## the release name
echo “Copying firmware to SD card”
rm -rf /tmp/qdroid-inst
mkdir -p /tmp/qdroid-inst
if tar -C /tmp/qdroid-inst/ -xjf “$PKG”; then
cp -r /tmp/qdroid-inst/*/boot  /tmp/MEDIA/
cp -a /tmp/qdroid-inst/*/Qdroid_rootfs/* /tmp/SYS/
cp    /tmp/qdroid-inst/*/kernel/$SMARTQ_DEV/qdroid_kernel /tmp/MEDIA/boot/
## settings for english usage on first bootup
mkdir -p   /tmp/SYS/data/property/
echo “US” > /tmp/SYS/data/property/persist.sys.country
echo “en” > /tmp/SYS/data/property/persist.sys.language
touch      /tmp/SYS/data/property/persist.sys.localevar
## ensure all files are readable, writable and executable on ext3 partition
chmod -R 777 /tmp/SYS/
else
echo “Error reading firmware”
exit 1
fi

echo “Syncing SD card”
sync

echo “Cleaning up”
umount /tmp/MEDIA /tmp/SYS

rm -rf /tmp/qdroid-inst/
rmdir  /tmp/MEDIA /tmp/SYS

echo “Done, now you can safely remove the SD card”

The script will create the intermediate directory /tmp/qdroid-inst/ and will unmount and mount the partitions as required. You must not access the SD card with any other application at this time, otherwise the unmount would fail.

After the script has terminated you can safely remove the SD card from reader and you can insert the SD-Card into the SmartQ7 device and switch on power, or just plugin the power supply which will cause the device to boot.  For few seconds the dual-boot manager will offer the choice for the native system or Android from SD card. Use the two up/down buttons left of screen to choose the Android systems and press the menu button left of screen to start the boot process. You can not use the touch screen to choose one of the options with finger tip, which irritated me on first trial.

I can confirm that the Wifi is working fine now. Also does the calibration programe, allthough the release notes mentioned it might not work for Q7. Otherwise you may use the workarround copying the calibration file from native Ubuntu Linux system onto the SD card, using a terminal window, from Ubuntu system’s “/etc/pointercal” to Qdroid’s “/data/etc/pointercal”.

The sound is still a problem, it may happen that after boot the volume is very low. The solution is to modify the sound volume in Settings menu once after startup, which seems to write the correct volume setting to sound driver.

The buttons  of the SmartQ7 have the following meaning:

• Power button:
  Short Press: Sleep;
  Long Press: Shutdown dialog;
  Continuous press twice: Wake up.
• Home button:
  Short Press: Goto home(desktop);
  Long Press: task switch.
• Menu button:
  Short Press: App menu;
  Long Press: Soft keyboard.
• Back button:
  Short Press: Go back;
  Long Press: None

Sadly the  Qdroid 2.0 Alpha can’t play video out of the box, but this more due to the lack of a video player. The solution is to install the free mVideoPlayer http://www.androlib.com/android.application.afzkl-development-mvideoplayer-pzDw.aspx from Qdroid-AppsStore, which is playing 3gp videos fine. In case of AVI videos they must be converted to 3GP format.

Links:

http://www.jiongtang.com/fourm/viewtopic.php?f=28&t=1218

http://code.google.com/p/qdroid/wiki/QdroidTwoAlphaOneEn

http://code.google.com/p/qdroid/

http://www.androlib.com/android.application.afzkl-development-mvideoplayer-pzDw.aspx

GNOME Application Menu

GNOME is a popular Desktop environment for Linux and Unix like operating systems. The following sections will explain how to integrate you application into the application menus, also known as start menus. In later posts I will explain how opensource code is managed and how it is packaged and shipped with Ubuntu and Redhat Linux distributions.

Development

The GNOME Desktop is based on the Gtk+ graphical toolkit to draw windows and widgets. Gtk+ has its roots in the GIMP project, providing a full featured graphics and image manipulation program. For that reason Gtk+ stands for The GIMP toolkit. Arround Gtk+ the GNOME project developed services and features, implementing a rich but simple to use Desktop environment, standardizing interfaces and services, such as printing, event management, etc.

The core libraries of GNOME and Gtk+ have been implemented in C for performance reasons and to allow easy interfacing from all kinds of environments and programming languages. Therefor you may choose from all kinds of programming languages to implement an application for the GNOME Desktop, such as C, C++, C#, Java, Python, and Perl, just to mention the most popular ones.

In contrast, the KDE project is based on the Qt library (say “cutie”), and the whole project is based on C++.

Developing a GNOME application I recommend the interpreted language Python, combined with GtkBuilder feature, formerly known as Glade. The GtkBuilder features allows to create the GUI with Interface Builder Glade Interface Designer, being stored as declerative XML file. The Python application just needs to invoke the GtkBuilder to read the file, build teh GUI and bind event handlers to the events and widgets. This allows a strict separation of GUI development and application logics. GUI events will be delegated to application logic/functions using callbacks which have been connected to before.

Compared to C the programming language Python allows more rapid development to bring your prototype to the street. The drawback of Python is the weak runtime type-checking which demands more discipline of the programmer.

Micah Carrick published an excellent Gtk and Glade tutorial explaining also usage with Python programming language.

Once you are done with your application,and ship it as package to users, you want it to show up in the system wide GNOME or KDE application menus after installation, such as for the Cheese webcam application shown here

Application Menu Description

The menu entries allow a comfortable start of your application via the GNOME Application Menus. The entries can be registered at a central location for all users or per user via configuration files.

A single file holds the description of the menu entry. System wide this file is placed in the directory /usr/share/applications/. The following file demonstrates a menu entry for the webcam tool cheese being shipped with Ubuntu Linux distribution. The original file has been simplified for better understanding. For example the long list of fullname translations has been shortened.

 1: # File /usr/share/applications/cheese.desktop
 2: [Desktop Entry]
 3: Name=Cheese
 4: X-GNOME-FullName=Cheese Webcam Booth
 5: X-GNOME-FullName[de]=Cheese Webcam-Automat
 6: X-GNOME-FullName[es]=Fotomatón de cámara web Cheese
 7: Comment=Take photos and videos with your webcam, with fun graphical effects
 8: Exec=cheese
 9: Terminal=false
10: Type=Application
11: StartupNotify=true
12: Icon=cheese
13: Categories=GNOME;AudioVideo;
14: X-GNOME-Bugzilla-Bugzilla=GNOME
15: X-GNOME-Bugzilla-Product=cheese
16: X-GNOME-Bugzilla-Component=general
17: X-GNOME-Bugzilla-Version=2.28.1
18: X-GNOME-Bugzilla-ExtraInfoScript=/usr/lib/cheese/cheese/cheese-bugreport.sh
19: X-Ubuntu-Gettext-Domain=cheese

Any time you place a new file in that specific directory, the GNOME Menu of all useser will be updated immediatly. The given file declares a number of attributes being explained here.

The file starts with a comment in line 1. Commenting lines can be placed anywhere in the file. The following line [Desktop Entry] declares the start of the menu description section. This style comes from times before XML became popular.

Most attributes are self explaining, but some are worth to look closer at.

Line 3: Name=Cheese defines the short name of the application being showed in menu tray.

Line 8: Exec=cheese declares the executable to be started in case the menu entry is selected. The file is searched for along the paths declared by PATH environment variable.

Line 8: Terminal=false defines that this application does not require a terminal window to be executed in. If the application does not open its own window, but expects a shell-terminal environment, this attribute must be set to true.

Line 9: Type=Application defines that this is a reference to an application. In case the menu entry is a weblink the type will be Link.

Line 12: Icon=cheese declares the icon being displayed in the menu entry. By default the icon is searched for in the system wide icon directory, so that the full name expaned will be /usr/share/icons/hicolor/48×48/apps/cheese.png.

The portable network graphics format (PNG) had been developed as replacement for GIF to get around patent issues.

Line 13: Categories=GNOME;AudioVideo; declares the menu folder the entry will be placed in. A number of categories have been predefined, an extended list of currently used categories is added as appendix.

Application categories

You have got to choose a category for your application. Files of the same category will be grouped into the same application menu subfolder for seclection.  The following is a list of categories of Linux desktop application being used currently. The list is incomplete,it reflects more the kind of applications installed on my system. The GNOME Desktop may group similar categories so that they may appear in the same menu folder.

The list is quite extensive. If you have got to choose one of the categories, my advice is first to choose the menu folder it should appear in, and then to look which categories the corresponding applications belong to. If your application is not GNOME specific, you should choose one of the more general ones, such as Application;Utility; if it is an utility.

Application;Development; 
Application;Network; 
Application;Office;Database; 
Application;Office;Math; 
Application;Office;Presentation; 
Application;Office;Spreadsheet; 
Application;Office;WordProcessor; 
Application;System; 
Application;System;Settings; 
Application;Utility; 
Application;Utility;TextEditor; 
AudioVideo; 
AudioVideo;Audio;AudioVideoEditing; 
AudioVideo;GTK;Player;TV; 
Core; 
Debugger;Development;GNOME;Profiling; 
Development; 
Development;ProjectManagement; 
Development;RevisionControl; 
Documentation;Development; 
Education; 
Emulator;Utility; 
Game;ArcadeGame; 
GNOME;Application;Core; 
GNOME;Application;Development; 
GNOME;Application;Network; 
GNOME;AudioVideo; 
GNOME;AudioVideo;DiscBurning; 
GNOME;Core;System; 
GNOME;Game;BoardGame; 
GNOME;GTK; 
GNOME;GTK;Accessibility;X-GNOME-PersonalSettings; 
GNOME;GTK;AudioVideo; 
GNOME;GTK;AudioVideo;Audio;Recorder; 
GNOME;GTK;Core; 
GNOME;GTK;Core;Documentation; 
GNOME;GTK;Development;IDE; 
GNOME;GTK;Game;ArcadeGame; 
GNOME;GTK;Game;BlocksGame; 
GNOME;GTK;Game;BoardGame; 
GNOME;GTK;Game;CardGame; 
GNOME;GTK;Game;LogicGame; 
GNOME;GTK;Graphics;RasterGraphics;Viewer; 
GNOME;GTK;Graphics;VectorGraphics;Viewer; 
GNOME;GTK;Network;InstantMessaging; 
GNOME;GTK;Network;RemoteAccess; 
GNOME;GTK;Network;Telephony; 
GNOME;GTK;Office;Dictionary; 
GNOME;GTK;Office;Email;Calendar;ContactManagement;X-Red-Hat-Base; 
GNOME;GTK;Security;Utility; 
GNOME;GTK;Settings; 
GNOME;GTK;Settings;DesktopSettings; 
GNOME;GTK;Settings;HardwareSettings; 
GNOME;GTK;Settings;System; 
GNOME;GTK;Settings;X-GNOME-NetworkSettings; 
GNOME;GTK;Settings;X-GNOME-PersonalSettings; 
GNOME;GTK;Settings;X-SuSE-ControlCenter-System;X-GNOME-NetworkSettings; 
GNOME;GTK;System; 
GNOME;GTK;System;Settings; 
GNOME;GTK;System;Settings;HardwareSettings; 
GNOME;GTK;System;Settings;Monitor; 
GNOME;GTK;System;Settings;X-GNOME-NetworkSettings; 
GNOME;GTK;System;Utility;Core; 
GNOME;GTK;Utility; 
GNOME;GTK;Utility;Calculator 
GNOME;GTK;Utility;Core; 
GNOME;GTK;Utility;TerminalEmulator; 
GNOME;GTK;Utility;TextEditor; 
GNOME;Network; 
GNOME;Office;X-Red-Hat-Base; 
GNOME;Settings;DesktopSettings; 
GNOME;System;Filesystem;Settings; 
Graphics;2DGraphics;RasterGraphics;GTK; 
Graphics;Photography;GNOME;GTK; 
Graphics;VectorGraphics; 
Graphics;VectorGraphics;GTK; 
GTK;AudioVideo;Audio;Video;Player;TV; 
GTK;GNOME;Application;System;Settings; 
GTK;GNOME;AudioVideo;Player;Video; 
GTK;GNOME;Settings;DesktopSettings; 
GTK;GNOME;Settings;HardwareSettings; 
GTK;GNOME;Settings;X-GNOME-PersonalSettings; 
GTK;GNOME;System;Monitor;Settings; 
GTK;GNOME;Utility; 
GTK;GNOME;Utility;Accessibility; 
GTK;GNOME;Utility;Archiving;Compression; 
GTK;GNOME;X-GNOME-NetworkSettings;Network; 
GTK;Graphics;RasterGraphics;Scanning;OCR; 
GTK;HardwareSettings;Settings; 
GTK;Monitor;Utility; 
GTK;Network;TrayIcon; 
GTK;Printing;HardwareSettings;Settings;System; 
GTK;Utility; 
Network; 
Network;Application; 
Network;FileTransfer;P2P;GTK; 
Network;InstantMessaging; 
PackageManager;GTK;System;Settings; 
PackageManager;System; 
Profiling;Development; 
Qt;Development;RevisionControl; 
Settings; 
Settings;X-GNOME-PersonalSettings; 
Settings;X-GNOME-SystemSettings; 
System; 
System;Settings; 
System;Settings;GNOME;GTK; 
System;Settings;GTK;HardwareSettings; 
System;Settings;PackageManager;GTK; 
X-nxclient; 

This List has been created using the command sequence

grep -h Categories /usr/share/applications/* |sort | uniq | sed 's/Categories=//g'

Various categories may share the same groupe in the GNOME Menus, such as the office applications. The user may define a new category, but is is recommended to choose one of the predefined categories.

Hello World!

This is our new channel to  publish technical content online. Sked.net provides consulting and development  for real-time applications, open-source platforms , embedded systems (ATmega) and mobile devices (Android).