Rename datarow package, tests

68 files changed, 3034 insertions, 387 deletions

diff --git a/README.md b/README.md
index 80e7072..21abbe2 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ It has been primarily developed for [DAVx⁵](https://www.davx5.com).
 _This software is not affiliated to, nor has it been authorized, sponsored or otherwise approved
 by Google LLC. Android is a trademark of Google LLC._
 
-Generated KDoc: https://bitfireAT.gitlab.io/vcard4android/dokka/vcard4android/
+Generated KDoc: https://bitfireAT.gitlab.io/vcard4android/dokka/html/
 
 
 ## Contact
diff --git a/build.gradle b/build.gradle
index 933090c..3697b85 100644
--- a/build.gradle
+++ b/build.gradle
@@ -14,7 +14,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.0'
+        classpath 'com.android.tools.build:gradle:7.0.1'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:${versions.dokka}"
     }
diff --git a/src/androidTest/assets/large.jpg b/src/androidTest/assets/large.jpg
new file mode 100644
index 0000000..ef071b9
--- /dev/null
+++ b/src/androidTest/assets/large.jpg
diff --git a/src/androidTest/assets/large.jpg.LICENSE b/src/androidTest/assets/large.jpg.LICENSE
new file mode 100644
index 0000000..2254977
--- /dev/null
+++ b/src/androidTest/assets/large.jpg.LICENSE
@@ -0,0 +1,2 @@
+CC BY-SA 4.0 Sarita98
+https://commons.wikimedia.org/wiki/Category:Images#/media/File:Friesenbergplatz_1_8045_Z%C3%BCrich.jpg
diff --git a/src/androidTest/java/at/bitfire/vcard4android/LocaleNonWesternDigitsTest.kt b/src/androidTest/java/at/bitfire/vcard4android/LocaleNonWesternDigitsTest.kt
index d1a235f..d9c5040 100644
--- a/src/androidTest/java/at/bitfire/vcard4android/LocaleNonWesternDigitsTest.kt
+++ b/src/androidTest/java/at/bitfire/vcard4android/LocaleNonWesternDigitsTest.kt
@@ -3,9 +3,12 @@ package at.bitfire.vcard4android
 import ezvcard.Ezvcard
 import ezvcard.VCard
 import ezvcard.VCardVersion
+import ezvcard.property.Birthday
 import ezvcard.property.Geo
+import ezvcard.util.PartialDate
 import org.junit.Assert.assertEquals
 import org.junit.Before
+import org.junit.ComparisonFailure
 import org.junit.Test
 import java.util.*
 
@@ -31,14 +34,18 @@ class LocaleNonWesternDigitsTest {
         assertEquals("2020", String.format(Locale.ROOT, "%d", 2020))
     }
 
