Merge lp:~sylvain-pineau/checkbox/plainbox-support into lp:checkbox

[Sylvain Pineau]

Implementation proposal of the new support library for plainbox provider scripts

Notes:
- Proposed package name: checkbox-support
- Proposed python namespace: checkbox_support
- Remove the original checkbox.parsers.pyparsing to use the ubuntu packaged version for python3
- Tests run ok

[Zygmunt Krynicki (zyga)]

ensure that all commits have correct, scoped first line (summary)

[Sylvain Pineau (sylvain-pineau)]

It's now ready for review/testing

review: Needs Resubmitting

[Zygmunt Krynicki (zyga)]

This looks good.
I need to look at it in the tree and think about any potential issues but you have my tentative +1

=== added directory 'checkbox-support'
=== added symlink 'checkbox-support/COPYING'
=== target is u'../plainbox/COPYING'
=== added file 'checkbox-support/README.rst'
--- checkbox-support/README.rst	1970-01-01 00:00:00 +0000
+++ checkbox-support/README.rst	2014-01-07 13:44:32 +0000
@@ -0,0 +1,6 @@
+CheckBox Support
+================
+
+CheckBox Support library is a collection of python modules used by PlainBox
+providers scripts.
+They were originally provided by the checkbox python package.

=== added directory 'checkbox-support/checkbox_support'
=== added file 'checkbox-support/checkbox_support/__init__.py'
=== added directory 'checkbox-support/checkbox_support/contrib'
=== added file 'checkbox-support/checkbox_support/contrib/__init__.py'
=== added file 'checkbox-support/checkbox_support/contrib/xrandr.py'
--- checkbox-support/checkbox_support/contrib/xrandr.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/contrib/xrandr.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,1064 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+#
+# Python-XRandR provides a high level API for the XRandR extension of the
+# X.org server. XRandR allows to configure resolution, refresh rate, rotation
+# of the screen and multiple outputs of graphics cards.
+#
+# Copyright 2007 © Sebastian Heinlein <[e-mail]>
+# Copyright 2007 © Michael Vogt <[e-mail]>
+# Copyright 2007 © Canonical Ltd.
+#
+# In many aspects it follows the design of the xrand tool of the X.org, which
+# comes with the following copyright:
+#
+# Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+# Copyright © 2002 Hewlett Packard Company, Inc.
+# Copyright © 2006 Intel Corporation
+#
+# And can be downloaded here:
+#
+# git://anongit.freedesktop.org/git/xorg/app/xrandr
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301  USA
+
+from ctypes import (
+    POINTER,
+    Structure,
+    byref,
+    c_char_p,
+    c_void_p,
+    c_int,
+    c_long,
+    c_ulong,
+    c_ushort,
+    cdll,
+)
+import os
+
+RR_ROTATE_0 = 1
+RR_ROTATE_90 = 2
+RR_ROTATE_180 = 4
+RR_ROTATE_270 = 8
+RR_REFLECT_X = 16
+RR_REFLECT_Y = 32
+
+RR_CONNECTED = 0
+RR_DISCONNECTED = 1
+RR_UNKOWN_CONNECTION = 2
+
+RR_BAD_OUTPUT = 0
+RR_BAD_CRTC = 1
+RR_BAD_MODE = 2
+
+RR_SET_CONFIG_SUCCESS = 0
+RR_SET_CONFIG_INVALID_CONFIG_TIME = 1
+RR_SET_CONFIG_INVALID_TIME = 2
+RR_SET_CONFIG_FAILED = 3
+
+# Flags to keep track of changes
+CHANGES_NONE = 0
+CHANGES_CRTC = 1
+CHANGES_MODE = 2
+CHANGES_RELATION = 4
+CHANGES_POSITION = 8
+CHANGES_ROTATION = 16
+CHANGES_REFLECTION = 32
+CHANGES_AUTOMATIC = 64
+CHANGES_REFRESH = 128
+CHANGES_PROPERTY = 256
+
+# Relation information
+RELATION_ABOVE = 0
+RELATION_BELOW = 1
+RELATION_RIGHT_OF = 2
+RELATION_LEFT_OF = 3
+RELATION_SAME_AS = 4
+
+# some fundamental datatypes
+RRCrtc = c_long
+RROutput = c_long
+RRMode = c_long
+Connection = c_ushort
+SubpixelOrder = c_ushort
+Time = c_ulong
+Rotation = c_ushort
+Status = c_int
+
+# load the libs
+xlib = cdll.LoadLibrary('libX11.so.6')
+rr = cdll.LoadLibrary('libXrandr.so.2')
+
+
+# query resources
+class _XRRModeInfo(Structure):
+    _fields_ = [
+        ("id", RRMode),  # XID is c_long
+        ("width", c_int),
+        ("height", c_int),
+        ("dotClock", c_long),
+        ("hSyncStart", c_int),
+        ("hSyncEnd", c_int),
+        ("hTotal", c_int),
+        ("hSkew", c_int),
+        ("vSyncStart", c_int),
+        ("vSyncEnd", c_int),
+        ("vTotal", c_int),
+        ("name", c_char_p),
+        ("nameLength", c_int),
+        ("modeFlags", c_long),
+        ]
+
+
+class _XRRScreenSize(Structure):
+    _fields_ = [
+        ("width", c_int),
+        ("height", c_int),
+        ("mwidth", c_int),
+        ("mheight", c_int)
+        ]
+
+
+class _XRRCrtcInfo(Structure):
+    _fields_ = [
+        ("timestamp", Time),
+        ("x", c_int),
+        ("y", c_int),
+        ("width", c_int),
+        ("height", c_int),
+        ("mode", RRMode),
+        ("rotation", c_int),
+        ("noutput", c_int),
+        ("outputs", POINTER(RROutput)),
+        ("rotations", Rotation),
+        ("npossible", c_int),
+        ("possible", POINTER(RROutput)),
+        ]
+
+
+class _XRRScreenResources(Structure):
+    _fields_ = [
+        ("timestamp", Time),
+        ("configTimestamp", Time),
+        ("ncrtc", c_int),
+        ("crtcs", POINTER(RRCrtc)),
+        ("noutput", c_int),
+        ("outputs", POINTER(RROutput)),
+        ("nmode", c_int),
+        ("modes", POINTER(_XRRModeInfo)),
+        ]
+
+
+class RRError(Exception):
+    """Base exception class of the module"""
+    pass
+
+
+class UnsupportedRRError(RRError):
+    """Raised if the required XRandR extension version is not available"""
+    def __init__(self, required, current):
+        self.required = required
+        self.current = current
+
+
+# XRRGetOutputInfo
+class _XRROutputInfo(Structure):
+    _fields_ = [
+        ("timestamp", Time),
+        ("crtc", c_int),
+        ("name", c_char_p),
+        ("nameLen", c_int),
+        ("mm_width", c_ulong),
+        ("mm_height", c_ulong),
+        ("connection", Connection),
+        ("subpixel_order", SubpixelOrder),
+        ("ncrtc", c_int),
+        ("crtcs", POINTER(RRCrtc)),
+        ("nclone", c_int),
+        ("clones", POINTER(RROutput)),
+        ("nmode", c_int),
+        ("npreferred", c_int),
+        ("modes", POINTER(RRMode))
+        ]
+
+
+class _XRRCrtcGamma(Structure):
+    _fields_ = [
+        ('size', c_int),
+        ('red', POINTER(c_ushort)),
+        ('green', POINTER(c_ushort)),
+        ('blue', POINTER(c_ushort)),
+        ]
+
+
+def _array_conv(array, type, conv=lambda x: x):
+    length = len(array)
+    res = (type * length)()
+    for i in range(length):
+        res[i] = conv(array[i])
+    return res
+
+
+class Output:
+    """The output is a reference to a supported output jacket of the graphics
+       card. Outputs are attached to a hardware pipe to be used. Furthermore
+       they can be a clone of another output or show a subset of the screen"""
+    def __init__(self, info, id, screen):
+        """Initializes an output instance"""
+        self._info = info
+        self.id = id
+        self._screen = screen
+        # Store changes later here
+        self._mode = None
+        self._crtc = None
+        self._rotation = RR_ROTATE_0
+        self._relation = None
+        self._relation_offset = 0
+        self._relative_to = None
+        self._position = None
+        self._reflection = None
+        self._automatic = None
+        self._rate = None
+        self._changes = CHANGES_NONE
+        self._x = 0
+        self._y = 0
+
+        self.name = self._info.contents.name
+
+    def __del__(self):
+        """Frees the internal reference to the output info if the output gets
+           removed"""
+        rr.XRRFreeOutputInfo(self._info)
+
+    def get_physical_width(self):
+        """Returns the display width reported by the connected output device"""
+        return self._info.contents.mm_width
+
+    def get_physical_height(self):
+        """
+        Returns the display height reported by the connected output device
+        """
+        return self._info.contents.mm_height
+
+    def get_crtc(self):
+        """Returns the xid of the hardware pipe to which the output is
+           attached. If the output is disabled it will return 0"""
+        return self._info.contents.crtc
+
+    def get_crtcs(self):
+        """Returns the xids of the hardware pipes to which the output could
+           be attached"""
+        crtcs = []
+        for i in range(self._info.contents.ncrtc):
+            for crtc in self._screen.crtcs:
+                if crtc.xid == self._info.contents.crtcs[i]:
+                    crtcs.append(crtc)
+        return crtcs
+
+    def get_available_rotations(self):
+        """Returns a binary flag of the supported rotations of the output or
+           0 if the output is disabled"""
+        rotations = RR_ROTATE_0
+        found = False
+        if self.is_active():
+            # Get the rotations supported by all crtcs to make assigning
+            # crtcs easier. Furthermore there don't seem to be so many
+            # cards which show another behavior
+            for crtc in self.get_crtcs():
+                # Set rotations to the value of the first found crtc and
+                # then create a subset only for all other crtcs
+                if not found:
+                    rotations = crtc.get_available_rotations()
+                    found = True
+                else:
+                    rotations = rotations & crtc.get_available_rotations()
+        return rotations
+
+    def get_available_modes(self):
+        """Returns the list of supported mode lines (resolution, refresh rate)
+           that are supported by the connected device"""
+        modes = []
+        for m in range(self._info.contents.nmode):
+            output_modes = self._info.contents.modes
+            for s in range(self._screen._resources.contents.nmode):
+                screen_modes = self._screen._resources.contents.modes
+                if screen_modes[s].id == output_modes[m]:
+                    modes.append(screen_modes[s])
+        return modes
+
+    def get_preferred_mode(self):
+        """Returns an index that refers to the list of available modes and
+           points to the preferred mode of the connected device"""
+        return self._info.contents.npreferred
+
+    def is_active(self):
+        """Returns True if the output is attached to a hardware pipe, is
+           enabled"""
+        return self._info.contents.crtc != 0
+
+    def is_connected(self):
+        """Return True if a device is detected at the output"""
+        if self._info.contents.connection in (RR_CONNECTED,
+                                              RR_UNKOWN_CONNECTION):
+            return True
+        return False
+
+    def disable(self):
+        """Disables the output"""
+        if not self.is_active():
+            return
+        self._mode = None
+        self._crtc._outputs.remove(self)
+        self._crtc = None
+        self._changes = self._changes | CHANGES_CRTC | CHANGES_MODE
+
+    def set_to_mode(self, mode):
+        modes = self.get_available_modes()
+        if mode in range(len(modes)):
+            self._mode = modes[mode].id
+            return
+        raise RRError("Mode is not available")
+
+    def set_to_preferred_mode(self):
+        modes = self.get_available_modes()
+        mode = modes[self.get_preferred_mode()]
+        if mode != None:
+            self._mode = mode.id
+            return
+        raise RRError("Preferred mode is not available")
+
+    def get_clones(self):
+        """Returns the xids of the outputs which can be clones of the output"""
+        clones = []
+        for i in range(self._info.contents.nclone):
+            id = self._info.contents.clones[i]
+            o = self._screen.get_output_by_id(id)
+            clones.append(o)
+        return clones
+
+    def set_relation(self, relative, relation, offset=0):
+        """Sets the position of the output in relation to the given one"""
+        rel = self._screen.get_output_by_name(relative)
+        if rel and relation in (RELATION_LEFT_OF, RELATION_RIGHT_OF,
+                                RELATION_ABOVE, RELATION_BELOW,
+                                RELATION_SAME_AS):
+            self._relation = relation
+            self._relative_to = rel
+            self._relation_offset = offset
+            self._changes = self._changes | CHANGES_RELATION
+        else:
+            raise RRError("The given relative output or relation is not "
+                          "available")
+
+    def has_changed(self, changes=None):
+        """Checks if the output has changed: Either for a specific change or
+           generally"""
+        if changes:
+            return self._changes & changes
+        else:
+            return self._changes != CHANGES_NONE
+
+
+class Crtc:
+    """The crtc is a reference to a hardware pipe that is provided by the
+       graphics device. Outputs can be attached to crtcs"""
+
+    def __init__(self, info, xid, screen):
+        """Initializes the hardware pipe object"""
+        self._info = info
+        self.xid = xid
+        self._screen = screen
+        self._outputs = []
+
+    def __del__(self):
+        """Frees the reference to the rendering pipe if the instance gets
+           removed"""
+        rr.XRRFreeCrtcConfigInfo(self._info)
+
+    def get_xid(self):
+        """Returns the internal id of the crtc from the X server"""
+        return self.xid
+
+    def get_available_rotations(self):
+        """Returns a binary flag that contains the supported rotations of the
+           hardware pipe"""
+        return self._info.contents.rotations
+
+    def set_config(self, x, y, mode, outputs, rotation=RR_ROTATE_0):
+        """Configures the render pipe with the given mode and outputs. X and y
+           set the position of the crtc output in the screen"""
+        rr.XRRSetCrtcConfig(self._screen._display,
+                            self._screen._resources,
+                            self.xid,
+                            self._screen.get_timestamp(),
+                            c_int(x), c_int(y),
+                            mode,
+                            rotation,
+                            _array_conv(outputs, RROutput, lambda x: x.id),
+                            len(outputs))
+
+    def apply_changes(self):
+        """Applies the stored changes"""
+        if len(self._outputs) > 0:
+            output = self._outputs[0]
+            self.set_config(output._x, output._y, output._mode,
+                            self._outputs, output._rotation)
+        else:
+            self.disable()
+
+    def disable(self):
+        """Turns off all outputs on the crtc"""
+        rr.XRRSetCrtcConfig(self._screen._display,
+                            self._screen._resources,
+                            self.xid,
+                            self._screen.get_timestamp(),
+                            0, 0,
+                            None,
+                            RR_ROTATE_0,
+                            0, 0)
+
+    #FIXME: support gamma settings
+    """
+    def get_gamma_size(self):
+        return rr.XRRGetCrtcGammaSize(self._screen._display, self.id)
+    def get_gamma(self):
+        result = rr.XRRGetCrtcGamma(self._screen._display, self.id)
+        return _from_gamma(result)
+    def set_gamma(self, gamma):
+        g = _to_gamma(gamma)
+        rr.XRRSetCrtcGamma(self._screen._display, self.id, g)
+        rr.XRRFreeGamma(g)
+        gamma = property(get_gamma, set_gamma)"""
+
+    def load_outputs(self):
+        """Get the currently assigned outputs"""
+        outputs = []
+        for i in range(self._info.contents.noutput):
+            id = self._info.contents.outputs[i]
+            o = self._screen.get_output_by_id(id)
+            outputs.append(o)
+        self._outputs = outputs
+
+    def get_outputs(self):
+        """Returns the list of attached outputs"""
+        return self._outputs
+
+    def add_output(self, output):
+        """Adds the specified output to the crtc"""
+        output._crtc = self
+        self._outputs.append(output)
+
+    def supports_output(self, output):
+        """Check if the output can be used by the crtc.
+           See check_crtc_for_output in xrandr.c"""
+        if not self.xid in [c.xid for c in output.get_crtcs()]:
+            return False
+        if len(self._outputs):
+            for other in self._outputs:
+                if other == output:
+                    continue
+                if other._x != output._x:
+                    return False
+                if other._y != output._y:
+                    return False
+                if other._mode != output._mode:
+                    return False
+                if other._rotation != output._rotation:
+                    return False
+        #FIXME: pick_crtc is still missing
+        elif self._info.contents.noutput > 0:
+            if self._info.contents.x != output._x:
+                return False
+            if self._info.contents.y != output._y:
+                return False
+            if self._info.contents.mode_info != output._mode:
+                return False
+            if self._info.rotation != output._rotation:
+                return False
+        return True
+
+    def supports_rotation(self, rotation):
+        """Check if the given rotation is supported by the crtc"""
+        rotations = self._info.contents.rotations
+        dir = rotation & (RR_ROTATE_0 | RR_ROTATE_90 | RR_ROTATE_180 |
+                          RR_ROTATE_270)
+        reflect = rotation & (RR_REFLECT_X | RR_REFLECT_Y)
+        if (((rotations & dir) != 0) and ((rotations & reflect) == reflect)):
+            return True
+        return False
+
+    def has_changed(self):
+        """Check if there are any new outputs assigned to the crtc or any
+           outputs with a changed mode or position"""
+        if len(self._outputs) != self._info.contents.noutput:
+            return True
+        for i in range(self._info.contents.noutput):
+            id = self._info.contents.outputs[i]
+            output = self._screen.get_output_by_id(id)
+            if not output in self._outputs:
+                return True
+            if output.has_changed():
+                return True
+        return False
+
+
+class Screen:
+    def __init__(self, dpy, screen=-1):
+        """Initializes the screen"""
+        # Some sane default values
+        self.outputs = {}
+        self.crtcs = []
+        self._width = 0
+        self._height = 0
+        self._width_max = 0
+        self._height_max = 0
+        self._width_min = 0
+        self._height_min = 0
+        self._width_mm = 0
+        self._height_mm = 0
+
+        self._display = dpy
+        if not -1 <= screen < xlib.XScreenCount(dpy):
+            raise RRError("The chosen screen is not available", screen)
+        elif screen == -1:
+            self._screen = xlib.XDefaultScreen(dpy)
+        else:
+            self._screen = screen
+        self._root = xlib.XDefaultRootWindow(self._display, self._screen)
+        self._id = rr.XRRRootToScreen(self._display, self._root)
+
+        self._load_resources()
+        self._load_config()
+        (self._width, self._height,
+         self._width_mm, self._height_mm) = self.get_size()
+        if XRANDR_VERSION >= (1, 2):
+            self._load_screen_size_range()
+            self._load_crtcs()
+            self._load_outputs()
+
+        # Store XRandR 1.0 changes here
+        self._rate = self.get_current_rate()
+        self._rotation = self.get_current_rotation()
+        self._size_index = self.get_current_size_index()
+
+    def __del__(self):
+        """Free the reference to the interal screen config if the screen
+           gets removed"""
+        rr.XRRFreeScreenConfigInfo(self._config)
+
+    def _load_config(self):
+        """Loads the screen configuration. Only needed privately by the
+           the bindings"""
+        class XRRScreenConfiguration(Structure):
+            " private to Xrandr "
+            pass
+        gsi = rr.XRRGetScreenInfo
+        gsi.restype = POINTER(XRRScreenConfiguration)
+        self._config = gsi(self._display, self._root)
+
+    def _load_screen_size_range(self):
+        """Detects the dimensionios of the screen"""
+        minWidth = c_int()
+        minHeight = c_int()
+        maxWidth = c_int()
+        maxHeight = c_int()
+        res = rr.XRRGetScreenSizeRange(self._display, self._root,
+                                       byref(minWidth), byref(minHeight),
+                                       byref(maxWidth), byref(maxHeight))
+        if res:
+            self._width_max = maxWidth.value
+            self._width_min = minWidth.value
+            self._height_max = maxHeight.value
+            self._height_min = minHeight.value
+
+    def _load_resources(self):
+        """Loads the screen resources. Only needed privately for the
+           bindings"""
+        gsr = rr.XRRGetScreenResources
+        gsr.restype = POINTER(_XRRScreenResources)
+        self._resources = gsr(self._display, self._root)
+
+    def _load_crtcs(self):
+        """Loads the available XRandR 1.2 crtcs (hardware pipes) of
+           the screen"""
+        gci = rr.XRRGetCrtcInfo
+        gci.restype = POINTER(_XRRCrtcInfo)
+        c = self._resources.contents.crtcs
+        for i in range(self._resources.contents.ncrtc):
+            xrrcrtcinfo = gci(self._display, self._resources, c[i])
+            self.crtcs.append(Crtc(xrrcrtcinfo, c[i], self))
+
+    def _load_outputs(self):
+        """Loads the available XRandR 1.2 outputs of the screen"""
+        goi = rr.XRRGetOutputInfo
+        goi.restype = POINTER(_XRROutputInfo)
+        o = self._resources.contents.outputs
+        for i in range(self._resources.contents.noutput):
+            xrroutputinfo = goi(self._display, self._resources, o[i])
+            output = Output(xrroutputinfo, o[i], self)
+            self.outputs[xrroutputinfo.contents.name] = output
+            # Store the mode of the crtc in the output instance
+            crtc = self.get_crtc_by_xid(output.get_crtc())
+            if crtc:
+                output._mode = crtc._info.contents.mode
+                crtc.add_output(output)
+
+    def get_size(self):
+        """Returns the current pixel and physical size of the screen"""
+        width = xlib.XDisplayWidth(self._display, self._screen)
+        width_mm = xlib.XDisplayWidthMM(self._display, self._screen)
+        height = xlib.XDisplayHeight(self._display, self._screen)
+        height_mm = xlib.XDisplayHeightMM(self._display, self._screen)
+        return width, height, width_mm, height_mm
+
+    def get_timestamp(self):
+        """Creates a X timestamp that must be used when applying changes, since
+           they can be delayed"""
+        config_timestamp = Time()
+        rr.XRRTimes.restpye = c_ulong
+        return rr.XRRTimes(self._display, self._id, byref(config_timestamp))
+
+    def get_crtc_by_xid(self, xid):
+        """Returns the crtc with the given xid or None"""
+        for crtc in self.crtcs:
+            if crtc.xid == xid:
+                return crtc
+        return None
+
+    def get_current_rate(self):
+        """Returns the currently used refresh rate"""
+        _check_required_version((1, 0))
+        xccr = rr.XRRConfigCurrentRate
+        xccr.restype = c_int
+        return xccr(self._config)
+
+    def get_available_rates_for_size_index(self, size_index):
+        """Returns the refresh rates that are supported by the screen for
+           the given resolution. See get_available_sizes for the resolution to
+           which size_index points"""
+        _check_required_version((1, 0))
+        rates = []
+        nrates = c_int()
+        rr.XRRConfigRates.restype = POINTER(c_ushort)
+        _rates = rr.XRRConfigRates(self._config, size_index, byref(nrates))
+        for r in range(nrates.value):
+            rates.append(_rates[r])
+        return rates
+
+    def get_current_rotation(self):
+        """Returns the currently used rotation. Can be RR_ROTATE_0,
+        RR_ROTATE_90, RR_ROTATE_180 or RR_ROTATE_270"""
+        _check_required_version((1, 0))
+        current = c_ushort()
+        rr.XRRConfigRotations(self._config, byref(current))
+        return current.value
+
+    def get_available_rotations(self):
+        """Returns a binary flag that holds the available resolutions"""
+        _check_required_version((1, 0))
+        current = c_ushort()
+        rotations = rr.XRRConfigRotations(self._config, byref(current))
+        return rotations
+
+    def get_current_size_index(self):
+        """Returns the position of the currently used resolution size in the
+           list of available resolutions. See get_available_sizes"""
+        _check_required_version((1, 0))
+        rotation = c_ushort()
+        size = rr.XRRConfigCurrentConfiguration(self._config,
+                                                byref(rotation))
+        return size
+
+    def get_available_sizes(self):
+        """Returns the available resolution sizes of the screen. The size
+           index points to the corresponding resolution of this list"""
+        _check_required_version((1, 0))
+        sizes = []
+        nsizes = c_int()
+        xcs = rr.XRRConfigSizes
+        xcs.restype = POINTER(_XRRScreenSize)
+        _sizes = xcs(self._config, byref(nsizes))
+        for r in range(nsizes.value):
+            sizes.append(_sizes[r])
+        return sizes
+
+    def set_config(self, size_index, rate, rotation):
+        """Configures the screen with the given resolution at the given size
+           index, rotation and refresh rate. To get in effect call
+           Screen.apply_config()"""
+        _check_required_version((1, 0))
+        self.set_size_index(size_index)
+        self.set_refresh_rate(rate)
+        self.set_rotation(rotation)
+
+    def set_size_index(self, index):
+        """Sets the reoslution of the screen. To get in effect call
+           Screen.apply_config()"""
+        if index in range(len(self.get_available_sizes())):
+            self._size_index = index
+        else:
+            raise RRError("There isn't any size associated "
+                          "to the index %s" % index)
+
+    def set_rotation(self, rotation):
+        """Sets the rotation of the screen. To get in effect call
+           Screen.apply_config()"""
+        if self.get_available_rotations() & rotation:
+            self._rotation = rotation
+        else:
+            raise RRError("The chosen rotation is not supported")
+
+    def set_refresh_rate(self, rate):
+        """Sets the refresh rate of the screen. To get in effect call
+           Screen.apply_config()"""
+        if rate in self.get_available_rates_for_size_index(self._size_index):
+            self._rate = rate
+        else:
+            raise RRError("The chosen refresh rate %s is not "
+                          "supported" % rate)
+
+    def get_mode_by_xid(self, xid):
+        """Returns the mode of the given xid"""
+        screen_modes = self._resources.contents.modes
+        for s in range(self._resources.contents.nmode):
+            if screen_modes[s].id == xid:
+                return screen_modes[s]
+        return None
+
+    def get_output_by_name(self, name):
+        """Returns the output of the screen with the given name or None"""
+        if name in self.outputs:
+            return self.outputs[name]
+        else:
+            return None
+
+    def get_output_by_id(self, id):
+        """Returns the output of the screen with the given xid or None"""
+        for o in list(self.outputs.values()):
+            if o.id == id:
+                return o
+        return None
+
+    def print_info(self, verbose=False):
+        """Prints some information about the detected screen and its outputs"""
+        _check_required_version((1, 0))
+        print("Screen %s: minimum %s x %s, current %s x %s, maximum %s x %s" %\
+              (self._screen,
+               self._width_min, self._height_min,
+               self._width, self._height,
+               self._width_max, self._height_max))
+        print("          %smm x %smm" % (self._width_mm, self._height_mm))
+        print("Crtcs: %s" % len(self.crtcs))
+        if verbose:
+            print("Modes (%s):" % self._resources.contents.nmode)
+            modes = self._resources.contents.modes
+            for i in range(self._resources.contents.nmode):
+                print("  %s - %sx%s" % (modes[i].name,
+                                       modes[i].width,
+                                       modes[i].height))
+        i = 0
+        print("Sizes @ Refresh Rates:")
+        for s in self.get_available_sizes():
+            print("  [%s] %s x %s @ %s" % (
+                i, s.width, s.height,
+                self.get_available_rates_for_size_index(i)))
+            i += 1
+        print("Rotations:")
+        rots = self.get_available_rotations()
+        if rots & RR_ROTATE_0:
+            print("normal")
+        if rots & RR_ROTATE_90:
+            print("right")
+        if rots & RR_ROTATE_180:
+            print("inverted")
+        if rots & RR_ROTATE_270:
+            print("left")
+        print("")
+        print("Outputs:")
+        for o in list(self.outputs.keys()):
+            output = self.outputs[o]
+            print("  %s" % o)
+            if output.is_connected():
+                print("(%smm x %smm)" % (output.get_physical_width(),
+                                         output.get_physical_height()))
+                modes = output.get_available_modes()
+                print("    Modes:")
+                for m in range(len(modes)):
+                    mode = modes[m]
+                    refresh = mode.dotClock / (mode.hTotal * mode.vTotal)
+                    print("      [%s] %s x %s @ %s" % (m,
+                                                       mode.width,
+                                                       mode.height,
+                                                       refresh))
+                    if mode.id == output._mode:
+                        print("*")
+                    if m == output.get_preferred_mode():
+                        print("(preferred)")
+                    print("")
+                print("    Rotations:")
+                rots = output.get_available_rotations()
+                if rots & RR_ROTATE_0:
+                    print("normal")
+                if rots & RR_ROTATE_90:
+                    print("right")
+                if rots & RR_ROTATE_180:
+                    print("inverted")
+                if rots & RR_ROTATE_270:
+                    print("left")
+                print("")
+            else:
+                print("(not connected)")
+            if verbose:
+                print("    Core properties:")
+                for (f, t) in output._info.contents._fields_:
+                    print("      %s: %s" % (
+                        f, getattr(output._info.contents, f)))
+
+    def get_outputs(self):
+        """Returns the outputs of the screen"""
+        _check_required_version((1, 2))
+        return list(self.outputs.values())
+
+    def get_output_names(self):
+        _check_required_version((1, 2))
+        return list(self.outputs.keys())
+
+    def set_size(self, width, height, width_mm, height_mm):
+        """Apply the given pixel and physical size to the screen"""
+        _check_required_version((1, 2))
+        # Check if we really need to apply the changes
+        if (width, height, width_mm, height_mm) == self.get_size():
+            return
+        rr.XRRSetScreenSize(self._display, self._root,
+                            c_int(width), c_int(height),
+                            c_int(width_mm), c_int(height_mm))
+
+    def apply_output_config(self):
+        """Used for instantly applying RandR 1.2 changes"""
+        _check_required_version((1, 2))
+        self._arrange_outputs()
+        self._calculate_size()
+        self.set_size(self._width, self._height,
+                      self._width_mm, self._height_mm)
+
+        # Assign all active outputs to crtcs
+        for output in list(self.outputs.values()):
+            if not output._mode or output._crtc:
+                continue
+            for crtc in output.get_crtcs():
+                if crtc and crtc.supports_output(output):
+                    crtc.add_output(output)
+                    output._changes = output._changes | CHANGES_CRTC
+                    break
+            if not output._crtc:
+                #FIXME: Take a look at the pick_crtc code in xrandr.c
+                raise RRError("There is no matching crtc for the output")
+
+        # Apply stored changes of crtcs
+        for crtc in self.crtcs:
+            if crtc.has_changed():
+                crtc.apply_changes()
+
+    def apply_config(self):
+        """Used for instantly applying RandR 1.0 changes"""
+        _check_required_version((1, 0))
+        status = rr.XRRSetScreenConfigAndRate(self._display,
+                                              self._config,
+                                              self._root,
+                                              self._size_index,
+                                              self._rotation,
+                                              self._rate,
+                                              self.get_timestamp())
+        return status
+
+    def _arrange_outputs(self):
+        """Arrange all output positions according to their relative position"""
+        for output in self.get_outputs():
+            # Skip not changed and not used outputs
+            if not output.has_changed(CHANGES_RELATION) or \
+               output._mode == None:
+                continue
+            relative = output._relative_to
+            mode = self.get_mode_by_xid(output._mode)
+            mode_relative = self.get_mode_by_xid(relative._mode)
+            if not relative or not relative._mode:
+                output._x = 0
+                output._y = 0
+                output._changes = output._changes | CHANGES_POSITION
+            if output._relation == RELATION_LEFT_OF:
+                output._y = relative._y + output._relation_offset
+                output._x = relative._x - \
+                            get_mode_width(mode, output._rotation)
+            elif output._relation == RELATION_RIGHT_OF:
+                output._y = relative._y + output._relation_offset
+                output._x = relative._x + get_mode_width(mode_relative,
+                                                         output._rotation)
+            elif output._relation == RELATION_ABOVE:
+                output._y = relative._y - get_mode_height(mode,
+                                                          output._rotation)
+                output._x = relative._x + output._relation_offset
+            elif output._relation == RELATION_BELOW:
+                output._y = relative._y + get_mode_height(mode_relative,
+                                                          output._rotation)
+                output._x = relative._x + output._relation_offset
+            elif output._relation == RELATION_SAME_AS:
+                output._y = relative._y + output._relation_offset
+                output._x = relative._x + output._relation_offset
+            output._changes = output._changes | CHANGES_POSITION
+        # Normalize the postions so to the upper left cornor of all outputs
+        # is at 0,0
+        min_x = 32768
+        min_y = 32768
+        for output in self.get_outputs():
+            if output._mode == None:
+                continue
+            if output._x < min_x:
+                min_x = output._x
+            if output._y < min_y:
+                min_y = output._y
+        for output in self.get_outputs():
+            if output._mode == None:
+                continue
+            output._x -= min_x
+            output._y -= min_y
+            output._changes = output._changes | CHANGES_POSITION
+
+    def _calculate_size(self):
+        """Recalculate the pixel and physical size of the screen so that
+           it covers all outputs"""
+        width = self._width
+        height = self._height
+        for output in self.get_outputs():
+            if not output._mode:
+                continue
+            mode = self.get_mode_by_xid(output._mode)
+            x = output._x
+            y = output._y
+            w = get_mode_width(mode, output._rotation)
+            h = get_mode_height(mode, output._rotation)
+            if x + w > width:
+                width = x + w
+            if y + h > height:
+                height = y + h
+        if width > self._width_max or height > self._height_max:
+            raise RRError("The required size is not supported",
+                          (width, height), (self._width_max, self._width_min))
+        else:
+            if height < self._height_min:
+                self._fb_height = self._height_min
+            else:
+                self._height = height
+            if width < self._width_min:
+                self._width = self._width_min
+            else:
+                self._width = width
+        #FIXME: Physical size is missing
+
+
+def get_current_display():
+    """Returns the currently used display"""
+    display_url = os.getenv("DISPLAY")
+    open_display = xlib.XOpenDisplay
+    # Set .argtypes and .restype, to ensure proper
+    # type check and conversion
+    open_display.restype = c_void_p
+    open_display.argtypes = [c_char_p]
+    # XOpenDisplay accepts a char*, but
+    # display_url is a unicode string therefore
+    # we convert it to a bytes string
+    dpy = open_display(display_url.encode('utf-8'))
+    return dpy
+
+
+def get_current_screen():
+    """Returns the currently used screen"""
+    screen = Screen(get_current_display())
+    return screen
+
+
+def get_screen_of_display(display, count):
+    """Returns the screen of the given display"""
+    dpy = xlib.XOpenDisplay(display)
+    return Screen(dpy, count)
+
+
+def get_version():
+    """Returns a tuple containing the major and minor version of the xrandr
+       extension or None if the extension is not available"""
+    major = c_int()
+    minor = c_int()
+    res = rr.XRRQueryVersion(get_current_display(),
+                             byref(major), byref(minor))
+    if res:
+        return (major.value, minor.value)
+    return None
+
+
+def has_extension():
+    """Returns True if the xrandr extension is available"""
+    if XRANDR_VERSION:
+        return True
+    return False
+
+
+def _to_gamma(gamma):
+    g = rr.XRRAllocGamma(len(gamma[0]))
+    for i in range(gamma[0]):
+        g.red[i] = gamma[0][i]
+        g.green[i] = gamma[1][i]
+        g.blue[i] = gamma[2][i]
+    return g
+
+
+def _from_gamma(g):
+    gamma = ([], [], [])
+    for i in range(g.size):
+        gamma[0].append(g.red[i])
+        gamma[1].append(g.green[i])
+        gamma[2].append(g.blue[i])
+    rr.XRRFreeGamma(g)
+
+
+def _check_required_version(version):
+    """Raises an exception if the given or a later version of xrandr is not
+       available"""
+    if XRANDR_VERSION == None or XRANDR_VERSION < version:
+        raise UnsupportedRRError(version, XRANDR_VERSION)
+
+
+def get_mode_height(mode, rotation):
+    """Return the height of the given mode taking the rotation into account"""
+    if rotation & (RR_ROTATE_0 | RR_ROTATE_180):
+        return mode.height
+    elif rotation & (RR_ROTATE_90 | RR_ROTATE_270):
+        return mode.width
+    else:
+        return 0
+
+
+def get_mode_width(mode, rotation):
+    """Return the width of the given mode taking the rotation into account"""
+    if rotation & (RR_ROTATE_0 | RR_ROTATE_180):
+        return mode.width
+    elif rotation & (RR_ROTATE_90 | RR_ROTATE_270):
+        return mode.height
+    else:
+        return 0
+
+
+XRANDR_VERSION = get_version()
+
+# vim:ts=4:sw=4:et

