Merge lp:~cyphermox/mtp/images into lp:mtp

[Mathieu Trudel-Lapierre]

[Ricardo Salveti (rsalveti)]

105 + timeout=10
106 + # loop 10 times and then exit, if the property service
107 + # isnt up after 80 sec # it is likely not starting at all
108 + while [ ! -e /dev/socket/property_service ]; do
109 + sleep 8
110 + if [ "$timeout" -le 0 ]; then
111 + stop
112 + exit 0
113 + fi
114 + timeout=$(($timeout - 1))
115 + done
116 +
117 + if [ -x /usr/bin/setprop ]; then
118 + /usr/bin/setprop sys.usb.config mtp,adb
119 + fi

You don't need to go over the timeout logic if setprop is not available.

121 + start mtp-server

Why do we need to manually start the mtp-server if the other upstart job is already watching for android_usb-device-changed udev events?

337 + readFiles("/home/phablet");

How hard would it be to not make it hardcoded to phablet? Guess the server would be per user anyway, right?

Rest looks fine, need testing.

review: Needs Information

[Ricardo Salveti (rsalveti)]

40 -mtp (0.0.1-1) raring; urgency=low
41 -
42 - * Initial release
43 -
44 - -- Thomas Voß <email address hidden> Mon, 10 June 2013 11:43:05 +0200
45 +mtp (0.0.4-0ubuntu1) UNRELEASED; urgency=low

Coming from 0.0.1 to 0.0.4, would probably be better to use 0.1 instead as you're replacing the changelog anyway.

[Mathieu Trudel-Lapierre (cyphermox)]

> You don't need to go over the timeout logic if setprop is not available.

Well, the timeout is more important, since this could possibly start before the android settings service is available to do something with the request. Should I jsut remove the check for the existence of setprop?

[lp:~cyphermox/mtp/images]

19. By Mathieu Trudel-Lapierre on 2013-09-11

Un-hardcode paths and user info.

20. By Mathieu Trudel-Lapierre on 2013-09-11

Fix saving files to the root MTP directory.

21. By Mathieu Trudel-Lapierre on 2013-09-11

Only check for property service if setprop is executable at all

22. By Mathieu Trudel-Lapierre on 2013-09-11

Fix changelog for archive release

23. By Mathieu Trudel-Lapierre on 2013-09-11

Add libboost-test-dev as a Build-Depends.

[Ricardo Salveti (rsalveti)]

747 +++ tests/MockMtpDatabase.h 2013-09-11 16:07:04 +0000

Mind adding copyright in this file?

review: Needs Fixing

[lp:~cyphermox/mtp/images]

24. By Mathieu Trudel-Lapierre on 2013-09-11

Fix changelog license for the files we added that are not from the Android library.

[Ricardo Salveti (rsalveti)]

Looks good, thanks!

review: Approve

=== added directory '.bzr-builddeb'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2013-09-11 16:32:38 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+split = True
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-06-13 10:22:21 +0000
+++ CMakeLists.txt	2013-09-11 16:32:38 +0000
@@ -10,6 +10,8 @@
 set(MTP_VERSION_MINOR 0)
 set(MTP_VERSION_PATCH 0)
 
+find_package(Boost REQUIRED COMPONENTS system filesystem unit_test_framework)
+
 set(
     MTP_HEADERS
     include/MtpDatabase.h
@@ -53,6 +55,7 @@
 include_directories(
     include/
     libusbhost/include
+    ${Boost_INCLUDE_DIRS}
 )
 
 add_library(
@@ -80,5 +83,9 @@
   PUBLIC_HEADER DESTINATION include/mtp
 )
 
+enable_testing()
+
 add_subdirectory(libusbhost)
-add_subdirectory(examples)
+add_subdirectory(server)
+add_subdirectory(tests)
+
 
=== modified file 'debian/changelog'
--- debian/changelog	2013-06-13 10:22:21 +0000
+++ debian/changelog	2013-09-11 16:32:38 +0000
@@ -1,5 +1,5 @@
-mtp (0.0.1-1) raring; urgency=low
+mtp (0.0.1-0ubuntu1) UNRELEASED; urgency=low
 
   * Initial release
 
- -- Thomas Voß <[e-mail]>  Mon, 10 June 2013 11:43:05 +0200
+ -- Mathieu Trudel-Lapierre <[e-mail]>  Fri, 06 Sep 2013 16:07:38 -0400
 
=== modified file 'debian/control'
--- debian/control	2013-06-13 10:22:21 +0000
+++ debian/control	2013-09-11 16:32:38 +0000
@@ -1,8 +1,13 @@
 Source: mtp
-Priority: extra
-Maintainer: Thomas Voß <[e-mail]>
+Section: utils
+Priority: optional
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Thomas Voß <[e-mail]>
 Build-Depends: debhelper (>= 8.0.0), 
-	       cmake, 
+               cmake, 
+               libboost-dev,
+               libboost-filesystem-dev,
+               libboost-test-dev,
 Standards-Version: 3.9.4
 Homepage: http://launchpad.net/mtp
 
@@ -24,12 +29,12 @@
  .
  Contains header files required to develop actual services.
 
-Package: mtp-examples
+Package: mtp-server
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends}
 Description: A server-implementation of MTP.
  Exposes phone storage over MTP. 	  
  .
- Contains example executables
+ Contains a simple MTP server that exposes images, videos, and music.
 
 
=== added file 'debian/mtp-server.conf'
--- debian/mtp-server.conf	1970-01-01 00:00:00 +0000
+++ debian/mtp-server.conf	2013-09-11 16:32:38 +0000
@@ -0,0 +1,18 @@
+description "MTP protocol server"
+
+start on :sys:android_usb-device-changed
+
+expect fork
+respawn
+
+pre-start script
+	state=`cat /sys/class/android_usb/android0/state`
+	if [ "$state" = "DISCONNECTED" ]; then
+		stop
+		exit 0
+	fi
+
+	rm -f ~/.cache/upstart/mtp-server.log
+end script
+
+exec /usr/bin/mtp-server &
 