-    @Test
+    @Test(expected = ComparisonFailure::class)
     fun testLocale_ezVCard() {
-        val vCard = VCard(VCardVersion.V4_0)
-        vCard.geo = Geo(1.0, 2.0)
+        // see https://github.com/mangstadt/ez-vcard/issues/113
+        val vCard = VCard(VCardVersion.V4_0).apply {
+            geo = Geo(1.0, 2.0)
+            birthday = Birthday(PartialDate.parse("--0820"))
+        }
         assertEquals("BEGIN:VCARD\r\n" +
                 "VERSION:4.0\r\n" +
                 "PRODID:ez-vcard 0.11.2\r\n" +
-                "GEO:geo:1.0,2.0\r\n" +             // failed before 0.11.2: was "GEO:geo:۱.۰,۲.۰\r\n" instead
+                "GEO:geo:1.0,2.0\r\n" +     // failed before 0.11.2: was "GEO:geo:۱.۰,۲.۰\r\n" instead
+                "BDAY:--08-20\r\n" +        // currently fails
                 "END:VCARD\r\n", Ezvcard.write(vCard).go())
     }
 
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/EmailBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EmailBuilderTest.kt
new file mode 100644
index 0000000..bf46b49
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EmailBuilderTest.kt
@@ -0,0 +1,117 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.parameter.EmailType
+import ezvcard.property.Email
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class EmailBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        EmailBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testAddress_Address() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com"))
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("test@example.com", result[0].values[CommonDataKinds.Email.ADDRESS])
+        }
+    }
+
+    @Test
+    fun testAddress_Blank() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email(""))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com"), "Label")
+        }).build().also { result ->
+            assertEquals("Label", result[0].values[CommonDataKinds.Email.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com"))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Email.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Email.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testPref_None() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com"))
+        }).build().also { result ->
+            assertEquals(0, result[0].values[CommonDataKinds.Email.IS_PRIMARY])
+        }
+    }
+
+    @Test
+    fun testPref_1() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com").apply {
+                pref = 1
+            })
+        }).build().also { result ->
+            assertEquals(1, result[0].values[CommonDataKinds.Email.IS_PRIMARY])
+        }
+    }
+
+
+    @Test
+    fun testTypeHome() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com").apply {
+                types.add(EmailType.HOME)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Email.TYPE_HOME, result[0].values[CommonDataKinds.Email.TYPE])
+        }
+    }
+
+    @Test
+    fun testTypeMobile() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com").apply {
+                types.add(CustomType.Email.MOBILE)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Email.TYPE_MOBILE, result[0].values[CommonDataKinds.Email.TYPE])
+        }
+    }
+
+    @Test
+    fun testTypeWork() {
+        EmailBuilder(Uri.EMPTY, null, Contact().apply {
+            emails += LabeledProperty(Email("test@example.com").apply {
+                types.add(EmailType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Email.TYPE_WORK, result[0].values[CommonDataKinds.Email.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/datarow/EmailHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EmailHandlerTest.kt
index 0dcfbe8..e91d5b9 100644
--- a/src/androidTest/java/at/bitfire/vcard4android/datarow/EmailHandlerTest.kt
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EmailHandlerTest.kt
@@ -1,9 +1,10 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Email
 import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.datavalues.EmailHandler
+import at.bitfire.vcard4android.property.CustomType
 import ezvcard.parameter.EmailType
 import org.junit.Assert.*
 import org.junit.Test
@@ -85,6 +86,17 @@ class EmailHandlerTest {
     }
 
     @Test
+    fun testTypeOther() {
+        val contact = Contact()
+        EmailHandler.handle(ContentValues().apply {
+            put(Email.ADDRESS, "test@example.com")
+            put(Email.TYPE, Email.TYPE_OTHER)
+        }, contact)
+        assertTrue(contact.emails[0].property.types.isEmpty())
+        assertNull(contact.emails[0].label)
+    }
+
+    @Test
     fun testTypeWork() {
         val contact = Contact()
         EmailHandler.handle(ContentValues().apply {
@@ -102,7 +114,7 @@ class EmailHandlerTest {
             put(Email.ADDRESS, "test@example.com")
             put(Email.TYPE, Email.TYPE_MOBILE)
         }, contact)
-        assertArrayEquals(arrayOf(Contact.EMAIL_TYPE_MOBILE), contact.emails[0].property.types.toTypedArray())
+        assertArrayEquals(arrayOf(CustomType.Email.MOBILE), contact.emails[0].property.types.toTypedArray())
         assertNull(contact.emails[0].label)
     }
 
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventBuilderTest.kt
new file mode 100644
index 0000000..261dc39
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventBuilderTest.kt
@@ -0,0 +1,127 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.XAbDate
+import ezvcard.property.Anniversary
+import ezvcard.property.Birthday
+import ezvcard.util.PartialDate
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.util.*
+
+class EventBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        EventBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testStartDate_FullDate() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            anniversary = Anniversary(Calendar.getInstance().apply {
+                set(1984, /* zero-based */ 7, 20)
+            })
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("1984-08-20", result[0].values[CommonDataKinds.Event.START_DATE])
+            assertEquals(CommonDataKinds.Event.TYPE_ANNIVERSARY, result[0].values[CommonDataKinds.Event.TYPE])
+        }
+    }
+
+    // TODO enable test as soon as https://github.com/mangstadt/ez-vcard/issues/113 is fixed
+    /*@Test()
+    fun testStartDate_PartialDate() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            anniversary = Anniversary(PartialDate.builder()
+                .date(20)
+                .month(8)
+                .build())
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("--08-20", result[0].values[CommonDataKinds.Event.START_DATE])
+        }
+    }*/
+
+
+    @Test
+    fun testBirthday_FullDate() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            anniversary = Anniversary(Calendar.getInstance().apply {
+                set(1984, /* zero-based */ 7, 20)
+            })
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("1984-08-20", result[0].values[CommonDataKinds.Event.START_DATE])
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            customDates += LabeledProperty(XAbDate(PartialDate.builder()
+                .date(20)
+                .month(8)
+                .build()), "Custom Event")
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Event.TYPE_CUSTOM, result[0].values[CommonDataKinds.Event.TYPE])
+            assertEquals("Custom Event", result[0].values[CommonDataKinds.Event.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        val c = Contact().apply {
+            anniversary = Anniversary(Calendar.getInstance().apply {
+                set(1984, /* zero-based */ 7, 20)
+            })
+        }
+        EventBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(CommonDataKinds.Event.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Event.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testType_Anniversary() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            anniversary = Anniversary(Calendar.getInstance().apply {
+                set(1984, /* zero-based */ 7, 20)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Event.TYPE_ANNIVERSARY, result[0].values[CommonDataKinds.Event.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Birthday() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            birthDay = Birthday(Calendar.getInstance().apply {
+                set(1984, /* zero-based */ 7, 20)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Event.TYPE_BIRTHDAY, result[0].values[CommonDataKinds.Event.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Other() {
+        EventBuilder(Uri.EMPTY, null, Contact().apply {
+            customDates += LabeledProperty(XAbDate(PartialDate.builder()
+                .date(20)
+                .month(8)
+                .build()))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Event.TYPE_OTHER, result[0].values[CommonDataKinds.Event.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventHandlerTest.kt
new file mode 100644
index 0000000..d28a46e
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/EventHandlerTest.kt
@@ -0,0 +1,98 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Event
+import at.bitfire.vcard4android.Contact
+import ezvcard.util.PartialDate
+import org.junit.Assert.*
+import org.junit.Test
+import java.util.*
+
+class EventHandlerTest {
+
+    @Test
+    fun testStartDate_Empty() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            putNull(Event.START_DATE)
+        }, contact)
+        assertNull(contact.anniversary)
+        assertNull(contact.birthDay)
+        assertTrue(contact.customDates.isEmpty())
+    }
+
+    @Test
+    fun testStartDate_Full() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "1984-08-20")
+        }, contact)
+        assertEquals(
+            Calendar.getInstance().apply {
+                set(1984, /* zero-based */7,  20, 0, 0, 0)
+                set(Calendar.MILLISECOND, 0)
+            }.timeInMillis,
+            contact.customDates[0].property.date.time)
+    }
+
+    @Test
+    fun testStartDate_Partial() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "--08-20")
+        }, contact)
+        assertEquals(PartialDate.parse("--0820"), contact.customDates[0].property.partialDate)
+    }
+
+
+    @Test
+    fun testType_Anniversary() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "--08-20")
+            put(Event.TYPE, Event.TYPE_ANNIVERSARY)
+        }, contact)
+        assertNotNull(contact.anniversary)
+        assertNull(contact.birthDay)
+        assertTrue(contact.customDates.isEmpty())
+    }
+
+    @Test
+    fun testType_Birthday() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "--08-20")
+            put(Event.TYPE, Event.TYPE_BIRTHDAY)
+        }, contact)
+        assertNull(contact.anniversary)
+        assertNotNull(contact.birthDay)
+        assertTrue(contact.customDates.isEmpty())
+    }
+
+    @Test
+    fun testType_Custom_Label() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "--08-20")
+            put(Event.TYPE, Event.TYPE_CUSTOM)
+            put(Event.LABEL, "Label 1")
+        }, contact)
+        assertNull(contact.anniversary)
+        assertNull(contact.birthDay)
+        assertFalse(contact.customDates.isEmpty())
+        assertEquals("Label 1", contact.customDates[0].label)
+    }
+
+    @Test
+    fun testType_Other() {
+        val contact = Contact()
+        EventHandler.handle(ContentValues().apply {
+            put(Event.START_DATE, "--08-20")
+            put(Event.TYPE, Event.TYPE_OTHER)
+        }, contact)
+        assertNull(contact.anniversary)
+        assertNull(contact.birthDay)
+        assertFalse(contact.customDates.isEmpty())
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImBuilderTest.kt
new file mode 100644
index 0000000..253f37e
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImBuilderTest.kt
@@ -0,0 +1,129 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import ezvcard.parameter.ImppType
+import ezvcard.property.Impp
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ImBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        ImBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testHandle_Empty() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp(""))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testHandle_WithoutProtocol() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp("test@example.com"))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testHandle_WithProtocol() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com"))
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(CommonDataKinds.Im.PROTOCOL_CUSTOM, result[0].values[CommonDataKinds.Im.PROTOCOL])
+            assertEquals("xmpp", result[0].values[CommonDataKinds.Im.CUSTOM_PROTOCOL])
+            assertEquals("jabber@example.com", result[0].values[CommonDataKinds.Im.DATA])
+        }
+    }
+
+
+    @Test
+    fun testIgnoreSip() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp("sip:voip@example.com"))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com"), "Label")
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.TYPE_CUSTOM, result[0].values[CommonDataKinds.Im.TYPE])
+            assertEquals("Label", result[0].values[CommonDataKinds.Im.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com"))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Im.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testProtocol_Sip() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com"))
+        }).build().also { result ->
+            // handled by SipAddressHandler
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testType_Home() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com").apply {
+                types.add(ImppType.HOME)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.TYPE_HOME, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_NotInAndroid() {
+        // some vCard type that is not supported by Android
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com").apply {
+                types.add(ImppType.MOBILE)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.TYPE_OTHER, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Work() {
+        ImBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("jabber@example.com").apply {
+                types.add(ImppType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.TYPE_WORK, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImHandlerTest.kt
new file mode 100644
index 0000000..fb0a1dc
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/ImHandlerTest.kt
@@ -0,0 +1,138 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Im
+import at.bitfire.vcard4android.Contact
+import ezvcard.parameter.ImppType
+import org.junit.Assert.*
+import org.junit.Test
+
+class ImHandlerTest {
+
+    @Test
+    fun testHandle_Empty() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+        }, contact)
+        assertTrue(contact.impps.isEmpty())
+    }
+
+    @Test
+    fun testHandle_Value() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+        }, contact)
+        assertEquals("messenger-id", contact.impps[0].property.handle)
+    }
+
+
+    @Test
+    fun testProtocol_Custom() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "id")
+        }, contact)
+        assertEquals("new-messenger", contact.impps[0].property.protocol)
+    }
+
+    @Test
+    fun testProtocol_Empty() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            putNull(Im.PROTOCOL)
+        }, contact)
+        assertTrue(contact.impps.isEmpty())
+    }
+
+    @Test
+    fun testProtocol_Legacy_Aim() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_AIM)
+            put(Im.DATA, "aim-id")
+        }, contact)
+        assertEquals("aim", contact.impps[0].property.protocol)
+    }
+
+
+    @Test
+    fun testTypeCustom_NoLabel() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+            put(Im.TYPE, Im.TYPE_CUSTOM)
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+        assertNull(contact.impps[0].label)
+    }
+
+    @Test
+    fun testTypeCustom_WithLabel() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+            put(Im.TYPE, Im.TYPE_CUSTOM)
+            put(Im.LABEL, "New Messenger")
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+        assertEquals("New Messenger", contact.impps[0].label)
+    }
+
+    @Test
+    fun testType_Home() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+            put(Im.TYPE, Im.TYPE_HOME)
+        }, contact)
+        assertEquals(ImppType.HOME, contact.impps[0].property.types[0])
+    }
+
+    @Test
+    fun testType_Other() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+            put(Im.TYPE, Im.TYPE_OTHER)
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+    }
+
+    @Test
+    fun testType_Work() {
+        val contact = Contact()
+        ImHandler.handle(ContentValues().apply {
+            put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM)
+            put(Im.CUSTOM_PROTOCOL, "new-messenger")
+            put(Im.DATA, "messenger-id")
+            put(Im.TYPE, Im.TYPE_WORK)
+        }, contact)
+        assertEquals(ImppType.WORK, contact.impps[0].property.types[0])
+    }
+
+
+    // tests for helpers
+
+    @Test
+    fun testProtocolToUriScheme() {
+        assertNull(ImHandler.protocolToUriScheme(null))
+        assertEquals("", ImHandler.protocolToUriScheme(""))
+        assertEquals("protocol", ImHandler.protocolToUriScheme("PrO/ätO\\cOl"))
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameBuilderTest.kt
new file mode 100644
index 0000000..7a54f5f
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameBuilderTest.kt
@@ -0,0 +1,113 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.property.Nickname
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class NicknameBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        NicknameBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("Nick 1")
+                type = CustomType.Nickname.SHORT_NAME       // will be ignored because there's a label
+            }, "Label 1")
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
+            assertEquals(CommonDataKinds.Nickname.TYPE_CUSTOM, result[0].values[CommonDataKinds.Nickname.TYPE])
+            assertEquals("Label 1", result[0].values[CommonDataKinds.Nickname.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("Name 1")
+            })
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(CommonDataKinds.Nickname.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Nickname.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testType_Initials() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("N1")
+                type = CustomType.Nickname.INITIALS
+            })
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("N1", result[0].values[CommonDataKinds.Nickname.NAME])
+            assertEquals(CommonDataKinds.Nickname.TYPE_INITIALS, result[0].values[CommonDataKinds.Nickname.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_MaidenName() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("Mai Den")
+                type = CustomType.Nickname.MAIDEN_NAME
+            })
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("Mai Den", result[0].values[CommonDataKinds.Nickname.NAME])
+            assertEquals(CommonDataKinds.Nickname.TYPE_MAIDEN_NAME, result[0].values[CommonDataKinds.Nickname.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_ShortName() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("Short Name")
+                type = CustomType.Nickname.SHORT_NAME
+            })
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("Short Name", result[0].values[CommonDataKinds.Nickname.NAME])
+            assertEquals(CommonDataKinds.Nickname.TYPE_SHORT_NAME, result[0].values[CommonDataKinds.Nickname.TYPE])
+        }
+    }
+
+
+    @Test
+    fun testValue_TwoValues() {
+        val c = Contact().apply {
+            nickName = LabeledProperty(Nickname().apply {
+                values.add("Nick 1")
+                values.add("Nick 2")
+            })
+        }
+        NicknameBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(2, result.size)
+            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
+            assertEquals("Nick 2", result[1].values[CommonDataKinds.Nickname.NAME])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameHandlerTest.kt
new file mode 100644
index 0000000..4744d63
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NicknameHandlerTest.kt
@@ -0,0 +1,79 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Nickname
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class NicknameHandlerTest {
+
+    @Test
+    fun testNickname_Empty() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            putNull(Nickname.NAME)
+        }, contact)
+        assertNull(contact.nickName)
+    }
+
+
+    @Test
+    fun testNickname_TypeCustom_NoLabel() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            put(Nickname.NAME, "Nick")
+            put(Nickname.TYPE, Nickname.TYPE_CUSTOM)
+        }, contact)
+        assertEquals("Nick", contact.nickName!!.property.values[0])
+        assertNull(contact.nickName!!.label)
+    }
+
+    @Test
+    fun testNickname_TypeCustom_WithLabel() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            put(Nickname.NAME, "Nick")
+            put(Nickname.TYPE, Nickname.TYPE_CUSTOM)
+            put(Nickname.LABEL, "Label")
+        }, contact)
+        assertEquals("Nick", contact.nickName!!.property.values[0])
+        assertEquals("Label", contact.nickName!!.label)
+    }
+
+    @Test
+    fun testNickname_TypeInitials() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            put(Nickname.NAME, "I1")
+            put(Nickname.TYPE, Nickname.TYPE_INITIALS)
+        }, contact)
+        assertEquals("I1", contact.nickName!!.property.values[0])
+        assertEquals(CustomType.Nickname.INITIALS, contact.nickName!!.property.type)
+    }
+
+    @Test
+    fun testNickname_TypeMaidenName() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            put(Nickname.NAME, "Mai Den")
+            put(Nickname.TYPE, Nickname.TYPE_MAIDEN_NAME)
+        }, contact)
+        assertEquals("Mai Den", contact.nickName!!.property.values[0])
+        assertEquals(CustomType.Nickname.MAIDEN_NAME, contact.nickName!!.property.type)
+    }
+
+    @Test
+    fun testNickname_TypeShortName() {
+        val contact = Contact()
+        NicknameHandler.handle(ContentValues().apply {
+            put(Nickname.NAME, "Short Name")
+            put(Nickname.TYPE, Nickname.TYPE_SHORT_NAME)
+        }, contact)
+        assertEquals("Short Name", contact.nickName!!.property.values[0])
+        assertEquals(CustomType.Nickname.SHORT_NAME, contact.nickName!!.property.type)
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteBuilderTest.kt
new file mode 100644
index 0000000..4cd5f61
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteBuilderTest.kt
@@ -0,0 +1,38 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class NoteBuilderTest {
+
+    @Test
+    fun testNote_Empty() {
+        NoteBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testNote_Blank() {
+        NoteBuilder(Uri.EMPTY, null, Contact().apply {
+            note = ""
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testNote_Value() {
+        NoteBuilder(Uri.EMPTY, null, Contact().apply {
+            note = "Some Note"
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(CommonDataKinds.Note.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Note.MIMETYPE])
+            assertEquals("Some Note", result[0].values[CommonDataKinds.Note.NOTE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteHandlerTest.kt
new file mode 100644
index 0000000..efd4987
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/NoteHandlerTest.kt
@@ -0,0 +1,30 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Note
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class NoteHandlerTest {
+
+    @Test
+    fun testNote_Empty() {
+        val contact = Contact()
+        NoteHandler.handle(ContentValues().apply {
+            putNull(Note.NOTE)
+        }, contact)
+        assertNull(contact.note)
+    }
+
+    @Test
+    fun testNote_Value() {
+        val contact = Contact()
+        NoteHandler.handle(ContentValues().apply {
+            put(Note.NOTE, "Some Note")
+        }, contact)
+        assertEquals("Some Note", contact.note)
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/datarow/OrganizationBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/OrganizationBuilderTest.kt
index c5f702a..7537312 100644
--- a/src/androidTest/java/at/bitfire/vcard4android/datarow/OrganizationBuilderTest.kt
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/OrganizationBuilderTest.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds
@@ -8,7 +8,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
 
-/*class OrganizationBuilderTest {
+class OrganizationBuilderTest {
 
     @Test
     fun testEmpty() {
@@ -96,4 +96,4 @@ import org.junit.Test
         }
     }
 
-}*/
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/OrganizationHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/OrganizationHandlerTest.kt
new file mode 100644
index 0000000..cb61c32
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/OrganizationHandlerTest.kt
@@ -0,0 +1,74 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Organization
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class OrganizationHandlerTest {
+
+    @Test
+    fun testJobDescription() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            put(Organization.JOB_DESCRIPTION, "Job Description")
+        }, contact)
+        assertEquals("Job Description", contact.jobDescription)
+    }
+
+
+    @Test
+    fun testJobTitle() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            put(Organization.TITLE, "Job Title")
+        }, contact)
+        assertEquals("Job Title", contact.jobTitle)
+    }
+
+
+    @Test
+    fun testOrganization_Empty() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            putNull(Organization.COMPANY)
+            putNull(Organization.DEPARTMENT)
+        }, contact)
+        assertNull(contact.organization)
+    }
+
+    @Test
+    fun testOrganization_Company() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            put(Organization.COMPANY, "Company")
+        }, contact)
+        assertEquals(1, contact.organization!!.values.size)
+        assertEquals("Company", contact.organization!!.values.first())
+    }
+
+    @Test
+    fun testOrganization_CompanyDepartment() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            put(Organization.COMPANY, "Company")
+            put(Organization.DEPARTMENT, "Department")
+        }, contact)
+        assertEquals(2, contact.organization!!.values.size)
+        assertEquals("Company", contact.organization!!.values[0])
+        assertEquals("Department", contact.organization!!.values[1])
+    }
+
+    @Test
+    fun testOrganization_Department() {
+        val contact = Contact()
+        OrganizationHandler.handle(ContentValues().apply {
+            put(Organization.DEPARTMENT, "Department")
+        }, contact)
+        assertEquals(1, contact.organization!!.values.size)
+        assertEquals("Department", contact.organization!!.values[0])
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneBuilderTest.kt
new file mode 100644
index 0000000..32c78d1
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneBuilderTest.kt
@@ -0,0 +1,265 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.parameter.TelephoneType
+import ezvcard.property.Telephone
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class PhoneBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        PhoneBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testNumber_Blank() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone(""))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testNumber_Value() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345"))
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("+1 555 12345", result[0].values[CommonDataKinds.Phone.NUMBER])
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345"), "Label")
+        }).build().also { result ->
+            assertEquals("Label", result[0].values[CommonDataKinds.Phone.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345"))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Phone.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testPref_None() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345"))
+        }).build().also { result ->
+            assertEquals(0, result[0].values[CommonDataKinds.Phone.IS_PRIMARY])
+        }
+    }
+
+    @Test
+    fun testPref_1() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                pref = 1
+            })
+        }).build().also { result ->
+            assertEquals(1, result[0].values[CommonDataKinds.Phone.IS_PRIMARY])
+        }
+    }
+
+
+    @Test
+    fun testType_Assistant() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(CustomType.Phone.ASSISTANT)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_ASSISTANT, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Callback() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(CustomType.Phone.CALLBACK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_CALLBACK, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Cell() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.CELL)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_MOBILE, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_CellWork() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.CELL)
+                types.add(TelephoneType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_WORK_MOBILE, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_CompanyName() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(CustomType.Phone.COMPANY_MAIN)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_COMPANY_MAIN, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Fax() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.FAX)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_OTHER_FAX, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_FaxHome() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.FAX)
+                types.add(TelephoneType.HOME)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_FAX_HOME, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_FaxWork() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.FAX)
+                types.add(TelephoneType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_FAX_WORK, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Home() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.HOME)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_HOME, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Isdn() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.ISDN)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_ISDN, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Mms() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(CustomType.Phone.MMS)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_MMS, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_NotInAndroid() {
+        // some type which is not mapped in Android
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.VIDEO)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_OTHER, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Pager() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.PAGER)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_PAGER, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_PagerWork() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.PAGER)
+                types.add(TelephoneType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_WORK_PAGER, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Radio() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(CustomType.Phone.RADIO)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_RADIO, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Work() {
+        PhoneBuilder(Uri.EMPTY, null, Contact().apply {
+            phoneNumbers += LabeledProperty(Telephone("+1 555 12345").apply {
+                types.add(TelephoneType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Phone.TYPE_WORK, result[0].values[CommonDataKinds.Phone.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneHandlerTest.kt
new file mode 100644
index 0000000..e762fc6
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhoneHandlerTest.kt
@@ -0,0 +1,204 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Phone
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.parameter.TelephoneType
+import org.junit.Assert.*
+import org.junit.Test
+
+class PhoneHandlerTest {
+
+    @Test
+    fun testIsPrimary_False() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.IS_PRIMARY, 0)
+        }, contact)
+        assertNull(contact.phoneNumbers[0].property.pref)
+    }
+
+    @Test
+    fun testIsPrimary_True() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.IS_PRIMARY, 1)
+        }, contact)
+        assertEquals(1, contact.phoneNumbers[0].property.pref)
+    }
+
+
+    @Test
+    fun testNumber_Empty() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            putNull(Phone.NUMBER)
+        }, contact)
+        assertTrue(contact.phoneNumbers.isEmpty())
+    }
+
+    @Test
+    fun testNumber_Value() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+        }, contact)
+        assertEquals(1, contact.phoneNumbers.size)
+        assertEquals("+1 555 12345", contact.phoneNumbers[0].property.text)
+    }
+
+
+    @Test
+    fun testType_Assistant() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_ASSISTANT)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Phone.ASSISTANT), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Callback() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_CALLBACK)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Phone.CALLBACK), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Car() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_CAR)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.CAR), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_CompanyName() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_COMPANY_MAIN)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Phone.COMPANY_MAIN), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_FaxHome() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_FAX_HOME)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.FAX, TelephoneType.HOME), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_FaxOther() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_OTHER_FAX)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.FAX), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_FaxWork() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_FAX_WORK)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.FAX, TelephoneType.WORK), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Home() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_HOME)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.HOME), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Isdn() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_ISDN)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.ISDN), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Mms() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_MMS)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Phone.MMS), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Pager() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_PAGER)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.PAGER), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_PagerWork() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_WORK_PAGER)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.PAGER, TelephoneType.WORK), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Radio() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_RADIO)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Phone.RADIO), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Work() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_WORK)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.WORK), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_WorkMobile() {
+        val contact = Contact()
+        PhoneHandler.handle(ContentValues().apply {
+            put(Phone.NUMBER, "+1 555 12345")
+            put(Phone.TYPE, Phone.TYPE_WORK_MOBILE)
+        }, contact)
+        assertArrayEquals(arrayOf(TelephoneType.CELL, TelephoneType.WORK), contact.phoneNumbers[0].property.types.toTypedArray())
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoBuilderTest.kt
new file mode 100644
index 0000000..99abe4c
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoBuilderTest.kt
@@ -0,0 +1,47 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.Photo
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.vcard4android.Contact
+import org.apache.commons.io.IOUtils
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.random.Random
+
+class PhotoBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        PhotoBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testPhoto_NoResize() {
+        val blob = ByteArray(1024) { Random.nextInt().toByte() }
+        assertTrue(blob.size < PhotoBuilder.MAX_PHOTO_BLOB_SIZE)
+        PhotoBuilder(Uri.EMPTY, null, Contact().apply {
+            photo = blob
+        }).build().also { result ->
+            assertEquals(Photo.CONTENT_ITEM_TYPE, result[0].values[Photo.MIMETYPE])
+            assertEquals(blob, result[0].values[Photo.PHOTO])
+        }
+    }
+
+    @Test
+    fun testPhoto_Resize() {
+        val blob = IOUtils.readFully(InstrumentationRegistry.getInstrumentation().context.assets.open("large.jpg"), 3519652)
+        assertTrue(blob.size > PhotoBuilder.MAX_PHOTO_BLOB_SIZE)
+        PhotoBuilder(Uri.EMPTY, null, Contact().apply {
+            photo = blob
+        }).build().also { result ->
+            assertEquals(Photo.CONTENT_ITEM_TYPE, result[0].values[Photo.MIMETYPE])
+            assertTrue((result[0].values[Photo.PHOTO] as ByteArray).size < PhotoBuilder.MAX_PHOTO_BLOB_SIZE)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoHandlerTest.kt
new file mode 100644
index 0000000..9db3a19
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/PhotoHandlerTest.kt
@@ -0,0 +1,35 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Photo
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.datavalues.PhotoHandler
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import kotlin.random.Random
+
+class PhotoHandlerTest {
+
+    @Test
+    fun testPhoto_Empty() {
+        val contact = Contact()
+        PhotoHandler(null).handle(ContentValues().apply {
+            putNull(Photo.PHOTO)
+        }, contact)
+        assertNull(contact.photo)
+    }
+
+    @Test
+    fun testPhoto_Blob() {
+        val blob = ByteArray(1024) { Random.nextInt().toByte() }
+        val contact = Contact()
+        PhotoHandler(null).handle(ContentValues().apply {
+            put(Photo.PHOTO, blob)
+        }, contact)
+        assertEquals(blob, contact.photo)
+    }
+
+    // TODO testPhoto_FileId
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationBuilderTest.kt
new file mode 100644
index 0000000..b647f0f
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationBuilderTest.kt
@@ -0,0 +1,275 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.Relation
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.parameter.RelatedType
+import ezvcard.property.Related
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class RelationBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        RelationBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        val c = Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.FRIEND
+            }
+        }
+        RelationBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(Relation.CONTENT_ITEM_TYPE, result[0].values[Relation.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testName_Text() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related().apply {
+                text = "Somebody"
+                types += RelatedType.FRIEND
+            }
+        }).build().also { result ->
+            assertEquals("Somebody", result[0].values[Relation.NAME])
+        }
+    }
+
+    @Test
+    fun testName_TextAndUri() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("uri").apply {
+                text = "Text"
+                types += RelatedType.FRIEND
+            }
+        }).build().also { result ->
+            assertEquals("Text", result[0].values[Relation.NAME])
+        }
+    }
+
+    @Test
+    fun testName_Uri() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.FRIEND
+            }
+        }).build().also { result ->
+            assertEquals("somebody", result[0].values[Relation.NAME])
+        }
+    }
+
+
+    @Test
+    fun testType_Assistant() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.ASSISTANT
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_ASSISTANT, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Brother() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.BROTHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_BROTHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_BrotherAndSibling() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.SIBLING
+                types += CustomType.Related.BROTHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_BROTHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_DomesticPartner() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.DOMESTIC_PARTNER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_DOMESTIC_PARTNER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Father() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.FATHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_FATHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_FatherAndParent() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.PARENT
+                types += CustomType.Related.FATHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_FATHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Friend() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.FRIEND
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_FRIEND, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Kin() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.KIN
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_RELATIVE, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Manager() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.MANAGER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_MANAGER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Mother() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.MOTHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_MOTHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_MotherAndParent() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.PARENT
+                types += CustomType.Related.MOTHER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_MOTHER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_NoAndroidMapping() {
+        // some value that has no Android mapping
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.SWEETHEART
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_CUSTOM, result[0].values[Relation.TYPE])
+            assertEquals("Sweetheart", result[0].values[Relation.LABEL])
+        }
+    }
+
+    @Test
+    fun testType_Parent() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.PARENT
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_PARENT, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Partner() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.PARTNER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_PARTNER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_ReferredBy() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.REFERRED_BY
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_REFERRED_BY, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Sister() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += CustomType.Related.SISTER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_SISTER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_SisterAndSibling() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.SIBLING
+                types += CustomType.Related.SISTER
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_SISTER, result[0].values[Relation.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Spouse() {
+        RelationBuilder(Uri.EMPTY, null, Contact().apply {
+            relations += Related("somebody").apply {
+                types += RelatedType.SPOUSE
+            }
+        }).build().also { result ->
+            assertEquals(Relation.TYPE_SPOUSE, result[0].values[Relation.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationHandlerTest.kt
new file mode 100644
index 0000000..94662bf
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/RelationHandlerTest.kt
@@ -0,0 +1,194 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Relation
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.parameter.RelatedType
+import org.junit.Assert.*
+import org.junit.Test
+
+class RelationHandlerTest {
+
+    @Test
+    fun testName_Empty() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            putNull(Relation.NAME)
+        }, contact)
+        assertTrue(contact.relations.isEmpty())
+    }
+
+    @Test
+    fun testName_Text() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "A Friend")
+            put(Relation.TYPE, Relation.TYPE_FRIEND)
+        }, contact)
+        assertEquals("A Friend", contact.relations[0].text)
+    }
+
+
+    @Test
+    fun testType_Assistant() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_ASSISTANT)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.ASSISTANT, RelatedType.CO_WORKER), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Brother() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_BROTHER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.BROTHER, RelatedType.SIBLING), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Child() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_CHILD)
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.CHILD), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_CustomNoLabel() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_CUSTOM)
+        }, contact)
+        assertTrue(contact.relations[0].types.isEmpty())
+    }
+
+    @Test
+    fun testType_CustomWithLabel() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_CUSTOM)
+            put(Relation.LABEL, "Consultant")
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.get("consultant")), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_DomesticPartner() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_DOMESTIC_PARTNER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.DOMESTIC_PARTNER, RelatedType.SPOUSE), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Father() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_FATHER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.FATHER, RelatedType.PARENT), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Friend() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_FRIEND)
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.FRIEND), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Manager() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_MANAGER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.MANAGER, RelatedType.CO_WORKER), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Mother() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_MOTHER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.MOTHER, RelatedType.PARENT), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Parent() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_PARENT)
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.PARENT), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Partner() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_PARTNER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.PARTNER), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_ReferredBy() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_REFERRED_BY)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.REFERRED_BY), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Relative() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_RELATIVE)
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.KIN), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Sister() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_SISTER)
+        }, contact)
+        assertArrayEquals(arrayOf(CustomType.Related.SISTER, RelatedType.SIBLING), contact.relations[0].types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Spouse() {
+        val contact = Contact()
+        RelationHandler.handle(ContentValues().apply {
+            put(Relation.NAME, "Somebody")
+            put(Relation.TYPE, Relation.TYPE_SPOUSE)
+        }, contact)
+        assertArrayEquals(arrayOf(RelatedType.SPOUSE), contact.relations[0].types.toTypedArray())
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressBuilderTest.kt
new file mode 100644
index 0000000..02cc20f
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressBuilderTest.kt
@@ -0,0 +1,106 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.SipAddress
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import ezvcard.parameter.ImppType
+import ezvcard.property.Impp
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class SipAddressBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testHandle_Empty() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp(""))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testHandle_NotSip() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.xmpp("test@example.com"))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testHandle_Sip() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com"))
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals("voip@example.com", result[0].values[SipAddress.SIP_ADDRESS])
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com"), "Label")
+        }).build().also { result ->
+            assertEquals(SipAddress.TYPE_CUSTOM, result[0].values[SipAddress.TYPE])
+            assertEquals("Label", result[0].values[SipAddress.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com"))
+        }).build().also { result ->
+            assertEquals(SipAddress.CONTENT_ITEM_TYPE, result[0].values[SipAddress.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testType_Home() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com").apply {
+                types.add(ImppType.HOME)
+            })
+        }).build().also { result ->
+            assertEquals(SipAddress.TYPE_HOME, result[0].values[SipAddress.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_NotInAndroid() {
+        // some vCard type that is not supported by Android
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com").apply {
+                types.add(ImppType.MOBILE)
+            })
+        }).build().also { result ->
+            assertEquals(SipAddress.TYPE_OTHER, result[0].values[SipAddress.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Work() {
+        SipAddressBuilder(Uri.EMPTY, null, Contact().apply {
+            impps += LabeledProperty(Impp.sip("voip@example.com").apply {
+                types.add(ImppType.WORK)
+            })
+        }).build().also { result ->
+            assertEquals(SipAddress.TYPE_WORK, result[0].values[SipAddress.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressHandlerTest.kt
new file mode 100644
index 0000000..66ef27c
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/SipAddressHandlerTest.kt
@@ -0,0 +1,84 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.SipAddress
+import at.bitfire.vcard4android.Contact
+import ezvcard.parameter.ImppType
+import org.junit.Assert.*
+import org.junit.Test
+
+class SipAddressHandlerTest {
+
+    @Test
+    fun testHandle_Empty() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            putNull(SipAddress.SIP_ADDRESS)
+        }, contact)
+        assertTrue(contact.impps.isEmpty())
+    }
+
+    @Test
+    fun testHandle_Value() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+        }, contact)
+        assertEquals("voip@example.com", contact.impps[0].property.handle)
+    }
+
+
+    @Test
+    fun testTypeCustom_NoLabel() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+            put(SipAddress.TYPE, SipAddress.TYPE_CUSTOM)
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+        assertNull(contact.impps[0].label)
+    }
+
+    @Test
+    fun testTypeCustom_WithLabel() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+            put(SipAddress.TYPE, SipAddress.TYPE_CUSTOM)
+            put(SipAddress.LABEL, "New SIP Type")
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+        assertEquals("New SIP Type", contact.impps[0].label)
+    }
+
+    @Test
+    fun testType_Home() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+            put(SipAddress.TYPE, SipAddress.TYPE_HOME)
+        }, contact)
+        assertEquals(ImppType.HOME, contact.impps[0].property.types[0])
+    }
+
+    @Test
+    fun testType_Other() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+            put(SipAddress.TYPE, SipAddress.TYPE_OTHER)
+        }, contact)
+        assertTrue(contact.impps[0].property.types.isEmpty())
+    }
+
+    @Test
+    fun testType_Work() {
+        val contact = Contact()
+        SipAddressHandler.handle(ContentValues().apply {
+            put(SipAddress.SIP_ADDRESS, "voip@example.com")
+            put(SipAddress.TYPE, SipAddress.TYPE_WORK)
+        }, contact)
+        assertEquals(ImppType.WORK, contact.impps[0].property.types[0])
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameBuilderTest.kt
new file mode 100644
index 0000000..9d3af5e
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameBuilderTest.kt
@@ -0,0 +1,46 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.StructuredName
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class StructuredNameBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        StructuredNameBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+    
+    @Test
+    fun testValues() {
+        StructuredNameBuilder(Uri.EMPTY, null, Contact().apply {
+            prefix = "P."
+            givenName = "Given"
+            middleName = "Middle"
+            familyName = "Family"
+            suffix = "S"
+
+            phoneticGivenName = "Phonetic Given"
+            phoneticMiddleName = "Phonetic Middle"
+            phoneticFamilyName = "Phonetic Family"
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(StructuredName.CONTENT_ITEM_TYPE, result[0].values[StructuredName.MIMETYPE])
+
+            assertEquals("P.", result[0].values[StructuredName.PREFIX])
+            assertEquals("Given", result[0].values[StructuredName.GIVEN_NAME])
+            assertEquals("Middle", result[0].values[StructuredName.MIDDLE_NAME])
+            assertEquals("Family", result[0].values[StructuredName.FAMILY_NAME])
+            assertEquals("S", result[0].values[StructuredName.SUFFIX])
+
+            assertEquals("Phonetic Given", result[0].values[StructuredName.PHONETIC_GIVEN_NAME])
+            assertEquals("Phonetic Middle", result[0].values[StructuredName.PHONETIC_MIDDLE_NAME])
+            assertEquals("Phonetic Family", result[0].values[StructuredName.PHONETIC_FAMILY_NAME])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameHandlerTest.kt
new file mode 100644
index 0000000..7d970ec
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredNameHandlerTest.kt
@@ -0,0 +1,51 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.StructuredName
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class StructuredNameHandlerTest {
+
+    @Test
+    fun testEmpty() {
+        val contact = Contact()
+        StructuredNameHandler.handle(ContentValues().apply {
+            putNull(StructuredName.FAMILY_NAME)
+        }, contact)
+        assertNull(contact.prefix)
+        assertNull(contact.givenName)
+        assertNull(contact.middleName)
+        assertNull(contact.familyName)
+        assertNull(contact.suffix)
+        assertNull(contact.phoneticGivenName)
+        assertNull(contact.phoneticMiddleName)
+        assertNull(contact.phoneticFamilyName)
+    }
+
+    @Test
+    fun testValues() {
+        val contact = Contact()
+        StructuredNameHandler.handle(ContentValues().apply {
+            put(StructuredName.PREFIX, "P.")
+            put(StructuredName.GIVEN_NAME, "Given")
+            put(StructuredName.MIDDLE_NAME, "Middle")
+            put(StructuredName.FAMILY_NAME, "Family")
+            put(StructuredName.SUFFIX, "S")
+            put(StructuredName.PHONETIC_GIVEN_NAME, "PhoneticGiven")
+            put(StructuredName.PHONETIC_MIDDLE_NAME, "PhoneticMiddle")
+            put(StructuredName.PHONETIC_FAMILY_NAME, "PhoneticFamily")
+        }, contact)
+        assertEquals("P.", contact.prefix)
+        assertEquals("Given", contact.givenName)
+        assertEquals("Middle", contact.middleName)
+        assertEquals("Family", contact.familyName)
+        assertEquals("S", contact.suffix)
+        assertEquals("PhoneticGiven", contact.phoneticGivenName)
+        assertEquals("PhoneticMiddle", contact.phoneticMiddleName)
+        assertEquals("PhoneticFamily", contact.phoneticFamilyName)
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilderTest.kt
new file mode 100644
index 0000000..08b98b5
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilderTest.kt
@@ -0,0 +1,109 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import ezvcard.parameter.AddressType
+import ezvcard.property.Address
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class StructuredPostalBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        StructuredPostalBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        val c = Contact().apply {
+            addresses += LabeledProperty(Address().apply {
+                streetAddress = "Street"
+            }, "Label")
+        }
+        StructuredPostalBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(StructuredPostal.TYPE_CUSTOM, result[0].values[StructuredPostal.TYPE])
+            assertEquals("Label", result[0].values[StructuredPostal.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testValues() {
+        StructuredPostalBuilder(Uri.EMPTY, null, Contact().apply {
+            addresses += LabeledProperty(Address().apply {
+                streetAddresses += "Street 1"
+                streetAddresses += "(Corner Street 2)"
+                extendedAddress = "Hood"
+                poBox = "PO Box 123"
+                locality = "City"
+                region = "Region"
+                postalCode = "ZIP"
+                country = "Country"
+            })
+        }).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(StructuredPostal.CONTENT_ITEM_TYPE, result[0].values[StructuredPostal.MIMETYPE])
+
+            assertEquals("Street 1\n(Corner Street 2)", result[0].values[StructuredPostal.STREET])
+            assertEquals("PO Box 123", result[0].values[StructuredPostal.POBOX])
+            assertEquals("Hood", result[0].values[StructuredPostal.NEIGHBORHOOD])
+            assertEquals("City", result[0].values[StructuredPostal.CITY])
+            assertEquals("Region", result[0].values[StructuredPostal.REGION])
+            assertEquals("ZIP", result[0].values[StructuredPostal.POSTCODE])
+            assertEquals("Country", result[0].values[StructuredPostal.COUNTRY])
+
+            assertEquals("Street 1\n" +
+                    "(Corner Street 2)\n" +
+                    "PO Box 123\n" +
+                    "Hood\n" +
+                    "ZIP City\n" +
+                    "Country (Region)", result[0].values[StructuredPostal.FORMATTED_ADDRESS])
+        }
+    }
+
+
+    @Test
+    fun testType_Home() {
+        val c = Contact().apply {
+            addresses += LabeledProperty(Address().apply {
+                streetAddress = "Street"
+                types += AddressType.HOME
+            })
+        }
+        StructuredPostalBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(StructuredPostal.TYPE_HOME, result[0].values[StructuredPostal.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_None() {
+        val c = Contact().apply {
+            addresses += LabeledProperty(Address().apply {
+                streetAddress = "Street"
+            })
+        }
+        StructuredPostalBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(StructuredPostal.TYPE_OTHER, result[0].values[StructuredPostal.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Work() {
+        val c = Contact().apply {
+            addresses += LabeledProperty(Address().apply {
+                streetAddress = "Street"
+                types += AddressType.WORK
+            })
+        }
+        StructuredPostalBuilder(Uri.EMPTY, null, c).build().also { result ->
+            assertEquals(StructuredPostal.TYPE_WORK, result[0].values[StructuredPostal.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandlerTest.kt
new file mode 100644
index 0000000..ae5885e
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandlerTest.kt
@@ -0,0 +1,100 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
+import at.bitfire.vcard4android.Contact
+import ezvcard.parameter.AddressType
+import org.junit.Assert.*
+import org.junit.Test
+
+class StructuredPostalHandlerTest {
+
+    @Test
+    fun testEmpty() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            putNull(StructuredPostal.STREET)
+        }, contact)
+        assertTrue(contact.addresses.isEmpty())
+    }
+
+
+    @Test
+    fun testValues() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street 1\n(Corner Street 2)")
+            put(StructuredPostal.POBOX, "PO Box 123")
+            put(StructuredPostal.NEIGHBORHOOD, "Near the park")
+            put(StructuredPostal.CITY, "Sampletown")
+            put(StructuredPostal.REGION, "Sampleregion")
+            put(StructuredPostal.POSTCODE, "ZIP")
+            put(StructuredPostal.COUNTRY, "Samplecountry")
+
+            put(StructuredPostal.FORMATTED_ADDRESS, "Full Formatted Address")
+        }, contact)
+        assertArrayEquals(arrayOf("Street 1", "(Corner Street 2)"), contact.addresses[0].property.streetAddresses.toTypedArray())
+        assertArrayEquals(arrayOf("PO Box 123"), contact.addresses[0].property.poBoxes.toTypedArray())
+        assertArrayEquals(arrayOf("Near the park"), contact.addresses[0].property.extendedAddresses.toTypedArray())
+        assertArrayEquals(arrayOf("PO Box 123"), contact.addresses[0].property.poBoxes.toTypedArray())
+        assertArrayEquals(arrayOf("Sampletown"), contact.addresses[0].property.localities.toTypedArray())
+        assertArrayEquals(arrayOf("Sampleregion"), contact.addresses[0].property.regions.toTypedArray())
+        assertArrayEquals(arrayOf("ZIP"), contact.addresses[0].property.postalCodes.toTypedArray())
+        assertArrayEquals(arrayOf("Samplecountry"), contact.addresses[0].property.countries.toTypedArray())
+        assertEquals("Full Formatted Address", contact.addresses[0].property.label)
+    }
+
+
+    @Test
+    fun testType_CustomNoLabel() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street")
+            put(StructuredPostal.TYPE, StructuredPostal.TYPE_CUSTOM)
+        }, contact)
+        assertTrue(contact.addresses[0].property.types.isEmpty())
+    }
+
+    @Test
+    fun testType_CustomWithLabel() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street")
+            put(StructuredPostal.TYPE, StructuredPostal.TYPE_CUSTOM)
+            put(StructuredPostal.LABEL, "Label")
+        }, contact)
+        assertTrue(contact.addresses[0].property.types.isEmpty())
+        assertEquals("Label", contact.addresses[0].label)
+    }
+
+    @Test
+    fun testType_Home() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street")
+            put(StructuredPostal.TYPE, StructuredPostal.TYPE_HOME)
+        }, contact)
+        assertArrayEquals(arrayOf(AddressType.HOME), contact.addresses[0].property.types.toTypedArray())
+    }
+
+    @Test
+    fun testType_Other() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street")
+            put(StructuredPostal.TYPE, StructuredPostal.TYPE_OTHER)
+        }, contact)
+        assertTrue(contact.addresses[0].property.types.isEmpty())
+    }
+
+    @Test
+    fun testType_Work() {
+        val contact = Contact()
+        StructuredPostalHandler.handle(ContentValues().apply {
+            put(StructuredPostal.STREET, "Street")
+            put(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK)
+        }, contact)
+        assertArrayEquals(arrayOf(AddressType.WORK), contact.addresses[0].property.types.toTypedArray())
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteBuilderTest.kt
new file mode 100644
index 0000000..2b516d3
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteBuilderTest.kt
@@ -0,0 +1,137 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.CustomType
+import ezvcard.property.Url
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class WebsiteBuilderTest {
+
+    @Test
+    fun testEmpty() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact()).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+
+    @Test
+    fun testUrl_Empty() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url(""))
+        }).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testUrl_Value() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com"))
+        }).build().also { result ->
+            assertEquals("https://example.com", result[0].values[CommonDataKinds.Website.URL])
+        }
+    }
+
+
+    @Test
+    fun testLabel() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com"), "Label")
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Im.TYPE_CUSTOM, result[0].values[CommonDataKinds.Website.TYPE])
+            assertEquals("Label", result[0].values[CommonDataKinds.Website.LABEL])
+        }
+    }
+
+
+    @Test
+    fun testMimeType() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com"))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Website.MIMETYPE])
+        }
+    }
+
+
+    @Test
+    fun testType_Blog() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com").apply {
+                type = CustomType.Url.TYPE_BLOG
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_BLOG, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Ftp() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("ftps://example.com").apply {
+                type = CustomType.Url.TYPE_FTP
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_FTP, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Home() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com").apply {
+                type = CustomType.HOME
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_HOME, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Homepage() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com").apply {
+                type = CustomType.Url.TYPE_HOMEPAGE
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_HOMEPAGE, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_None() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("ftps://example.com"))
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_OTHER, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Profile() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com").apply {
+                type = CustomType.Url.TYPE_PROFILE
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_PROFILE, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+    @Test
+    fun testType_Work() {
+        WebsiteBuilder(Uri.EMPTY, null, Contact().apply {
+            urls += LabeledProperty(Url("https://example.com").apply {
+                type = CustomType.WORK
+            })
+        }).build().also { result ->
+            assertEquals(CommonDataKinds.Website.TYPE_WORK, result[0].values[CommonDataKinds.Im.TYPE])
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteHandlerTest.kt b/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteHandlerTest.kt
new file mode 100644
index 0000000..745661b
--- /dev/null
+++ b/src/androidTest/java/at/bitfire/vcard4android/contactrow/WebsiteHandlerTest.kt
@@ -0,0 +1,113 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.Website
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
+import org.junit.Assert.*
+import org.junit.Test
+
+class WebsiteHandlerTest {
+
+    @Test
+    fun testUrl_Empty() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            putNull(Website.URL)
+        }, contact)
+        assertTrue(contact.urls.isEmpty())
+    }
+
+    @Test
+    fun testUrl_Value() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+        }, contact)
+        assertEquals("https://example.com", contact.urls[0].property.value)
+    }
+
+
+    @Test
+    fun testType_Blog() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_BLOG)
+        }, contact)
+        assertEquals(CustomType.Url.TYPE_BLOG, contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Custom_Label() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_CUSTOM)
+            put(Website.LABEL, "Label")
+        }, contact)
+        assertNull(contact.urls[0].property.type)
+        assertEquals("Label", contact.urls[0].label)
+    }
+
+    @Test
+    fun testType_Custom_NoLabel() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_CUSTOM)
+        }, contact)
+        assertNull(contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Ftp() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_FTP)
+        }, contact)
+        assertEquals(CustomType.Url.TYPE_FTP, contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Home() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_HOME)
+        }, contact)
+        assertEquals(CustomType.HOME, contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Homepage() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_HOMEPAGE)
+        }, contact)
+        assertEquals(CustomType.Url.TYPE_HOMEPAGE, contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Profile() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_PROFILE)
+        }, contact)
+        assertEquals(CustomType.Url.TYPE_PROFILE, contact.urls[0].property.type)
+    }
+
+    @Test
+    fun testType_Work() {
+        val contact = Contact()
+        WebsiteHandler.handle(ContentValues().apply {
+            put(Website.URL, "https://example.com")
+            put(Website.TYPE, Website.TYPE_WORK)
+        }, contact)
+        assertEquals(CustomType.WORK, contact.urls[0].property.type)
+    }
+
+}
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/datarow/NicknameBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/datarow/NicknameBuilderTest.kt
deleted file mode 100644
index 642b790..0000000
--- a/src/androidTest/java/at/bitfire/vcard4android/datarow/NicknameBuilderTest.kt
+++ /dev/null
@@ -1,94 +0,0 @@
-package at.bitfire.vcard4android.datarow
-
-import android.net.Uri
-import android.provider.ContactsContract.CommonDataKinds
-import at.bitfire.vcard4android.LabeledProperty
-import at.bitfire.vcard4android.property.CustomType
-import ezvcard.property.Nickname
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-/*class NicknameBuilderTest {
-
-    @Test
-    fun testEmpty() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname())).build().also { result ->
-            assertEquals(0, result.size)
-        }
-    }
-
-
-    @Test
-    fun testLabel() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Nick 1")
-            type = CustomType.Nickname.SHORT_NAME       // will be ignored because there's a label
-        }, "Label 1")).build().also { result ->
-            assertEquals(1, result.size)
-            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
-            assertEquals(CommonDataKinds.Nickname.TYPE_CUSTOM, result[0].values[CommonDataKinds.Nickname.TYPE])
-            assertEquals("Label 1", result[0].values[CommonDataKinds.Nickname.LABEL])
-        }
-    }
-
-
-    @Test
-    fun testMimeType() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Name 1")
-        })).build().also { result ->
-            assertEquals(CommonDataKinds.Nickname.CONTENT_ITEM_TYPE, result[0].values[CommonDataKinds.Nickname.MIMETYPE])
-        }
-    }
-
-
-    @Test
-    fun testType_Initials() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Nick 1")
-            type = CustomType.Nickname.INITIALS
-        })).build().also { result ->
-            assertEquals(1, result.size)
-            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
-            assertEquals(CommonDataKinds.Nickname.TYPE_INITIALS, result[0].values[CommonDataKinds.Nickname.TYPE])
-        }
-    }
-
-    @Test
-    fun testType_MaidenName() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Nick 1")
-            type = CustomType.Nickname.MAIDEN_NAME
-        })).build().also { result ->
-            assertEquals(1, result.size)
-            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
-            assertEquals(CommonDataKinds.Nickname.TYPE_MAIDEN_NAME, result[0].values[CommonDataKinds.Nickname.TYPE])
-        }
-    }
-
-    @Test
-    fun testType_ShortName() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Nick 1")
-            type = CustomType.Nickname.SHORT_NAME
-        })).build().also { result ->
-            assertEquals(1, result.size)
-            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
-            assertEquals(CommonDataKinds.Nickname.TYPE_SHORT_NAME, result[0].values[CommonDataKinds.Nickname.TYPE])
-        }
-    }
-
-
-    @Test
-    fun testValue_TwoValues() {
-        NicknameBuilder(Uri.EMPTY, null, LabeledProperty(Nickname().apply {
-            values.add("Nick 1")
-            values.add("Nick 2")
-        })).build().also { result ->
-            assertEquals(2, result.size)
-            assertEquals("Nick 1", result[0].values[CommonDataKinds.Nickname.NAME])
-            assertEquals("Nick 2", result[1].values[CommonDataKinds.Nickname.NAME])
-        }
-    }
-
-}*/
\ No newline at end of file
diff --git a/src/androidTest/java/at/bitfire/vcard4android/datarow/StructuredNameBuilderTest.kt b/src/androidTest/java/at/bitfire/vcard4android/datarow/StructuredNameBuilderTest.kt
deleted file mode 100644
index da3b59b..0000000
--- a/src/androidTest/java/at/bitfire/vcard4android/datarow/StructuredNameBuilderTest.kt
+++ /dev/null
@@ -1,45 +0,0 @@
-package at.bitfire.vcard4android.datarow
-
-import android.net.Uri
-import android.provider.ContactsContract
-import at.bitfire.vcard4android.Contact
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class StructuredNameBuilderTest {
-
-    @Test
-    fun testEmpty() {
-        StructuredNameBuilder("", Uri.EMPTY, null, Contact()).build().also { result ->
-            assertEquals(0, result.size)
-        }
-    }
-
-    @Test
-    fun testValues() {
-        StructuredNameBuilder("", Uri.EMPTY, null, Contact().apply {
-            prefix = "P."
-            givenName = "Given"
-            middleName = "Middle"
-            familyName = "Family"
-            suffix = "S"
-
-            phoneticGivenName = "Phonetic Given"
-            phoneticMiddleName = "Phonetic Middle"
-            phoneticFamilyName = "Phonetic Family"
-        }).build().also { result ->
-            assertEquals(1, result.size)
-
-            assertEquals("P.", result[0].values[ContactsContract.CommonDataKinds.StructuredName.PREFIX])
-            assertEquals("Given", result[0].values[ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME])
-            assertEquals("Middle", result[0].values[ContactsContract.CommonDataKinds.StructuredName.MIDDLE_NAME])
-            assertEquals("Family", result[0].values[ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME])
-            assertEquals("S", result[0].values[ContactsContract.CommonDataKinds.StructuredName.SUFFIX])
-
-            assertEquals("Phonetic Given", result[0].values[ContactsContract.CommonDataKinds.StructuredName.PHONETIC_GIVEN_NAME])
-            assertEquals("Phonetic Middle", result[0].values[ContactsContract.CommonDataKinds.StructuredName.PHONETIC_MIDDLE_NAME])
-            assertEquals("Phonetic Family", result[0].values[ContactsContract.CommonDataKinds.StructuredName.PHONETIC_FAMILY_NAME])
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/AndroidContact.kt b/src/main/java/at/bitfire/vcard4android/AndroidContact.kt
index 45ca96b..a19b5aa 100644
--- a/src/main/java/at/bitfire/vcard4android/AndroidContact.kt
+++ b/src/main/java/at/bitfire/vcard4android/AndroidContact.kt
@@ -18,12 +18,12 @@ import android.provider.ContactsContract
 import android.provider.ContactsContract.RawContacts
 import android.provider.ContactsContract.RawContacts.Data
 import androidx.annotation.CallSuper
-import at.bitfire.vcard4android.datarow.ContactProcessor
+import at.bitfire.vcard4android.contactrow.ContactProcessor
 import org.apache.commons.lang3.builder.ToStringBuilder
 import java.io.FileNotFoundException
 
 open class AndroidContact(
-        val addressBook: AndroidAddressBook<out AndroidContact, out AndroidGroup>
+        open val addressBook: AndroidAddressBook<out AndroidContact, out AndroidGroup>
 ) {
 
     companion object {
diff --git a/src/main/java/at/bitfire/vcard4android/Contact.kt b/src/main/java/at/bitfire/vcard4android/Contact.kt
index 6935570..889a812 100644
--- a/src/main/java/at/bitfire/vcard4android/Contact.kt
+++ b/src/main/java/at/bitfire/vcard4android/Contact.kt
@@ -88,20 +88,9 @@ class Contact {
 
         const val LABEL_GROUP_PREFIX = "item"
 
-        // TEL x-types to store Android types
-        val PHONE_TYPE_CALLBACK = TelephoneType.get("x-callback")!!
-        val PHONE_TYPE_COMPANY_MAIN = TelephoneType.get("x-company_main")!!
-        val PHONE_TYPE_RADIO = TelephoneType.get("x-radio")!!
-        val PHONE_TYPE_ASSISTANT = TelephoneType.get("X-assistant")!!
-        val PHONE_TYPE_MMS = TelephoneType.get("x-mms")!!
-
-        // EMAIL x-types to store Android types
-        val EMAIL_TYPE_MOBILE = EmailType.get("x-mobile")!!
-
         const val DATE_PARAMETER_OMIT_YEAR = "X-APPLE-OMIT-YEAR"
         const val DATE_PARAMETER_OMIT_YEAR_DEFAULT = 1604
 
-
         /**
          * Parses an InputStream that contains a vCard.
          *
diff --git a/src/main/java/at/bitfire/vcard4android/ContactReader.kt b/src/main/java/at/bitfire/vcard4android/ContactReader.kt
index 2d65083..5590257 100644
--- a/src/main/java/at/bitfire/vcard4android/ContactReader.kt
+++ b/src/main/java/at/bitfire/vcard4android/ContactReader.kt
@@ -7,6 +7,7 @@ import ezvcard.VCard
 import ezvcard.parameter.RelatedType
 import ezvcard.property.*
 import ezvcard.util.PartialDate
+import org.apache.commons.lang3.ObjectUtils
 import org.apache.commons.lang3.StringUtils
 import java.net.URI
 import java.net.URISyntaxException
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/ContactProcessor.kt b/src/main/java/at/bitfire/vcard4android/contactrow/ContactProcessor.kt
index c34470a..3ceb183 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/ContactProcessor.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/ContactProcessor.kt
@@ -1,9 +1,8 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentProviderClient
 import android.content.ContentValues
 import android.net.Uri
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
 import android.provider.ContactsContract.RawContacts
 import at.bitfire.vcard4android.AndroidContact
 import at.bitfire.vcard4android.BatchOperation
@@ -11,7 +10,6 @@ import at.bitfire.vcard4android.Constants
 import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.datavalues.EmailHandler
 import at.bitfire.vcard4android.datavalues.PhotoHandler
-import java.util.*
 import java.util.logging.Level
 
 class ContactProcessor(
@@ -26,7 +24,7 @@ class ContactProcessor(
         NicknameHandler,
         NoteHandler,
         OrganizationHandler,
-        PhoneNumberHandler,
+        PhoneHandler,
         PhotoHandler(provider),
         RelationHandler,
         SipAddressHandler,
@@ -35,8 +33,7 @@ class ContactProcessor(
         WebsiteHandler
     )
 
-    private val dataRowBuilderFactories = LinkedList<DataRowBuilder.Factory<*>>()
-    private val defaultDataRowBuilderFactories = arrayOf(
+    private val dataRowBuilderFactories = mutableListOf<DataRowBuilder.Factory<*>>(
         EmailBuilder.Factory,
         EventBuilder.Factory,
         ImBuilder.Factory,
@@ -56,8 +53,6 @@ class ContactProcessor(
     init {
         for (handler in defaultDataRowHandlers)
             registerHandler(handler)
-        for (factory in defaultDataRowBuilderFactories)
-            registerBuilderFactory(factory)
     }
 
 
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/DataRowBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/DataRowBuilder.kt
index b0f5f78..5e279d7 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/DataRowBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/DataRowBuilder.kt
@@ -1,7 +1,8 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract
+import at.bitfire.vcard4android.AndroidAddressBook
 import at.bitfire.vcard4android.BatchOperation
 import at.bitfire.vcard4android.Contact
 
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/DataRowHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/DataRowHandler.kt
index bffdfd3..d8401b8 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/DataRowHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/DataRowHandler.kt
@@ -1,6 +1,5 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
-import android.content.ContentProviderClient
 import android.content.ContentValues
 import androidx.annotation.CallSuper
 import at.bitfire.vcard4android.Contact
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/EmailBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/EmailBuilder.kt
index 4ae918c..8f27f52 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/EmailBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/EmailBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract
@@ -6,12 +6,13 @@ import android.provider.ContactsContract.CommonDataKinds.Email
 import at.bitfire.vcard4android.BatchOperation
 import at.bitfire.vcard4android.Constants
 import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
 import ezvcard.parameter.EmailType
 import java.util.*
 import java.util.logging.Level
 
-class EmailBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class EmailBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -45,7 +46,7 @@ class EmailBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
                     when (type) {
                         EmailType.HOME -> typeCode = Email.TYPE_HOME
                         EmailType.WORK -> typeCode = Email.TYPE_WORK
-                        Contact.EMAIL_TYPE_MOBILE -> typeCode = Email.TYPE_MOBILE
+                        CustomType.Email.MOBILE -> typeCode = Email.TYPE_MOBILE
                     }
             }
 
@@ -64,7 +65,7 @@ class EmailBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
     object Factory: DataRowBuilder.Factory<EmailBuilder> {
         override fun mimeType() = Email.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            EmailBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            EmailBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/EmailHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/EmailHandler.kt
index 6c6aed4..b8b8d84 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/EmailHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/EmailHandler.kt
@@ -4,7 +4,8 @@ import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Email
 import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.LabeledProperty
-import at.bitfire.vcard4android.datarow.DataRowHandler
+import at.bitfire.vcard4android.contactrow.DataRowHandler
+import at.bitfire.vcard4android.property.CustomType
 import ezvcard.parameter.EmailType
 
 object EmailHandler: DataRowHandler() {
@@ -25,7 +26,7 @@ object EmailHandler: DataRowHandler() {
             Email.TYPE_WORK ->
                 email.types += EmailType.WORK
             Email.TYPE_MOBILE ->
-                email.types += Contact.EMAIL_TYPE_MOBILE
+                email.types += CustomType.Email.MOBILE
             Email.TYPE_CUSTOM ->
                 values.getAsString(Email.LABEL)?.let {
                     labeledEmail.label = it
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/EventBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/EventBuilder.kt
index 2501148..b90211b 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/EventBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/EventBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Event
@@ -10,8 +10,8 @@ import java.text.SimpleDateFormat
 import java.util.*
 import java.util.logging.Level
 
-class EventBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class EventBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -19,8 +19,14 @@ class EventBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
         buildEvent(contact.birthDay, Event.TYPE_BIRTHDAY)?.let { result += it }
         buildEvent(contact.anniversary, Event.TYPE_ANNIVERSARY)?.let { result += it }
 
-        for (customDate in contact.customDates)
-            buildEvent(customDate.property, Event.TYPE_CUSTOM, customDate.label)?.let { result += it }
+        for (customDate in contact.customDates) {
+            val label = customDate.label
+            val typeCode = if (label != null)
+                Event.TYPE_CUSTOM
+            else
+                Event.TYPE_OTHER
+            buildEvent(customDate.property, typeCode, label)?.let { result += it }
+        }
 
         return result
     }
@@ -36,7 +42,7 @@ class EventBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
                 format.format(dateOrTime.date)
             }
             dateOrTime.partialDate != null ->
-                dateOrTime.partialDate.toString()
+                dateOrTime.partialDate.toISO8601(true)      // AOSP Contacts app expects this format ("--06-01")
             else -> {
                 Constants.log.log(Level.WARNING, "Ignoring date/time without (partial) date", dateOrTime)
                 return null
@@ -57,7 +63,7 @@ class EventBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
     object Factory: DataRowBuilder.Factory<EventBuilder> {
         override fun mimeType() = Event.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            EventBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            EventBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/EventHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/EventHandler.kt
index 0da95e5..1c6b7a2 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/EventHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/EventHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Event
@@ -22,7 +22,7 @@ object EventHandler: DataRowHandler() {
     override fun handle(values: ContentValues, contact: Contact) {
         super.handle(values, contact)
 
-        val dateStr = values.getAsString(Event.START_DATE)
+        val dateStr = values.getAsString(Event.START_DATE) ?: return
         var full: Date? = null
         var partial: PartialDate? = null
         val fullFormat = SimpleDateFormat("yyyy-MM-dd", Locale.ROOT)
@@ -42,8 +42,9 @@ object EventHandler: DataRowHandler() {
                     contact.anniversary = if (full != null) Anniversary(full) else Anniversary(partial)
                 Event.TYPE_BIRTHDAY ->
                     contact.birthDay = if (full != null) Birthday(full) else Birthday(partial)
-                Event.TYPE_OTHER,
-                Event.TYPE_CUSTOM -> {
+                /* Event.TYPE_OTHER,
+                Event.TYPE_CUSTOM */
+                else -> {
                     val abDate = if (full != null) XAbDate(full) else XAbDate(partial)
                     val label = StringUtils.trimToNull(values.getAsString(Event.LABEL))
                     contact.customDates += LabeledProperty(abDate, label)
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/ImBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/ImBuilder.kt
index 69805ab..18ad3f5 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/ImBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/ImBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Im
@@ -8,8 +8,8 @@ import at.bitfire.vcard4android.Contact
 import ezvcard.parameter.ImppType
 import java.util.*
 
-class ImBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class ImBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -55,7 +55,7 @@ class ImBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact:
     object Factory: DataRowBuilder.Factory<ImBuilder> {
         override fun mimeType() = Im.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            ImBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            ImBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/ImHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/ImHandler.kt
index c491d05..f2c3968 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/ImHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/ImHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Im
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/NicknameBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/NicknameBuilder.kt
index b96965c..ad28176 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/NicknameBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/NicknameBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds
@@ -7,8 +7,8 @@ import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.property.CustomType
 import java.util.*
 
-class NicknameBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class NicknameBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val labeledNick = contact.nickName ?: return emptyList()
@@ -49,7 +49,7 @@ class NicknameBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, co
     object Factory: DataRowBuilder.Factory<NicknameBuilder> {
         override fun mimeType() = CommonDataKinds.Nickname.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            NicknameBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            NicknameBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/NicknameHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/NicknameHandler.kt
index 73d8108..558bf90 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/NicknameHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/NicknameHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Nickname
@@ -11,8 +11,9 @@ object NicknameHandler: DataRowHandler() {
     override fun forMimeType() = Nickname.CONTENT_ITEM_TYPE
 
     override fun handle(values: ContentValues, contact: Contact) {
-        val name = values.getAsString(Nickname.NAME) ?: return
+        super.handle(values, contact)
 
+        val name = values.getAsString(Nickname.NAME) ?: return
         val nick = ezvcard.property.Nickname()
         val labeledNick = LabeledProperty(nick)
 
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/NoteBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/NoteBuilder.kt
index 32229f7..9002935 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/NoteBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/NoteBuilder.kt
@@ -1,12 +1,12 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Note
 import at.bitfire.vcard4android.BatchOperation
 import at.bitfire.vcard4android.Contact
 
-class NoteBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class NoteBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val note = contact.note
@@ -22,7 +22,7 @@ class NoteBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contac
     object Factory: DataRowBuilder.Factory<NoteBuilder> {
         override fun mimeType() = Note.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            NoteBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            NoteBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/NoteHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/NoteHandler.kt
index d5371e4..b42499a 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/NoteHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/NoteHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Note
@@ -10,7 +10,6 @@ object NoteHandler: DataRowHandler() {
 
     override fun handle(values: ContentValues, contact: Contact) {
         super.handle(values, contact)
-
         contact.note = values.getAsString(Note.NOTE)
     }
 
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/OrganizationBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/OrganizationBuilder.kt
index 3af4c98..571ca04 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/OrganizationBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/OrganizationBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Organization
@@ -7,8 +7,8 @@ import at.bitfire.vcard4android.Contact
 import org.apache.commons.lang3.StringUtils
 import java.util.*
 
-class OrganizationBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class OrganizationBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         var company: String? = null
@@ -39,7 +39,7 @@ class OrganizationBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?
     object Factory: DataRowBuilder.Factory<OrganizationBuilder> {
         override fun mimeType() = Organization.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            OrganizationBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            OrganizationBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/OrganizationHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/OrganizationHandler.kt
index 18c88e8..3de189f 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/OrganizationHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/OrganizationHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Organization
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/PhoneBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/PhoneBuilder.kt
index d9cb8f7..26718ee 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/PhoneBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/PhoneBuilder.kt
@@ -1,16 +1,17 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Phone
 import at.bitfire.vcard4android.BatchOperation
 import at.bitfire.vcard4android.Constants
 import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.property.CustomType
 import ezvcard.parameter.TelephoneType
 import java.util.*
 import java.util.logging.Level
 
-class PhoneBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class PhoneBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -42,17 +43,17 @@ class PhoneBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
             } else {
                 when {
                     // 1 Android type <-> 2 vCard types: fax, cell, pager
+                    types.contains(TelephoneType.CELL) ->
+                        typeCode = if (types.contains(TelephoneType.WORK))
+                            Phone.TYPE_WORK_MOBILE
+                        else
+                            Phone.TYPE_MOBILE
                     types.contains(TelephoneType.FAX) ->
                         typeCode = when {
                             types.contains(TelephoneType.HOME) -> Phone.TYPE_FAX_HOME
                             types.contains(TelephoneType.WORK) -> Phone.TYPE_FAX_WORK
                             else                               -> Phone.TYPE_OTHER_FAX
                         }
-                    types.contains(TelephoneType.CELL) ->
-                        typeCode = if (types.contains(TelephoneType.WORK))
-                            Phone.TYPE_WORK_MOBILE
-                        else
-                            Phone.TYPE_MOBILE
                     types.contains(TelephoneType.PAGER) ->
                         typeCode = if (types.contains(TelephoneType.WORK))
                             Phone.TYPE_WORK_PAGER
@@ -64,19 +65,19 @@ class PhoneBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
                         typeCode = Phone.TYPE_HOME
                     types.contains(TelephoneType.WORK) ->
                         typeCode = Phone.TYPE_WORK
-                    types.contains(Contact.PHONE_TYPE_CALLBACK) ->
+                    types.contains(CustomType.Phone.CALLBACK) ->
                         typeCode = Phone.TYPE_CALLBACK
                     types.contains(TelephoneType.CAR) ->
                         typeCode = Phone.TYPE_CAR
-                    types.contains(Contact.PHONE_TYPE_COMPANY_MAIN) ->
+                    types.contains(CustomType.Phone.COMPANY_MAIN) ->
                         typeCode = Phone.TYPE_COMPANY_MAIN
                     types.contains(TelephoneType.ISDN) ->
                         typeCode = Phone.TYPE_ISDN
-                    types.contains(Contact.PHONE_TYPE_RADIO) ->
+                    types.contains(CustomType.Phone.RADIO) ->
                         typeCode = Phone.TYPE_RADIO
-                    types.contains(Contact.PHONE_TYPE_ASSISTANT) ->
+                    types.contains(CustomType.Phone.ASSISTANT) ->
                         typeCode = Phone.TYPE_ASSISTANT
-                    types.contains(Contact.PHONE_TYPE_MMS) ->
+                    types.contains(CustomType.Phone.MMS) ->
                         typeCode = Phone.TYPE_MMS
                 }
             }
@@ -96,7 +97,7 @@ class PhoneBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
     object Factory: DataRowBuilder.Factory<PhoneBuilder> {
         override fun mimeType() = Phone.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            PhoneBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            PhoneBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/PhoneNumberHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/PhoneHandler.kt
index 6650a39..7e3020e 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/PhoneNumberHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/PhoneHandler.kt
@@ -1,13 +1,14 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Phone
 import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.LabeledProperty
+import at.bitfire.vcard4android.property.CustomType
 import ezvcard.parameter.TelephoneType
 import ezvcard.property.Telephone
 
-object PhoneNumberHandler: DataRowHandler() {
+object PhoneHandler: DataRowHandler() {
 
     override fun forMimeType() = Phone.CONTENT_ITEM_TYPE
 
@@ -36,11 +37,11 @@ object PhoneNumberHandler: DataRowHandler() {
             Phone.TYPE_PAGER ->
                 tel.types += TelephoneType.PAGER
             Phone.TYPE_CALLBACK ->
-                tel.types += Contact.PHONE_TYPE_CALLBACK
+                tel.types += CustomType.Phone.CALLBACK
             Phone.TYPE_CAR ->
                 tel.types += TelephoneType.CAR
             Phone.TYPE_COMPANY_MAIN ->
-                tel.types += Contact.PHONE_TYPE_COMPANY_MAIN
+                tel.types += CustomType.Phone.COMPANY_MAIN
             Phone.TYPE_ISDN ->
                 tel.types += TelephoneType.ISDN
             Phone.TYPE_MAIN ->
@@ -48,7 +49,7 @@ object PhoneNumberHandler: DataRowHandler() {
             Phone.TYPE_OTHER_FAX ->
                 tel.types += TelephoneType.FAX
             Phone.TYPE_RADIO ->
-                tel.types += Contact.PHONE_TYPE_RADIO
+                tel.types += CustomType.Phone.RADIO
             Phone.TYPE_TELEX ->
                 tel.types += TelephoneType.TEXTPHONE
             Phone.TYPE_TTY_TDD ->
@@ -62,9 +63,9 @@ object PhoneNumberHandler: DataRowHandler() {
                 tel.types += TelephoneType.WORK
             }
             Phone.TYPE_ASSISTANT ->
-                tel.types += Contact.PHONE_TYPE_ASSISTANT
+                tel.types += CustomType.Phone.ASSISTANT
             Phone.TYPE_MMS ->
-                tel.types += Contact.PHONE_TYPE_MMS
+                tel.types += CustomType.Phone.MMS
             Phone.TYPE_CUSTOM -> {
                 values.getAsString(Phone.LABEL)?.let { label ->
                     labeledNumber.label = label
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/PhotoBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/PhotoBuilder.kt
index 3925ec9..5fca982 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/PhotoBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/PhotoBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
@@ -11,8 +11,8 @@ import at.bitfire.vcard4android.Contact
 import java.io.ByteArrayOutputStream
 import java.util.*
 
-class PhotoBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class PhotoBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     companion object {
         val MAX_PHOTO_BLOB_SIZE = 950*1024    // IPC limit 1 MB, minus 50 kB for the protocol itself = 950 kB
@@ -89,7 +89,7 @@ class PhotoBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, conta
     object Factory: DataRowBuilder.Factory<PhotoBuilder> {
         override fun mimeType() = Photo.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            PhotoBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            PhotoBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/PhotoHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/PhotoHandler.kt
index 7f57b5c..a7f03b6 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/PhotoHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/PhotoHandler.kt
@@ -7,7 +7,7 @@ import android.provider.ContactsContract
 import android.provider.ContactsContract.CommonDataKinds.Photo
 import at.bitfire.vcard4android.Constants
 import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.datarow.DataRowHandler
+import at.bitfire.vcard4android.contactrow.DataRowHandler
 import org.apache.commons.io.IOUtils
 import java.io.IOException
 import java.util.logging.Level
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/RelationBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/RelationBuilder.kt
index fc0894e..0298e1a 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/RelationBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/RelationBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Relation
@@ -10,8 +10,8 @@ import org.apache.commons.lang3.StringUtils
 import org.apache.commons.text.WordUtils
 import java.util.*
 
-class RelationBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class RelationBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -64,7 +64,7 @@ class RelationBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, co
     object Factory: DataRowBuilder.Factory<RelationBuilder> {
         override fun mimeType() = Relation.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            RelationBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            RelationBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/RelationHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/RelationHandler.kt
index 302ccc7..b4d0283 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/RelationHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/RelationHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Relation
@@ -14,7 +14,6 @@ object RelationHandler: DataRowHandler() {
 
     override fun handle(values: ContentValues, contact: Contact) {
         super.handle(values, contact)
-
         val name = values.getAsString(Relation.NAME) ?: return
 
         val related = Related()
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/SipAddressBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/SipAddressBuilder.kt
index ac147eb..1c3812a 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/SipAddressBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/SipAddressBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.SipAddress
@@ -7,8 +7,8 @@ import at.bitfire.vcard4android.Contact
 import ezvcard.parameter.ImppType
 import java.util.*
 
-class SipAddressBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class SipAddressBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -48,7 +48,7 @@ class SipAddressBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?,
     object Factory: DataRowBuilder.Factory<SipAddressBuilder> {
         override fun mimeType() = SipAddress.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            SipAddressBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            SipAddressBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/SipAddressHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/SipAddressHandler.kt
index 0290c13..5fd48e3 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/SipAddressHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/SipAddressHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.SipAddress
@@ -14,7 +14,6 @@ object SipAddressHandler: DataRowHandler() {
 
     override fun handle(values: ContentValues, contact: Contact) {
         super.handle(values, contact)
-
         val sip = values.getAsString(SipAddress.SIP_ADDRESS) ?: return
 
         try {
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/StructuredNameBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredNameBuilder.kt
index 17ec159..1f050d7 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/StructuredNameBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredNameBuilder.kt
@@ -1,12 +1,12 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.StructuredName
 import at.bitfire.vcard4android.BatchOperation
 import at.bitfire.vcard4android.Contact
 
-class StructuredNameBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class StructuredNameBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         if (contact.displayName == null &&
@@ -33,7 +33,7 @@ class StructuredNameBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Lon
     object Factory: DataRowBuilder.Factory<StructuredNameBuilder> {
         override fun mimeType() = StructuredName.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            StructuredNameBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            StructuredNameBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/StructuredNameHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredNameHandler.kt
index e242778..e293329 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/StructuredNameHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredNameHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.StructuredName
diff --git a/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilder.kt
new file mode 100644
index 0000000..4a367c3
--- /dev/null
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalBuilder.kt
@@ -0,0 +1,103 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.net.Uri
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
+import at.bitfire.vcard4android.BatchOperation
+import at.bitfire.vcard4android.Contact
+import ezvcard.parameter.AddressType
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+/**
+ * Data row builder for structured addresses.
+ *
+ * Android requires a formatted address. If the contact data doesn't contain a
+ * formatted address, it's built like this:
+ *
+ *     | field             | example                      |
+ *     |-------------------|------------------------------|
+ *     | street            | Sample Street 123            |
+ *     | poBox             | P/O Box 45                   |
+ *     | extended          | Near the park                |
+ *     | postalCode city   | 12345 Sampletown             |
+ *     | country (region)  | Samplecountry (Sampleregion) |
+ *
+ * TODO: should be localized (there are many different international formats)
+ *
+ */
+class StructuredPostalBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
+
+    override fun build(): List<BatchOperation.CpoBuilder> {
+        val result = LinkedList<BatchOperation.CpoBuilder>()
+        for (labeledAddress in contact.addresses) {
+            val address = labeledAddress.property
+
+            var formattedAddress = address.label
+            if (formattedAddress.isNullOrBlank()) {
+                val lines = LinkedList<String>()
+                for (street in address.streetAddresses.filterNot { s -> s.isNullOrBlank() })
+                    lines += street
+                for (poBox in address.poBoxes.filterNot { s -> s.isNullOrBlank() })
+                    lines += poBox
+                for (extended in address.extendedAddresses.filterNot { s -> s.isNullOrBlank() })
+                    lines += extended
+
+                val postalAndCity = LinkedList<String>()
+                if (StringUtils.trimToNull(address.postalCode) != null)
+                    postalAndCity += address.postalCodes.joinToString(" / ")
+                if (StringUtils.trimToNull(address.locality) != null)
+                    postalAndCity += address.localities.joinToString(" / ")
+                if (postalAndCity.isNotEmpty())
+                    lines += postalAndCity.joinToString(" ")
+
+                if (StringUtils.trimToNull(address.country) != null) {
+                    val line = StringBuilder(address.countries.joinToString(" / "))
+                    if (!address.region.isNullOrBlank()) {
+                        val regions = address.regions.joinToString(" / ")
+                        line.append(" ($regions)")
+                    }
+                    lines += line.toString()
+                } else
+                    if (!address.region.isNullOrBlank())
+                        lines += address.regions.joinToString(" / ")
+
+                formattedAddress = lines.joinToString("\n")
+            }
+
+            val types = address.types
+            val typeCode: Int
+            var typeLabel: String? = null
+            if (labeledAddress.label != null) {
+                typeCode = StructuredPostal.TYPE_CUSTOM
+                typeLabel = labeledAddress.label
+            } else
+                typeCode = when {
+                    types.contains(AddressType.HOME) -> StructuredPostal.TYPE_HOME
+                    types.contains(AddressType.WORK) -> StructuredPostal.TYPE_WORK
+                    else -> StructuredPostal.TYPE_OTHER
+                }
+
+            result += newDataRow()
+                    .withValue(StructuredPostal.FORMATTED_ADDRESS, formattedAddress)
+                    .withValue(StructuredPostal.TYPE, typeCode)
+                    .withValue(StructuredPostal.LABEL, typeLabel)
+                    .withValue(StructuredPostal.STREET, address.streetAddresses.joinToString("\n"))
+                    .withValue(StructuredPostal.POBOX, address.poBoxes.joinToString("\n"))
+                    .withValue(StructuredPostal.NEIGHBORHOOD, address.extendedAddresses.joinToString("\n"))
+                    .withValue(StructuredPostal.CITY, address.localities.joinToString("\n"))
+                    .withValue(StructuredPostal.REGION, address.regions.joinToString("\n"))
+                    .withValue(StructuredPostal.POSTCODE, address.postalCodes.joinToString("\n"))
+                    .withValue(StructuredPostal.COUNTRY, address.countries.joinToString("\n"))
+        }
+        return result
+    }
+
+
+    object Factory: DataRowBuilder.Factory<StructuredPostalBuilder> {
+        override fun mimeType() = StructuredPostal.CONTENT_ITEM_TYPE
+        override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
+            StructuredPostalBuilder(dataRowUri, rawContactId, contact)
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandler.kt
new file mode 100644
index 0000000..20d45e6
--- /dev/null
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/StructuredPostalHandler.kt
@@ -0,0 +1,64 @@
+package at.bitfire.vcard4android.contactrow
+
+import android.content.ContentValues
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.LabeledProperty
+import ezvcard.parameter.AddressType
+import ezvcard.property.Address
+
+object StructuredPostalHandler: DataRowHandler() {
+
+    override fun forMimeType() = StructuredPostal.CONTENT_ITEM_TYPE
+
+    override fun handle(values: ContentValues, contact: Contact) {
+        super.handle(values, contact)
+
+        val address = Address()
+        val labeledAddress = LabeledProperty(address)
+
+        address.label = values.getAsString(StructuredPostal.FORMATTED_ADDRESS)
+        when (values.getAsInteger(StructuredPostal.TYPE)) {
+            StructuredPostal.TYPE_HOME ->
+                address.types += AddressType.HOME
+            StructuredPostal.TYPE_WORK ->
+                address.types += AddressType.WORK
+            StructuredPostal.TYPE_CUSTOM -> {
+                values.getAsString(StructuredPostal.LABEL)?.let {
+                    labeledAddress.label = it
+                }
+            }
+        }
+        values.getAsString(StructuredPostal.STREET)?.let { streets ->
+            address.streetAddresses += streets.split('\n')
+        }
+        values.getAsString(StructuredPostal.POBOX)?.let { poBoxes ->
+            address.poBoxes += poBoxes.split('\n')
+        }
+        values.getAsString(StructuredPostal.NEIGHBORHOOD)?.let { neighborhoods ->
+            address.extendedAddresses += neighborhoods.split('\n')
+        }
+        values.getAsString(StructuredPostal.CITY)?.let { cities ->
+            address.localities += cities.split('\n')
+        }
+        values.getAsString(StructuredPostal.REGION)?.let { regions ->
+            address.regions += regions.split('\n')
+        }
+        values.getAsString(StructuredPostal.POSTCODE)?.let { postalCodes ->
+            address.postalCodes += postalCodes.split('\n')
+        }
+        values.getAsString(StructuredPostal.COUNTRY)?.let { countries ->
+            address.countries += countries.split('\n')
+        }
+
+        if (address.streetAddresses.isNotEmpty() ||
+            address.poBoxes.isNotEmpty() ||
+            address.extendedAddresses.isNotEmpty() ||
+            address.localities.isNotEmpty() ||
+            address.regions.isNotEmpty() ||
+            address.postalCodes.isNotEmpty() ||
+            address.countries.isNotEmpty())
+            contact.addresses += labeledAddress
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/WebsiteBuilder.kt b/src/main/java/at/bitfire/vcard4android/contactrow/WebsiteBuilder.kt
index f5b4eb5..16608ea 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/WebsiteBuilder.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/WebsiteBuilder.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.net.Uri
 import android.provider.ContactsContract.CommonDataKinds.Website
@@ -7,8 +7,8 @@ import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.property.CustomType
 import java.util.*
 
-class WebsiteBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
+class WebsiteBuilder(dataRowUri: Uri, rawContactId: Long?, contact: Contact)
+    : DataRowBuilder(Factory.mimeType(), dataRowUri, rawContactId, contact) {
 
     override fun build(): List<BatchOperation.CpoBuilder> {
         val result = LinkedList<BatchOperation.CpoBuilder>()
@@ -27,13 +27,13 @@ class WebsiteBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, con
                     CustomType.Url.TYPE_HOMEPAGE -> Website.TYPE_HOMEPAGE
                     CustomType.Url.TYPE_BLOG ->     Website.TYPE_BLOG
                     CustomType.Url.TYPE_PROFILE ->  Website.TYPE_PROFILE
+                    CustomType.Url.TYPE_FTP ->      Website.TYPE_FTP
                     CustomType.HOME ->              Website.TYPE_HOME
                     CustomType.WORK ->              Website.TYPE_WORK
-                    CustomType.Url.TYPE_FTP ->      Website.TYPE_FTP
                     else ->                         Website.TYPE_OTHER
                 }
 
-            val builder = newDataRow()
+            result += newDataRow()
                 .withValue(Website.URL, url.value)
                 .withValue(Website.TYPE, typeCode)
                 .withValue(Website.LABEL, typeLabel)
@@ -45,7 +45,7 @@ class WebsiteBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, con
     object Factory: DataRowBuilder.Factory<WebsiteBuilder> {
         override fun mimeType() = Website.CONTENT_ITEM_TYPE
         override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            WebsiteBuilder(mimeType(), dataRowUri, rawContactId, contact)
+            WebsiteBuilder(dataRowUri, rawContactId, contact)
     }
 
 }
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/WebsiteHandler.kt b/src/main/java/at/bitfire/vcard4android/contactrow/WebsiteHandler.kt
index 25a78a6..42255ab 100644
--- a/src/main/java/at/bitfire/vcard4android/datarow/WebsiteHandler.kt
+++ b/src/main/java/at/bitfire/vcard4android/contactrow/WebsiteHandler.kt
@@ -1,4 +1,4 @@
-package at.bitfire.vcard4android.datarow
+package at.bitfire.vcard4android.contactrow
 
 import android.content.ContentValues
 import android.provider.ContactsContract.CommonDataKinds.Website
@@ -14,7 +14,7 @@ object WebsiteHandler: DataRowHandler() {
     override fun handle(values: ContentValues, contact: Contact) {
         super.handle(values, contact)
 
-        val url = Url(values.getAsString(Website.URL))
+        val url = Url(values.getAsString(Website.URL) ?: return)
         val labeledUrl = LabeledProperty(url)
 
         when (values.getAsInteger(Website.TYPE)) {
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalBuilder.kt b/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalBuilder.kt
deleted file mode 100644
index ce9423a..0000000
--- a/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalBuilder.kt
+++ /dev/null
@@ -1,80 +0,0 @@
-package at.bitfire.vcard4android.datarow
-
-import android.net.Uri
-import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
-import at.bitfire.vcard4android.BatchOperation
-import at.bitfire.vcard4android.Contact
-import ezvcard.parameter.AddressType
-import java.util.*
-
-class StructuredPostalBuilder(mimeType: String, dataRowUri: Uri, rawContactId: Long?, contact: Contact)
-    : DataRowBuilder(mimeType, dataRowUri, rawContactId, contact) {
-
-    override fun build(): List<BatchOperation.CpoBuilder> {
-        val result = LinkedList<BatchOperation.CpoBuilder>()
-        for (labeledAddress in contact.addresses) {
-            val address = labeledAddress.property
-
-            var formattedAddress = address.label
-            if (formattedAddress.isNullOrBlank()) {
-                /*	StructuredPostal.FORMATTED_ADDRESS must not be empty, but no formatted address
-                 *  was in the vCard. So we build it like this:
-                 *
-                 *  street po.box (extended)
-                 *	postcode city
-                 *	region
-                 *	COUNTRY
-                 */
-
-                val lineStreet = arrayOf(address.streetAddress, address.poBox, address.extendedAddress).filterNot { it.isNullOrEmpty() }.joinToString(" ")
-                val lineLocality = arrayOf(address.postalCode, address.locality).filterNot { it.isNullOrEmpty() }.joinToString(" ")
-
-                val lines = LinkedList<String>()
-                if (lineStreet.isNotEmpty())
-                    lines += lineStreet
-                if (lineLocality.isNotEmpty())
-                    lines += lineLocality
-                if (!address.region.isNullOrEmpty())
-                    lines += address.region
-                if (!address.country.isNullOrEmpty())
-                    lines += address.country.toUpperCase(Locale.getDefault())
-
-                formattedAddress = lines.joinToString("\n")
-            }
-
-            val types = address.types
-            val typeCode: Int
-            var typeLabel: String? = null
-            if (labeledAddress.label != null) {
-                typeCode = StructuredPostal.TYPE_CUSTOM
-                typeLabel = labeledAddress.label
-            } else
-                typeCode = when {
-                    types.contains(AddressType.HOME) -> StructuredPostal.TYPE_HOME
-                    types.contains(AddressType.WORK) -> StructuredPostal.TYPE_WORK
-                    else -> StructuredPostal.TYPE_OTHER
-                }
-
-            val builder = newDataRow()
-                    .withValue(StructuredPostal.FORMATTED_ADDRESS, formattedAddress)
-                    .withValue(StructuredPostal.TYPE, typeCode)
-                    .withValue(StructuredPostal.LABEL, typeLabel)
-                    .withValue(StructuredPostal.STREET, address.streetAddress)
-                    .withValue(StructuredPostal.POBOX, address.poBox)
-                    .withValue(StructuredPostal.NEIGHBORHOOD, address.extendedAddress)
-                    .withValue(StructuredPostal.CITY, address.locality)
-                    .withValue(StructuredPostal.REGION, address.region)
-                    .withValue(StructuredPostal.POSTCODE, address.postalCode)
-                    .withValue(StructuredPostal.COUNTRY, address.country)
-        }
-        return result
-    }
-
-
-    object Factory: DataRowBuilder.Factory<StructuredPostalBuilder> {
-        override fun mimeType() = StructuredPostal.CONTENT_ITEM_TYPE
-        override fun newInstance(dataRowUri: Uri, rawContactId: Long?, contact: Contact) =
-            StructuredPostalBuilder(mimeType(), dataRowUri, rawContactId, contact)
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalHandler.kt b/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalHandler.kt
deleted file mode 100644
index 9d00ddb..0000000
--- a/src/main/java/at/bitfire/vcard4android/datarow/StructuredPostalHandler.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package at.bitfire.vcard4android.datarow
-
-import android.content.ContentValues
-import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.LabeledProperty
-import ezvcard.parameter.AddressType
-import ezvcard.property.Address
-
-object StructuredPostalHandler: DataRowHandler() {
-
-    override fun forMimeType() = StructuredPostal.CONTENT_ITEM_TYPE
-
-    override fun handle(values: ContentValues, contact: Contact) {
-        super.handle(values, contact)
-
-        val address = Address()
-        val labeledAddress = LabeledProperty(address)
-
-        address.label = values.getAsString(StructuredPostal.FORMATTED_ADDRESS)
-        when (values.getAsInteger(StructuredPostal.TYPE)) {
-            StructuredPostal.TYPE_HOME ->
-                address.types += AddressType.HOME
-            StructuredPostal.TYPE_WORK ->
-                address.types += AddressType.WORK
-            StructuredPostal.TYPE_CUSTOM -> {
-                values.getAsString(StructuredPostal.LABEL)?.let {
-                    labeledAddress.label = it
-                }
-            }
-        }
-        address.streetAddress = values.getAsString(StructuredPostal.STREET)
-        address.poBox = values.getAsString(StructuredPostal.POBOX)
-        address.extendedAddress = values.getAsString(StructuredPostal.NEIGHBORHOOD)
-        address.locality = values.getAsString(StructuredPostal.CITY)
-        address.region = values.getAsString(StructuredPostal.REGION)
-        address.postalCode = values.getAsString(StructuredPostal.POSTCODE)
-        address.country = values.getAsString(StructuredPostal.COUNTRY)
-        contact.addresses += labeledAddress
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/java/at/bitfire/vcard4android/property/CustomType.kt b/src/main/java/at/bitfire/vcard4android/property/CustomType.kt
index 945182c..3a4df3f 100644
--- a/src/main/java/at/bitfire/vcard4android/property/CustomType.kt
+++ b/src/main/java/at/bitfire/vcard4android/property/CustomType.kt
@@ -1,18 +1,35 @@
 package at.bitfire.vcard4android.property
 
+import ezvcard.parameter.EmailType
 import ezvcard.parameter.RelatedType
+import ezvcard.parameter.TelephoneType
 
+/**
+ * Custom TYPE parameter definitions
+ */
 object CustomType {
 
     val HOME = "home"
     val WORK = "work"
 
+    object Email {
+        val MOBILE = EmailType.get("x-mobile")
+    }
+
     object Nickname {
         val INITIALS = "x-initials"
         val MAIDEN_NAME = "x-maiden-name"
         val SHORT_NAME = "x-short-name"
     }
 
+    object Phone {
+        val ASSISTANT = TelephoneType.get("x-assistant")!!
+        val CALLBACK = TelephoneType.get("x-callback")!!
+        val COMPANY_MAIN = TelephoneType.get("x-company_main")!!
+        val MMS = TelephoneType.get("x-mms")!!
+        val RADIO = TelephoneType.get("x-radio")!!
+    }
+
     object Related {
         val ASSISTANT = RelatedType.get("assistant")
         val BROTHER = RelatedType.get("brother")