=== added directory 'checkbox-support/checkbox_support/dbus'
=== added file 'checkbox-support/checkbox_support/dbus/__init__.py'
--- checkbox-support/checkbox_support/dbus/__init__.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/dbus/__init__.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,89 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+checkbox_support.dbus
+=============
+
+Utility modules for working with various things accessible over dbus
+"""
+
+import logging
+
+from dbus import SystemBus
+from dbus.mainloop.glib import DBusGMainLoop
+from dbus import (Array, Boolean, Byte, Dictionary, Double, Int16, Int32,
+                  Int64, ObjectPath, String, Struct, UInt16, UInt32, UInt64)
+from gi.repository import GObject
+
+
+def connect_to_system_bus():
+    """
+    Connect to the system bus properly.
+
+    Returns a tuple (system_bus, loop) where loop is a GObject.MainLoop
+    instance. The loop is there so that you can listen to signals.
+    """
+    # We'll need an event loop to observe signals. We will need the instance
+    # later below so let's keep it. Note that we're not passing it directly
+    # below as DBus needs specific API. The DBusGMainLoop class that we
+    # instantiate and pass is going to work with this instance transparently.
+    #
+    # NOTE: DBus tutorial suggests that we should create the loop _before_
+    # connecting to the bus.
+    logging.debug("Setting up glib-based event loop")
+    loop = GObject.MainLoop()
+    # Let's get the system bus object. We need that to access UDisks2 object
+    logging.debug("Connecting to DBus system bus")
+    system_bus = SystemBus(mainloop=DBusGMainLoop())
+    return system_bus, loop
+
+
+def drop_dbus_type(value):
+    """
+    Convert types from the DBus bindings to their python counterparts.
+
+    This function is mostly lossless, except for arrays of bytes (DBus
+    signature "y") that are transparently converted to strings, assuming
+    an UTF-8 encoded string.
+
+    The point of this function is to simplify printing of nested DBus data that
+    gets displayed in a rather illegible way.
+    """
+    if isinstance(value, Array) and value.signature == "y":
+        # Some other things are reported as array of bytes that are just
+        # strings but due to Unix heritage the encoding is not known.
+        # In practice it is better to treat them as UTF-8 strings
+        return bytes(value).decode("UTF-8", "replace").strip("\0")
+    elif isinstance(value, (Struct, Array)):
+        return [drop_dbus_type(item) for item in value]
+    elif isinstance(value, (Dictionary)):
+        return {drop_dbus_type(dict_key): drop_dbus_type(dict_value)
+                for dict_key, dict_value in value.items()}
+    elif isinstance(value, (String, ObjectPath)):
+        return str(value)
+    elif isinstance(value, (Byte, UInt16, UInt32, UInt64,
+                            Int16, Int32, Int64)):
+        return int(value)
+    elif isinstance(value, Boolean):
+        return bool(value)
+    elif isinstance(value, Double):
+        return float(value)
+    else:
+        return value

=== added file 'checkbox-support/checkbox_support/dbus/udisks2.py'
--- checkbox-support/checkbox_support/dbus/udisks2.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/dbus/udisks2.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,479 @@
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox_support.dbus.udisks2
+=====================
+
+Module for working with UDisks2 from python.
+
+There are two main classes that are interesting here.
+
+The first class is UDisksObserver, which is easy to setup and has pythonic API
+to all of the stuff that happens in UDisks2. It offers simple signal handlers
+for any changes that occur in UDisks2 that were advertised by DBus.
+
+The second class is UDisksModel, that builds on the observer class to offer
+persistent collection of objects managed by UDisks2.
+
+To work with this model you will likely want to look at:
+    http://udisks.freedesktop.org/docs/latest/ref-dbus.html
+"""
+
+import logging
+
+from dbus import Interface, PROPERTIES_IFACE
+from dbus.exceptions import DBusException
+
+from checkbox_support.dbus import drop_dbus_type
+
+__all__ = ['UDisks2Observer', 'UDisks2Model', 'Signal', 'is_udisks2_supported',
+           'lookup_udev_device']
+
+
+def is_udisks2_supported(system_bus):
+    """
+    Check if udisks2 is available on the system bus.
+
+    ..note::
+        Calling this _may_ trigger activation of the UDisks2 daemon but it
+        should only happen on systems where it is already expected to run all
+        the time.
+    """
+    observer = UDisks2Observer()
+    try:
+        logging.debug("Trying to connect to UDisks2...")
+        observer.connect_to_bus(system_bus)
+    except DBusException as exc:
+        if exc.get_dbus_name() == "org.freedesktop.DBus.Error.ServiceUnknown":
+            logging.debug("No UDisks2 on the system bus")
+            return False
+        else:
+            raise
+    else:
+        logging.debug("Got UDisks2 connection")
+        return True
+
+
+def map_udisks1_connection_bus(udisks1_connection_bus):
+    """
+    Map the value of udisks1 ConnectionBus property to the corresponding values
+    in udisks2. This a lossy function as some values are no longer supported.
+
+    Incorrect values raise LookupError
+    """
+    return {
+        'ata_serial_esata': '',  # gone from udisks2
+        'firewire': 'ieee1394',  # renamed
+        'scsi': '',              # gone from udisks2
+        'sdio': 'sdio',          # as-is
+        'usb': 'usb',            # as-is
+    }[udisks1_connection_bus]
+
+
+def lookup_udev_device(udisks2_object, udev_devices):
+    """
+    Find the udev_device that corresponds to the udisks2 object
+
+    Devices are matched by unix filesystem path of the special file (device).
+    The udisks2_object must implement the block device interface (so that the
+    block device path can be determined) or a ValueError is raised.
+
+    The udisks2_object must be the dictionary that maps from interface names to
+    dictionaries of properties. For compatible data see
+    UDisks2Model.managed_objects The udev_devices must be a list of udev
+    device, as returned from GUdev.
+
+    If there is no match, LookupError is raised with the unix block device
+    path.
+    """
+    try:
+        block_props = udisks2_object[UDISKS2_BLOCK_INTERFACE]
+    except KeyError:
+        raise ValueError("udisks2_object must be a block device")
+    else:
+        block_dev = block_props['Device']
+    for udev_device in udev_devices:
+        if udev_device.get_device_file() == block_dev:
+            return udev_device
+    raise LookupError(block_dev)
+
+
+# The well-known name for the ObjectManager interface, sadly it is not a part
+# of the python binding along with the rest of well-known names.
+OBJECT_MANAGER_INTERFACE = "org.freedesktop.DBus.ObjectManager"
+
+# The well-known name of the filesystem interface implemented by certain
+# objects exposed by UDisks2
+UDISKS2_FILESYSTEM_INTERFACE = "org.freedesktop.UDisks2.Filesystem"
+
+# The well-known name of the block (device) interface implemented by certain
+# objects exposed by UDisks2
+UDISKS2_BLOCK_INTERFACE = "org.freedesktop.UDisks2.Block"
+
+# The well-known name of the drive interface implemented by certain objects
+# exposed by UDisks2
+UDISKS2_DRIVE_INTERFACE = "org.freedesktop.UDisks2.Drive"
+
+
+class Signal:
+    """
+    Basic signal that supports arbitrary listeners.
+
+    While this class can be used directly it is best used with the helper
+    decorator Signal.define on a member function. The function body is ignored,
+    apart from the documentation.
+
+    The function name then becomes a unique (per encapsulating class instance)
+    object (an instance of this Signal class) that is created on demand.
+
+    In practice you just have a documentation and use
+    object.signal_name.connect() and object.signal_name(*args, **kwargs) to
+    fire it.
+    """
+
+    def __init__(self, signal_name):
+        """
+        Construct a signal with the given name
+        """
+        self._listeners = []
+        self._signal_name = signal_name
+
+    def connect(self, listener):
+        """
+        Connect a new listener to this signal
+
+        That listener will be called whenever fire() is invoked on the signal
+        """
+        self._listeners.append(listener)
+
+    def disconnect(self, listener):
+        """
+        Disconnect an existing listener from this signal
+        """
+        self._listeners.remove(listener)
+
+    def fire(self, args, kwargs):
+        """
+        Fire this signal with the specified arguments and keyword arguments.
+
+        Typically this is used by using __call__() on this object which is more
+        natural as it does all the argument packing/unpacking transparently.
+        """
+        for listener in self._listeners:
+            listener(*args, **kwargs)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Call fire() with all arguments forwarded transparently
+        """
+        self.fire(args, kwargs)
+
+    @classmethod
+    def define(cls, dummy_func):
+        """
+        Helper decorator to define a signal descriptor in a class
+
+        The decorated function is never called but is used to get
+        documentation.
+        """
+        return _SignalDescriptor(dummy_func)
+
+
+class _SignalDescriptor:
+    """
+    Descriptor for convenient signal access.
+
+    Typically this class is used indirectly, when accessed from Signal.define
+    method decorator. It is used to do all the magic required when accessing
+    signal name on a class or instance.
+    """
+
+    def __init__(self, dummy_func):
+        self.signal_name = dummy_func.__name__
+        self.__doc__ = dummy_func.__doc__
+
+    def __repr__(self):
+        return "<SignalDecorator for signal: %r>" % self.signal_name
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        # Ensure that the instance has __signals__ property
+        if not hasattr(instance, "__signals__"):
+            instance.__signals__ = {}
+        if self.signal_name not in instance.__signals__:
+            instance.__signals__[self.signal_name] = Signal(self.signal_name)
+        return instance.__signals__[self.signal_name]
+
+    def __set__(self, instance, value):
+        raise AttributeError("You cannot overwrite signals")
+
+    def __delete__(self, instance):
+        raise AttributeError("You cannot delete signals")
+
+
+class UDisks2Observer:
+    """
+    Class for observing ongoing changes in UDisks2
+    """
+
+    def __init__(self):
+        """
+        Create a UDisks2 model.
+
+        The model must be connected to a bus before it is first used, see
+        connect()
+        """
+        # Proxy to the UDisks2 object
+        self._udisks2_obj = None
+        # Proxy to the ObjectManager interface exposed by UDisks2 object
+        self._udisks2_obj_manager = None
+
+    @Signal.define
+    def on_initial_objects(self, managed_objects):
+        """
+        Signal fired when the initial list of objects becomes available
+        """
+
+    @Signal.define
+    def on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Signal fired when one or more interfaces gets added to a specific
+        object.
+        """
+
+    @Signal.define
+    def on_interfaces_removed(self, object_path, interfaces):
+        """
+        Signal fired when one or more interface gets removed from a specific
+        object
+        """
+
+    @Signal.define
+    def on_properties_changed(self, interface_name, changed_properties,
+                              invalidated_properties, sender=None):
+        """
+        Signal fired when one or more property changes value or becomes
+        invalidated.
+        """
+
+    def connect_to_bus(self, bus):
+        """
+        Establish initial connection to UDisks2 on the specified DBus bus.
+
+        This will also load the initial set of objects from UDisks2 and thus
+        fire the on_initial_objects() signal from the model. Please call this
+        method only after connecting that signal if you want to observe that
+        event.
+        """
+        # Once everything is ready connect to udisks2
+        self._connect_to_udisks2(bus)
+        # And read all the initial objects and setup
+        # change event handlers
+        self._get_initial_objects()
+
+    def _connect_to_udisks2(self, bus):
+        """
+        Setup the initial connection to UDisks2
+
+        This step can fail if UDisks2 is not available and cannot be
+        service-activated.
+        """
+        # Access the /org/freedesktop/UDisks2 object sitting on the
+        # org.freedesktop.UDisks2 bus name. This will trigger the necessary
+        # activation if udisksd is not running for any reason
+        logging.debug("Accessing main UDisks2 object")
+        self._udisks2_obj = bus.get_object(
+            "org.freedesktop.UDisks2", "/org/freedesktop/UDisks2")
+        # Now extract the standard ObjectManager interface so that we can
+        # observe and iterate the collection of objects that UDisks2 provides.
+        logging.debug("Accessing ObjectManager interface on UDisks2 object")
+        self._udisks2_obj_manager = Interface(
+            self._udisks2_obj, OBJECT_MANAGER_INTERFACE)
+        # Connect to the PropertiesChanged signal. Here unlike before we want
+        # to listen to all signals, regardless of who was sending them in the
+        # first place.
+        logging.debug("Setting up DBus signal handler for PropertiesChanged")
+        bus.add_signal_receiver(
+            self._on_properties_changed,
+            signal_name="PropertiesChanged",
+            dbus_interface=PROPERTIES_IFACE,
+            # Use the sender_keyword keyword argument to indicate that we wish
+            # to know the sender of each signal. For consistency with other
+            # signals we choose to use the 'object_path' keyword argument.
+            sender_keyword='sender')
+
+    def _get_initial_objects(self):
+        """
+        Get the initial collection of objects.
+
+        Needs to be called before the first signals from DBus are observed.
+        Requires a working connection to UDisks2.
+        """
+        # Having this interface we can now peek at the existing objects.
+        # We can use the standard method GetManagedObjects() to do that
+        logging.debug("Accessing GetManagedObjects() on UDisks2 object")
+        managed_objects = self._udisks2_obj_manager.GetManagedObjects()
+        managed_objects = drop_dbus_type(managed_objects)
+        # Fire the public signal for getting initial objects
+        self.on_initial_objects(managed_objects)
+        # Connect our internal handles to the DBus signal handlers
+        logging.debug("Setting up DBus signal handler for InterfacesAdded")
+        self._udisks2_obj_manager.connect_to_signal(
+            "InterfacesAdded", self._on_interfaces_added)
+        logging.debug("Setting up DBus signal handler for InterfacesRemoved")
+        self._udisks2_obj_manager.connect_to_signal(
+            "InterfacesRemoved", self._on_interfaces_removed)
+
+    def _on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        object_path = drop_dbus_type(object_path)
+        interfaces_and_properties = drop_dbus_type(interfaces_and_properties)
+        # Log what's going on
+        logging.debug("The object %r has gained the following interfaces and "
+                      "properties: %r", object_path, interfaces_and_properties)
+        # Call the signal handler
+        self.on_interfaces_added(object_path, interfaces_and_properties)
+
+    def _on_interfaces_removed(self, object_path, interfaces):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        object_path = drop_dbus_type(object_path)
+        interfaces = drop_dbus_type(interfaces)
+        # Log what's going on
+        logging.debug("The object %r has lost the following interfaces: %r",
+                      object_path, interfaces)
+        # Call the signal handler
+        self.on_interfaces_removed(object_path, interfaces)
+
+    def _on_properties_changed(self, interface_name, changed_properties,
+                               invalidated_properties, sender=None):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        interface_name = drop_dbus_type(interface_name)
+        changed_properties = drop_dbus_type(changed_properties)
+        invalidated_properties = drop_dbus_type(invalidated_properties)
+        sender = drop_dbus_type(sender)
+        # Log what's going on
+        logging.debug("Some object with the interface %r has changed "
+                      "properties: %r and invalidated properties %r "
+                      "(sender: %s)",
+                      interface_name, changed_properties,
+                      invalidated_properties, sender)
+        # Call the signal handler
+        self.on_properties_changed(interface_name, changed_properties,
+                                   invalidated_properties, sender)
+
+
+class UDisks2Model:
+    """
+    Model for working with UDisks2
+
+    This class maintains a persistent model of what UDisks2 knows about, based
+    on the UDisks2Observer class and the signals it offers.
+    """
+
+    def __init__(self, observer):
+        """
+        Create a UDisks2 model.
+
+        The model will track changes using the specified observer (which is
+        expected to be a UDisks2Observer instance)
+
+        You should only connect the observer to the bus after creating the
+        model otherwise the initial objects will not be detected.
+        """
+        # Local state, everything that UDisks2 tells us
+        self._managed_objects = {}
+        self._observer = observer
+        # Connect all the signals to the observer
+        self._observer.on_initial_objects.connect(self._on_initial_objects)
+        self._observer.on_interfaces_added.connect(self._on_interfaces_added)
+        self._observer.on_interfaces_removed.connect(
+            self._on_interfaces_removed)
+        self._observer.on_properties_changed.connect(
+            self._on_properties_changed)
+
+    @Signal.define
+    def on_change(self):
+        """
+        Signal sent whenever the collection of managed object changes
+
+        Note that this signal is fired _after_ the change has occurred
+        """
+
+    @property
+    def managed_objects(self):
+        """
+        A collection of objects that is managed by this model. All changes as
+        well as the initial state, are reflected here.
+        """
+        return self._managed_objects
+
+    def _on_initial_objects(self, managed_objects):
+        """
+        Internal callback called when we get the initial collection of objects
+        """
+        self._managed_objects = drop_dbus_type(managed_objects)
+
+    def _on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Internal callback called when an interface is added to certain object
+        """
+        # Update internal state
+        if object_path not in self._managed_objects:
+            self._managed_objects[object_path] = {}
+        obj = self._managed_objects[object_path]
+        obj.update(interfaces_and_properties)
+        # Fire the change signal
+        self.on_change()
+
+    def _on_interfaces_removed(self, object_path, interfaces):
+        """
+        Internal callback called when an interface is removed from a certain
+        object
+        """
+        # Update internal state
+        if object_path in self._managed_objects:
+            obj = self._managed_objects[object_path]
+            for interface in interfaces:
+                if interface in obj:
+                    del obj[interface]
+        # Fire the change signal
+        self.on_change()
+
+    def _on_properties_changed(self, interface_name, changed_properties,
+                               invalidated_properties, sender=None):
+        # XXX: This is a workaround the fact that we cannot
+        # properly track changes to all properties :-(
+        self._managed_objects = drop_dbus_type(
+            self._observer._udisks2_obj_manager.GetManagedObjects())
+        # Fire the change signal()
+        self.on_change()

=== added directory 'checkbox-support/checkbox_support/heuristics'
=== added file 'checkbox-support/checkbox_support/heuristics/__init__.py'
--- checkbox-support/checkbox_support/heuristics/__init__.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/heuristics/__init__.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,56 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox_support.heuristics
+===================
+
+This module contains implementations behind various heuristics used throughout
+the code. The intent of this module is twofold:
+
+    1) To encourage code reuse so that developers can use one implementation of
+       "guesswork" that is sometimes needed in our test. This reduces duplicate
+       bugs where many scripts do similar things in a different way.
+
+    2) To identify missing features in plumbing layer APIs such as
+       udev/udisks/dbus etc. Ideally no program should have to guess this, the
+       plumbing layer should be able to provide this meta data to allow
+       application developers deliver consistent behavior across userspace.
+
+Heuristics should be reusable from both python and shell. To make that possible
+each heuristics needs to be constrained to serializable input and output. This
+levels the playing field and allows both shell developers and python developers
+to reuse the same function.
+
+Additionally heuristics should try to avoid accessing thick APIs (such as
+objects returned by various libraries. This is meant to decrease the likelihood
+that updates to those libraries break this code. As an added side effect this
+also should make the implementation more explicit and easier to understand.
+
+In the long term each heuristic should be discussed with upstream developers of
+the particular problem area (udev, udisks, etc) to see if that subsystem can
+provide the required information directly, without us having to guess and fill
+the gaps.
+
+Things to consider when adding entries to this package:
+
+    1) File a bug on the upstream package about missing feature.
+
+    2) File a bug on checkbox to de-duplicate similar heuristics
+"""