=== renamed file 'debian/mtp-examples.install' => 'debian/mtp-server.install'
--- debian/mtp-examples.install	2013-06-13 10:22:21 +0000
+++ debian/mtp-server.install	2013-09-11 16:32:38 +0000
@@ -1,1 +1,2 @@
-usr/bin/mtp-server
 \ No newline at end of file
+usr/bin/mtp-server
+debian/mtp-server.conf /usr/share/upstart/sessions/
 
=== added file 'debian/mtp-server.mtp-server-bootup.upstart'
--- debian/mtp-server.mtp-server-bootup.upstart	1970-01-01 00:00:00 +0000
+++ debian/mtp-server.mtp-server-bootup.upstart	2013-09-11 16:32:38 +0000
@@ -0,0 +1,27 @@
+description "MTP protocol server bootup"
+
+start on android
+
+task
+
+emits android_usb-device-changed        
+
+script
+        if [ -x /usr/bin/setprop ]; then
+                timeout=10
+                # loop 10 times and then exit, if the property service
+                # isnt up after 80 sec # it is likely not starting at all
+                while [ ! -e /dev/socket/property_service ]; do
+                        sleep 8
+                        if [ "$timeout" -le 0 ]; then
+                                stop
+                                exit 0
+                        fi
+                        timeout=$(($timeout - 1))
+                done
+
+                /usr/bin/setprop sys.usb.config mtp,adb
+        fi
+
+        initctl emit android_usb-device-changed        
+end script
 
=== modified file 'debian/rules'
--- debian/rules	2013-06-13 10:22:21 +0000
+++ debian/rules	2013-09-11 16:32:38 +0000
@@ -1,13 +1,11 @@
 #!/usr/bin/make -f
-# -*- makefile -*-
-# Sample debian/rules that uses debhelper.
-# This file was originally written by Joey Hess and Craig Small.
-# As a special exception, when this file is copied by dh-make into a
-# dh-make output file, you may use that output file without restriction.
-# This special exception was added by Craig Small in version 0.37 of dh-make.
 
 # Uncomment this to turn on verbose mode.
 # export DH_VERBOSE=1
 
 %:
-	dh $@
 \ No newline at end of file
+	dh $@
+
+override_dh_installinit:
+	dh_installinit -pmtp-server --name=mtp-server-bootup
+	dh_installinit
 
=== renamed directory 'examples' => 'server'
=== modified file 'server/CMakeLists.txt'
--- examples/CMakeLists.txt	2013-06-13 10:22:21 +0000
+++ server/CMakeLists.txt	2013-09-11 16:32:38 +0000
@@ -5,13 +5,18 @@
     server.cpp
 )
 
+set_target_properties(mtp-server PROPERTIES COMPILE_FLAGS -fPIC)
+
 target_link_libraries(
     mtp-server
     mtp
     usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_system_LIBRARIES}
+    ${Boost_filesystem_LIBRARIES}
 )
 
 install(
   TARGETS mtp-server
   RUNTIME DESTINATION bin
-)
 \ No newline at end of file
+)
 
=== renamed file 'examples/StubMtpDatabase.h' => 'server/UbuntuMtpDatabase.h'
--- examples/StubMtpDatabase.h	2013-06-13 10:22:21 +0000
+++ server/UbuntuMtpDatabase.h	2013-09-11 16:32:38 +0000
@@ -1,3 +1,19 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef STUB_MTP_DATABASE_H_
 #define STUB_MTP_DATABASE_H_
 
@@ -7,73 +23,106 @@
 #include <MtpObjectInfo.h>
 #include <MtpProperty.h>
 
+#include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <map>
+#include <vector>
 #include <string>
 #include <tuple>
 