=== added directory 'checkbox-support/checkbox_support/heuristics/tests'
=== added file 'checkbox-support/checkbox_support/heuristics/tests/__init__.py'
=== added file 'checkbox-support/checkbox_support/heuristics/tests/test_udisks2.py'
--- checkbox-support/checkbox_support/heuristics/tests/test_udisks2.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/heuristics/tests/test_udisks2.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,40 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+checkbox_support.heuristics.tests.test_udisks2
+======================================
+
+Unit tests for checkbox_support.heuristics.udisks2 module
+"""
+
+from unittest import TestCase
+
+from checkbox_support.heuristics.udisks2 import is_memory_card
+
+
+class TestIsMemoryCard(TestCase):
+
+    def test_generic(self):
+        """
+        Device with vendor string "GENERIC" is a memory card
+        """
+        self.assertTrue(
+            is_memory_card(vendor="Generic", model="", udisks2_media=None))

=== added file 'checkbox-support/checkbox_support/heuristics/udev.py'
--- checkbox-support/checkbox_support/heuristics/udev.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/heuristics/udev.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,44 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox_support.heuristics.dev
+=======================
+
+Heuristics for udev.
+
+    Documentation: http://udisks.freedesktop.org/docs/latest/
+    Source code: http://cgit.freedesktop.org/systemd/systemd/ (src/udev)
+    Bug tracker: http://bugs.freedesktop.org/ (using systemd product)
+"""
+
+
+def is_virtual_device(device_file):
+    """
+    Given a device name like /dev/ramX, /dev/sdX or /dev/loopX determine if
+    this is a virtual device. Virtual devices are typically uninteresting to
+    users. The only exception may be nonempty loopback device.
+
+    Possible prior art: gnome-disks, palimpset (precursor, suffering from this
+    flaw and showing all the /dev/ram devices by default)
+    """
+    for part in device_file.split("/"):
+        if part.startswith("ram") or part.startswith("loop"):
+            return True
+    return False

=== added file 'checkbox-support/checkbox_support/heuristics/udisks2.py'
--- checkbox-support/checkbox_support/heuristics/udisks2.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/heuristics/udisks2.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,62 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox_support.heuristics.udisks2
+===========================
+
+Heuristics for udisks2.
+
+    Documentation: http://udisks.freedesktop.org/docs/latest/
+    Source code: http://cgit.freedesktop.org/systemd/systemd/ (src/udev)
+    Bug tracker: http://bugs.freedesktop.org/ (using systemd product)
+"""
+
+from checkbox_support.parsers.udevadm import CARD_READER_RE, GENERIC_RE, FLASH_RE
+
+
+def is_memory_card(vendor, model, udisks2_media):
+    """
+    Check if the device seems to be a memory card
+
+    The vendor and model arguments are _strings_, not integers.
+    The udisks2_media argument is the value of org.freedesktop.UDisks2.Drive/
+
+
+    This is rather fuzzy, sadly udev and udisks2 don't do a very good job and
+    mostly don't specify the "media" property (it has a few useful values, such
+    as flash_cf, flash_ms, flash_sm, flash_sd, flash_sdhc, flash_sdxc and
+    flash_mmc but I have yet to see a device that reports such values)
+    """
+    # Treat any udisks2_media that contains 'flash' as a memory card
+    if udisks2_media is not None and FLASH_RE.search(udisks2_media):
+        return True
+    # Treat any device that match model name to the following regular
+    # expression as a memory card reader.
+    if CARD_READER_RE.search(model):
+        return True
+    # Treat any device that contains the word 'Generic' in the vendor string as
+    # a memory card reader.
+    #
+    # XXX: This seems odd but strangely enough seems to gets the job done. I
+    # guess if I should start filing tons of bugs/patches on udev/udisks2 to
+    # just have a few more rules and make this rule obsolete.
+    if GENERIC_RE.search(vendor):
+        return True
+    return False

=== added directory 'checkbox-support/checkbox_support/lib'
=== added file 'checkbox-support/checkbox_support/lib/__init__.py'
=== added file 'checkbox-support/checkbox_support/lib/bit.py'
--- checkbox-support/checkbox_support/lib/bit.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/bit.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,46 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+from struct import calcsize
+
+
+def get_bitmask(key):
+    bitmask = []
+    for value in reversed(key.split()):
+        value = int(value, 16)
+        bitmask.append(value)
+
+    return bitmask
+
+def get_bitcount(bitmask):
+    bitcount = 0
+    for value in bitmask:
+        while value:
+            bitcount += 1
+            value &= (value - 1)
+
+    return bitcount
+
+def test_bit(bit, bitmask, bits=None):
+    if bits is None:
+        bits = calcsize("l") * 8
+    offset = bit % bits
+    long = int(bit / bits)
+    if long >= len(bitmask):
+        return 0
+    return (bitmask[long] >> offset) & 1

=== added file 'checkbox-support/checkbox_support/lib/conversion.py'
--- checkbox-support/checkbox_support/lib/conversion.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/conversion.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,172 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+
+from datetime import (
+    datetime,
+    timedelta,
+    )
+
+from checkbox_support.lib.tz import tzutc
+
+
+DATETIME_RE = re.compile(r"""
+    ^(?P<year>\d\d\d\d)-?(?P<month>\d\d)-?(?P<day>\d\d)
+    T(?P<hour>\d\d):?(?P<minute>\d\d):?(?P<second>\d\d)
+    (?:\.(?P<second_fraction>\d{0,6}))?
+    (?P<tz>
+        (?:(?P<tz_sign>[-+])(?P<tz_hour>\d\d):(?P<tz_minute>\d\d))
+        | Z)?$
+    """, re.VERBOSE)
+
+TYPE_FORMATS = (
+    (r"(yes|true)", lambda v: True),
+    (r"(no|false)", lambda v: False),
+    (r"-?\d+", lambda v: int(v.group(0))),
+    (r"-?\d+\.\d+", lambda v: float(v.group(0))),
+    (r"(-?\d+) ?([kmgt]?b?)", lambda v: int(v.group(1))),
+    (r"(-?\d+\.\d+) ?([kmgt]?b?)", lambda v: float(v.group(1))),
+    (r"(-?\d+) ?([kmgt]?hz)", lambda v: int(v.group(1))),
+    (r"(-?\d+\.\d+) ?([kmgt]?hz)", lambda v: float(v.group(1))))
+TYPE_FORMATS = tuple(
+    (re.compile(r"^%s$" % pattern, re.IGNORECASE), format)
+    for pattern, format in TYPE_FORMATS)
+
+TYPE_MULTIPLIERS = (
+    (r"b", 1),
+    (r"kb?", 1024),
+    (r"mb?", 1024 * 1024),
+    (r"gb?", 1024 * 1024 * 1024),
+    (r"tb?", 1024 * 1024 * 1024 * 1024),
+    (r"hz", 1),
+    (r"khz?", 1024),
+    (r"mhz?", 1024 * 1024),
+    (r"ghz?", 1024 * 1024 * 1024),
+    (r"thz?", 1024 * 1024 * 1024 * 1024))
+TYPE_MULTIPLIERS = tuple(
+    (re.compile(r"^%s$" % pattern, re.IGNORECASE), multiplier)
+    for pattern, multiplier in TYPE_MULTIPLIERS)
+
+
+def datetime_to_string(dt):
+    """Return a consistent string representation for a given datetime.
+
+    :param dt: The datetime object.
+    """
+    return dt.isoformat()
+
+
+def string_to_datetime(string):
+    """Return a datetime object from a consistent string representation.
+
+    :param string: The string representation.
+    """
+    # we cannot use time.strptime: this function accepts neither fractions
+    # of a second nor a time zone given e.g. as '+02:30'.
+    match = DATETIME_RE.match(string)
+
+    # The Relax NG schema allows a leading minus sign and year numbers
+    # with more than four digits, which are not "covered" by _time_regex.
+    if not match:
+        raise ValueError("Datetime with unreasonable value: %s" % string)
+
+    time_parts = match.groupdict()
+
+    year = int(time_parts['year'])
+    month = int(time_parts['month'])
+    day = int(time_parts['day'])
+    hour = int(time_parts['hour'])
+    minute = int(time_parts['minute'])
+    second = int(time_parts['second'])
+    second_fraction = time_parts['second_fraction']
+    if second_fraction is not None:
+        milliseconds = second_fraction + '0' * (6 - len(second_fraction))
+        milliseconds = int(milliseconds)
+    else:
+        milliseconds = 0
+
+    # The Relax NG validator accepts leap seconds, but the datetime
+    # constructor rejects them. The time values submitted by the HWDB
+    # client are not necessarily very precise, hence we can round down
+    # to 59.999999 seconds without losing any real precision.
+    if second > 59:
+        second = 59
+        milliseconds = 999999
+
+    dt = datetime(
+        year, month, day, hour, minute, second, milliseconds, tzinfo=tzutc)
+
+    tz_sign = time_parts['tz_sign']
+    tz_hour = time_parts['tz_hour']
+    tz_minute = time_parts['tz_minute']
+    if tz_sign in ('-', '+'):
+        delta = timedelta(hours=int(tz_hour), minutes=int(tz_minute))
+        if tz_sign == '-':
+            dt = dt + delta
+        else:
+            dt = dt - delta
+
+    return dt
+
+
+def sizeof_bytes(bytes):
+    for x in ["bytes", "KB", "MB", "GB", "TB"]:
+        string = "%3.1f%s" % (bytes, x)
+        if bytes < 1024.0:
+            break
+        bytes /= 1024.0
+
+    return string
+
+
+def sizeof_hertz(hertz):
+    for x in ["Hz", "KHz", "MHz", "GHz"]:
+        string = "%3.1f%s" % (hertz, x)
+        if hertz < 1000.0:
+            break
+        hertz /= 1000.0
+
+    return string
+
+
+def string_to_type(string):
+    """Return a typed representation for the given string.
+
+    The result might be a bool, int or float. The string might also be
+    supplemented by a multiplier like KB which would return an int or
+    float multiplied by 1024 for example.
+
+    :param string: The string representation.
+    """
+    for regex, formatter in TYPE_FORMATS:
+        match = regex.match(string)
+        if match:
+            string = formatter(match)
+            if len(match.groups()) > 1:
+                unit = match.group(2)
+                for regex, multiplier in TYPE_MULTIPLIERS:
+                    match = regex.match(unit)
+                    if match:
+                        string *= multiplier
+                        break
+                else:
+                    raise ValueError("Unknown multiplier: %s" % unit)
+            break
+
+    return string

=== added file 'checkbox-support/checkbox_support/lib/dmi.py'
--- checkbox-support/checkbox_support/lib/dmi.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/dmi.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,241 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+from checkbox_support.lib.conversion import string_to_type
+
+# See also 3.3.4.1 of the "System Management BIOS Reference Specification,
+# Version 2.6.1" (Preliminary Standard) document, available from
+# http://www.dmtf.org/standards/smbios.
+class Dmi:
+    chassis = (
+        ("Undefined",             "unknown"),  # 0x00
+        ("Other",                 "unknown"),
+        ("Unknown",               "unknown"),
+        ("Desktop",               "desktop"),
+        ("Low Profile Desktop",   "desktop"),
+        ("Pizza Box",             "server"),
+        ("Mini Tower",            "desktop"),
+        ("Tower",                 "desktop"),
+        ("Portable",              "laptop"),
+        ("Laptop",                "laptop"),
+        ("Notebook",              "laptop"),
+        ("Hand Held",             "handheld"),
+        ("Docking Station",       "laptop"),
+        ("All In One",            "unknown"),
+        ("Sub Notebook",          "laptop"),
+        ("Space-saving",          "desktop"),
+        ("Lunch Box",             "unknown"),
+        ("Main Server Chassis",   "server"),
+        ("Expansion Chassis",     "unknown"),
+        ("Sub Chassis",           "unknown"),
+        ("Bus Expansion Chassis", "unknown"),
+        ("Peripheral Chassis",    "unknown"),
+        ("RAID Chassis",          "unknown"),
+        ("Rack Mount Chassis",    "unknown"),
+        ("Sealed-case PC",        "unknown"),
+        ("Multi-system",          "unknown"),
+        ("CompactPCI",            "unknonw"),
+        ("AdvancedTCA",           "unknown"),
+        ("Blade",                 "server"),
+        ("Blade Enclosure",       "unknown"))
+
+    chassis_names = tuple(c[0] for c in chassis)
+    chassis_types = tuple(c[1] for c in chassis)
+    chassis_name_to_type = dict(chassis)
+
+    type_names = (
+        "BIOS",  # 0x00
+        "System",
+        "Base Board",
+        "Chassis",
+        "Processor",
+        "Memory Controller",
+        "Memory Module",
+        "Cache",
+        "Port Connector",
+        "System Slots",
+        "On Board Devices",
+        "OEM Strings",
+        "System Configuration Options",
+        "BIOS Language",
+        "Group Associations",
+        "System Event Log",
+        "Physical Memory Array",
+        "Memory Device",
+        "32-bit Memory Error",
+        "Memory Array Mapped Address",
+        "Memory Device Mapped Address",
+        "Built-in Pointing Device",
+        "Portable Battery",
+        "System Reset",
+        "Hardware Security",
+        "System Power Controls",
+        "Voltage Probe",
+        "Cooling Device",
+        "Temperature Probe",
+        "Electrical Current Probe",
+        "Out-of-band Remote Access",
+        "Boot Integrity Services",
+        "System Boot",
+        "64-bit Memory Error",
+        "Management Device",
+        "Management Device Component",
+        "Management Device Threshold Data",
+        "Memory Channel",
+        "IPMI Device",
+        "Power Supply",
+        )
+
+
+class DmiDevice:
+
+    bus = "dmi"
+    driver = None
+    product_id = None
+    vendor_id = None
+
+    _product_blacklist = (
+        "<BAD INDEX>",
+        "N/A",
+        "Not Available",
+        "INVALID",
+        "OEM",
+        "Product Name",
+        "System Product Name",
+        "To be filled by O.E.M.",
+        "To Be Filled By O.E.M.",
+        "To Be Filled By O.E.M. by More String",
+        "Unknown",
+        "Uknown",
+        "Unknow",
+        "xxxxxxxxxxxxxx",
+        )
+    _vendor_blacklist = (
+        "<BAD INDEX>",
+        "Not Available",
+        "OEM",
+        "OEM Manufacturer",
+        "System manufacturer",
+        "System Manufacturer",
+        "System Name",
+        "To be filled by O.E.M.",
+        "To Be Filled By O.E.M.",
+        "To Be Filled By O.E.M. by More String",
+        "Unknow",  # XXX This is correct mispelling
+        "Unknown",
+        )
+    _serial_blacklist = (
+       "0",
+       "00000000",
+       "00 00 00 00 00 00 00 00",
+       "0123456789",
+       "Base Board Serial Number",
+       "Chassis Serial Number",
+       "N/A",
+       "None",
+       "Not Applicable",
+       "Not Available",
+       "Not Specified",
+       "OEM",
+       "System Serial Number",
+       )
+    _version_blacklist = (
+        "-1",
+        "<BAD INDEX>",
+        "N/A",
+        "None",
+        "Not Applicable",
+        "Not Available",
+        "Not Specified",
+        "OEM",
+        "System Version",
+        "Unknown",
+        "x.x",
+        )
+
+    def __init__(self, attributes, category):
+        self._attributes = attributes
+        self.category = category
+
+    @property
+    def path(self):
+        path = "/devices/virtual/dmi/id"
+        return os.path.join(path, self.category.lower())
+
+    @property
+    def product(self):
+        if self.category == "CHASSIS":
+            type_string = self._attributes.get("chassis_type", "0")
+            try:
+                type_index = int(type_string)
+                return Dmi.chassis_names[type_index]
+            except ValueError:
+                return type_string
+
+        for name in "name", "version":
+            attribute = "%s_%s" % (self.category.lower(), name)
+            product = self._attributes.get(attribute)
+            if product and product not in self._product_blacklist:
+                return product
+
+        return None
+
+    @property
+    def vendor(self):
+        for name in "manufacturer", "vendor":
+            attribute = "%s_%s" % (self.category.lower(), name)
+            vendor = self._attributes.get(attribute)
+            if vendor and vendor not in self._vendor_blacklist:
+                return vendor
+
+        return None
+
+    @property
+    def serial(self):
+        attribute = "%s_serial" % self.category.lower()
+        serial = self._attributes.get(attribute)
+        if serial and serial not in self._serial_blacklist:
+            return serial
+
+        return None
+
+    @property
+    def version(self):
+        attribute = "%s_version" % self.category.lower()
+        version = self._attributes.get(attribute)
+        if version and version not in self._version_blacklist:
+            return version
+
+        return None
+
+    @property
+    def size(self):
+        attribute = "%s_size" % self.category.lower()
+        size = self._attributes.get(attribute)
+
+        if size:
+            size = string_to_type(size)
+
+        return size
+
+    @property
+    def form(self):
+        attribute = "%s_form" % self.category.lower()
+        return self._attributes.get(attribute)

=== added file 'checkbox-support/checkbox_support/lib/input.py'
--- checkbox-support/checkbox_support/lib/input.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/input.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,585 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# See linux/input.h
+class Input:
+    KEY_RESERVED            = 0
+    KEY_ESC                 = 1
+    KEY_1                   = 2
+    KEY_2                   = 3
+    KEY_3                   = 4
+    KEY_4                   = 5
+    KEY_5                   = 6
+    KEY_6                   = 7
+    KEY_7                   = 8
+    KEY_8                   = 9
+    KEY_9                   = 10
+    KEY_0                   = 11
+    KEY_MINUS               = 12
+    KEY_EQUAL               = 13
+    KEY_BACKSPACE           = 14
+    KEY_TAB                 = 15
+    KEY_Q                   = 16
+    KEY_W                   = 17
+    KEY_E                   = 18
+    KEY_R                   = 19
+    KEY_T                   = 20
+    KEY_Y                   = 21
+    KEY_U                   = 22
+    KEY_I                   = 23
+    KEY_O                   = 24
+    KEY_P                   = 25
+    KEY_LEFTBRACE           = 26
+    KEY_RIGHTBRACE          = 27
+    KEY_ENTER               = 28
+    KEY_LEFTCTRL            = 29
+    KEY_A                   = 30
+    KEY_S                   = 31
+    KEY_D                   = 32
+    KEY_F                   = 33
+    KEY_G                   = 34
+    KEY_H                   = 35
+    KEY_J                   = 36
+    KEY_K                   = 37
+    KEY_L                   = 38
+    KEY_SEMICOLON           = 39
+    KEY_APOSTROPHE          = 40
+    KEY_GRAVE               = 41
+    KEY_LEFTSHIFT           = 42
+    KEY_BACKSLASH           = 43
+    KEY_Z                   = 44
+    KEY_X                   = 45
+    KEY_C                   = 46
+    KEY_V                   = 47
+    KEY_B                   = 48
+    KEY_N                   = 49
+    KEY_M                   = 50
+    KEY_COMMA               = 51
+    KEY_DOT                 = 52
+    KEY_SLASH               = 53
+    KEY_RIGHTSHIFT          = 54
+    KEY_KPASTERISK          = 55
+    KEY_LEFTALT             = 56
+    KEY_SPACE               = 57
+    KEY_CAPSLOCK            = 58
+    KEY_F1                  = 59
+    KEY_F2                  = 60
+    KEY_F3                  = 61
+    KEY_F4                  = 62
+    KEY_F5                  = 63
+    KEY_F6                  = 64
+    KEY_F7                  = 65
+    KEY_F8                  = 66
+    KEY_F9                  = 67
+    KEY_F10                 = 68
+    KEY_NUMLOCK             = 69
+    KEY_SCROLLLOCK          = 70
+    KEY_KP7                 = 71
+    KEY_KP8                 = 72
+    KEY_KP9                 = 73
+    KEY_KPMINUS             = 74
+    KEY_KP4                 = 75
+    KEY_KP5                 = 76
+    KEY_KP6                 = 77
+    KEY_KPPLUS              = 78
+    KEY_KP1                 = 79
+    KEY_KP2                 = 80
+    KEY_KP3                 = 81
+    KEY_KP0                 = 82
+    KEY_KPDOT               = 83
+
+    KEY_ZENKAKUHANKAKU      = 85
+    KEY_102ND               = 86
+    KEY_F11                 = 87
+    KEY_F12                 = 88
+    KEY_RO                  = 89
+    KEY_KATAKANA            = 90
+    KEY_HIRAGANA            = 91
+    KEY_HENKAN              = 92
+    KEY_KATAKANAHIRAGANA    = 93
+    KEY_MUHENKAN            = 94
+    KEY_KPJPCOMMA           = 95
+    KEY_KPENTER             = 96
+    KEY_RIGHTCTRL           = 97
+    KEY_KPSLASH             = 98
+    KEY_SYSRQ               = 99
+    KEY_RIGHTALT            = 100
+    KEY_LINEFEED            = 101
+    KEY_HOME                = 102
+    KEY_UP                  = 103
+    KEY_PAGEUP              = 104
+    KEY_LEFT                = 105
+    KEY_RIGHT               = 106
+    KEY_END                 = 107
+    KEY_DOWN                = 108
+    KEY_PAGEDOWN            = 109
+    KEY_INSERT              = 110
+    KEY_DELETE              = 111
+    KEY_MACRO               = 112
+    KEY_MUTE                = 113
+    KEY_VOLUMEDOWN          = 114
+    KEY_VOLUMEUP            = 115
+    KEY_POWER               = 116     # SC System Power Down
+    KEY_KPEQUAL             = 117
+    KEY_KPPLUSMINUS         = 118
+    KEY_PAUSE               = 119
+    KEY_SCALE               = 120     # AL Compiz Scale (Expose)
+
+    KEY_KPCOMMA             = 121
+    KEY_HANGEUL             = 122
+    KEY_HANGUEL             = KEY_HANGEUL
+    KEY_HANJA               = 123
+    KEY_YEN                 = 124
+    KEY_LEFTMETA            = 125
+    KEY_RIGHTMETA           = 126
+    KEY_COMPOSE             = 127
+
+    KEY_STOP                = 128     # AC Stop
+    KEY_AGAIN               = 129
+    KEY_PROPS               = 130     # AC Properties
+    KEY_UNDO                = 131     # AC Undo
+    KEY_FRONT               = 132
+    KEY_COPY                = 133     # AC Copy
+    KEY_OPEN                = 134     # AC Open
+    KEY_PASTE               = 135     # AC Paste
+    KEY_FIND                = 136     # AC Search
+    KEY_CUT                 = 137     # AC Cut
+    KEY_HELP                = 138     # AL Integrated Help Center
+    KEY_MENU                = 139     # Menu (show menu)
+    KEY_CALC                = 140     # AL Calculator
+    KEY_SETUP               = 141
+    KEY_SLEEP               = 142     # SC System Sleep
+    KEY_WAKEUP              = 143     # System Wake Up
+    KEY_FILE                = 144     # AL Local Machine Browser
+    KEY_SENDFILE            = 145
+    KEY_DELETEFILE          = 146
+    KEY_XFER                = 147
+    KEY_PROG1               = 148
+    KEY_PROG2               = 149
+    KEY_WWW                 = 150     # AL Internet Browser
+    KEY_MSDOS               = 151
+    KEY_COFFEE              = 152     # AL Terminal Lock/Screensaver
+    KEY_SCREENLOCK          = KEY_COFFEE
+    KEY_DIRECTION           = 153
+    KEY_CYCLEWINDOWS        = 154
+    KEY_MAIL                = 155
+    KEY_BOOKMARKS           = 156     # AC Bookmarks
+    KEY_COMPUTER            = 157
+    KEY_BACK                = 158     # AC Back
+    KEY_FORWARD             = 159     # AC Forward
+    KEY_CLOSECD             = 160
+    KEY_EJECTCD             = 161
+    KEY_EJECTCLOSECD        = 162
+    KEY_NEXTSONG            = 163
+    KEY_PLAYPAUSE           = 164
+    KEY_PREVIOUSSONG        = 165
+    KEY_STOPCD              = 166
+    KEY_RECORD              = 167
+    KEY_REWIND              = 168
+    KEY_PHONE               = 169     # Media Select Telephone
+    KEY_ISO                 = 170
+    KEY_CONFIG              = 171     # AL Consumer Control Configuration
+    KEY_HOMEPAGE            = 172     # AC Home
+    KEY_REFRESH             = 173     # AC Refresh
+    KEY_EXIT                = 174     # AC Exit
+    KEY_MOVE                = 175
+    KEY_EDIT                = 176
+    KEY_SCROLLUP            = 177
+    KEY_SCROLLDOWN          = 178
+    KEY_KPLEFTPAREN         = 179
+    KEY_KPRIGHTPAREN        = 180
+    KEY_NEW                 = 181     # AC New
+    KEY_REDO                = 182     # AC Redo/Repeat
+
+    KEY_F13                 = 183
+    KEY_F14                 = 184
+    KEY_F15                 = 185
+    KEY_F16                 = 186
+    KEY_F17                 = 187
+    KEY_F18                 = 188
+    KEY_F19                 = 189
+    KEY_F20                 = 190
+    KEY_F21                 = 191
+    KEY_F22                 = 192
+    KEY_F23                 = 193
+    KEY_F24                 = 194
+
+    KEY_PLAYCD              = 200
+    KEY_PAUSECD             = 201
+    KEY_PROG3               = 202
+    KEY_PROG4               = 203
+    KEY_DASHBOARD           = 204     # AL Dashboard
+    KEY_SUSPEND             = 205
+    KEY_CLOSE               = 206     # AC Close
+    KEY_PLAY                = 207
+    KEY_FASTFORWARD         = 208
+    KEY_BASSBOOST           = 209
+    KEY_PRINT               = 210     # AC Print
+    KEY_HP                  = 211
+    KEY_CAMERA              = 212
+    KEY_SOUND               = 213
+    KEY_QUESTION            = 214
+    KEY_EMAIL               = 215
+    KEY_CHAT                = 216
+    KEY_SEARCH              = 217
+    KEY_CONNECT             = 218
+    KEY_FINANCE             = 219     # AL Checkbook/Finance
+    KEY_SPORT               = 220
+    KEY_SHOP                = 221
+    KEY_ALTERASE            = 222
+    KEY_CANCEL              = 223     # AC Cancel
+    KEY_BRIGHTNESSDOWN      = 224
+    KEY_BRIGHTNESSUP        = 225
+    KEY_MEDIA               = 226
+
+    KEY_SWITCHVIDEOMODE     = 227     # Cycle between available video
+                                      # outputs (Monitor/LCD/TV-out/etc)
+    KEY_KBDILLUMTOGGLE      = 228
+    KEY_KBDILLUMDOWN        = 229
+    KEY_KBDILLUMUP          = 230
+
+    KEY_SEND                = 231     # AC Send
+    KEY_REPLY               = 232     # AC Reply
+    KEY_FORWARDMAIL         = 233     # AC Forward Msg
+    KEY_SAVE                = 234     # AC Save
+    KEY_DOCUMENTS           = 235
+
+    KEY_BATTERY             = 236
+
+    KEY_BLUETOOTH           = 237
+    KEY_WLAN                = 238
+    KEY_UWB                 = 239
+
+    KEY_UNKNOWN             = 240
+
+    KEY_VIDEO_NEXT          = 241     # drive next video source
+    KEY_VIDEO_PREV          = 242     # drive previous video source
+    KEY_BRIGHTNESS_CYCLE    = 243     # brightness up, after max is min
+    KEY_BRIGHTNESS_ZERO     = 244     # brightness off, use ambient
+    KEY_DISPLAY_OFF         = 245     # display device to off state
+
+    KEY_WIMAX               = 246
+
+    # Range = 248 - 255 is reserved for special needs of AT keyboard driver
+
+    BTN_MISC                = 0x100
+    BTN_0                   = 0x100
+    BTN_1                   = 0x101
+    BTN_2                   = 0x102
+    BTN_3                   = 0x103
+    BTN_4                   = 0x104
+    BTN_5                   = 0x105
+    BTN_6                   = 0x106
+    BTN_7                   = 0x107
+    BTN_8                   = 0x108
+    BTN_9                   = 0x109
+
+    BTN_MOUSE               = 0x110
+    BTN_LEFT                = 0x110
+    BTN_RIGHT               = 0x111
+    BTN_MIDDLE              = 0x112
+    BTN_SIDE                = 0x113
+    BTN_EXTRA               = 0x114
+    BTN_FORWARD             = 0x115
+    BTN_BACK                = 0x116
+    BTN_TASK                = 0x117
+
+    BTN_JOYSTICK            = 0x120
+    BTN_TRIGGER             = 0x120
+    BTN_THUMB               = 0x121
+    BTN_THUMB2              = 0x122
+    BTN_TOP                 = 0x123
+    BTN_TOP2                = 0x124
+    BTN_PINKIE              = 0x125
+    BTN_BASE                = 0x126
+    BTN_BASE2               = 0x127
+    BTN_BASE3               = 0x128
+    BTN_BASE4               = 0x129
+    BTN_BASE5               = 0x12a
+    BTN_BASE6               = 0x12b
+    BTN_DEAD                = 0x12f
+
+    BTN_GAMEPAD             = 0x130
+    BTN_A                   = 0x130
+    BTN_B                   = 0x131
+    BTN_C                   = 0x132
+    BTN_X                   = 0x133
+    BTN_Y                   = 0x134
+    BTN_Z                   = 0x135
+    BTN_TL                  = 0x136
+    BTN_TR                  = 0x137
+    BTN_TL2                 = 0x138
+    BTN_TR2                 = 0x139
+    BTN_SELECT              = 0x13a
+    BTN_START               = 0x13b
+    BTN_MODE                = 0x13c
+    BTN_THUMBL              = 0x13d
+    BTN_THUMBR              = 0x13e
+
+    BTN_DIGI                = 0x140
+    BTN_TOOL_PEN            = 0x140
+    BTN_TOOL_RUBBER         = 0x141
+    BTN_TOOL_BRUSH          = 0x142
+    BTN_TOOL_PENCIL         = 0x143
+    BTN_TOOL_AIRBRUSH       = 0x144
+    BTN_TOOL_FINGER         = 0x145
+    BTN_TOOL_MOUSE          = 0x146
+    BTN_TOOL_LENS           = 0x147
+    BTN_TOUCH               = 0x14a
+    BTN_STYLUS              = 0x14b
+    BTN_STYLUS2             = 0x14c
+    BTN_TOOL_DOUBLETAP      = 0x14d
+    BTN_TOOL_TRIPLETAP      = 0x14e
+
+    BTN_WHEEL               = 0x150
+    BTN_GEAR_DOWN           = 0x150
+    BTN_GEAR_UP             = 0x151
+
+    KEY_OK                  = 0x160
+    KEY_SELECT              = 0x161
+    KEY_GOTO                = 0x162
+    KEY_CLEAR               = 0x163
+    KEY_POWER2              = 0x164
+    KEY_OPTION              = 0x165
+    KEY_INFO                = 0x166   # AL OEM Features/Tips/Tutorial
+    KEY_TIME                = 0x167
+    KEY_VENDOR              = 0x168
+    KEY_ARCHIVE             = 0x169
+    KEY_PROGRAM             = 0x16a   # Media Select Program Guide
+    KEY_CHANNEL             = 0x16b
+    KEY_FAVORITES           = 0x16c
+    KEY_EPG                 = 0x16d
+    KEY_PVR                 = 0x16e   # Media Select Home
+    KEY_MHP                 = 0x16f
+    KEY_LANGUAGE            = 0x170
+    KEY_TITLE               = 0x171
+    KEY_SUBTITLE            = 0x172
+    KEY_ANGLE               = 0x173
+    KEY_ZOOM                = 0x174
+    KEY_MODE                = 0x175
+    KEY_KEYBOARD            = 0x176
+    KEY_SCREEN              = 0x177
+    KEY_PC                  = 0x178   # Media Select Computer
+    KEY_TV                  = 0x179   # Media Select TV
+    KEY_TV2                 = 0x17a   # Media Select Cable
+    KEY_VCR                 = 0x17b   # Media Select VCR
+    KEY_VCR2                = 0x17c   # VCR Plus
+    KEY_SAT                 = 0x17d   # Media Select Satellite
+    KEY_SAT2                = 0x17e
+    KEY_CD                  = 0x17f   # Media Select CD
+    KEY_TAPE                = 0x180   # Media Select Tape
+    KEY_RADIO               = 0x181
+    KEY_TUNER               = 0x182   # Media Select Tuner
+    KEY_PLAYER              = 0x183
+    KEY_TEXT                = 0x184
+    KEY_DVD                 = 0x185   # Media Select DVD
+    KEY_AUX                 = 0x186
+    KEY_MP3                 = 0x187
+    KEY_AUDIO               = 0x188
+    KEY_VIDEO               = 0x189
+    KEY_DIRECTORY           = 0x18a
+    KEY_LIST                = 0x18b
+    KEY_MEMO                = 0x18c   # Media Select Messages
+    KEY_CALENDAR            = 0x18d
+    KEY_RED                 = 0x18e
+    KEY_GREEN               = 0x18f
+    KEY_YELLOW              = 0x190
+    KEY_BLUE                = 0x191
+    KEY_CHANNELUP           = 0x192   # Channel Increment
+    KEY_CHANNELDOWN         = 0x193   # Channel Decrement
+    KEY_FIRST               = 0x194
+    KEY_LAST                = 0x195   # Recall Last
+    KEY_AB                  = 0x196
+    KEY_NEXT                = 0x197
+    KEY_RESTART             = 0x198
+    KEY_SLOW                = 0x199
+    KEY_SHUFFLE             = 0x19a
+    KEY_BREAK               = 0x19b
+    KEY_PREVIOUS            = 0x19c
+    KEY_DIGITS              = 0x19d
+    KEY_TEEN                = 0x19e
+    KEY_TWEN                = 0x19f
+    KEY_VIDEOPHONE          = 0x1a0   # Media Select Video Phone
+    KEY_GAMES               = 0x1a1   # Media Select Games
+    KEY_ZOOMIN              = 0x1a2   # AC Zoom In
+    KEY_ZOOMOUT             = 0x1a3   # AC Zoom Out
+    KEY_ZOOMRESET           = 0x1a4   # AC Zoom
+    KEY_WORDPROCESSOR       = 0x1a5   # AL Word Processor
+    KEY_EDITOR              = 0x1a6   # AL Text Editor
+    KEY_SPREADSHEET         = 0x1a7   # AL Spreadsheet
+    KEY_GRAPHICSEDITOR      = 0x1a8   # AL Graphics Editor
+    KEY_PRESENTATION        = 0x1a9   # AL Presentation App
+    KEY_DATABASE            = 0x1aa   # AL Database App
+    KEY_NEWS                = 0x1ab   # AL Newsreader
+    KEY_VOICEMAIL           = 0x1ac   # AL Voicemail
+    KEY_ADDRESSBOOK         = 0x1ad   # AL Contacts/Address Book
+    KEY_MESSENGER           = 0x1ae   # AL Instant Messaging
+    KEY_DISPLAYTOGGLE       = 0x1af   # Turn display (LCD) on and off
+    KEY_SPELLCHECK          = 0x1b0   # AL Spell Check
+    KEY_LOGOFF              = 0x1b1   # AL Logoff
+
+    KEY_DOLLAR              = 0x1b2
+    KEY_EURO                = 0x1b3
+
+    KEY_FRAMEBACK           = 0x1b4   # Consumer - transport controls
+    KEY_FRAMEFORWARD        = 0x1b5
+    KEY_CONTEXT_MENU        = 0x1b6   # GenDesc - system context menu
+    KEY_MEDIA_REPEAT        = 0x1b7   # Consumer - transport control
+
+    KEY_DEL_EOL             = 0x1c0
+    KEY_DEL_EOS             = 0x1c1
+    KEY_INS_LINE            = 0x1c2
+    KEY_DEL_LINE            = 0x1c3
+
+    KEY_FN                  = 0x1d0
+    KEY_FN_ESC              = 0x1d1
+    KEY_FN_F1               = 0x1d2
+    KEY_FN_F2               = 0x1d3
+    KEY_FN_F3               = 0x1d4
+    KEY_FN_F4               = 0x1d5
+    KEY_FN_F5               = 0x1d6
+    KEY_FN_F6               = 0x1d7
+    KEY_FN_F7               = 0x1d8
+    KEY_FN_F8               = 0x1d9
+    KEY_FN_F9               = 0x1da
+    KEY_FN_F10              = 0x1db
+    KEY_FN_F11              = 0x1dc
+    KEY_FN_F12              = 0x1dd
+    KEY_FN_1                = 0x1de
+    KEY_FN_2                = 0x1df
+    KEY_FN_D                = 0x1e0
+    KEY_FN_E                = 0x1e1
+    KEY_FN_F                = 0x1e2
+    KEY_FN_S                = 0x1e3
+    KEY_FN_B                = 0x1e4
+
+    KEY_BRL_DOT1            = 0x1f1
+    KEY_BRL_DOT2            = 0x1f2
+    KEY_BRL_DOT3            = 0x1f3
+    KEY_BRL_DOT4            = 0x1f4
+    KEY_BRL_DOT5            = 0x1f5
+    KEY_BRL_DOT6            = 0x1f6
+    KEY_BRL_DOT7            = 0x1f7
+    KEY_BRL_DOT8            = 0x1f8
+    KEY_BRL_DOT9            = 0x1f9
+    KEY_BRL_DOT10           = 0x1fa
+
+    KEY_NUMERIC_0           = 0x200   # used by phones, remote controls,
+    KEY_NUMERIC_1           = 0x201   # and other keypads
+    KEY_NUMERIC_2           = 0x202
+    KEY_NUMERIC_3           = 0x203
+    KEY_NUMERIC_4           = 0x204
+    KEY_NUMERIC_5           = 0x205
+    KEY_NUMERIC_6           = 0x206
+    KEY_NUMERIC_7           = 0x207
+    KEY_NUMERIC_8           = 0x208
+    KEY_NUMERIC_9           = 0x209
+    KEY_NUMERIC_STAR        = 0x20a
+    KEY_NUMERIC_POUND       = 0x20b
+
+    # Relative axes
+
+    REL_X                   = 0x00
+    REL_Y                   = 0x01
+    REL_Z                   = 0x02
+    REL_RX                  = 0x03
+    REL_RY                  = 0x04
+    REL_RZ                  = 0x05
+    REL_HWHEEL              = 0x06
+    REL_DIAL                = 0x07
+    REL_WHEEL               = 0x08
+    REL_MISC                = 0x09
+    REL_MAX                 = 0x0f
+    REL_CNT                 = REL_MAX+1
+
+    # Absolute axes
+
+    ABS_X                   = 0x00
+    ABS_Y                   = 0x01
+    ABS_Z                   = 0x02
+    ABS_RX                  = 0x03
+    ABS_RY                  = 0x04
+    ABS_RZ                  = 0x05
+    ABS_THROTTLE            = 0x06
+    ABS_RUDDER              = 0x07
+    ABS_WHEEL               = 0x08
+    ABS_GAS                 = 0x09
+    ABS_BRAKE               = 0x0a
+    ABS_HAT0X               = 0x10
+    ABS_HAT0Y               = 0x11
+    ABS_HAT1X               = 0x12
+    ABS_HAT1Y               = 0x13
+    ABS_HAT2X               = 0x14
+    ABS_HAT2Y               = 0x15
+    ABS_HAT3X               = 0x16
+    ABS_HAT3Y               = 0x17
+    ABS_PRESSURE            = 0x18
+    ABS_DISTANCE            = 0x19
+    ABS_TILT_X              = 0x1a
+    ABS_TILT_Y              = 0x1b
+    ABS_TOOL_WIDTH          = 0x1c
+    ABS_VOLUME              = 0x20
+    ABS_MISC                = 0x28
+    ABS_MAX                 = 0x3f
+    ABS_CNT                 = ABS_MAX+1
+
+    # Switch events
+
+    SW_LID                  = 0x00  # set = lid shut
+    SW_TABLET_MODE          = 0x01  # set = tablet mode
+    SW_HEADPHONE_INSERT     = 0x02  # set = inserted
+    SW_RFKILL_ALL           = 0x03  # rfkill master switch, type "any"
+                                    # set = radio enabled
+    SW_RADIO                = SW_RFKILL_ALL   # deprecated
+    SW_MICROPHONE_INSERT    = 0x04  # set = inserted
+    SW_DOCK                 = 0x05  # set = plugged into dock
+    SW_MAX                  = 0x0f
+    SW_CNT                  = SW_MAX+1
+
+    # Misc events
+
+    MSC_SERIAL              = 0x00
+    MSC_PULSELED            = 0x01
+    MSC_GESTURE             = 0x02
+    MSC_RAW                 = 0x03
+    MSC_SCAN                = 0x04
+    MSC_MAX                 = 0x07
+    MSC_CNT                 = MSC_MAX+1
+
+    # LEDs
+
+    LED_NUML                = 0x00
+    LED_CAPSL               = 0x01
+    LED_SCROLLL             = 0x02
+    LED_COMPOSE             = 0x03
+    LED_KANA                = 0x04
+    LED_SLEEP               = 0x05
+    LED_SUSPEND             = 0x06
+    LED_MUTE                = 0x07
+    LED_MISC                = 0x08
+    LED_MAIL                = 0x09
+    LED_CHARGING            = 0x0a
+    LED_MAX                 = 0x0f
+    LED_CNT                 = LED_MAX+1
+
+    # Autorepeat values
+
+    REP_DELAY               = 0x00
+    REP_PERIOD              = 0x01
+    REP_MAX                 = 0x01

=== added file 'checkbox-support/checkbox_support/lib/path.py'
--- checkbox-support/checkbox_support/lib/path.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/path.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,62 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+from glob import glob
+
+
+def path_split(path):
+    return path.split(os.path.sep)
+
+def path_common(l1, l2, common=[]):
+    if len(l1) < 1:
+        return (common, l1, l2)
+
+    if len(l2) < 1:
+        return (common, l1, l2)
+
+    if l1[0] != l2[0]:
+        return (common, l1, l2)
+
+    return path_common(l1[1:], l2[1:], common + [l1[0]])
+
+def path_relative(p1, p2):
+    (common, l1, l2) = path_common(path_split(p1), path_split(p2))
+    p = []
+    if len(l1) > 0:
+        p = ["..%s" % os.path.sep * len(l1)]
+
+    p = p + l2
+    return os.path.join( *p )
+
+def path_expand(path):
+    path = os.path.expanduser(path)
+    return glob(path)
+
+def path_expand_recursive(path):
+    paths = []
+    for path in path_expand(path):
+        if os.path.isdir(path):
+            for dirpath, dirnames, filenames in os.walk(path):
+                for filename in filenames:
+                    paths.append(os.path.join(dirpath, filename))
+        else:
+            paths.append(path)
+
+    return paths

=== added file 'checkbox-support/checkbox_support/lib/pci.py'
--- checkbox-support/checkbox_support/lib/pci.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/pci.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,89 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# See http://pciids.sourceforge.net/pci.ids.bz2
+class Pci:
+
+    BASE_CLASS_STORAGE              = 1
+    CLASS_STORAGE_SCSI              = 0
+    CLASS_STORAGE_IDE               = 1
+    CLASS_STORAGE_FLOPPY            = 2
+    CLASS_STORAGE_IPI               = 3
+    CLASS_STORAGE_RAID              = 4
+    CLASS_STORAGE_OTHER             = 80
+
+    BASE_CLASS_NETWORK              = 2
+    CLASS_NETWORK_ETHERNET          = 0
+    CLASS_NETWORK_TOKEN_RING        = 1
+    CLASS_NETWORK_FDDI              = 2
+    CLASS_NETWORK_ATM               = 3
+    CLASS_NETWORK_OTHER             = 80
+    CLASS_NETWORK_WIRELESS          = 128
+
+    BASE_CLASS_DISPLAY              = 3
+    CLASS_DISPLAY_VGA               = 0
+    CLASS_DISPLAY_XGA               = 1
+    CLASS_DISPLAY_3D                = 2
+    CLASS_DISPLAY_OTHER             = 80
+
+    BASE_CLASS_MULTIMEDIA           = 4
+    CLASS_MULTIMEDIA_VIDEO          = 0
+    CLASS_MULTIMEDIA_AUDIO          = 1
+    CLASS_MULTIMEDIA_PHONE          = 2
+    CLASS_MULTIMEDIA_AUDIO_DEVICE   = 3
+    CLASS_MULTIMEDIA_OTHER          = 80
+
+    BASE_CLASS_BRIDGE               = 6
+    CLASS_BRIDGE_HOST               = 0
+    CLASS_BRIDGE_ISA                = 1
+    CLASS_BRIDGE_EISA               = 2
+    CLASS_BRIDGE_MC                 = 3
+    CLASS_BRIDGE_PCI                = 4
+    CLASS_BRIDGE_PCMCIA             = 5
+    CLASS_BRIDGE_NUBUS              = 6
+    CLASS_BRIDGE_CARDBUS            = 7
+    CLASS_BRIDGE_RACEWAY            = 8
+    CLASS_BRIDGE_OTHER              = 80
+
+    BASE_CLASS_COMMUNICATION        = 7
+    CLASS_COMMUNICATION_SERIAL      = 0
+    CLASS_COMMUNICATION_PARALLEL    = 1
+    CLASS_COMMUNICATION_MULTISERIAL = 2
+    CLASS_COMMUNICATION_MODEM       = 3
+    CLASS_COMMUNICATION_OTHER       = 80
+
+    BASE_CLASS_INPUT                = 9
+    CLASS_INPUT_KEYBOARD            = 0
+    CLASS_INPUT_PEN                 = 1
+    CLASS_INPUT_MOUSE               = 2
+    CLASS_INPUT_SCANNER             = 3
+    CLASS_INPUT_GAMEPORT            = 4
+    CLASS_INPUT_OTHER               = 80
+
+    BASE_CLASS_SERIAL               = 12
+    CLASS_SERIAL_FIREWIRE           = 0
+    CLASS_SERIAL_ACCESS             = 1
+
+    BASE_CLASS_WIRELESS             = 13
+    CLASS_WIRELESS_BLUETOOTH        = 17
+
+    CLASS_SERIAL_SSA                = 2
+    CLASS_SERIAL_USB                = 3
+    CLASS_SERIAL_FIBER              = 4
+    CLASS_SERIAL_SMBUS              = 5

=== added file 'checkbox-support/checkbox_support/lib/template.py'
--- checkbox-support/checkbox_support/lib/template.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/template.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,143 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+import logging
+
+
+EXTENDED_STRING = "_extended"
+
+
+class Template:
+
+    def _reader(self, file, size=4096, delimiter=r"\n{2,}"):
+        buffer_old = ""
+        while True:
+            buffer_new = file.read(size)
+            if not buffer_new:
+                break
+
+            lines = re.split(delimiter, buffer_old + buffer_new)
+            buffer_old = lines.pop(-1)
+
+            for line in lines:
+                yield line
+
+        yield buffer_old
+
+    def dump_file(self, elements, file, filename="<stream>"):
+        for element in elements:
+            for long_key in list(element.keys()):
+                if long_key.endswith(EXTENDED_STRING):
+                    short_key = long_key.replace(EXTENDED_STRING, "")
+                    del element[short_key]
+
+            for key, value in element.items():
+                if key.endswith(EXTENDED_STRING):
+                    key = key.replace(EXTENDED_STRING, "")
+                    file.write("%s:\n" % key)
+                    for line in value.split("\n"):
+                        file.write(" %s\n" % line)
+                elif isinstance(value, (list, tuple)):
+                    file.write("%s:\n" % key)
+                    for v in value:
+                        file.write(" %s\n" % v)
+                else:
+                    file.write("%s: %s\n" % (key, value))
+
+            file.write("\n")
+
+    def dump_filename(self, elements, filename):
+        logging.info("Dumping elements to filename: %s", filename)
+
+        with open(filename, "w") as stream:
+            return self.dump_file(elements, stream, filename)
+
+    def load_file(self, file, filename="<stream>"):
+        elements = []
+        for string in self._reader(file):
+            if not string:
+                break
+
+            element = {}
+
+            def _save(field, value, extended):
+                extended = extended.rstrip("\n")
+                if field:
+                    if field in element:
+                        raise Exception("Template %s has a duplicate "
+                            "field '%s' with a new value '%s'." 
+                                % (filename, field, value))
+                    element[field] = value
+                    if extended:
+                        element["%s%s" % (field, EXTENDED_STRING)] = extended
+
+            string = string.strip("\n")
+            field = value = extended = ""
+            for line in string.split("\n"):
+                line.strip()
+                if line.startswith("#"):
+                    continue
+
+                match = re.search(r"^([-_.A-Za-z0-9@]*):\s?(.*)", line)
+                if match:
+                    _save(field, value, extended)
+                    field = match.groups()[0]
+                    value = match.groups()[1].rstrip()
+                    extended = ""
+                    continue
+
+                if re.search(r"^\s\.$", line):
+                    extended += "\n\n"
+                    continue
+
+                match = re.search(r"^\s(\s+.*)", line)
+                if match:
+                    bit = match.groups()[0].rstrip()
+                    if len(extended) and not re.search(r"[\n ]$", extended):
+                        extended += "\n"
+
+                    extended += bit + "\n"
+                    continue
+
+                match = re.search(r"^\s(.*)", line)
+                if match:
+                    bit = match.groups()[0].rstrip()
+                    if len(extended) and not re.search(r"[\n ]$", extended):
+                        if extended.endswith("\\"):
+                            extended = extended[:-1].rstrip() + " "
+                        else:
+                            extended += "\n"
+
+                    extended += bit
+                    continue
+
+                raise Exception("Template %s parse error at: %s" \
+                    % (filename, line))
+
+            _save(field, value, extended)
+
+            elements.append(element)
+
+        return elements
+
+    def load_filename(self, filename):
+        logging.info("Loading elements from filename: %s", filename)
+
+        with open(filename, "r", encoding="utf-8") as stream:
+            return self.load_file(stream, filename)

=== added file 'checkbox-support/checkbox_support/lib/tz.py'
--- checkbox-support/checkbox_support/lib/tz.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/tz.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,55 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+__all__ = [
+    "tzutc",
+    ]
+
+from datetime import (
+    timedelta,
+    tzinfo,
+    )
+
+
+ZERO = timedelta(0)
+
+
+class _tzutc(tzinfo):
+
+    def utcoffset(self, dt):
+        return ZERO
+
+    def dst(self, dt):
+        return ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def __eq__(self, other):
+        return isinstance(other, tzutc)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return "%s()" % self.__class__.__name__
+
+    __reduce__ = object.__reduce__
+
+
+tzutc = _tzutc()

=== added file 'checkbox-support/checkbox_support/lib/usb.py'
--- checkbox-support/checkbox_support/lib/usb.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/lib/usb.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,59 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# See http://www.linux-usb.org/usb.ids
+class Usb:
+
+    BASE_CLASS_INTERFACE             = 0
+
+    BASE_CLASS_AUDIO                 = 1
+    CLASS_AUDIO_CONTROL_DEVICE       = 1
+    CLASS_AUDIO_STREAMING            = 2
+    CLASS_AUDIO_MIDI_STREAMING       = 3
+
+    BASE_CLASS_COMMUNICATIONS        = 2
+    CLASS_COMMUNICATIONS_DIRECT_LINE = 1
+    CLASS_COMMUNICATIONS_ABSTRACT    = 2
+    CLASS_COMMUNICATIONS_TELEPHONE   = 3
+
+    BASE_CLASS_PRINTER               = 7
+    CLASS_PRINTER_OTHER              = 1
+
+    BASE_CLASS_STORAGE               = 8
+    CLASS_STORAGE_RBC                = 1
+    CLASS_STORAGE_SFF                = 2
+    CLASS_STORAGE_QIC                = 3
+    CLASS_STORAGE_FLOPPY             = 4
+    CLASS_STORAGE_SFF                = 5
+    CLASS_STORAGE_SCSI               = 6
+
+    BASE_CLASS_HUB                   = 9
+    CLASS_HUB_UNUSED                 = 0
+
+    BASE_CLASS_VIDEO                 = 14
+    CLASS_VIDEO_UNDEFINED            = 0
+    CLASS_VIDEO_CONTROL              = 1
+    CLASS_VIDEO_STREAMING            = 2
+    CLASS_VIDEO_INTERFACE_COLLECTION = 3
+
+    BASE_CLASS_WIRELESS              = 224
+    CLASS_WIRELESS_RADIO_FREQUENCY   = 1
+    CLASS_WIRELESS_USB_ADAPTER       = 2
+    
+    PROTOCOL_BLUETOOTH               = 1

=== added directory 'checkbox-support/checkbox_support/parsers'
=== added file 'checkbox-support/checkbox_support/parsers/__init__.py'
=== added file 'checkbox-support/checkbox_support/parsers/cpuinfo.py'
--- checkbox-support/checkbox_support/parsers/cpuinfo.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/cpuinfo.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,180 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+
+from os import uname
+
+from checkbox_support.lib.conversion import string_to_type
+
+
+class CpuinfoParser:
+    """Parser for the /proc/cpuinfo file."""
+
+    def __init__(self, stream, machine=None):
+        self.stream = stream
+        self.machine = machine or uname()[4].lower()
+
+    def getAttributes(self):
+        count = 0
+        attributes = {}
+        cpuinfo = self.stream.read()
+        for block in re.split(r"\n{2,}", cpuinfo):
+            block = block.strip()
+            if not block:
+                continue
+
+            for line in block.split("\n"):
+                if not line:
+                    continue
+                key, value = line.split(":", 1)
+                key, value = key.strip(), value.strip()
+                
+                if key == 'processor':
+                    count += 1
+
+                # Handle bogomips on sparc
+                if key.endswith("Bogo"):
+                    key = "bogomips"
+
+                attributes[key] = value
+
+        if attributes:
+            attributes["count"] = count
+
+        return attributes
+
+    def run(self, result):
+        attributes = self.getAttributes()
+        if not attributes:
+            return
+
+        # Default values
+        machine = self.machine
+        processor = {
+            "platform": machine,
+            "count": 1,
+            "type": machine,
+            "model": machine,
+            "model_number": "",
+            "model_version": "",
+            "model_revision": "",
+            "cache": 0,
+            "bogomips": 0,
+            "speed": -1,
+            "other": ""}
+
+        # Conversion table
+        platform_to_conversion = {
+            ("i386", "i486", "i586", "i686", "x86_64",): {
+                "type": "vendor_id",
+                "model": "model name",
+                "model_number": "cpu family",
+                "model_version": "model",
+                "model_revision": "stepping",
+                "cache": "cache size",
+                "other": "flags",
+                "speed": "cpu MHz"},
+            ("alpha", "alphaev6",): {
+                "count": "cpus detected",
+                "type": "cpu",
+                "model": "cpu model",
+                "model_number": "cpu variation",
+                "model_version": ("system type", "system variation",),
+                "model_revision": "cpu revision",
+                "other": "platform string",
+                "speed": "cycle frequency [Hz]"},
+            ("armv7l",): {
+                "type": "Hardware",
+                "model": "Processor",
+                "model_number": "CPU variant",
+                "model_version": "CPU architecture",
+                "model_revision": "CPU revision",
+                "other": "Features",
+                "bogomips": "BogoMIPS"},
+            ("ia64",): {
+                "type": "vendor",
+                "model": "family",
+                "model_version": "archrev",
+                "model_revision": "revision",
+                "other": "features",
+                "speed": "cpu mhz"},
+            ("ppc64", "ppc",): {
+                "type": "platform",
+                "model": "cpu",
+                "model_version": "revision",
+                "speed": "clock"},
+            ("sparc64", "sparc",): {
+                "count": "ncpus probed",
+                "type": "type",
+                "model": "cpu",
+                "model_version": "type",
+                "speed": "bogomips"}}
+
+        for key in processor:
+            if attributes.get(key):
+                processor[key] = attributes.get(key)
+
+        for platform, conversion in platform_to_conversion.items():
+            if machine in platform:
+                for pkey, ckey in conversion.items():
+                    if isinstance(ckey, (list, tuple)):
+                        processor[pkey] = "/".join([attributes[k]
+                                                    for k in ckey])
+                    elif ckey in attributes:
+                        processor[pkey] = attributes[ckey]
+
+        # Adjust platform
+        if machine[0] == "i" and machine[-2:] == "86":
+            processor["platform"] = "i386"
+        elif machine[:5] == "alpha":
+            processor["platform"] = "alpha"
+
+        # Adjust cache
+        if processor["cache"]:
+            processor["cache"] = string_to_type(processor["cache"])
+
+        # Adjust speed
+        try:
+            if machine[:5] == "alpha":
+                speed = processor["speed"].split()[0]
+                processor["speed"] = int(round(float(speed))) / 1000000
+            elif machine[:5] == "sparc":
+                speed = processor["speed"]
+                processor["speed"] = int(round(float(speed))) / 2
+            elif machine[:3] == "ppc":
+                # String is appended with "mhz"
+                speed = processor["speed"][:-3]
+        except ValueError:
+            processor["speed"] = -1
+
+        # Make sure speed and bogomips are integers    
+        processor["speed"] = int(round(float(processor["speed"])) - 1)
+        processor["bogomips"] = int(round(float(processor["bogomips"])))
+
+        # Adjust count
+        try:
+            processor["count"] = int(processor["count"])
+        except ValueError:
+            processor["count"] = 1
+        else:
+            # There is at least one processor
+            if processor["count"] == 0:
+                processor["count"] = 1
+
+        result.setProcessor(processor)

=== added file 'checkbox-support/checkbox_support/parsers/dmidecode.py'
--- checkbox-support/checkbox_support/parsers/dmidecode.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/dmidecode.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,126 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+
+from string import (
+    hexdigits,
+    ascii_uppercase,
+    )
+
+from checkbox_support.lib.dmi import (
+    Dmi,
+    DmiDevice,
+    )
+
+
+HANDLE_RE = re.compile(
+    r"^Handle (?P<handle>0x[%s]{4}), "
+    r"DMI type (?P<type>\d+), "
+    r"(?P<size>\d+) bytes$"
+    % hexdigits)
+KEY_VALUE_RE = re.compile(
+    r"^\t(?P<key>[%s].+):( (?P<value>.+))?$"
+    % ascii_uppercase)
+
+
+class DmidecodeParser:
+    """Parser for the dmidecode command."""
+
+    _key_map = {
+        "ID": "serial",
+        "Manufacturer": "vendor",
+        "Product Name": "name",
+        "Serial Number": "serial",
+        "Type": "type",
+        "Vendor": "vendor",
+        "Version": "version",
+        "Size": "size",
+        "Form Factor": "form",
+        }
+
+    def __init__(self, stream):
+        self.stream = stream
+
+    def _parseKey(self, key):
+        return self._key_map.get(key)
+
+    def _parseValue(self, value):
+        if value is not None:
+            value = value.strip()
+            if not value:
+                value = None
+
+        return value
+
+    def run(self, result):
+        output = self.stream.read()
+        for record in re.split(r"\n{2,}", output):
+            record = record.strip()
+            # Skip empty records
+            if not record:
+                continue
+
+            # Skip header record
+            lines = record.split("\n")
+            line = lines.pop(0)
+            if line.startswith("#"):
+                continue
+
+            # Skip records with an unsupported handle
+            match = HANDLE_RE.match(line)
+            if not match:
+                continue
+
+            # Skip records that are empty or inactive
+            if not lines or lines.pop(0) == "Inactive":
+                continue
+
+            # Skip disabled entries and end-of-table marker
+            type_index = int(match.group("type"))
+            if type_index >= len(Dmi.type_names):
+                continue
+
+            category = Dmi.type_names[type_index]
+            category = category.upper().split(" ")[-1]
+            if category not in (
+                "BOARD", "BIOS", "CHASSIS", "DEVICE", "PROCESSOR", "SYSTEM"):
+                continue
+
+            # Parse attributes
+            attributes = {}
+
+            for line in lines:
+                # Skip lines with an unsupported key/value pair
+                match = KEY_VALUE_RE.match(line)
+                if not match:
+                    continue
+
+                # Skip lines with an unsupported key
+                key = self._parseKey(match.group("key"))
+                if not key:
+                    continue
+
+                key = "%s_%s" % (category.lower(), key)
+                value = self._parseValue(match.group("value"))
+                attributes[key] = value
+
+            device = DmiDevice(attributes, category)
+            result.addDmiDevice(device)
+
+        return result

=== added file 'checkbox-support/checkbox_support/parsers/efi.py'
--- checkbox-support/checkbox_support/parsers/efi.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/efi.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,52 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+
+
+class EfiDevice:
+
+    path = "/sys/class/dmi/id/bios_version"
+    category = "EFI"
+
+    def __init__(self, product, vendor=None):
+        self.product = product
+        self.vendor = vendor
+
+
+class EfiParser:
+    """Parser for EFI information."""
+
+    def __init__(self, stream):
+        self.stream = stream
+
+    def run(self, result):
+        vendor_product_pattern = re.compile(
+            r"^(?P<vendor>.*)\s+by\s+(?P<product>.*)$")
+
+        for line in self.stream.readlines():
+            line = line.strip()
+            match = vendor_product_pattern.match(line)
+            if match:
+                product = match.group("product")
+                vendor = match.group("vendor")
+                device = EfiDevice(product, vendor)
+            else:
+                device = EfiDevice(line)
+
+            result.setEfiDevice(device)

=== added file 'checkbox-support/checkbox_support/parsers/lshwjson.py'
--- checkbox-support/checkbox_support/parsers/lshwjson.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/lshwjson.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,23 @@
+import sys
+import json
+
+class LshwJsonParser:
+
+    def __init__(self, stream_or_string):
+        self.stream_or_string = stream_or_string
+
+    def _parse_lshw(self, lshw, result):
+        if 'children' in lshw.keys():
+            for child in lshw['children']:
+                self._parse_lshw(child, result)
+            del lshw['children']
+
+        result.addHardware(lshw)
+
+    def run(self, result):
+        try:
+            lshw = json.loads(self.stream_or_string)
+        except:
+            print('not valid json')
+
+        self._parse_lshw(lshw, result)

=== added file 'checkbox-support/checkbox_support/parsers/meminfo.py'
--- checkbox-support/checkbox_support/parsers/meminfo.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/meminfo.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,46 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import re
+
+
+class MeminfoParser:
+    """Parser for the /proc/meminfo file."""
+
+    def __init__(self, stream):
+        self.stream = stream
+
+    def run(self, result):
+        key_value_pattern = re.compile(r"(?P<key>.*):\s+(?P<value>.*)")
+        meminfo_map = {
+            "MemTotal": "total",
+            "SwapTotal": "swap"}
+
+        meminfo = {}
+        for line in self.stream.readlines():
+            line = line.strip()
+            match = key_value_pattern.match(line)
+            if match:
+                key = match.group("key")
+                if key in meminfo_map:
+                    key = meminfo_map[key]
+                    value = match.group("value")
+                    (integer, factor) = value.split()
+                    meminfo[key] = int(integer) * 1024
+
+        result.setMemory(meminfo)

=== added file 'checkbox-support/checkbox_support/parsers/modinfo.py'
--- checkbox-support/checkbox_support/parsers/modinfo.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/modinfo.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,89 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+class ModinfoParser:
+    """
+    Parser for modinfo information.
+    This will take the stdout for modinfo output and return a dict populated
+    with each field.
+
+    Basic usage in your script:
+    try:
+        output = subprocess.check_output('/sbin/modinfo e1000e',
+                                         stderr=subprocess.STDOUT,
+                                         universal_newlines=True)
+    except CalledProcessError as err:
+        print("Error while running modinfo")
+        print(err.output)
+        return err.returncode
+
+    parser = ModinfoParser(output)
+    all_fields = parser.get_all()
+    one_field = parser.get_field(field)
+    """
+
+    def __init__(self, stream):
+        self._modinfo = {'alias': [],
+                         'author': '',
+                         'depends': [],
+                         'description': '',
+                         'filename': '',
+                         'firmware': [],
+                         'intree': '',
+                         'license': '',
+                         'parm': [],
+                         'srcversion': '',
+                         'vermagic': '',
+                         'version': ''}
+        self._get_info(stream)
+
+    def _get_info(self, stream):
+        for line in stream.splitlines():
+            # At this point, stream should be the stdout from the modinfo
+            # command, in a list.
+            try:
+                key, data = line.split(':', 1)
+            except ValueError:
+                # Most likely this will be caused by a blank line in the
+                # stream, so we just ignore it and move on.
+                continue                
+            else:
+                key = key.strip()
+                data = data.strip()
+                # First, we need to handle alias, parm, firmware, and depends
+                # because there can be multiple lines of output for these.
+                if key in ('alias', 'depend', 'firmware', 'parm',):
+                    self._modinfo[key].append(data)
+                # Now handle unknown keys
+                elif key not in self._modinfo.keys():
+                    self._modinfo[key] = ("WARNING: Unknown Key %s providing "
+                                     "data: %s") % (key, data)
+                # And finally known keys
+                else:
+                    self._modinfo[key] = data
+
+    def get_all(self):
+        return self._modinfo
+
+    def get_field(self, field):
+        if field not in self._modinfo.keys():
+            raise Exception("Key not found: %s" % field)
+        else:
+            return self._modinfo[field]

=== added file 'checkbox-support/checkbox_support/parsers/pactl.py'
--- checkbox-support/checkbox_support/parsers/pactl.py	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/pactl.py	2014-01-07 13:44:32 +0000
@@ -0,0 +1,543 @@
+# This file is part of Checkbox.
+#
+# Copyright 2013 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`checkbox_support.parsers.pactl` -- `pactl list` parser
+====================================================
+
+Parser for the output of ``pactl list`` syntax.
+
+The abstract syntax tree of 'pactl list' is as follows::
+
+    Document: Record + ('\n' + Record)*
+
+    Record: RECORD-NAME ':' Attribute+
+
+    Attribute: ATTRIBUTE-NAME ':' AttributeValue
+
+    AttributeValue: SIMPLE-VALUE '\n'
+                    | PropertyValue
+                    | VOLUME-VALUE
+                    | BASE-VOLUME-VALUE
+                    | PORT+
+                    | PORT-WITH-PROFILE+
+
+    PropertyValue: PROPERTY-NAME '=' PROPERTY-VALUE
+
+    (other all-upsercase values are not specified in detail)
+
+Some parts of the output  are always localized while others depend on the
+locale of the current user. This is caused by the fact that ``pactl`` talks to
+pulse audio server over DBus. Some of the data obtained from pulse that was is
+localized and it is difficult to influence. This should be of no problem for
+the parser but actual usage of the data can be more difficult.
+"""
+
+from collections import OrderedDict
+from inspect import isroutine
+
+import pyparsing as p
+
+
+# Enable packrat paring.
+#
+# This reduces the complexity of the parser
+# from O(2**N) to O(N) at the cost of memory O(N) vs O(1).
+p.ParserElement.enablePackrat()
+
+# XXX: Hack, changes global stuff
+#
+# This makes pyparsing not so ignorant to whitespace. Normally pyparsing is
+# happily treating newlines, tabs, spaces and carriage returns as irrelevant
+# spacers between tokens. Because pactl syntax is so whitespace-sensitive this
+# is globally turned off. A proper solution would apply this on a
+# per-ParserElement level
+p.ParserElement.DEFAULT_WHITE_CHARS = " "
+
+
+class NodeMeta(type):
+    """
+    Metaclass for all Node types.
+
+    Helps to setup the `Syntax` attribute using the special `__syntax__`
+    attribute. It also calls from_tokens() with the appropriate class.
+    """
+
+    def __new__(mcls, name, bases, ns):
+        cls = type.__new__(mcls, name, bases, ns)
+        if hasattr(cls, '__syntax__'):
+            cls.Syntax = (
+                cls.__syntax__
+            ).setParseAction(
+                cls.from_tokens
+            ).parseWithTabs()
+        return cls
+
+
+class Node(metaclass=NodeMeta):
+    """
+    Base class for things parsed by pyparsing.
+
+    Defines sensible __repr__(), __init__() and from_tokens(). That
+    last class method uses __fragments__ to pick things from pyparsing
+    ParseResults and assign them to attributes of the Node instance.
+
+    This serves as a buffer between pyparsing and external code, so that
+    anything we do to the syntax is irrelevant as long as the tree of
+    Nodes remains the same.
+    """
+
+    __fragments__ = {}
+
+    def __init__(self, **kwargs):
+        for attr, value in kwargs.items():
+            setattr(self, attr, value)
+
+    def __repr__(self):
+        return "{}({})".format(
+            type(self).__name__, ", ".join([
+                "{}={!r}".format(attr, getattr(self, attr))
+                for attr in self.__fragments__]))
+
+    @classmethod
+    def from_tokens(cls, tokens):
+        """
+        Create a node from tokens that were matched from __syntax__
+        """
+        data = {
+            attr: mapper(tokens) if isroutine(mapper) else tokens[mapper]
+            for attr, mapper in cls.__fragments__.items()
+        }
+        return cls(**data)
+
+
+class Property(Node):
+    """
+    A key=value pair.
+
+    A list of properties is a possible syntax for Attribute value.
+    """
+
+    __fragments__ = {
+        'name': 'property-name',
+        'value': 'property-value'
+    }
+
+    __syntax__ = (
+        p.Word(p.alphanums + "-_.").setResultsName("property-name")
+        + p.Suppress('=')
+        + p.QuotedString('"').setResultsName("property-value")
+    ).setResultsName('property')
+
+
+class Profile(Node):
+    """
+    Description of a pulseaudio profile.
+    """
+
+    __fragments__ = {
+        'name': 'profile-name',
+        'label': 'profile-label',
+        'sink_cnt': 'profile-sink-count',
+        'source_cnt': 'profile-source-count',
+        'priority': 'profile-priority',
+    }
+
+    __syntax__ = (
+        p.Word(p.alphanums + "+-:").setParseAction(
+            lambda t: t[0].rstrip(':')
+        ).setResultsName("profile-name")
+        + p.delimitedList(
+            p.Literal("(HDMI)") | p.Literal("(IEC958)") | p.Regex('[^ (\n]+'),
+            ' ', combine=True
+        ).setResultsName('profile-label')
+        + p.Suppress('(')
+        + p.Keyword('sinks').suppress()
+        + p.Suppress(':')
+        + p.Word(p.nums).setParseAction(
+            lambda t: int(t[0])
+        ).setResultsName('profile-sink-count')
+        + p.Suppress(',')
+        + p.Keyword('sources').suppress()
+        + p.Suppress(':')
+        + p.Word(p.nums).setParseAction(
+            lambda t: int(t[0])
+        ).setResultsName('profile-source-count')
+        + p.Suppress(',')
+        + p.Keyword('priority').suppress()
+        + p.MatchFirst([
+            p.Suppress('.'),
+            # http://cgit.freedesktop.org/pulseaudio/pulseaudio/commit/src/utils/pactl.c?id=83c3cf0a65fb05900f81bd2dbb38e6956eb23935
+            p.Suppress(':'),
+        ])
+        + p.Word(p.nums).setParseAction(
+            lambda t: int(t[0])
+        ).setResultsName('profile-priority')
+        + p.Suppress(')')
+    ).setResultsName("profile")
+
+
+class Port(Node):
+    """
+    Description of a port on a sink
+    """
+
+    __fragments__ = {
+        'name': 'port-name',
+        'label': 'port-label',
+        'priority': 'port-priority',
+        'availability': 'port-availability'
+    }
+
+    __syntax__ = (
+        p.Word(p.alphanums + "-;").setResultsName('port-name')
+        + p.Suppress(':')
+        # This part was very tricky to write. The label is basically
+        # arbitrary localized Unicode text.  We want to grab all of it in
+        # one go but without consuming the upcoming '(' character or the
+        # space that comes immediately before.
+        #
+        # The syntax here combines a sequence of words, as defined by
+        # anything other than a space and '(', delimited by a single
+        # whitespace.
+        + p.delimitedList(
+            p.Regex('[^ (\n]+'), ' ', combine=True
+        ).setResultsName('port-label')
+        + p.Suppress('(')
+        + p.Keyword('priority').suppress()
+        + p.Suppress(':')
+        + p.Word(p.nums).setParseAction(
+            lambda t: int(t[0])
+        ).setResultsName('port-priority')
+        + p.MatchFirst([
+            p.Suppress(',') + p.Literal('not available'),
+            p.Suppress(',') + p.Literal('available'),
+            p.Empty().setParseAction(lambda t: '')
+        ]).setResultsName('port-availability')
+        + p.Suppress(')')
+    ).setResultsName("port")
+
+
+# =================
+# Shared Attributes
+# =================
+
+PropertyAttributeValue = (
+    p.Group(
+        p.OneOrMore(
+            p.LineStart().suppress()
+            + p.Optional(p.White('\t')).suppress()
+            + p.Optional(Property.Syntax)
+            + p.LineEnd().suppress()
+        )
+    ).setResultsName("attribute-value"))
+
+
+class PortWithProfile(Node):
+    """
+    Variant of :class:`Port` that is used by "card" records inside
+    the "Ports" property. It differs from the normal port syntax by having
+    different entries inside the last section. Availability is not listed
+    here, only priority. Priority does not have a colon before the actual
+    number. This port is followed by profile assignment.
+    """
+    __fragments__ = {
+        'name': 'port-name',
+        'label': 'port-label',
+        'priority': 'port-priority',
+        'latency_offset': 'port-latency-offset',
+        'availability': 'port-availability',
+        'properties': lambda t: t['port-properties'].asList(),
+        'profile_list': lambda t: t['port-profile-list'].asList(),
+    }
+
+    __syntax__ = (
+        p.Word(p.alphanums + "-;").setResultsName('port-name')
+        + p.Suppress(':')
+        # This part was very tricky to write. The label is basically arbitrary
+        # localized Unicode text. We want to grab all of it in one go but
+        # without consuming the upcoming and latest '(' character or the space
+        # that comes immediately before.
+        #
+        # The syntax here combines a sequence of words, as defined by anything
+        # other than a space and '(', delimited by a single whitespace.
+        + p.Combine(
+            p.OneOrMore(
+                ~p.FollowedBy(
+                    p.Regex('\(.+?\)')
+                    + p.LineEnd()
+                )
+                + p.Regex('[^ \n]+')
+                + p.White().suppress()
+            ),
+            ' '
+        ).setResultsName('port-label')
+        + p.Suppress('(')
+        + p.Keyword('priority').suppress()
+        + p.Optional(
+            p.Suppress(':')
+        )
+        + p.Word(p.nums).setParseAction(
+            lambda t: int(t[0])
+        ).setResultsName('port-priority')
+        + p.Optional(
+            p.MatchFirst([
+                p.Suppress(',') + p.Keyword('latency offset:').suppress()
+                + p.Word(p.nums).setParseAction(lambda t: int(t[0]))
+                + p.Literal("usec").suppress(),
+                p.Empty().setParseAction(lambda t: '')
+            ]).setResultsName('port-latency-offset')
+        )
+        + p.Optional(
+            p.MatchFirst([
+                p.Suppress(',') + p.Literal('not available'),
+                p.Suppress(',') + p.Literal('available'),
+                p.Empty().setParseAction(lambda t: '')
+            ]).setResultsName('port-availability')
+        )
+        + p.Suppress(')')
+        + p.LineEnd().suppress()
+        + p.Optional(
+            p.MatchFirst([
+                p.LineStart().suppress()
+                + p.NotAny(p.White(' '))
+                + p.White('\t').suppress()
+                + p.Keyword('Properties:').suppress()
+                + p.LineEnd().suppress()
+                + PropertyAttributeValue,
+                p.Empty().setParseAction(lambda t: [])
+            ]).setResultsName('port-properties')
+        )
+        + p.White('\t', max=3).suppress()
+        + p.Literal("Part of profile(s)").suppress()
+        + p.Suppress(":")
+        + p.delimitedList(
+            p.Word(p.alphanums + "+-:"), ", "
+        ).setResultsName("port-profile-list")
+    ).setResultsName("port")
+
+
+# =========================
+# Non-collection attributes
+# =========================
+
+AttributeName = p.Regex("[a-zA-Z][^:\n]+").setResultsName("attribute-name")
+
+
+VolumeAttributeValue = (
+    p.Combine(
+        p.Or([
+            p.Literal("(invalid)"),
+            p.Regex("([0-9]+: +[0-9]+% ?)+")
+        ])
+        + p.LineEnd()
+        + p.Optional(p.White('\t').suppress())
+        + p.Or([
+            p.Literal("(invalid)"),
+            p.Regex("([0-9]+: -?[0-9]+\.[0-9]+ dB ?)+")
+        ])
+        + p.LineEnd()
+        + p.Optional(p.White('\t').suppress())
+        + p.Regex("balance [0-9]+\.[0-9]+")
+        + p.LineEnd(),
+        adjacent=False
+    ).setResultsName("attribute-value")
+)
+
+
+BaseVolumeAttributeValue = (
+    p.Combine(
+        p.Regex("[0-9]+%")
+        + p.LineEnd()
+        + p.Optional(p.White('\t').suppress())
+        + p.Regex("-?[0-9]+\.[0-9]+ dB")
+        + p.LineEnd(),
+        adjacent=False
+    ).setResultsName("attribute-value")
+)
+
+
+SimpleAttributeValue = (
+    p.Regex("[^\n]*").setResultsName("attribute-value")
+    + p.LineEnd().suppress())
+
+# simple values
+GenericSimpleAttributeValue = p.MatchFirst([
+    VolumeAttributeValue,
+    BaseVolumeAttributeValue,
+    SimpleAttributeValue,
+])
+
+
+class GenericSimpleAttribute(Node):
+
+    __fragments__ = {
+        'name': 'attribute-name',
+        'value': 'attribute-value',
+    }
+
+    __syntax__ = (
+        p.LineStart().suppress()
+        + p.NotAny(p.White(' '))
+        + p.Optional(p.White('\t')).suppress()
+        + AttributeName
+        + p.Literal(':').suppress()
+        + GenericSimpleAttributeValue
+    ).setResultsName("attribute")
+
+
+# =====================
+# Collection Attributes
+# =====================
+
+PortsAttributeValue = (
+    p.Group(
+        p.OneOrMore(
+            p.LineStart().suppress()
+            + p.Optional(p.White('\t')).suppress()
+            + Port.Syntax
+            + p.LineEnd().suppress())
+    ).setResultsName("attribute-value"))
+
+PortsWithProfilesAttributeValue = (
+    p.Group(
+        p.OneOrMore(
+            p.LineStart().suppress()
+            + p.Optional(p.White('\t')).suppress()
+            + PortWithProfile.Syntax
+            + p.LineEnd().suppress())
+    ).setResultsName("attribute-value"))
+
+FormatsAttributeValue = (
+    p.Group(
+        p.OneOrMore(
+            p.LineStart().suppress()
+            + p.Optional(p.White('\t')).suppress()
+            + p.Word(p.alphas)
+            + p.LineEnd().suppress())
+    ).setResultsName("attribute-value"))
+
+ProfilesAttributeValue = (
+    p.Group(
+        p.OneOrMore(
+            p.LineStart().suppress()
+            + p.Optional(p.White('\t')).suppress()
+            + Profile.Syntax
+            + p.LineEnd().suppress())
+    ).setResultsName("attribute-value"))
+
+
+GenericListAttributeValue = p.MatchFirst([
+    PortsAttributeValue,
+    PropertyAttributeValue,
+    PortsWithProfilesAttributeValue,
+    ProfilesAttributeValue,
+    FormatsAttributeValue,
+])
+
+
+class GenericListAttribute(Node):
+
+    __fragments__ = {
+        'name': 'attribute-name',
+        'value': lambda t: t['attribute-value'].asList()
+    }
+
+    __syntax__ = (
+        p.LineStart().suppress()
+        + p.NotAny(p.White(' '))
+        + p.Optional(p.White('\t')).suppress()
+        + AttributeName
+        + p.Literal(':').suppress()
+        + p.LineEnd().suppress()
+        + GenericListAttributeValue
+    ).setResultsName("attribute")
+
+
+class Record(Node):
+    """
+    Single standalone entry of `pactl list`.
+
+    The record is composed of a name and a list of attributes.  Pulseaudio
+    exposes objects such as cards, sinks and sources as separate records.
+
+    Each attribute may be of a different type. Some attributes are simple
+    values while others have finer structure, including lits and even
+    additional recursive attributes.
+    """
+
+    __fragments__ = {
+        'name': 'record-name',
+        'attribute_list': lambda t: t['record-attributes'].asList(),
+        'attribute_map': lambda t: OrderedDict(
+            (attr.name, attr)
+            for attr in t['record-attributes'].asList()),
+    }
+
+    __syntax__ = (
+        p.LineStart()
+        + p.NotAny(p.White(' \t'))
+        + p.Regex("[A-Z][a-zA-Z ]+ #[0-9]+").setResultsName("record-name")
+        + p.LineEnd().suppress()
+        + p.OneOrMore(
+            p.Or([
+                GenericListAttribute.Syntax,
+                GenericSimpleAttribute.Syntax,
+            ])
+        ).setResultsName("record-attributes")
+    ).setResultsName("record")
+
+    def as_json(self):
+        return {
+            'name': self.name,
+            'attribute_list': self.attribute_list,
+        }
+
+    def __repr__(self):
+        # Custom __repr__ that skips attribute_map
+        return "{}({})".format(
+            type(self).__name__, ", ".join([
+                "{}={!r}".format(attr, getattr(self, attr))
+                for attr in ['name', 'attribute_list']]))
+
+
+class Document(Node):
+    """
+    Encompasses whole output of `pactl list`
+    The document is composed of a list of :class:`Record` objects
+    """
+
+    __fragments__ = {
+        'record_list': lambda t: t['record-list'].asList(),
+    }
+
+    __syntax__ = (
+        p.OneOrMore(
+            Record.Syntax + p.Optional("\n").suppress()
+        ).setResultsName("record-list")
+    ).parseWithTabs()
+
+
+def parse_pactl_output(output):
+    """
+    Parse output of `LANG=C pactl list`
+
+    :returns: :class:`Document` object that corresponds to the parsed input
+    """
+    return Document.Syntax.parseString(output, parseAll=True)[0]