+#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/range/adaptors.hpp>
+#include <boost/range/algorithm.hpp>
+
+using namespace boost::filesystem;
+
 namespace android
 {
-class StubMtpDatabase : public android::MtpDatabase {
+class UbuntuMtpDatabase : public android::MtpDatabase {
 private:
     struct DbEntry
     {
         MtpStorageID storage_id;
         std::string object_name;
         MtpObjectFormat object_format;
+        MtpObjectHandle parent;
         size_t object_size;
-        size_t width;
-        size_t height;
-        size_t bit_depth;
         std::string display_name;
         std::string path;
     };
 
-    enum PngImageHandles
-    {
-        png_image_1,
-        png_image_2,
-        png_image_3,
-        png_image_4,
-        png_image_5,
-        png_image_6,                        
-        png_image_7,
-        png_image_8,
-        png_image_9,
-        png_image_10,
-        png_image_size                        
-    };
-    static const uint32_t reserved_slots = png_image_size;
-    
     uint32_t counter;
-    std::map<std::tuple<MtpStorageID, MtpObjectFormat>, MtpObjectHandleList> db = 
+    std::map<MtpObjectHandle, DbEntry> db;
+    
+    void parse_directory(path p, MtpObjectHandle parent)
     {
+	DbEntry entry;
+        std::vector<path> v;
+
+        copy(directory_iterator(p), directory_iterator(), std::back_inserter(v));
+
+        for (std::vector<path>::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
         {
-            std::make_tuple(MTP_STORAGE_REMOVABLE_RAM, MTP_FORMAT_PNG), 
-            {png_image_1, png_image_2, png_image_3, png_image_4, png_image_5, png_image_6, png_image_7, png_image_8, png_image_9, png_image_10}
+            MtpObjectHandle handle = counter;
+
+            counter++;
+
+            std::cout << "   " << *it << " handle: " << handle << " parent: " << parent << std::endl;
+
+            entry.storage_id = MTP_STORAGE_FIXED_RAM;
+            entry.parent = parent;
+            entry.object_name = it->filename().string();
+            entry.display_name = it->filename().string();
+            entry.path = it->string();
+
+            if (is_regular_file (*it)) {
+                entry.object_format = MTP_FORMAT_DEFINED;
+                entry.object_size = file_size(*it);
+
+                db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
+            } else if (is_directory (*it)) {
+                entry.object_format = MTP_FORMAT_ASSOCIATION;
+                entry.object_size = 0;
+
+                db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
+
+                parse_directory (*it, handle);
+	    }
         }
-    };
-    
-    std::map<MtpObjectHandle, DbEntry> entries = 
+    }
+
+    void readFiles(const std::string& sourcedir)
     {
-        {png_image_1, {MTP_STORAGE_REMOVABLE_RAM, "png_image_1", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_1", "png_image_1.png"}},
-        {png_image_2, {MTP_STORAGE_REMOVABLE_RAM, "png_image_2", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_2", "png_image_2.png"}},
-        {png_image_3, {MTP_STORAGE_REMOVABLE_RAM, "png_image_3", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_3", "png_image_3.png"}},
-        {png_image_4, {MTP_STORAGE_REMOVABLE_RAM, "png_image_4", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_4", "png_image_4.png"}},                
-        {png_image_5, {MTP_STORAGE_REMOVABLE_RAM, "png_image_5", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_5", "png_image_5.png"}},
-        {png_image_6, {MTP_STORAGE_REMOVABLE_RAM, "png_image_6", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_6", "png_image_6.png"}},
-        {png_image_7, {MTP_STORAGE_REMOVABLE_RAM, "png_image_7", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_7", "png_image_7.png"}},
-        {png_image_8, {MTP_STORAGE_REMOVABLE_RAM, "png_image_8", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_8", "png_image_8.png"}},
-        {png_image_9, {MTP_STORAGE_REMOVABLE_RAM, "png_image_9", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_9", "png_image_9.png"}},
-        {png_image_10, {MTP_STORAGE_REMOVABLE_RAM, "png_image_10", MTP_FORMAT_PNG, 20 * 20 * 4, 20, 20, 4, "png_image_10", "png_image_10.png"}}
-    };
-    
+        path p (sourcedir);
+
+        try {
+            if (exists(p)) {
+                if (is_directory(p)) {
+                    std::cout << p << " is a directory containing:\n";
+
+                    parse_directory (p, MTP_PARENT_ROOT);
+                }
+            } else
+                std::cout << p << " does not exist\n";
+        }
+        catch (const filesystem_error& ex) {
+            std::cout << ex.what() << '\n';
+        }
+
+    }
+
 public:
-    StubMtpDatabase() : counter(StubMtpDatabase::reserved_slots)
+    UbuntuMtpDatabase(const char *dir) : counter(1)
     {
+	db = std::map<MtpObjectHandle, DbEntry>();
+	readFiles(std::string(dir));
+	
+        std::cout << __PRETTY_FUNCTION__ << ": object count:" << db.size() << std::endl;
     }
-    virtual ~StubMtpDatabase() {}
+
+    virtual ~UbuntuMtpDatabase() {}
 
     // called from SendObjectInfo to reserve a database entry for the incoming file
     virtual MtpObjectHandle beginSendObject(
@@ -84,8 +133,25 @@
         uint64_t size,
         time_t modified)
     {
-        std::cout << __PRETTY_FUNCTION__ << ": " << path << std::endl;
-        return counter++; 
+	DbEntry entry;
+	MtpObjectHandle handle = counter;
+	MtpObjectHandle parent_id = parent == 0 ? MTP_PARENT_ROOT : parent;
+
+        std::cout << __PRETTY_FUNCTION__ << ": " << path << " - " << parent << std::endl;
+
+        entry.storage_id = storage;
+        entry.parent = parent_id;
+        entry.object_name = std::string(basename(path.c_str()));
+        entry.display_name = std::string(basename(path.c_str()));
+        entry.path = path;
+        entry.object_format = format;
+        entry.object_size = size;
+
+        db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
+
+	counter++;
+
+        return handle; 
     }
 
     // called to report success or failure of the SendObject file transfer
@@ -98,6 +164,10 @@
         bool succeeded)
     {
         std::cout << __PRETTY_FUNCTION__ << ": " << path << std::endl;
+
+	if (!succeeded) {
+		db.erase(handle);
+	}
     }
 
     virtual MtpObjectHandleList* getObjectList(
@@ -109,7 +179,14 @@
         MtpObjectHandleList* list = nullptr;
         try
         {
-            list = new MtpObjectHandleList(db.at(std::make_tuple(storageID, MTP_FORMAT_PNG)));
+            std::vector<MtpObjectHandle> keys;
+
+            BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+                if (db.at(i).parent == parent)
+                    keys.push_back(i);
+            }
+
+            list = new MtpObjectHandleList(keys);
         } catch(...)
         {
             list = new MtpObjectHandleList();
@@ -126,7 +203,7 @@
         std::cout << __PRETTY_FUNCTION__ << ": " << storageID << ", " << format << ", " << parent << std::endl;
         try
         {
-            return db.at(std::make_tuple(storageID, MTP_FORMAT_PNG)).size();
+            return db.size();
         } catch(...)
         {
         }
@@ -153,12 +230,15 @@
     virtual MtpObjectPropertyList* getSupportedObjectProperties(MtpObjectFormat format)
     {
         std::cout << __PRETTY_FUNCTION__ << std::endl;
+	/*
         if (format != MTP_FORMAT_PNG)
             return nullptr;
+        */
             
         static const MtpObjectPropertyList list = 
         {
             MTP_PROPERTY_STORAGE_ID,
+            MTP_PROPERTY_PARENT_OBJECT,
             MTP_PROPERTY_OBJECT_FORMAT,
             MTP_PROPERTY_OBJECT_SIZE,
             MTP_PROPERTY_WIDTH,
@@ -185,13 +265,11 @@
         std::cout << __PRETTY_FUNCTION__ << std::endl;
         switch(property)
         {
-            case MTP_PROPERTY_STORAGE_ID: packet.putUInt32(entries.at(handle).storage_id); break;            
-            case MTP_PROPERTY_OBJECT_FORMAT: packet.putUInt32(entries.at(handle).object_format); break;
-            case MTP_PROPERTY_OBJECT_SIZE: packet.putUInt32(entries.at(handle).object_size); break;
-            case MTP_PROPERTY_WIDTH: packet.putUInt32(entries.at(handle).width); break;
-            case MTP_PROPERTY_HEIGHT: packet.putUInt32(entries.at(handle).height); break;
-            case MTP_PROPERTY_IMAGE_BIT_DEPTH: packet.putUInt32(entries.at(handle).bit_depth); break;
-            case MTP_PROPERTY_DISPLAY_NAME: packet.putString(entries.at(handle).display_name.c_str()); break;
+            case MTP_PROPERTY_STORAGE_ID: packet.putUInt32(db.at(handle).storage_id); break;            
+            case MTP_PROPERTY_PARENT_OBJECT: packet.putUInt32(db.at(handle).parent); break;            
+            case MTP_PROPERTY_OBJECT_FORMAT: packet.putUInt32(db.at(handle).object_format); break;
+            case MTP_PROPERTY_OBJECT_SIZE: packet.putUInt32(db.at(handle).object_size); break;
+            case MTP_PROPERTY_DISPLAY_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
             default: return MTP_RESPONSE_GENERAL_ERROR; break;                
         }
         
@@ -248,22 +326,22 @@
     {
         std::cout << __PRETTY_FUNCTION__ << std::endl;
         info.mHandle = handle;
-        info.mStorageID = entries.at(handle).storage_id;
-        info.mFormat = entries.at(handle).object_format;
+        info.mStorageID = db.at(handle).storage_id;
+        info.mFormat = db.at(handle).object_format;
         info.mProtectionStatus = 0x0;
         info.mCompressedSize = 0;
-        info.mThumbFormat = entries.at(handle).object_format;
+        info.mThumbFormat = db.at(handle).object_format;
         info.mThumbCompressedSize = 20*20*4;
         info.mThumbPixWidth = 20;
         info.mThumbPixHeight  =20;
         info.mImagePixWidth = 20;
         info.mImagePixHeight = 20;
         info.mImagePixDepth = 4;
-        info.mParent = MTP_PARENT_ROOT;
+        info.mParent = db.at(handle).parent;
         info.mAssociationType = 0;
         info.mAssociationDesc = 0;
         info.mSequenceNumber = 0;
-        info.mName = ::strdup("test");
+        info.mName = ::strdup(db.at(handle).object_name.c_str());
         info.mDateCreated = 0;
         info.mDateModified = 0;
         info.mKeywords = ::strdup("ubuntu,touch");
@@ -273,10 +351,11 @@
 
     virtual void* getThumbnail(MtpObjectHandle handle, size_t& outThumbSize)
     {
-        std::cout << __PRETTY_FUNCTION__ << std::endl;
-        outThumbSize = 20*20*4;
-        void* result = malloc(20*20*4);
-        memset(result, 0, 20*20*4);
+        void* result;
+
+	outThumbSize = 0;
+	memset(result, 0, outThumbSize);
+
         return result;
     }
 
@@ -286,17 +365,61 @@
         int64_t& outFileLength,
         MtpObjectFormat& outFormat)
     {
+        DbEntry entry = db.at(handle);
+
         std::cout << __PRETTY_FUNCTION__ << std::endl;
-        outFilePath = entries.at(handle).path;
-        outFileLength = 1024;
-        outFormat = entries.at(handle).object_format;
+
+        outFilePath = std::string(entry.path);
+        outFileLength = entry.object_size;
+        outFormat = entry.object_format;
+
+        return MTP_RESPONSE_OK;
     }
 
     virtual MtpResponseCode deleteFile(MtpObjectHandle handle)
     {
-        std::cout << __PRETTY_FUNCTION__ << std::endl;
-        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
-    }
+        size_t orig_size = db.size();
+        size_t new_size;
+
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+        new_size = db.erase(handle);
+
+        if (orig_size > new_size) {
+            /* Recursively remove children object from the DB as well.
+             * we can safely ignore failures here, since the objects
+             * would not be reachable anyway.
+             */
+            BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+                if (db.at(i).parent == handle)
+                    db.erase(i);
+            }
+            return MTP_RESPONSE_OK;
+        }
+        else
+            return MTP_RESPONSE_GENERAL_ERROR;
+    }
+
+    /*
+    virtual MtpResponseCode moveFile(MtpObjectHandle handle, MtpObjectHandle new_parent)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+        // change parent
+
+        return MTP_RESPONSE_OK
+    }
+
+    virtual MtpResponseCode copyFile(MtpObjectHandle handle, MtpObjectHandle new_parent)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+        // duplicate DbEntry
+        // change parent
+
+        return MTP_RESPONSE_OK
+    }
+    */
 
     virtual MtpObjectHandleList* getObjectReferences(MtpObjectHandle handle)
     {
 
=== modified file 'server/server.cpp'
--- examples/server.cpp	2013-06-13 10:22:21 +0000
+++ server/server.cpp	2013-09-11 16:32:38 +0000
@@ -1,4 +1,20 @@
-#include "StubMtpDatabase.h"
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "UbuntuMtpDatabase.h"
 
 #include <MtpServer.h>
 #include <MtpStorage.h>
@@ -10,27 +26,23 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <pwd.h>
 
 namespace
 {
 struct FileSystemConfig
 {
-    static const int file_group = 1023; // Taken from android's config. Might need to be adjusted.
     static const int file_perm = 0664;
     static const int directory_perm = 0755;
 };
 
-android::MtpStorage* removable_storage = new android::MtpStorage(
-    MTP_STORAGE_REMOVABLE_RAM, 
-    ".",
-    "Dummy storage", 
-    1024 * 1024 * 1024 * 200,
-    true,
-    1024 * 1024 * 1024);
+android::MtpStorage* home_storage;
+
 }
 
 int main(int argc, char** argv)
 {
+    struct passwd *userdata = getpwuid (getuid());
     int fd = open("/dev/mtp_usb", O_RDWR);
     
     if (fd < 0)
@@ -38,17 +50,25 @@
         std::cout << "Error opening /dev/mtp_usb, aborting now..." << std::endl;
     }
         
+    home_storage = new android::MtpStorage(
+        MTP_STORAGE_FIXED_RAM, 
+        userdata->pw_dir,
+        userdata->pw_name, 
+        1024 * 1024 * 100,  /* 100 MB reserved space, to avoid filling the disk */
+        false,
+        1024 * 1024 * 1024 * 2  /* 2GB arbitrary max file size */);
+
     std::shared_ptr<android::MtpServer> server
     {
         new android::MtpServer(
             fd, 
-            new android::StubMtpDatabase(),
+            new android::UbuntuMtpDatabase(userdata->pw_dir),
             false, 
-            FileSystemConfig::file_group, 
+            userdata->pw_gid, 
             FileSystemConfig::file_perm, 
             FileSystemConfig::directory_perm)
     };
-    server->addStorage(removable_storage);
+    server->addStorage(home_storage);
     server->run();
 
     /*
 
=== modified file 'src/MtpUtils.cpp'
--- src/MtpUtils.cpp	2013-06-13 10:22:21 +0000
+++ src/MtpUtils.cpp	2013-09-11 16:32:38 +0000
@@ -49,6 +49,7 @@
 
     // hack to compute timezone
     time_t dummy;
+    tzset();
     localtime_r(&dummy, &tm);
 
     tm.tm_sec = second;
 
=== added directory 'tests'
=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2013-09-11 16:32:38 +0000
@@ -0,0 +1,91 @@
+
+# MtpUtils
+add_executable(
+    test-utils
+    TestMtpUtils.cpp
+)
+
+target_link_libraries(
+    test-utils
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-utils test-utils)
+
+# MtpDebug
+add_executable(
+    test-debug
+    TestMtpDebug.cpp
+)
+
+target_link_libraries(
+    test-debug
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-debug test-debug)
+
+# MtpPacket
+add_executable(
+    test-packet
+    TestMtpPacket.cpp
+)
+
+target_link_libraries(
+    test-packet
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-packet test-packet)
+
+# MtpProperty
+add_executable(
+    test-property
+    TestMtpProperty.cpp
+)
+
+target_link_libraries(
+    test-property
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-property test-property)
+
+# MtpStorage
+add_executable(
+    test-storage
+    TestMtpStorage.cpp
+)
+
+target_link_libraries(
+    test-storage
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-storage test-storage)
+
+# MtpServer
+add_executable(
+    test-server
+    TestMtpServer.cpp
+)
+
+target_link_libraries(
+    test-server
+    mtp
+    usbhost
+    ${Boost_LIBRARIES}
+    ${Boost_unit_test_framework_LIBRARIES}
+)
+add_test(test-server test-server)
+
 
=== added file 'tests/MockMtpDatabase.h'
--- tests/MockMtpDatabase.h	1970-01-01 00:00:00 +0000
+++ tests/MockMtpDatabase.h	2013-09-11 16:32:38 +0000
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef STUB_MOCK_MTP_DATABASE_H_
+#define STUB_MOCK_MTP_DATABASE_H_
+
+#include <mtp.h>
+#include <MtpDatabase.h>
+#include <MtpDataPacket.h>
+#include <MtpObjectInfo.h>
+#include <MtpProperty.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <string>
+#include <tuple>
+
+#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/range/adaptors.hpp>
+#include <boost/range/algorithm.hpp>
+
+namespace android
+{
+class MockMtpDatabase : public android::MtpDatabase {
+private:
+    struct DbEntry
+    {
+        MtpStorageID storage_id;
+        std::string object_name;
+        MtpObjectFormat object_format;
+        MtpObjectHandle parent;
+        size_t object_size;
+        std::string display_name;
+        std::string path;
+    };
+
+    uint32_t counter;
+    std::map<MtpObjectHandle, DbEntry> db;
+    
+public:
+    MockMtpDatabase() : counter(1)
+    {
+        DbEntry entry;
+	db = std::map<MtpObjectHandle, DbEntry>();
+
+        entry.storage_id = 666;
+        entry.object_name = std::string("Test Object");
+        entry.object_format = MTP_FORMAT_PNG;
+        entry.parent = MTP_PARENT_ROOT;
+        entry.object_size = 666;
+        entry.display_name = std::string("Test Object");
+        entry.path = std::string("TestObject");
+
+        db.insert( std::pair<MtpObjectHandle, DbEntry>(counter, entry) );
+    }
+
+    virtual ~MockMtpDatabase() {}
+
+    virtual MtpObjectHandle beginSendObject(
+        const MtpString& path,
+        MtpObjectFormat format,
+        MtpObjectHandle parent,
+        MtpStorageID storage,
+        uint64_t size,
+        time_t modified)
+    {
+        return 1;
+    }
+
+    virtual void endSendObject(
+        const MtpString& path,
+        MtpObjectHandle handle,
+        MtpObjectFormat format,
+        bool succeeded)
+    {
+        std::cout << __PRETTY_FUNCTION__ << ": " << path << std::endl;
+
+	if (!succeeded) {
+		db.erase(handle);
+	}
+    }
+
+    virtual MtpObjectHandleList* getObjectList(
+        MtpStorageID storageID,
+        MtpObjectFormat format,
+        MtpObjectHandle parent)
+    {
+        MtpObjectHandleList* list = nullptr;
+
+        if (db.empty()) {
+            list = new MtpObjectHandleList();
+        } else {
+            std::vector<MtpObjectHandle> keys;
+            keys.push_back(1);
+            list = new MtpObjectHandleList(keys);
+        }
+        
+        return list;
+    }
+
+    virtual int getNumObjects(
+        MtpStorageID storageID,
+        MtpObjectFormat format,
+        MtpObjectHandle parent)
+    {
+        return db.size();
+    }
+
+    virtual MtpObjectFormatList* getSupportedPlaybackFormats()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        static const MtpObjectFormatList list = {MTP_FORMAT_PNG};
+        return new MtpObjectFormatList{list};
+    }
+    
+    virtual MtpObjectFormatList* getSupportedCaptureFormats()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        static const MtpObjectFormatList list = {MTP_FORMAT_ASSOCIATION, MTP_FORMAT_PNG};
+        return new MtpObjectFormatList{list};
+    }
+    
+    virtual MtpObjectPropertyList* getSupportedObjectProperties(MtpObjectFormat format)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+            
+        static const MtpObjectPropertyList list = 
+        {
+            MTP_PROPERTY_STORAGE_ID,
+            MTP_PROPERTY_PARENT_OBJECT,
+            MTP_PROPERTY_OBJECT_FORMAT,
+            MTP_PROPERTY_OBJECT_SIZE,
+            MTP_PROPERTY_WIDTH,
+            MTP_PROPERTY_HEIGHT,
+            MTP_PROPERTY_IMAGE_BIT_DEPTH,
+            MTP_PROPERTY_DISPLAY_NAME            
+        };
+         
+        return new MtpObjectPropertyList{list};
+    }
+    
+    virtual MtpDevicePropertyList* getSupportedDeviceProperties()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        static const MtpDevicePropertyList list = { MTP_DEVICE_PROPERTY_UNDEFINED };
+        return new MtpDevicePropertyList{list};
+    }
+
+    virtual MtpResponseCode getObjectPropertyValue(
+        MtpObjectHandle handle,
+        MtpObjectProperty property,
+        MtpDataPacket& packet)
+    {        
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        switch(property)
+        {
+            case MTP_PROPERTY_STORAGE_ID: packet.putUInt32(db.at(handle).storage_id); break;            
+            case MTP_PROPERTY_PARENT_OBJECT: packet.putUInt32(db.at(handle).parent); break;            
+            case MTP_PROPERTY_OBJECT_FORMAT: packet.putUInt32(db.at(handle).object_format); break;
+            case MTP_PROPERTY_OBJECT_SIZE: packet.putUInt32(db.at(handle).object_size); break;
+            case MTP_PROPERTY_DISPLAY_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
+            default: return MTP_RESPONSE_GENERAL_ERROR; break;                
+        }
+        
+        return MTP_RESPONSE_OK;
+    }
+
+    virtual MtpResponseCode setObjectPropertyValue(
+        MtpObjectHandle handle,
+        MtpObjectProperty property,
+        MtpDataPacket& packet)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+    }
+
+    virtual MtpResponseCode getDevicePropertyValue(
+        MtpDeviceProperty property,
+        MtpDataPacket& packet)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_GENERAL_ERROR;
+    }
+
+    virtual MtpResponseCode setDevicePropertyValue(
+        MtpDeviceProperty property,
+        MtpDataPacket& packet)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+    }
+
+    virtual MtpResponseCode resetDeviceProperty(
+        MtpDeviceProperty property)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+    }
+
+    virtual MtpResponseCode getObjectPropertyList(
+        MtpObjectHandle handle,
+        uint32_t format, 
+        uint32_t property,
+        int groupCode, 
+        int depth,
+        MtpDataPacket& packet)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+    }
+
+    virtual MtpResponseCode getObjectInfo(
+        MtpObjectHandle handle,
+        MtpObjectInfo& info)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        info.mHandle = handle;
+        info.mStorageID = db.at(handle).storage_id;
+        info.mFormat = db.at(handle).object_format;
+        info.mProtectionStatus = 0x0;
+        info.mCompressedSize = 0;
+        info.mThumbFormat = db.at(handle).object_format;
+        info.mThumbCompressedSize = 20*20*4;
+        info.mThumbPixWidth = 20;
+        info.mThumbPixHeight  =20;
+        info.mImagePixWidth = 20;
+        info.mImagePixHeight = 20;
+        info.mImagePixDepth = 4;
+        info.mParent = db.at(handle).parent;
+        info.mAssociationType = 0;
+        info.mAssociationDesc = 0;
+        info.mSequenceNumber = 0;
+        info.mName = ::strdup(db.at(handle).object_name.c_str());
+        info.mDateCreated = 0;
+        info.mDateModified = 0;
+        info.mKeywords = ::strdup("test");
+        
+        return MTP_RESPONSE_OK;
+    }
+
+    virtual void* getThumbnail(MtpObjectHandle handle, size_t& outThumbSize)
+    {
+        void* result;
+
+	outThumbSize = 0;
+	memset(result, 0, outThumbSize);
+
+        return result;
+    }
+
+    virtual MtpResponseCode getObjectFilePath(
+        MtpObjectHandle handle,
+        MtpString& outFilePath,
+        int64_t& outFileLength,
+        MtpObjectFormat& outFormat)
+    {
+        DbEntry entry = db.at(handle);
+
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+        outFilePath = std::string(entry.path);
+        outFileLength = entry.object_size;
+        outFormat = entry.object_format;
+
+        return MTP_RESPONSE_OK;
+    }
+
+    virtual MtpResponseCode deleteFile(MtpObjectHandle handle)
+    {
+        size_t orig_size = db.size();
+        size_t new_size;
+
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+        new_size = db.erase(handle);
+
+        if (orig_size > new_size) {
+            BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+                if (db.at(i).parent == handle)
+                    db.erase(i);
+            }
+            return MTP_RESPONSE_OK;
+        }
+        else
+            return MTP_RESPONSE_GENERAL_ERROR;
+    }
+
+    virtual MtpObjectHandleList* getObjectReferences(MtpObjectHandle handle)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return nullptr;
+    }
+
+    virtual MtpResponseCode setObjectReferences(
+        MtpObjectHandle handle,
+        MtpObjectHandleList* references)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;    
+    }
+
+    virtual MtpProperty* getObjectPropertyDesc(
+        MtpObjectProperty property,
+        MtpObjectFormat format)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        MtpProperty* result = nullptr;
+        switch(property)
+        {
+            case MTP_PROPERTY_STORAGE_ID: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_OBJECT_FORMAT: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_OBJECT_SIZE: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_WIDTH: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_HEIGHT: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_IMAGE_BIT_DEPTH: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_DISPLAY_NAME: result = new MtpProperty(property, MTP_TYPE_STR); break;
+            default: break;                
+        }
+        
+        return result;
+    }
+
+    virtual MtpProperty* getDevicePropertyDesc(MtpDeviceProperty property)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        return new MtpProperty(MTP_DEVICE_PROPERTY_UNDEFINED, MTP_TYPE_UNDEFINED);
+    }
+    
+    virtual void sessionStarted()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+    }
+
+    virtual void sessionEnded()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+    }
+};
+}
+
+#endif // STUB_MOCK_MTP_DATABASE_H_
 
=== added file 'tests/TestMtpDebug.cpp'
--- tests/TestMtpDebug.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpDebug.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include "mtp.h"
+#include "MtpDebug.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(DebugGetOperationCodeName)
+{
+    BOOST_CHECK_EQUAL( MtpDebug::getOperationCodeName(MTP_OPERATION_GET_DEVICE_INFO), "MTP_OPERATION_GET_DEVICE_INFO" );
+}
+
+BOOST_AUTO_TEST_CASE(DebugGetFormatCodeName)
+{
+    BOOST_CHECK_EQUAL( MtpDebug::getFormatCodeName(MTP_FORMAT_PNG), "MTP_FORMAT_PNG" );
+}
+
+BOOST_AUTO_TEST_CASE(DebugGetObjectPropCodeName)
+{
+    BOOST_CHECK_EQUAL( MtpDebug::getObjectPropCodeName(MTP_PROPERTY_STORAGE_ID), "MTP_PROPERTY_STORAGE_ID" );
+}
+
+BOOST_AUTO_TEST_CASE(DebugGetDevicePropCodeName)
+{
+    BOOST_CHECK_EQUAL( MtpDebug::getDevicePropCodeName(MTP_DEVICE_PROPERTY_BATTERY_LEVEL), "MTP_DEVICE_PROPERTY_BATTERY_LEVEL" );
+}
+
+BOOST_AUTO_TEST_CASE(DebugGetCodeNameUnknown)
+{
+    BOOST_CHECK_EQUAL( MtpDebug::getOperationCodeName (1), "UNKNOWN");
+}
 
=== added file 'tests/TestMtpPacket.cpp'
--- tests/TestMtpPacket.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpPacket.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include "mtp.h"
+#include "MtpPacket.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(Packet)
+{
+    MtpPacket *p = new MtpPacket (4);
+
+    BOOST_REQUIRE(p);
+}
+
+BOOST_AUTO_TEST_CASE(PacketReset)
+{
+    MtpPacket *p = new MtpPacket (MTP_CONTAINER_PARAMETER_OFFSET + 4);
+    uint32_t value = UINT32_MAX;
+    uint32_t result;
+
+    BOOST_REQUIRE(p);
+
+    p->setParameter(1, value);
+    result = p->getParameter(1);
+    BOOST_CHECK_EQUAL (value, result);
+
+    p->reset();
+
+    result = p->getParameter(1);
+    BOOST_CHECK (value != result);
+    BOOST_CHECK (result == 0);
+}
 
=== added file 'tests/TestMtpProperty.cpp'
--- tests/TestMtpProperty.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpProperty.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include "mtp.h"
+#include "MtpProperty.h"
+#include "MtpStringBuffer.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(PropertyConstructorString)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_NAME, MTP_TYPE_STR, false);
+
+    BOOST_CHECK (prop);
+    BOOST_CHECK (prop->mType == MTP_TYPE_STR);
+    BOOST_CHECK (prop->mCode == MTP_PROPERTY_NAME);
+    BOOST_CHECK (prop->mWriteable == false);
+
+    BOOST_CHECK (prop->mDefaultValue.u.u64 == 0);
+    BOOST_CHECK (prop->mCurrentValue.u.u64 == 0);
+}
+
+BOOST_AUTO_TEST_CASE(PropertyConstructorUInt32)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, true, 42);
+
+    BOOST_CHECK (prop);
+    BOOST_CHECK (prop->mType == MTP_TYPE_UINT32);
+    BOOST_CHECK (prop->mCode == MTP_PROPERTY_STORAGE_ID);
+    BOOST_CHECK (prop->mWriteable == true);
+
+    BOOST_CHECK (prop->mDefaultValue.u.u32 == 42);
+    BOOST_CHECK (prop->mCurrentValue.u.u64 == 0);
+}
+
+BOOST_AUTO_TEST_CASE(PropertySetFormRange)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, true, 42);
+
+    prop->setFormRange(0, 90, 2);
+
+    BOOST_CHECK(prop->mMinimumValue.u.u32 == 0);
+    BOOST_CHECK(prop->mMaximumValue.u.u32 == 90);
+    BOOST_CHECK(prop->mStepSize.u.u32 == 2);
+}
+
+BOOST_AUTO_TEST_CASE(PropertySetFormEnum)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, true, 42);
+    const int values[4] = { 1, 2, 3, 4, };
+
+    prop->setFormEnum(values, 4);
+
+    BOOST_CHECK(prop->mEnumValues[0].u.u32 == 1);
+    BOOST_CHECK(prop->mEnumValues[1].u.u32 == 2);
+    BOOST_CHECK(prop->mEnumValues[2].u.u32 == 3);
+    BOOST_CHECK(prop->mEnumValues[3].u.u32 == 4);
+}
+
+BOOST_AUTO_TEST_CASE(PropertySetFormDateTime)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, true, 42);
+
+    prop->setFormDateTime();
+
+    BOOST_CHECK(prop->mFormFlag == MtpProperty::kFormDateTime);
+}
+
+BOOST_AUTO_TEST_CASE(PropertyPrintToBuffer)
+{
+    MtpProperty *prop = new MtpProperty(MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, true, 42);
+    std::string expected ("42");
+    std::string result;
+
+    prop->print(prop->mDefaultValue, result);
+
+    BOOST_CHECK (result == expected);
+}
 
=== added file 'tests/TestMtpServer.cpp'
--- tests/TestMtpServer.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpServer.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include "mtp.h"
+#include "MockMtpDatabase.h"
+#include "MtpServer.h"
+#include "MtpStorage.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(ServerConstructor)
+{
+    MtpDatabase *db = new MockMtpDatabase ();
+    MtpServer *server = new MtpServer (0, db, false, 0, 0, 0);
+
+    BOOST_CHECK(server);
+}
+
+BOOST_AUTO_TEST_CASE(ServerAddGetStorage)
+{
+    MtpDatabase *db = new MockMtpDatabase ();
+    MtpServer *server = new MtpServer (0, db, false, 0, 0, 0);
+    MtpStorage *storage = new MtpStorage (666, "/tmp", "Test storage", 0, false, 64);
+
+    server->addStorage(storage);
+
+    BOOST_CHECK(server->getStorage(666) != NULL);
+}
+
+BOOST_AUTO_TEST_CASE(ServerGetStorageNull)
+{
+    MtpDatabase *db = new MockMtpDatabase ();
+    MtpServer *server = new MtpServer (0, db, false, 0, 0, 0);
+
+    BOOST_CHECK(server->getStorage(666) == NULL);
+}
+
+BOOST_AUTO_TEST_CASE(ServerHasStorageTrue)
+{
+    MtpDatabase *db = new MockMtpDatabase ();
+    MtpServer *server = new MtpServer (0, db, false, 0, 0, 0);
+    MtpStorage *storage = new MtpStorage (666, "/tmp", "Test storage", 0, false, 64);
+
+    server->addStorage(storage);
+
+    BOOST_CHECK(server->hasStorage(666));
+}
+
+BOOST_AUTO_TEST_CASE(ServerHasStorageFalse)
+{
+    MtpDatabase *db = new MockMtpDatabase ();
+    MtpServer *server = new MtpServer (0, db, false, 0, 0, 0);
+
+    BOOST_CHECK(server->hasStorage(667) == false);
+}
 
=== added file 'tests/TestMtpStorage.cpp'
--- tests/TestMtpStorage.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpStorage.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include "mtp.h"
+#include "MtpStorage.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(StorageConstructor)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, false, 64);
+
+    BOOST_CHECK(s);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetTypeFixed)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, false, 64);
+
+    BOOST_CHECK (s->getType() == MTP_STORAGE_FIXED_RAM);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetTypeRemovable)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getType() == MTP_STORAGE_REMOVABLE_RAM);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetFileSystemType)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getFileSystemType() == MTP_STORAGE_FILESYSTEM_HIERARCHICAL);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetAccessCapa)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getAccessCapability() == MTP_STORAGE_READ_WRITE);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetMaxCapacity)
+{
+    MtpStorage *s = new MtpStorage (666, "/tmp", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getMaxCapacity() > 0);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetMaxCapacityInvalidPath)
+{
+    MtpStorage *s = new MtpStorage (666, "", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getMaxCapacity() == -1);
+}
+
+BOOST_AUTO_TEST_CASE(StoageGetFreeSpace)
+{
+    MtpStorage *s = new MtpStorage (666, "/", "Test storage", 0, true, 64);
+
+    BOOST_CHECK (s->getFreeSpace() != -1);
+}
+
+BOOST_AUTO_TEST_CASE(StorageGetDescription)
+{
+    MtpStorage *s = new MtpStorage (666, "/", "Test storage", 0, true, 64);
+
+    BOOST_CHECK_EQUAL( strcmp( s->getDescription(), "Test storage" ), 0);
+}
 
=== added file 'tests/TestMtpUtils.cpp'
--- tests/TestMtpUtils.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestMtpUtils.cpp	2013-09-11 16:32:38 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <cstdlib>
+
+// #include <cutils/tztime.h>
+#include "MtpUtils.h"
+
+using namespace android;
+
+BOOST_AUTO_TEST_CASE(UtilsParseDateTime)
+{
+    time_t seconds;
+
+    setenv("TZ", "UTC", 1);
+
+    parseDateTime("20130909T114143", seconds);
+    BOOST_CHECK_EQUAL(seconds, 1378726903l);
+}
+
+BOOST_AUTO_TEST_CASE(UtilsFormatDateTime)
+{
+    time_t seconds = 1378726903;
+    char buffer[25];
+    char *expected = "20130909T114143";
+
+    setenv("TZ", "UTC", 1);
+
+    formatDateTime(seconds, buffer, 25);
+    BOOST_CHECK_EQUAL(strcmp(expected, buffer), 0);
+}