=== added directory 'checkbox-support/checkbox_support/parsers/tests'
=== added file 'checkbox-support/checkbox_support/parsers/tests/__init__.py'
=== added directory 'checkbox-support/checkbox_support/parsers/tests/fixtures'
=== added file 'checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_quantal.txt'
--- checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_quantal.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_quantal.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,143 @@
+⎡ Virtual core pointer id=2 [master pointer (3)]
+Reporting 4 classes:
+Class originated from: 10. Type: XIButtonClass
+Buttons supported: 10
+Button labels: "Button Unknown" "Button Unknown" "Button Unknown" 
+"Button Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button 
+Horiz Wheel Right" None None None
+Button state:
+Class originated from: 10. Type: XIValuatorClass
+Detail for Valuator 0:
+Label: Abs MT Position X
+Range: 0.000000 - 1919.000000
+Resolution: 0 units/m
+Mode: absolute
+Current value: 1664.000000
+Class originated from: 10. Type: XIValuatorClass
+Detail for Valuator 1:
+Label: Abs MT Position Y
+Range: 0.000000 - 1079.000000
+Resolution: 0 units/m
+Mode: absolute
+Current value: 932.000000
+Class originated from: 0. Type: XITouchClass
+Touch mode: direct
+Max number of touches: 17
+
+⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)]
+Reporting 3 classes:
+Class originated from: 4. Type: XIButtonClass
+Buttons supported: 10
+Button labels: "Button Left" "Button Middle" "Button Right" "Button 
+Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button Horiz 
+Wheel Right" None None None
+Button state:
+Class originated from: 4. Type: XIValuatorClass
+Detail for Valuator 0:
+Label: Rel X
+Range: -1.000000 - -1.000000
+Resolution: 0 units/m
+Mode: relative
+Class originated from: 4. Type: XIValuatorClass
+Detail for Valuator 1:
+Label: Rel Y
+Range: -1.000000 - -1.000000
+Resolution: 0 units/m
+Mode: relative
+
+⎜ ↳ Quanta OpticalTouchScreen id=10 [slave pointer (2)]
+Reporting 4 classes:
+Class originated from: 10. Type: XIButtonClass
+Buttons supported: 5
+Button labels: "Button Unknown" "Button Unknown" "Button Unknown" 
+"Button Wheel Up" "Button Wheel Down"
+Button state:
+Class originated from: 10. Type: XIValuatorClass
+Detail for Valuator 0:
+Label: Abs MT Position X
+Range: 0.000000 - 1919.000000
+Resolution: 0 units/m
+Mode: absolute
+Current value: 1664.000000
+Class originated from: 10. Type: XIValuatorClass
+Detail for Valuator 1:
+Label: Abs MT Position Y
+Range: 0.000000 - 1079.000000
+Resolution: 0 units/m
+Mode: absolute
+Current value: 932.000000
+Class originated from: 0. Type: XITouchClass
+Touch mode: direct
+Max number of touches: 9
+
+⎜ ↳ MCE IR Keyboard/Mouse (nuvoton-cir) id=12 [slave pointer (2)]
+Reporting 4 classes:
+Class originated from: 12. Type: XIButtonClass
+Buttons supported: 5
+Button labels: "Button Left" "Button Unknown" "Button Right" "Button 
+Wheel Up" "Button Wheel Down"
+Button state:
+Class originated from: 12. Type: XIKeyClass
+Keycodes supported: 248
+Class originated from: 12. Type: XIValuatorClass
+Detail for Valuator 0:
+Label: Rel X
+Range: -1.000000 - -1.000000
+Resolution: 1 units/m
+Mode: relative
+Class originated from: 12. Type: XIValuatorClass
+Detail for Valuator 1:
+Label: Rel Y
+Range: -1.000000 - -1.000000
+Resolution: 1 units/m
+Mode: relative
+
+⎣ Virtual core keyboard id=3 [master keyboard (2)]
+Reporting 1 classes:
+Class originated from: 14. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Virtual core XTEST keyboard id=5 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 5. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Power Button id=6 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 6. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Power Button id=7 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 7. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Laptop_Integrated_Webcam_2M id=8 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 8. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ HID 413c:8161 id=9 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 9. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Nuvoton w836x7hg Infrared Remote Transceiver id=11 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 11. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Dell AIO WMI hotkeys id=13 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 13. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Chicony USB Keyboard id=14 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 14. Type: XIKeyClass
+Keycodes supported: 248
+
+↳ Chicony USB Keyboard id=15 [slave keyboard (3)]
+Reporting 1 classes:
+Class originated from: 15. Type: XIKeyClass
+Keycodes supported: 248

=== added file 'checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_toshiba.txt'
--- checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_toshiba.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/fixtures/xinput_toshiba.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,166 @@
+⎡ Virtual core pointer                    	id=2	[master pointer  (3)]
+	Reporting 8 classes:
+		Class originated from: 12. Type: XIButtonClass
+		Buttons supported: 12
+		Button labels: "Button Left" "Button Middle" "Button Right" "Button Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button Horiz Wheel Right" None None None None None
+		Button state:
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 0:
+		  Label: Rel X
+		  Range: 0.000000 - 2000.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 1:
+		  Label: Rel Y
+		  Range: 0.000000 - 1400.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 2:
+		  Label: Rel Horiz Scroll
+		  Range: 0.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 3:
+		  Label: Rel Vert Scroll
+		  Range: 0.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIScrollClass
+		Scroll info for Valuator 2
+		  type: 2 (horizontal)
+		  increment: 48.000000
+		  flags: 0x0
+		Class originated from: 12. Type: XIScrollClass
+		Scroll info for Valuator 3
+		  type: 1 (vertical)
+		  increment: 48.000000
+		  flags: 0x0
+		Class originated from: 0. Type: XITouchClass
+		Touch mode: dependent
+		Max number of touches: 2
+
+⎜   ↳ Virtual core XTEST pointer              	id=4	[slave  pointer  (2)]
+	Reporting 3 classes:
+		Class originated from: 4. Type: XIButtonClass
+		Buttons supported: 10
+		Button labels: "Button Left" "Button Middle" "Button Right" "Button Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button Horiz Wheel Right" None None None
+		Button state:
+		Class originated from: 4. Type: XIValuatorClass
+		Detail for Valuator 0:
+		  Label: Rel X
+		  Range: -1.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 4. Type: XIValuatorClass
+		Detail for Valuator 1:
+		  Label: Rel Y
+		  Range: -1.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+
+⎜   ↳ DualPoint Stick                         	id=11	[slave  pointer  (2)]
+	Reporting 3 classes:
+		Class originated from: 11. Type: XIButtonClass
+		Buttons supported: 7
+		Button labels: "Button Left" "Button Middle" "Button Right" "Button Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button Horiz Wheel Right"
+		Button state:
+		Class originated from: 11. Type: XIValuatorClass
+		Detail for Valuator 0:
+		  Label: Rel X
+		  Range: -1.000000 - -1.000000
+		  Resolution: 1 units/m
+		  Mode: relative
+		Class originated from: 11. Type: XIValuatorClass
+		Detail for Valuator 1:
+		  Label: Rel Y
+		  Range: -1.000000 - -1.000000
+		  Resolution: 1 units/m
+		  Mode: relative
+
+⎜   ↳ AlpsPS/2 ALPS DualPoint TouchPad        	id=12	[slave  pointer  (2)]
+	Reporting 8 classes:
+		Class originated from: 12. Type: XIButtonClass
+		Buttons supported: 12
+		Button labels: "Button Left" "Button Middle" "Button Right" "Button Wheel Up" "Button Wheel Down" "Button Horiz Wheel Left" "Button Horiz Wheel Right" None None None None None
+		Button state:
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 0:
+		  Label: Rel X
+		  Range: 0.000000 - 2000.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 1:
+		  Label: Rel Y
+		  Range: 0.000000 - 1400.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 2:
+		  Label: Rel Horiz Scroll
+		  Range: 0.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIValuatorClass
+		Detail for Valuator 3:
+		  Label: Rel Vert Scroll
+		  Range: 0.000000 - -1.000000
+		  Resolution: 0 units/m
+		  Mode: relative
+		Class originated from: 12. Type: XIScrollClass
+		Scroll info for Valuator 2
+		  type: 2 (horizontal)
+		  increment: 48.000000
+		  flags: 0x0
+		Class originated from: 12. Type: XIScrollClass
+		Scroll info for Valuator 3
+		  type: 1 (vertical)
+		  increment: 48.000000
+		  flags: 0x0
+		Class originated from: 0. Type: XITouchClass
+		Touch mode: dependent
+		Max number of touches: 2
+
+⎣ Virtual core keyboard                   	id=3	[master keyboard (2)]
+	Reporting 1 classes:
+		Class originated from: 10. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ Virtual core XTEST keyboard             	id=5	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 5. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ Power Button                            	id=6	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 6. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ Video Bus                               	id=7	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 7. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ Power Button                            	id=8	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 8. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ CNF9055                                 	id=9	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 9. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ AT Translated Set 2 keyboard            	id=10	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 10. Type: XIKeyClass
+		Keycodes supported: 248
+
+    ↳ Toshiba input device                    	id=13	[slave  keyboard (3)]
+	Reporting 1 classes:
+		Class originated from: 13. Type: XIKeyClass
+		Keycodes supported: 248
+

=== added directory 'checkbox-support/checkbox_support/parsers/tests/pactl_data'
=== added file 'checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-0.txt'
--- checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-0.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-0.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,33 @@
+Card #0
+	Name: alsa_card.pci-0000_02_00.1
+	Driver: module-alsa-card.c
+	Owner Module: 4
+	Properties:
+		alsa.card = "2"
+		alsa.card_name = "HDA NVidia"
+		alsa.long_card_name = "HDA NVidia at 0xfbdfc000 irq 34"
+		alsa.driver_name = "snd_hda_intel"
+		device.bus_path = "pci-0000:02:00.1"
+		sysfs.path = "/devices/pci0000:00/0000:00:03.0/0000:02:00.1/sound/card2"
+		device.bus = "pci"
+		device.vendor.id = "10de"
+		device.vendor.name = "NVIDIA Corporation"
+		device.string = "2"
+		device.description = "HDA NVidia"
+		module-udev-detect.discovered = "1"
+		device.icon_name = "audio-card-pci"
+	Profiles:
+		output:hdmi-stereo: Wyjście Digital Stereo (HDMI) (sinks: 1, sources: 0, priority. 5400)
+		output:hdmi-surround: Wyjście Digital Surround 5.1 (HDMI) (sinks: 1, sources: 0, priority. 300)
+		output:hdmi-stereo-extra1: Wyjście Digital Stereo (HDMI) (sinks: 1, sources: 0, priority. 5200)
+		output:hdmi-stereo-extra2: Wyjście Digital Stereo (HDMI) (sinks: 1, sources: 0, priority. 5200)
+		output:hdmi-surround-extra2: Wyjście Digital Surround 5.1 (HDMI) (sinks: 1, sources: 0, priority. 100)
+		off: Wyłącz (sinks: 0, sources: 0, priority. 0)
+	Active Profile: output:hdmi-stereo-extra1
+	Ports:
+		hdmi-output-0: HDMI / DisplayPort (priority 5900)
+			Part of profile(s): output:hdmi-stereo, output:hdmi-surround
+		hdmi-output-1: HDMI / DisplayPort 2 (priority 5800)
+			Part of profile(s): output:hdmi-stereo-extra1
+		hdmi-output-2: HDMI / DisplayPort 3 (priority 5700)
+			Part of profile(s): output:hdmi-stereo-extra2, output:hdmi-surround-extra2

=== added file 'checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-1.txt'
--- checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-1.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-1.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,51 @@
+Card #1
+	Name: alsa_card.pci-0000_00_1b.0
+	Driver: module-alsa-card.c
+	Owner Module: 5
+	Properties:
+		alsa.card = "0"
+		alsa.card_name = "HDA Intel"
+		alsa.long_card_name = "HDA Intel at 0xf9ff8000 irq 70"
+		alsa.driver_name = "snd_hda_intel"
+		device.bus_path = "pci-0000:00:1b.0"
+		sysfs.path = "/devices/pci0000:00/0000:00:1b.0/sound/card0"
+		device.bus = "pci"
+		device.vendor.id = "8086"
+		device.vendor.name = "Intel Corporation"
+		device.product.name = "82801JI (ICH10 Family) HD Audio Controller"
+		device.form_factor = "internal"
+		device.string = "0"
+		device.description = "Wbudowany dźwięk"
+		module-udev-detect.discovered = "1"
+		device.icon_name = "audio-card-pci"
+	Profiles:
+		output:analog-stereo: Wyjście Analogowe stereo (sinks: 1, sources: 0, priority. 6000)
+		output:analog-stereo+input:analog-stereo: Analogowy dupleks stereo (sinks: 1, sources: 1, priority. 6060)
+		output:analog-surround-40: Wyjście Analogowe surround 4.0 (sinks: 1, sources: 0, priority. 700)
+		output:analog-surround-40+input:analog-stereo: Wyjście Analogowe surround 4.0 + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 760)
+		output:analog-surround-41: Wyjście Analogowe surround 4.1 (sinks: 1, sources: 0, priority. 800)
+		output:analog-surround-41+input:analog-stereo: Wyjście Analogowe surround 4.1 + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 860)
+		output:analog-surround-50: Wyjście Analogowe surround 5.0 (sinks: 1, sources: 0, priority. 700)
+		output:analog-surround-50+input:analog-stereo: Wyjście Analogowe surround 5.0 + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 760)
+		output:analog-surround-51: Wyjście Analogowe surround 5.1 (sinks: 1, sources: 0, priority. 800)
+		output:analog-surround-51+input:analog-stereo: Wyjście Analogowe surround 5.1 + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 860)
+		output:analog-surround-71: Wyjście Analog Surround 7.1 (sinks: 1, sources: 0, priority. 700)
+		output:analog-surround-71+input:analog-stereo: Wyjście Analog Surround 7.1 + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 760)
+		output:iec958-stereo: Wyjście Cyfrowe stereo (IEC958) (sinks: 1, sources: 0, priority. 5500)
+		output:iec958-stereo+input:analog-stereo: Wyjście Cyfrowe stereo (IEC958) + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 5560)
+		input:analog-stereo: Wejście Analogowe stereo (sinks: 0, sources: 1, priority. 60)
+		off: Wyłącz (sinks: 0, sources: 0, priority. 0)
+	Active Profile: output:analog-stereo+input:analog-stereo
+	Ports:
+		analog-output: Wyjście analogowe (priority 9900)
+			Part of profile(s): output:analog-stereo, output:analog-stereo+input:analog-stereo, output:analog-surround-40, output:analog-surround-40+input:analog-stereo, output:analog-surround-41, output:analog-surround-41+input:analog-stereo, output:analog-surround-50, output:analog-surround-50+input:analog-stereo, output:analog-surround-51, output:analog-surround-51+input:analog-stereo, output:analog-surround-71, output:analog-surround-71+input:analog-stereo
+		analog-output-headphones: Słuchawki (priority 9000)
+			Part of profile(s): output:analog-stereo, output:analog-stereo+input:analog-stereo
+		analog-input-microphone-front: Przedni mikrofon (priority 8500)
+			Part of profile(s): output:analog-stereo+input:analog-stereo, output:analog-surround-40+input:analog-stereo, output:analog-surround-41+input:analog-stereo, output:analog-surround-50+input:analog-stereo, output:analog-surround-51+input:analog-stereo, output:analog-surround-71+input:analog-stereo, output:iec958-stereo+input:analog-stereo, input:analog-stereo
+		analog-input-microphone-rear: Tylny mikrofon (priority 8200)
+			Part of profile(s): output:analog-stereo+input:analog-stereo, output:analog-surround-40+input:analog-stereo, output:analog-surround-41+input:analog-stereo, output:analog-surround-50+input:analog-stereo, output:analog-surround-51+input:analog-stereo, output:analog-surround-71+input:analog-stereo, output:iec958-stereo+input:analog-stereo, input:analog-stereo
+		analog-input-linein: Wejście liniowe (priority 8100)
+			Part of profile(s): output:analog-stereo+input:analog-stereo, output:analog-surround-40+input:analog-stereo, output:analog-surround-41+input:analog-stereo, output:analog-surround-50+input:analog-stereo, output:analog-surround-51+input:analog-stereo, output:analog-surround-71+input:analog-stereo, output:iec958-stereo+input:analog-stereo, input:analog-stereo
+		iec958-stereo-output: Wyjście cyfrowe (S/PDIF) (priority 0)
+			Part of profile(s): output:iec958-stereo, output:iec958-stereo+input:analog-stereo

=== added file 'checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-2.txt'
--- checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-2.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise-2.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,30 @@
+Card #2
+	Name: alsa_card.usb-046d_0825_0E3A8A10-02-U0x46d0x825
+	Driver: module-alsa-card.c
+	Owner Module: 6
+	Properties:
+		alsa.card = "1"
+		alsa.card_name = "USB Device 0x46d:0x825"
+		alsa.long_card_name = "USB Device 0x46d:0x825 at usb-0000:00:1d.7-1, high speed"
+		alsa.driver_name = "snd_usb_audio"
+		device.bus_path = "pci-0000:00:1d.7-usb-0:1:1.2"
+		sysfs.path = "/devices/pci0000:00/0000:00:1d.7/usb2/2-1/2-1:1.2/sound/card1"
+		udev.id = "usb-046d_0825_0E3A8A10-02-U0x46d0x825"
+		device.bus = "usb"
+		device.vendor.id = "046d"
+		device.vendor.name = "Logitech, Inc."
+		device.product.id = "0825"
+		device.product.name = "Webcam C270"
+		device.serial = "046d_0825_0E3A8A10"
+		device.form_factor = "webcam"
+		device.string = "1"
+		device.description = "Webcam C270"
+		module-udev-detect.discovered = "1"
+		device.icon_name = "camera-web-usb"
+	Profiles:
+		input:analog-mono: Wejście Analogowe mono (sinks: 0, sources: 1, priority. 1)
+		off: Wyłącz (sinks: 0, sources: 0, priority. 0)
+	Active Profile: input:analog-mono
+	Ports:
+		analog-input-microphone: Mikrofon (priority 8700)
+			Part of profile(s): input:analog-mono

=== added file 'checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise.txt'
--- checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/pactl_data/cards-desktop-precise.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,41 @@
+Card #0
+	Name: alsa_card.pci-0000_00_1b.0
+	Driver: module-alsa-card.c
+	Owner Module: 4
+	Properties:
+		alsa.card = "0"
+		alsa.card_name = "HDA Intel PCH"
+		alsa.long_card_name = "HDA Intel PCH at 0xe0610000 irq 46"
+		alsa.driver_name = "snd_hda_intel"
+		device.bus_path = "pci-0000:00:1b.0"
+		sysfs.path = "/devices/pci0000:00/0000:00:1b.0/sound/card0"
+		device.bus = "pci"
+		device.vendor.id = "8086"
+		device.vendor.name = "Intel Corporation"
+		device.product.name = "Panther Point High Definition Audio Controller"
+		device.form_factor = "internal"
+		device.string = "0"
+		device.description = "Wbudowany dźwięk"
+		module-udev-detect.discovered = "1"
+		device.icon_name = "audio-card-pci"
+	Profiles:
+		output:analog-stereo: Wyjście Analogowe stereo (sinks: 1, sources: 0, priority. 6000)
+		output:analog-stereo+input:analog-stereo: Analogowy dupleks stereo (sinks: 1, sources: 1, priority. 6060)
+		output:hdmi-stereo: Wyjście Digital Stereo (HDMI) (sinks: 1, sources: 0, priority. 5400)
+		output:hdmi-stereo+input:analog-stereo: Wyjście Digital Stereo (HDMI) + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 5460)
+		output:hdmi-surround: Wyjście Digital Surround 5.1 (HDMI) (sinks: 1, sources: 0, priority. 300)
+		output:hdmi-surround+input:analog-stereo: Wyjście Digital Surround 5.1 (HDMI) + Wejście Analogowe stereo (sinks: 1, sources: 1, priority. 360)
+		input:analog-stereo: Wejście Analogowe stereo (sinks: 0, sources: 1, priority. 60)
+		off: Wyłącz (sinks: 0, sources: 0, priority. 0)
+	Active Profile: output:analog-stereo+input:analog-stereo
+	Ports:
+		analog-output-speaker: Głośniki (priority 10000)
+			Part of profile(s): output:analog-stereo, output:analog-stereo+input:analog-stereo
+		analog-output-headphones: Słuchawki (priority 9000)
+			Part of profile(s): output:analog-stereo, output:analog-stereo+input:analog-stereo
+		analog-input-microphone-internal: Wewnętrzny mikrofon (priority 8900)
+			Part of profile(s): output:analog-stereo+input:analog-stereo, output:hdmi-stereo+input:analog-stereo, output:hdmi-surround+input:analog-stereo, input:analog-stereo
+		analog-input-microphone: Mikrofon (priority 8700)
+			Part of profile(s): output:analog-stereo+input:analog-stereo, output:hdmi-stereo+input:analog-stereo, output:hdmi-surround+input:analog-stereo, input:analog-stereo
+		hdmi-output-0: HDMI / DisplayPort (priority 5900)
+			Part of profile(s): output:hdmi-stereo, output:hdmi-stereo+input:analog-stereo, output:hdmi-surround, output:hdmi-surround+input:analog-stereo

=== added file 'checkbox-support/checkbox_support/parsers/tests/pactl_data/desktop-precise-radeon-hdmi-available.txt'
--- checkbox-support/checkbox_support/parsers/tests/pactl_data/desktop-precise-radeon-hdmi-available.txt	1970-01-01 00:00:00 +0000
+++ checkbox-support/checkbox_support/parsers/tests/pactl_data/desktop-precise-radeon-hdmi-available.txt	2014-01-07 13:44:32 +0000
@@ -0,0 +1,608 @@
+Module #0
+	Name: module-device-restore
+	Argument: 
+	Usage counter: n/a
+	Properties:
+		module.author = "Lennart Poettering"
+		module.description = "Automatically restore the volume/mute state of devices"
+		module.version = "1.1"
+
+Module #1
+	Name: module-stream-restore
+	Argument: